diff options
Diffstat (limited to 'clang')
94 files changed, 17770 insertions, 23090 deletions
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/ReleaseNotes.rst b/clang/docs/ReleaseNotes.rst index 99aa545..65b086c 100644 --- a/clang/docs/ReleaseNotes.rst +++ b/clang/docs/ReleaseNotes.rst @@ -180,6 +180,9 @@ C Language Changes C2y Feature Support ^^^^^^^^^^^^^^^^^^^ +- No longer triggering ``-Wstatic-in-inline`` in C2y mode; use of a static + function or variable within an extern inline function is no longer a + constraint per `WG14 N3622 <https://www.open-std.org/jtc1/sc22/wg14/www/docs/n3622.txt>`_. - Clang now supports `N3355 <https://www.open-std.org/jtc1/sc22/wg14/www/docs/n3355.htm>`_ Named Loops. C23 Feature Support diff --git a/clang/docs/UsersManual.rst b/clang/docs/UsersManual.rst index 12c2ada..5745e4b 100644 --- a/clang/docs/UsersManual.rst +++ b/clang/docs/UsersManual.rst @@ -2778,7 +2778,7 @@ usual build cycle when using sample profilers for optimization: > clang-cl /O2 -gdwarf -gline-tables-only ^ /clang:-fdebug-info-for-profiling /clang:-funique-internal-linkage-names ^ - code.cc /Fe:code /fuse-ld=lld /link /debug:dwarf + code.cc /Fe:code -fuse-ld=lld /link /debug:dwarf .. note:: @@ -2861,13 +2861,15 @@ usual build cycle when using sample profilers for optimization: that executes faster than the original one. Note that you are not required to build the code with the exact same arguments that you used in the first step. The only requirement is that you build the code - with the same debug info options and ``-fprofile-sample-use``. + with the same debug info options and ``-fprofile-sample-use``. ``-gdwarf`` + and ``-gline-tables-only`` can be omitted if you do not need debug info + in the final binary. On Linux: .. code-block:: console - $ clang++ -O2 -gline-tables-only \ + $ clang++ -O2 \ -fdebug-info-for-profiling -funique-internal-linkage-names \ -fprofile-sample-use=code.prof code.cc -o code @@ -2875,9 +2877,9 @@ usual build cycle when using sample profilers for optimization: .. code-block:: winbatch - > clang-cl /O2 -gdwarf -gline-tables-only ^ + > clang-cl /O2 ^ /clang:-fdebug-info-for-profiling /clang:-funique-internal-linkage-names ^ - -fprofile-sample-use=code.prof code.cc /Fe:code -fuse-ld=lld /link /debug:dwarf + -fprofile-sample-use=code.prof code.cc /Fe:code [OPTIONAL] Sampling-based profiles can have inaccuracies or missing block/ edge counters. The profile inference algorithm (profi) can be used to infer @@ -2886,7 +2888,7 @@ usual build cycle when using sample profilers for optimization: .. code-block:: console - $ clang++ -fsample-profile-use-profi -O2 -gline-tables-only \ + $ clang++ -fsample-profile-use-profi -O2 \ -fdebug-info-for-profiling -funique-internal-linkage-names \ -fprofile-sample-use=code.prof code.cc -o code @@ -2894,9 +2896,9 @@ usual build cycle when using sample profilers for optimization: .. code-block:: winbatch - > clang-cl /clang:-fsample-profile-use-profi /O2 -gdwarf -gline-tables-only ^ + > clang-cl /clang:-fsample-profile-use-profi /O2 ^ /clang:-fdebug-info-for-profiling /clang:-funique-internal-linkage-names ^ - -fprofile-sample-use=code.prof code.cc /Fe:code -fuse-ld=lld /link /debug:dwarf + -fprofile-sample-use=code.prof code.cc /Fe:code Sample Profile Formats """""""""""""""""""""" diff --git a/clang/docs/analyzer/developer-docs/Statistics.rst b/clang/docs/analyzer/developer-docs/Statistics.rst index 595b44d..4f2484a 100644 --- a/clang/docs/analyzer/developer-docs/Statistics.rst +++ b/clang/docs/analyzer/developer-docs/Statistics.rst @@ -22,7 +22,6 @@ However, note that with ``LLVM_ENABLE_STATS`` disabled, only storage of the valu If you want to define a statistic only for entry point, EntryPointStats.h has four classes at your disposal: -- ``BoolEPStat`` - a boolean value assigned at most once per entry point. For example: "has the inline limit been reached". - ``UnsignedEPStat`` - an unsigned value assigned at most once per entry point. For example: "the number of source characters in an entry-point body". - ``CounterEPStat`` - an additive statistic. It starts with 0 and you can add to it as many times as needed. For example: "the number of bugs discovered". - ``UnsignedMaxEPStat`` - a maximizing statistic. It starts with 0 and when you join it with a value, it picks the maximum of the previous value and the new one. For example, "the longest execution path of a bug". diff --git a/clang/include/clang/AST/Expr.h b/clang/include/clang/AST/Expr.h index e1a4005..573cc72 100644 --- a/clang/include/clang/AST/Expr.h +++ b/clang/include/clang/AST/Expr.h @@ -7160,6 +7160,18 @@ public: /// Return original type of the base expression for array section. static QualType getBaseOriginalType(const Expr *Base); + /// Return the effective 'element' type of this array section. As the array + /// section itself returns a collection of elements (closer to its `getBase` + /// type), this is only useful for figuring out the effective type of this if + /// it were a normal Array subscript expr. + QualType getElementType() const; + + /// Returns the effective 'type' of the base of this array section. This + /// should be the array/pointer type that this operates on. Just + /// getBase->getType isn't sufficient, since it doesn't look through existing + /// Array sections to figure out the actual 'base' of this. + QualType getBaseType() const; + static bool classof(const Stmt *T) { return T->getStmtClass() == ArraySectionExprClass; } diff --git a/clang/include/clang/Basic/BuiltinsAMDGPU.def b/clang/include/clang/Basic/BuiltinsAMDGPU.def index 3e45c04..8428fa9 100644 --- a/clang/include/clang/Basic/BuiltinsAMDGPU.def +++ b/clang/include/clang/Basic/BuiltinsAMDGPU.def @@ -885,5 +885,79 @@ TARGET_BUILTIN(__builtin_amdgcn_cooperative_atomic_store_16x8B, "vV2i*V2iIicC*", TARGET_BUILTIN(__builtin_amdgcn_cooperative_atomic_load_8x16B, "V4iV4i*IicC*", "nc", "gfx1250-insts,wavefrontsize32") TARGET_BUILTIN(__builtin_amdgcn_cooperative_atomic_store_8x16B, "vV4i*V4iIicC*", "nc", "gfx1250-insts,wavefrontsize32") +//===----------------------------------------------------------------------===// +// Image builtins +//===----------------------------------------------------------------------===// +TARGET_BUILTIN(__builtin_amdgcn_image_load_1d_v4f32_i32, "V4fiiQtii", "nc", "image-insts") +TARGET_BUILTIN(__builtin_amdgcn_image_load_1d_v4f16_i32, "V4hiiQtii", "nc", "image-insts") +TARGET_BUILTIN(__builtin_amdgcn_image_load_1darray_v4f32_i32, "V4fiiiQtii", "nc", "image-insts") +TARGET_BUILTIN(__builtin_amdgcn_image_load_1darray_v4f16_i32, "V4hiiiQtii", "nc", "image-insts") +TARGET_BUILTIN(__builtin_amdgcn_image_load_2d_f32_i32, "fiiiQtii", "nc", "image-insts") +TARGET_BUILTIN(__builtin_amdgcn_image_load_2d_v4f32_i32, "V4fiiiQtii", "nc", "image-insts") +TARGET_BUILTIN(__builtin_amdgcn_image_load_2d_v4f16_i32, "V4hiiiQtii", "nc", "image-insts") +TARGET_BUILTIN(__builtin_amdgcn_image_load_2darray_f32_i32, "fiiiiQtii", "nc", "image-insts") +TARGET_BUILTIN(__builtin_amdgcn_image_load_2darray_v4f32_i32, "V4fiiiiQtii", "nc", "image-insts") +TARGET_BUILTIN(__builtin_amdgcn_image_load_2darray_v4f16_i32, "V4hiiiiQtii", "nc", "image-insts") +TARGET_BUILTIN(__builtin_amdgcn_image_load_3d_v4f32_i32, "V4fiiiiQtii", "nc", "image-insts") +TARGET_BUILTIN(__builtin_amdgcn_image_load_3d_v4f16_i32, "V4hiiiiQtii", "nc", "image-insts") +TARGET_BUILTIN(__builtin_amdgcn_image_load_cube_v4f32_i32, "V4fiiiiQtii", "nc", "image-insts") +TARGET_BUILTIN(__builtin_amdgcn_image_load_cube_v4f16_i32, "V4hiiiiQtii", "nc", "image-insts") +TARGET_BUILTIN(__builtin_amdgcn_image_load_mip_1d_v4f32_i32, "V4fiiiQtii", "nc", "image-insts") +TARGET_BUILTIN(__builtin_amdgcn_image_load_mip_1d_v4f16_i32, "V4hiiiQtii", "nc", "image-insts") +TARGET_BUILTIN(__builtin_amdgcn_image_load_mip_1darray_v4f32_i32, "V4fiiiiQtii", "nc", "image-insts") +TARGET_BUILTIN(__builtin_amdgcn_image_load_mip_1darray_v4f16_i32, "V4hiiiiQtii", "nc", "image-insts") +TARGET_BUILTIN(__builtin_amdgcn_image_load_mip_2d_f32_i32, "fiiiiQtii", "nc", "image-insts") +TARGET_BUILTIN(__builtin_amdgcn_image_load_mip_2d_v4f32_i32, "V4fiiiiQtii", "nc", "image-insts") +TARGET_BUILTIN(__builtin_amdgcn_image_load_mip_2d_v4f16_i32, "V4hiiiiQtii", "nc", "image-insts") +TARGET_BUILTIN(__builtin_amdgcn_image_load_mip_2darray_f32_i32, "fiiiiiQtii", "nc", "image-insts") +TARGET_BUILTIN(__builtin_amdgcn_image_load_mip_2darray_v4f32_i32, "V4fiiiiiQtii", "nc", "image-insts") +TARGET_BUILTIN(__builtin_amdgcn_image_load_mip_2darray_v4f16_i32, "V4hiiiiiQtii", "nc", "image-insts") +TARGET_BUILTIN(__builtin_amdgcn_image_load_mip_3d_v4f32_i32, "V4fiiiiiQtii", "nc", "image-insts") +TARGET_BUILTIN(__builtin_amdgcn_image_load_mip_3d_v4f16_i32, "V4hiiiiiQtii", "nc", "image-insts") +TARGET_BUILTIN(__builtin_amdgcn_image_load_mip_cube_v4f32_i32, "V4fiiiiiQtii", "nc", "image-insts") +TARGET_BUILTIN(__builtin_amdgcn_image_load_mip_cube_v4f16_i32, "V4hiiiiiQtii", "nc", "image-insts") +TARGET_BUILTIN(__builtin_amdgcn_image_store_1d_v4f32_i32, "vV4fiiQtii", "nc", "image-insts") +TARGET_BUILTIN(__builtin_amdgcn_image_store_1d_v4f16_i32, "vV4hiiQtii", "nc", "image-insts") +TARGET_BUILTIN(__builtin_amdgcn_image_store_1darray_v4f32_i32, "vV4fiiiQtii", "nc", "image-insts") +TARGET_BUILTIN(__builtin_amdgcn_image_store_1darray_v4f16_i32, "vV4hiiiQtii", "nc", "image-insts") +TARGET_BUILTIN(__builtin_amdgcn_image_store_2d_f32_i32, "vfiiiQtii", "nc", "image-insts") +TARGET_BUILTIN(__builtin_amdgcn_image_store_2d_v4f32_i32, "vV4fiiiQtii", "nc", "image-insts") +TARGET_BUILTIN(__builtin_amdgcn_image_store_2d_v4f16_i32, "vV4hiiiQtii", "nc", "image-insts") +TARGET_BUILTIN(__builtin_amdgcn_image_store_2darray_f32_i32, "vfiiiiQtii", "nc", "image-insts") +TARGET_BUILTIN(__builtin_amdgcn_image_store_2darray_v4f32_i32, "vV4fiiiiQtii", "nc", "image-insts") +TARGET_BUILTIN(__builtin_amdgcn_image_store_2darray_v4f16_i32, "vV4hiiiiQtii", "nc", "image-insts") +TARGET_BUILTIN(__builtin_amdgcn_image_store_3d_v4f32_i32, "vV4fiiiiQtii", "nc", "image-insts") +TARGET_BUILTIN(__builtin_amdgcn_image_store_3d_v4f16_i32, "vV4hiiiiQtii", "nc", "image-insts") +TARGET_BUILTIN(__builtin_amdgcn_image_store_cube_v4f32_i32, "vV4fiiiiQtii", "nc", "image-insts") +TARGET_BUILTIN(__builtin_amdgcn_image_store_cube_v4f16_i32, "vV4hiiiiQtii", "nc", "image-insts") +TARGET_BUILTIN(__builtin_amdgcn_image_store_mip_1d_v4f32_i32, "vV4fiiiQtii", "nc", "image-insts") +TARGET_BUILTIN(__builtin_amdgcn_image_store_mip_1d_v4f16_i32, "vV4hiiiQtii", "nc", "image-insts") +TARGET_BUILTIN(__builtin_amdgcn_image_store_mip_1darray_v4f32_i32, "vV4fiiiiQtii", "nc", "image-insts") +TARGET_BUILTIN(__builtin_amdgcn_image_store_mip_1darray_v4f16_i32, "vV4hiiiiQtii", "nc", "image-insts") +TARGET_BUILTIN(__builtin_amdgcn_image_store_mip_2d_f32_i32, "vfiiiiQtii", "nc", "image-insts") +TARGET_BUILTIN(__builtin_amdgcn_image_store_mip_2d_v4f32_i32, "vV4fiiiiQtii", "nc", "image-insts") +TARGET_BUILTIN(__builtin_amdgcn_image_store_mip_2d_v4f16_i32, "vV4hiiiiQtii", "nc", "image-insts") +TARGET_BUILTIN(__builtin_amdgcn_image_store_mip_2darray_f32_i32, "vfiiiiiQtii", "nc", "image-insts") +TARGET_BUILTIN(__builtin_amdgcn_image_store_mip_2darray_v4f32_i32, "vV4fiiiiiQtii", "nc", "image-insts") +TARGET_BUILTIN(__builtin_amdgcn_image_store_mip_2darray_v4f16_i32, "vV4hiiiiiQtii", "nc", "image-insts") +TARGET_BUILTIN(__builtin_amdgcn_image_store_mip_3d_v4f32_i32, "vV4fiiiiiQtii", "nc", "image-insts") +TARGET_BUILTIN(__builtin_amdgcn_image_store_mip_3d_v4f16_i32, "vV4hiiiiiQtii", "nc", "image-insts") +TARGET_BUILTIN(__builtin_amdgcn_image_store_mip_cube_v4f32_i32, "vV4fiiiiiQtii", "nc", "image-insts") +TARGET_BUILTIN(__builtin_amdgcn_image_store_mip_cube_v4f16_i32, "vV4hiiiiiQtii", "nc", "image-insts") +TARGET_BUILTIN(__builtin_amdgcn_image_sample_1d_v4f32_f32, "V4fifQtV4ibii", "nc", "image-insts") +TARGET_BUILTIN(__builtin_amdgcn_image_sample_1d_v4f16_f32, "V4hifQtV4ibii", "nc", "image-insts") +TARGET_BUILTIN(__builtin_amdgcn_image_sample_1darray_v4f32_f32, "V4fiffQtV4ibii", "nc", "image-insts") +TARGET_BUILTIN(__builtin_amdgcn_image_sample_1darray_v4f16_f32, "V4hiffQtV4ibii", "nc", "image-insts") +TARGET_BUILTIN(__builtin_amdgcn_image_sample_2d_f32_f32, "fiffQtV4ibii", "nc", "image-insts") +TARGET_BUILTIN(__builtin_amdgcn_image_sample_2d_v4f32_f32, "V4fiffQtV4ibii", "nc", "image-insts") +TARGET_BUILTIN(__builtin_amdgcn_image_sample_2d_v4f16_f32, "V4hiffQtV4ibii", "nc", "image-insts") +TARGET_BUILTIN(__builtin_amdgcn_image_sample_2darray_f32_f32, "fifffQtV4ibii", "nc", "image-insts") +TARGET_BUILTIN(__builtin_amdgcn_image_sample_2darray_v4f32_f32, "V4fifffQtV4ibii", "nc", "image-insts") +TARGET_BUILTIN(__builtin_amdgcn_image_sample_2darray_v4f16_f32, "V4hifffQtV4ibii", "nc", "image-insts") +TARGET_BUILTIN(__builtin_amdgcn_image_sample_3d_v4f32_f32, "V4fifffQtV4ibii", "nc", "image-insts") +TARGET_BUILTIN(__builtin_amdgcn_image_sample_3d_v4f16_f32, "V4hifffQtV4ibii", "nc", "image-insts") +TARGET_BUILTIN(__builtin_amdgcn_image_sample_cube_v4f32_f32, "V4fifffQtV4ibii", "nc", "image-insts") +TARGET_BUILTIN(__builtin_amdgcn_image_sample_cube_v4f16_f32, "V4hifffQtV4ibii", "nc", "image-insts") + #undef BUILTIN #undef TARGET_BUILTIN diff --git a/clang/include/clang/Basic/DiagnosticGroups.td b/clang/include/clang/Basic/DiagnosticGroups.td index 4b27a42..ef3f59f 100644 --- a/clang/include/clang/Basic/DiagnosticGroups.td +++ b/clang/include/clang/Basic/DiagnosticGroups.td @@ -1400,7 +1400,7 @@ def C23 : DiagGroup<"c23-extensions", [VariadicMacroArgumentsOmitted]>; def : DiagGroup<"c2x-extensions", [C23]>; // A warning group for warnings about using C2y features as extensions. -def C2y : DiagGroup<"c2y-extensions">; +def C2y : DiagGroup<"c2y-extensions", [StaticInInline]>; // Previously supported warning group which is no longer pertinent as binary // literals are a C++14 and C23 extension now instead of a GNU extension. diff --git a/clang/include/clang/Basic/DiagnosticSemaKinds.td b/clang/include/clang/Basic/DiagnosticSemaKinds.td index 5be63c0..40bc7b9 100644 --- a/clang/include/clang/Basic/DiagnosticSemaKinds.td +++ b/clang/include/clang/Basic/DiagnosticSemaKinds.td @@ -6326,11 +6326,14 @@ def warn_internal_linkage_local_storage : Warning< InGroup<IgnoredAttributes>; def ext_internal_in_extern_inline : ExtWarn< - "static %select{function|variable}0 %1 is used in an inline function with " - "external linkage">, InGroup<StaticInInline>; + "using static %select{function|variable}0 %1 in an inline function with " + "external linkage is a C2y extension">, InGroup<StaticInInline>; def ext_internal_in_extern_inline_quiet : Extension< - "static %select{function|variable}0 %1 is used in an inline function with " - "external linkage">, InGroup<StaticInInline>; + ext_internal_in_extern_inline.Summary>, InGroup<StaticInInline>; +def warn_c2y_compat_internal_in_extern_inline : Warning< + "using static %select{function|variable}0 %1 in an inline function with " + "external linkage is incompatible with standards before C2y">, + InGroup<CPre2yCompat>, DefaultIgnore; def warn_static_local_in_extern_inline : Warning< "non-constant static local variable in inline function may be different " "in different files">, InGroup<StaticLocalInInline>; @@ -13662,6 +13665,11 @@ def warn_acc_var_referenced_lacks_op "reference has no effect">, InGroup<DiagGroup<"openacc-var-lacks-operation">>, DefaultError; +def err_acc_reduction_recipe_no_op + : Error<"variable of type %0 referenced in OpenACC 'reduction' clause does " + "not have a valid operation available">; +def note_acc_reduction_recipe_noop_field + : Note<"while forming combiner for compound type %0">; // AMDGCN builtins diagnostics def err_amdgcn_load_lds_size_invalid_value : Error<"invalid size value">; diff --git a/clang/include/clang/Basic/arm_sve.td b/clang/include/clang/Basic/arm_sve.td index 9a9a9874..d2b7b78b 100644 --- a/clang/include/clang/Basic/arm_sve.td +++ b/clang/include/clang/Basic/arm_sve.td @@ -953,7 +953,7 @@ def SVCVTNT_BF16_F32 : SInst<"svcvtnt_bf16[_f32]", "$$Pd", "f", MergeOp1, "aar // SVCVTNT_X_BF16_F32 : Implemented as macro by SveEmitter.cpp } -let SVETargetGuard = "sve2" in { +let SVETargetGuard = "sve2|sme" in { defm SVCVTLT_F32_F16 : SInstCvtMX<"svcvtlt_f32[_f16]", "ddPh", "dPh", "f", "aarch64_sve_fcvtlt_f32f16">; defm SVCVTLT_F64_F32 : SInstCvtMX<"svcvtlt_f64[_f32]", "ddPh", "dPh", "d", "aarch64_sve_fcvtlt_f64f32">; @@ -1243,7 +1243,7 @@ let SVETargetGuard = "sve2p1|sme2", SMETargetGuard = "sve2p1|sme2" in { //////////////////////////////////////////////////////////////////////////////// // SVE2 WhileGE/GT -let SVETargetGuard = "sve2" in { +let SVETargetGuard = "sve2|sme" in { def SVWHILEGE_S32 : SInst<"svwhilege_{d}[_{1}]", "Pkk", "PcPsPiPl", MergeNone, "aarch64_sve_whilege", [IsOverloadWhileOrMultiVecCvt, VerifyRuntimeMode]>; def SVWHILEGE_S64 : SInst<"svwhilege_{d}[_{1}]", "Pll", "PcPsPiPl", MergeNone, "aarch64_sve_whilege", [IsOverloadWhileOrMultiVecCvt, VerifyRuntimeMode]>; def SVWHILEGT_S32 : SInst<"svwhilegt_{d}[_{1}]", "Pkk", "PcPsPiPl", MergeNone, "aarch64_sve_whilegt", [IsOverloadWhileOrMultiVecCvt, VerifyRuntimeMode]>; @@ -1268,7 +1268,7 @@ let SVETargetGuard = "sve2p1|sme2", SMETargetGuard = "sve2p1|sme2" in { //////////////////////////////////////////////////////////////////////////////// // SVE2 - Uniform DSP operations -let SVETargetGuard = "sve2" in { +let SVETargetGuard = "sve2|sme" in { defm SVQADD_S : SInstZPZZ<"svqadd", "csli", "aarch64_sve_sqadd", "aarch64_sve_sqadd">; defm SVQADD_U : SInstZPZZ<"svqadd", "UcUsUiUl", "aarch64_sve_uqadd", "aarch64_sve_uqadd">; defm SVHADD_S : SInstZPZZ<"svhadd", "csli", "aarch64_sve_shadd", "aarch64_sve_shadd">; @@ -1303,7 +1303,7 @@ multiclass SInstZPZxZ<string name, string types, string pat_v, string pat_n, str def _N_Z : SInst<name # "[_n_{d}]", pat_n, types, MergeZero, intrinsic, flags>; } -let SVETargetGuard = "sve2" in { +let SVETargetGuard = "sve2|sme" in { defm SVQRSHL_S : SInstZPZxZ<"svqrshl", "csil", "dPdx", "dPdK", "aarch64_sve_sqrshl", [VerifyRuntimeMode]>; defm SVQRSHL_U : SInstZPZxZ<"svqrshl", "UcUsUiUl", "dPdx", "dPdK", "aarch64_sve_uqrshl", [VerifyRuntimeMode]>; defm SVQSHL_S : SInstZPZxZ<"svqshl", "csil", "dPdx", "dPdK", "aarch64_sve_sqshl", [VerifyRuntimeMode]>; @@ -1357,7 +1357,7 @@ multiclass SInstPairwise<string name, string types, string intrinsic, list<FlagT def _X : SInst<name # "[_{d}]", "dPdd", types, MergeAny, intrinsic, flags>; } -let SVETargetGuard = "sve2" in { +let SVETargetGuard = "sve2|sme" in { defm SVADDP : SInstPairwise<"svaddp", "csliUcUsUiUl", "aarch64_sve_addp", [VerifyRuntimeMode]>; defm SVADDP_F : SInstPairwise<"svaddp", "hfd", "aarch64_sve_faddp", [VerifyRuntimeMode]>; defm SVMAXNMP : SInstPairwise<"svmaxnmp", "hfd", "aarch64_sve_fmaxnmp", [VerifyRuntimeMode]>; @@ -1373,7 +1373,7 @@ defm SVMINP_U : SInstPairwise<"svminp", "UcUsUiUl", "aarch64_sve_uminp", [ //////////////////////////////////////////////////////////////////////////////// // SVE2 - Widening pairwise arithmetic -let SVETargetGuard = "sve2" in { +let SVETargetGuard = "sve2|sme" in { def SVADALP_S_M : SInst<"svadalp[_{d}]", "dPdh", "sil", MergeOp1, "aarch64_sve_sadalp", [VerifyRuntimeMode]>; def SVADALP_S_X : SInst<"svadalp[_{d}]", "dPdh", "sil", MergeAny, "aarch64_sve_sadalp", [VerifyRuntimeMode]>; def SVADALP_S_Z : SInst<"svadalp[_{d}]", "dPdh", "sil", MergeZero, "aarch64_sve_sadalp", [VerifyRuntimeMode]>; @@ -1387,7 +1387,7 @@ def SVADALP_U_Z : SInst<"svadalp[_{d}]", "dPdh", "UsUiUl", MergeZero, "aarch64_s // SVE2 - Bitwise ternary logical instructions // -let SVETargetGuard = "sve2" in { +let SVETargetGuard = "sve2|sme" in { def SVBCAX : SInst<"svbcax[_{d}]", "dddd", "csilUcUsUiUl", MergeNone, "aarch64_sve_bcax", [VerifyRuntimeMode]>; def SVBSL : SInst<"svbsl[_{d}]", "dddd", "csilUcUsUiUl", MergeNone, "aarch64_sve_bsl", [VerifyRuntimeMode]>; def SVBSL1N : SInst<"svbsl1n[_{d}]", "dddd", "csilUcUsUiUl", MergeNone, "aarch64_sve_bsl1n", [VerifyRuntimeMode]>; @@ -1407,7 +1407,7 @@ def SVXAR_N : SInst<"svxar[_n_{d}]", "dddi", "csilUcUsUiUl", MergeNone, "aar //////////////////////////////////////////////////////////////////////////////// // SVE2 - Large integer arithmetic -let SVETargetGuard = "sve2" in { +let SVETargetGuard = "sve2|sme" in { def SVADCLB : SInst<"svadclb[_{d}]", "dddd", "UiUl", MergeNone, "aarch64_sve_adclb", [VerifyRuntimeMode]>; def SVADCLT : SInst<"svadclt[_{d}]", "dddd", "UiUl", MergeNone, "aarch64_sve_adclt", [VerifyRuntimeMode]>; def SVSBCLB : SInst<"svsbclb[_{d}]", "dddd", "UiUl", MergeNone, "aarch64_sve_sbclb", [VerifyRuntimeMode]>; @@ -1422,7 +1422,7 @@ def SVSBCLT_N : SInst<"svsbclt[_n_{d}]", "ddda", "UiUl", MergeNone, "aarch64_sve //////////////////////////////////////////////////////////////////////////////// // SVE2 - Multiplication by indexed elements -let SVETargetGuard = "sve2" in { +let SVETargetGuard = "sve2|sme" in { def SVMLA_LANE_2 : SInst<"svmla_lane[_{d}]", "ddddi", "silUsUiUl", MergeNone, "aarch64_sve_mla_lane", [VerifyRuntimeMode], [ImmCheck<3, ImmCheckLaneIndex, 2>]>; def SVMLS_LANE_2 : SInst<"svmls_lane[_{d}]", "ddddi", "silUsUiUl", MergeNone, "aarch64_sve_mls_lane", [VerifyRuntimeMode], [ImmCheck<3, ImmCheckLaneIndex, 2>]>; def SVMUL_LANE_2 : SInst<"svmul_lane[_{d}]", "dddi", "silUsUiUl", MergeNone, "aarch64_sve_mul_lane", [VerifyRuntimeMode], [ImmCheck<2, ImmCheckLaneIndex, 1>]>; @@ -1430,7 +1430,7 @@ def SVMUL_LANE_2 : SInst<"svmul_lane[_{d}]", "dddi", "silUsUiUl", MergeNone, "a //////////////////////////////////////////////////////////////////////////////// // SVE2 - Uniform complex integer arithmetic -let SVETargetGuard = "sve2" in { +let SVETargetGuard = "sve2|sme" in { def SVCADD : SInst<"svcadd[_{d}]", "dddi", "csilUcUsUiUl", MergeNone, "aarch64_sve_cadd_x", [VerifyRuntimeMode], [ImmCheck<2, ImmCheckComplexRot90_270>]>; def SVSQCADD : SInst<"svqcadd[_{d}]", "dddi", "csil", MergeNone, "aarch64_sve_sqcadd_x", [VerifyRuntimeMode], [ImmCheck<2, ImmCheckComplexRot90_270>]>; def SVCMLA : SInst<"svcmla[_{d}]", "ddddi", "csilUcUsUiUl", MergeNone, "aarch64_sve_cmla_x", [VerifyRuntimeMode], [ImmCheck<3, ImmCheckComplexRotAll90>]>; @@ -1457,7 +1457,7 @@ multiclass SInstWideDSPWide<string name, string types, string intrinsic> { def _N : SInst<name # "[_n_{d}]", "ddR", types, MergeNone, intrinsic, [VerifyRuntimeMode]>; } -let SVETargetGuard = "sve2" in { +let SVETargetGuard = "sve2|sme" in { defm SVABALB_S : SInstWideDSPAcc<"svabalb", "sil", "aarch64_sve_sabalb">; defm SVABALB_U : SInstWideDSPAcc<"svabalb", "UsUiUl", "aarch64_sve_uabalb">; defm SVABALT_S : SInstWideDSPAcc<"svabalt", "sil", "aarch64_sve_sabalt">; @@ -1536,7 +1536,7 @@ def SVQDMULLT_LANE : SInst<"svqdmullt_lane[_{d}]", "dhhi", "il", MergeNone, " //////////////////////////////////////////////////////////////////////////////// // SVE2 - Narrowing DSP operations -let SVETargetGuard = "sve2" in { +let SVETargetGuard = "sve2|sme" in { def SVADDHNB : SInst<"svaddhnb[_{d}]", "hdd", "silUsUiUl", MergeNone, "aarch64_sve_addhnb", [VerifyRuntimeMode]>; def SVADDHNT : SInst<"svaddhnt[_{d}]", "hhdd", "silUsUiUl", MergeNone, "aarch64_sve_addhnt", [VerifyRuntimeMode]>; def SVRADDHNB : SInst<"svraddhnb[_{d}]", "hdd", "silUsUiUl", MergeNone, "aarch64_sve_raddhnb", [VerifyRuntimeMode]>; @@ -1576,7 +1576,7 @@ def SVQRSHRNT_U : SInst<"svqrshrnt[_n_{d}]", "hhdi", "UsUiUl", MergeNone, "a //////////////////////////////////////////////////////////////////////////////// // SVE2 - Unary narrowing operations -let SVETargetGuard = "sve2" in { +let SVETargetGuard = "sve2|sme" in { def SVQXTNB_S : SInst<"svqxtnb[_{d}]", "hd", "sil", MergeNone, "aarch64_sve_sqxtnb", [VerifyRuntimeMode]>; def SVQXTNB_U : SInst<"svqxtnb[_{d}]", "hd", "UsUiUl", MergeNone, "aarch64_sve_uqxtnb", [VerifyRuntimeMode]>; def SVQXTUNB_S : SInst<"svqxtunb[_{d}]", "ed", "sil", MergeNone, "aarch64_sve_sqxtunb", [VerifyRuntimeMode]>; @@ -1589,7 +1589,7 @@ def SVQXTUNT_S : SInst<"svqxtunt[_{d}]", "eed", "sil", MergeNone, "aarch64_sv //////////////////////////////////////////////////////////////////////////////// // SVE2 - Widening complex integer arithmetic -let SVETargetGuard = "sve2" in { +let SVETargetGuard = "sve2|sme" in { defm SVADDLBT : SInstWideDSPLong<"svaddlbt", "sil", "aarch64_sve_saddlbt">; defm SVSUBLBT : SInstWideDSPLong<"svsublbt", "sil", "aarch64_sve_ssublbt">; defm SVSUBLTB : SInstWideDSPLong<"svsubltb", "sil", "aarch64_sve_ssubltb">; @@ -1723,7 +1723,7 @@ def SVSTNT1W_SCATTER_INDEX_S : MInst<"svstnt1w_scatter[_{2}base]_index[_{d}]", " //////////////////////////////////////////////////////////////////////////////// // SVE2 - Polynomial arithmetic -let SVETargetGuard = "sve2" in { +let SVETargetGuard = "sve2|sme" in { def SVEORBT : SInst<"sveorbt[_{d}]", "dddd", "csilUcUsUiUl", MergeNone, "aarch64_sve_eorbt", [VerifyRuntimeMode]>; def SVEORBT_N : SInst<"sveorbt[_n_{d}]", "ddda", "csilUcUsUiUl", MergeNone, "aarch64_sve_eorbt", [VerifyRuntimeMode]>; def SVEORTB : SInst<"sveortb[_{d}]", "dddd", "csilUcUsUiUl", MergeNone, "aarch64_sve_eortb", [VerifyRuntimeMode]>; @@ -1744,7 +1744,7 @@ def SVPMULLT_PAIR_N : SInst<"svpmullt_pair[_n_{d}]", "dda", "UcUi", MergeNone, //////////////////////////////////////////////////////////////////////////////// // SVE2 - Complex integer dot product -let SVETargetGuard = "sve2" in { +let SVETargetGuard = "sve2|sme" in { def SVCDOT : SInst<"svcdot[_{d}]", "ddqqi", "il", MergeNone, "aarch64_sve_cdot", [VerifyRuntimeMode], [ImmCheck<3, ImmCheckComplexRotAll90>]>; def SVCDOT_LANE : SInst<"svcdot_lane[_{d}]", "ddqqii", "il", MergeNone, "aarch64_sve_cdot_lane", [VerifyRuntimeMode], [ImmCheck<4, ImmCheckComplexRotAll90>, ImmCheck<3, ImmCheckLaneIndexDot, 2>]>; } @@ -1752,7 +1752,7 @@ def SVCDOT_LANE : SInst<"svcdot_lane[_{d}]", "ddqqii", "il", MergeNone, "aarch //////////////////////////////////////////////////////////////////////////////// // SVE2 - Floating-point widening multiply-accumulate -let SVETargetGuard = "sve2" in { +let SVETargetGuard = "sve2|sme" in { def SVMLALB_F : SInst<"svmlalb[_{d}]", "ddhh", "f", MergeNone, "aarch64_sve_fmlalb", [VerifyRuntimeMode]>; def SVMLALB_F_N : SInst<"svmlalb[_n_{d}]", "ddhR", "f", MergeNone, "aarch64_sve_fmlalb", [VerifyRuntimeMode]>; def SVMLALB_F_LANE : SInst<"svmlalb_lane[_{d}]", "ddhhi", "f", MergeNone, "aarch64_sve_fmlalb_lane", [VerifyRuntimeMode], [ImmCheck<3, ImmCheckLaneIndex, 2>]>; @@ -1770,7 +1770,7 @@ def SVMLSLT_F_LANE : SInst<"svmlslt_lane[_{d}]", "ddhhi", "f", MergeNone, "aarch //////////////////////////////////////////////////////////////////////////////// // SVE2 - Floating-point integer binary logarithm -let SVETargetGuard = "sve2" in { +let SVETargetGuard = "sve2|sme" in { def SVLOGB_M : SInst<"svlogb[_{d}]", "xxPd", "hfd", MergeOp1, "aarch64_sve_flogb", [VerifyRuntimeMode]>; def SVLOGB_X : SInst<"svlogb[_{d}]", "xPd", "hfd", MergeAnyExp, "aarch64_sve_flogb", [VerifyRuntimeMode]>; def SVLOGB_Z : SInst<"svlogb[_{d}]", "xPd", "hfd", MergeZeroExp, "aarch64_sve_flogb", [VerifyRuntimeMode]>; @@ -1794,7 +1794,7 @@ def SVNMATCH : SInst<"svnmatch[_{d}]", "PPdd", "csUcUs", MergeNone, "aarch64_sve //////////////////////////////////////////////////////////////////////////////// // SVE2 - Contiguous conflict detection -let SVETargetGuard = "sve2" in { +let SVETargetGuard = "sve2|sme" in { def SVWHILERW_B : SInst<"svwhilerw[_{1}]", "Pcc", "cUc", MergeNone, "aarch64_sve_whilerw_b", [IsOverloadWhileRW, VerifyRuntimeMode]>; def SVWHILERW_H : SInst<"svwhilerw[_{1}]", "Pcc", "sUshb", MergeNone, "aarch64_sve_whilerw_h", [IsOverloadWhileRW, VerifyRuntimeMode]>; def SVWHILERW_S : SInst<"svwhilerw[_{1}]", "Pcc", "iUif", MergeNone, "aarch64_sve_whilerw_s", [IsOverloadWhileRW, VerifyRuntimeMode]>; @@ -1808,14 +1808,14 @@ def SVWHILEWR_D : SInst<"svwhilewr[_{1}]", "Pcc", "lUld", MergeNone, "aarch64_sv //////////////////////////////////////////////////////////////////////////////// // SVE2 - Extended table lookup/permute -let SVETargetGuard = "sve2" in { +let SVETargetGuard = "sve2|sme" in { def SVTBL2 : SInst<"svtbl2[_{d}]", "d2u", "csilUcUsUiUlhfdb", MergeNone, "", [VerifyRuntimeMode]>; def SVTBX : SInst<"svtbx[_{d}]", "dddu", "csilUcUsUiUlhfdb", MergeNone, "aarch64_sve_tbx", [VerifyRuntimeMode]>; } //////////////////////////////////////////////////////////////////////////////// // SVE2 - Lookup table -let SVETargetGuard = "sve2,lut", SMETargetGuard = "sme2,lut" in { +let SVETargetGuard = "(sve2|sme2),lut", SMETargetGuard = "sme2,lut" in { def SVLUTI2_B : SInst<"svluti2_lane[_{d}]", "dd[i", "cUc", MergeNone, "aarch64_sve_luti2_lane", [VerifyRuntimeMode], [ImmCheck<2, ImmCheck0_3>]>; def SVLUTI2_H : SInst<"svluti2_lane[_{d}]", "dd[i", "sUshb", MergeNone, "aarch64_sve_luti2_lane", [VerifyRuntimeMode], [ImmCheck<2, ImmCheck0_7>]>; @@ -1841,7 +1841,7 @@ def SVPMULLT_PAIR_U64 : SInst<"svpmullt_pair[_{d}]", "ddd", "Ul", MergeNone, def SVPMULLT_PAIR_N_U64 : SInst<"svpmullt_pair[_n_{d}]", "dda", "Ul", MergeNone, "aarch64_sve_pmullt_pair", [VerifyRuntimeMode]>; } -let SVETargetGuard = "sve-sha3", SMETargetGuard = "sve-sha3,sme2p1" in { +let SVETargetGuard = "sve-sha3", SMETargetGuard = "sme2p1,sve-sha3" in { def SVRAX1 : SInst<"svrax1[_{d}]", "ddd", "lUl", MergeNone, "aarch64_sve_rax1", [IsOverloadNone, VerifyRuntimeMode]>; } @@ -1884,7 +1884,7 @@ def SVFMAXQV : SInst<"svmaxqv[_{d}]", "{Pd", "hfd", MergeNone, "aarch64_sve_ def SVFMINQV : SInst<"svminqv[_{d}]", "{Pd", "hfd", MergeNone, "aarch64_sve_fminqv", [IsReductionQV, VerifyRuntimeMode]>; } -let SVETargetGuard = "sve2p1", SMETargetGuard = "sme2" in { +let SVETargetGuard = "sve2p1", SMETargetGuard = "sve2p1|sme2" in { def SVPEXT_SINGLE : SInst<"svpext_lane_{d}", "P}i", "QcQsQiQl", MergeNone, "aarch64_sve_pext", [VerifyRuntimeMode], [ImmCheck<1, ImmCheck0_3>]>; def SVPEXT_X2 : SInst<"svpext_lane_{d}_x2", "2.P}i", "QcQsQiQl", MergeNone, "aarch64_sve_pext_x2", [VerifyRuntimeMode], [ImmCheck<1, ImmCheck0_1>]>; @@ -1923,7 +1923,7 @@ multiclass MultiVecLoad<string i> { def SV # NAME # D_VNUM_X4 : MInst<"sv" # i # "_vnum" # "[_{2}]_x4", "4}cl", "lUld", [IsStructLoad, VerifyRuntimeMode], MemEltTyDefault, "aarch64_sve_" # i # "_pn_x4">; } -let SVETargetGuard = "sve2p1", SMETargetGuard = "sme2" in { +let SVETargetGuard = "sve2p1", SMETargetGuard = "sve2p1|sme2" in { defm LD1 : MultiVecLoad<"ld1">; defm LDNT1 : MultiVecLoad<"ldnt1">; } @@ -1948,7 +1948,7 @@ multiclass MultiVecStore<string i> { def SV # NAME # D_VNUM_X4 : MInst<"sv" # i # "_vnum" # "[_{2}_x4]", "v}pl4", "lUld", [IsStructStore, VerifyRuntimeMode], MemEltTyDefault, "aarch64_sve_" # i # "_pn_x4">; } -let SVETargetGuard = "sve2p1", SMETargetGuard = "sme2" in { +let SVETargetGuard = "sve2p1", SMETargetGuard = "sve2p1|sme2" in { defm ST1 : MultiVecStore<"st1">; defm STNT1 : MultiVecStore<"stnt1">; } @@ -1972,7 +1972,7 @@ def SVUCLAMP : SInst<"svclamp[_{d}]", "dddd", "UcUsUiUl", MergeNone, "aarch64_sv defm SVREVD : SInstZPZ<"svrevd", "csilUcUsUiUlmbhfd", "aarch64_sve_revd">; } -let SVETargetGuard = "sve2p1", SMETargetGuard = "sme2" in { +let SVETargetGuard = "sve2p1", SMETargetGuard = "sve2p1|sme2" in { def SVPTRUE_COUNT : SInst<"svptrue_{d}", "}v", "QcQsQiQl", MergeNone, "aarch64_sve_ptrue_{d}", [IsOverloadNone, VerifyRuntimeMode], []>; def SVCNTP_COUNT : SInst<"svcntp_{d}", "n}i", "QcQsQiQl", MergeNone, "aarch64_sve_cntp_{d}", [IsOverloadNone, VerifyRuntimeMode], [ImmCheck<1, ImmCheck2_4_Mul2>]>; @@ -2131,7 +2131,7 @@ let SVETargetGuard = InvalidMode, SMETargetGuard = "sme2,faminmax" in { def FAMAX_X4 : Inst<"svamax[_{d}_x4]", "444", "hfd", MergeNone, "aarch64_sme_famax_x4", [IsStreaming], []>; } -let SVETargetGuard = "sve2p1", SMETargetGuard = "sme2" in { +let SVETargetGuard = "sve2p1", SMETargetGuard = "sve2p1|sme2" in { def REINTERPRET_SVBOOL_TO_SVCOUNT : Inst<"svreinterpret[_c]", "}P", "Pc", MergeNone, "", [VerifyRuntimeMode], []>; def REINTERPRET_SVCOUNT_TO_SVBOOL : Inst<"svreinterpret[_b]", "P}", "Pc", MergeNone, "", [VerifyRuntimeMode], []>; } @@ -2225,9 +2225,9 @@ let SVETargetGuard = InvalidMode, SMETargetGuard = "sme-f16f16" in { // Multi-vector saturating extract narrow // let SVETargetGuard = InvalidMode, SMETargetGuard = "sme2" in { - def SVQCVT_S16_S32_X2 : SInst<"svqcvt_s16[_{d}_x2]", "h2.d", "i", MergeNone, "aarch64_sve_sqcvt_x2", [IsStreaming], []>; - def SVQCVT_U16_U32_X2 : SInst<"svqcvt_u16[_{d}_x2]", "e2.d", "Ui", MergeNone, "aarch64_sve_uqcvt_x2", [IsStreaming], []>; - def SVQCVT_U16_S32_X2 : SInst<"svqcvt_u16[_{d}_x2]", "e2.d", "i", MergeNone, "aarch64_sve_sqcvtu_x2", [IsStreaming], []>; + def SVQCVT_S16_S32_X2 : SInst<"svqcvt_s16[_{d}_x2]", "h2.d", "i", MergeNone, "aarch64_sve_sqcvt_x2", [IsStreaming], []>; + def SVQCVT_U16_U32_X2 : SInst<"svqcvt_u16[_{d}_x2]", "e2.d", "Ui", MergeNone, "aarch64_sve_uqcvt_x2", [IsStreaming], []>; + def SVQCVT_U16_S32_X2 : SInst<"svqcvt_u16[_{d}_x2]", "e2.d", "i", MergeNone, "aarch64_sve_sqcvtu_x2", [IsStreaming], []>; def SVQCVT_S8_S32_X4 : SInst<"svqcvt_s8[_{d}_x4]", "q4.d", "i", MergeNone, "aarch64_sve_sqcvt_x4", [IsStreaming], []>; def SVQCVT_U8_U32_X4 : SInst<"svqcvt_u8[_{d}_x4]", "b4.d", "Ui", MergeNone, "aarch64_sve_uqcvt_x4", [IsStreaming], []>; @@ -2316,12 +2316,12 @@ let SVETargetGuard = "sve2p1|sme2", SMETargetGuard = "sve2p1|sme2" in { def SVBFMLSLT_LANE : SInst<"svbfmlslt_lane[_{d}]", "dd$$i", "f", MergeNone, "aarch64_sve_bfmlslt_lane", [IsOverloadNone, VerifyRuntimeMode], [ImmCheck<3, ImmCheck0_7>]>; } -let SVETargetGuard = "sve2,faminmax", SMETargetGuard = "sme2,faminmax" in { +let SVETargetGuard = "(sve2|sme2),faminmax", SMETargetGuard = "sme2,faminmax" in { defm SVAMIN : SInstZPZZ<"svamin", "hfd", "aarch64_sve_famin", "aarch64_sve_famin_u">; defm SVAMAX : SInstZPZZ<"svamax", "hfd", "aarch64_sve_famax", "aarch64_sve_famax_u">; } -let SVETargetGuard = "sve2,fp8", SMETargetGuard = "sme2,fp8" in { +let SVETargetGuard = "(sve2|sme2),fp8", SMETargetGuard = "sme2,fp8" in { // SVE FP8 widening conversions // 8-bit floating-point convert to BFloat16/Float16 diff --git a/clang/include/clang/CIR/Dialect/Builder/CIRBaseBuilder.h b/clang/include/clang/CIR/Dialect/Builder/CIRBaseBuilder.h index 11ad61f..b4c24d7 100644 --- a/clang/include/clang/CIR/Dialect/Builder/CIRBaseBuilder.h +++ b/clang/include/clang/CIR/Dialect/Builder/CIRBaseBuilder.h @@ -451,6 +451,11 @@ public: return createBitcast(src, getPointerTo(newPointeeTy)); } + mlir::Value createPtrIsNull(mlir::Value ptr) { + mlir::Value nullPtr = getNullPtr(ptr.getType(), ptr.getLoc()); + return createCompare(ptr.getLoc(), cir::CmpOpKind::eq, ptr, nullPtr); + } + //===--------------------------------------------------------------------===// // Binary Operators //===--------------------------------------------------------------------===// @@ -644,6 +649,12 @@ public: return getI64IntegerAttr(size.getQuantity()); } + // Creates constant nullptr for pointer type ty. + cir::ConstantOp getNullPtr(mlir::Type ty, mlir::Location loc) { + assert(!cir::MissingFeatures::targetCodeGenInfoGetNullPointer()); + return cir::ConstantOp::create(*this, loc, getConstPtrAttr(ty, 0)); + } + /// Create a loop condition. cir::ConditionOp createCondition(mlir::Value condition) { return cir::ConditionOp::create(*this, condition.getLoc(), condition); diff --git a/clang/include/clang/CIR/MissingFeatures.h b/clang/include/clang/CIR/MissingFeatures.h index ace2086..df82ca1 100644 --- a/clang/include/clang/CIR/MissingFeatures.h +++ b/clang/include/clang/CIR/MissingFeatures.h @@ -85,6 +85,7 @@ struct MissingFeatures { static bool opFuncReadOnly() { return false; } static bool opFuncSection() { return false; } static bool opFuncWillReturn() { return false; } + static bool opFuncNoReturn() { return false; } static bool setLLVMFunctionFEnvAttributes() { return false; } static bool setFunctionAttributes() { return false; } @@ -256,6 +257,8 @@ struct MissingFeatures { static bool loopInfoStack() { return false; } static bool lowerAggregateLoadStore() { return false; } static bool lowerModeOptLevel() { return false; } + static bool loweringPrepareX86CXXABI() { return false; } + static bool loweringPrepareAArch64XXABI() { return false; } static bool maybeHandleStaticInExternC() { return false; } static bool mergeAllConstants() { return false; } static bool metaDataNode() { return false; } diff --git a/clang/include/clang/Driver/Distro.h b/clang/include/clang/Driver/Distro.h index 5c25592..008de0d 100644 --- a/clang/include/clang/Driver/Distro.h +++ b/clang/include/clang/Driver/Distro.h @@ -48,11 +48,6 @@ public: Fedora, Gentoo, OpenSUSE, - UbuntuHardy, - UbuntuIntrepid, - UbuntuJaunty, - UbuntuKarmic, - UbuntuLucid, UbuntuMaverick, UbuntuNatty, UbuntuOneiric, @@ -135,7 +130,7 @@ public: } bool IsUbuntu() const { - return DistroVal >= UbuntuHardy && DistroVal <= UbuntuQuesting; + return DistroVal >= UbuntuMaverick && DistroVal <= UbuntuQuesting; } bool IsAlpineLinux() const { return DistroVal == AlpineLinux; } diff --git a/clang/include/clang/Parse/Parser.h b/clang/include/clang/Parse/Parser.h index e301cf1..0d2316f 100644 --- a/clang/include/clang/Parse/Parser.h +++ b/clang/include/clang/Parse/Parser.h @@ -2173,7 +2173,7 @@ private: if (Tok.is(tok::kw___attribute)) { ParsedAttributes Attrs(AttrFactory); ParseGNUAttributes(Attrs, LateAttrs, &D); - D.takeAttributes(Attrs); + D.takeAttributesAppending(Attrs); } } @@ -2272,7 +2272,7 @@ private: if (isAllowedCXX11AttributeSpecifier()) { ParsedAttributes Attrs(AttrFactory); ParseCXX11Attributes(Attrs); - D.takeAttributes(Attrs); + D.takeAttributesAppending(Attrs); } } @@ -2292,7 +2292,7 @@ private: ParsedAttributes AttrsWithRange(AttrFactory); ParseMicrosoftAttributes(AttrsWithRange); AttrsParsed = !AttrsWithRange.empty(); - Attrs.takeAllFrom(AttrsWithRange); + Attrs.takeAllAppendingFrom(AttrsWithRange); } return AttrsParsed; } @@ -5175,7 +5175,7 @@ private: if (Tok.is(tok::colon)) { ParsedAttributes Attrs(AttrFactory); ParseHLSLAnnotations(Attrs, EndLoc, CouldBeBitField); - D.takeAttributes(Attrs); + D.takeAttributesAppending(Attrs); return true; } return false; diff --git a/clang/include/clang/Sema/DeclSpec.h b/clang/include/clang/Sema/DeclSpec.h index c1a99a1..43a48c9 100644 --- a/clang/include/clang/Sema/DeclSpec.h +++ b/clang/include/clang/Sema/DeclSpec.h @@ -835,7 +835,7 @@ public: /// \endcode /// void addAttributes(const ParsedAttributesView &AL) { - Attrs.addAll(AL.begin(), AL.end()); + Attrs.prepend(AL.begin(), AL.end()); } bool hasAttributes() const { return !Attrs.empty(); } @@ -843,8 +843,8 @@ public: ParsedAttributes &getAttributes() { return Attrs; } const ParsedAttributes &getAttributes() const { return Attrs; } - void takeAttributesFrom(ParsedAttributes &attrs) { - Attrs.takeAllFrom(attrs); + void takeAttributesAppendingingFrom(ParsedAttributes &attrs) { + Attrs.takeAllAppendingFrom(attrs); } /// Finish - This does final analysis of the declspec, issuing diagnostics for @@ -2327,7 +2327,7 @@ public: void AddTypeInfo(const DeclaratorChunk &TI, ParsedAttributes &&attrs, SourceLocation EndLoc) { DeclTypeInfo.push_back(TI); - DeclTypeInfo.back().getAttrs().addAll(attrs.begin(), attrs.end()); + DeclTypeInfo.back().getAttrs().prepend(attrs.begin(), attrs.end()); getAttributePool().takeAllFrom(attrs.getPool()); if (!EndLoc.isInvalid()) @@ -2638,8 +2638,8 @@ public: return InventedTemplateParameterList; } - /// takeAttributes - Takes attributes from the given parsed-attributes - /// set and add them to this declarator. + /// takeAttributesAppending - Takes attributes from the given + /// ParsedAttributes set and add them to this declarator. /// /// These examples both add 3 attributes to "var": /// short int var __attribute__((aligned(16),common,deprecated)); @@ -2647,8 +2647,8 @@ public: /// __attribute__((common,deprecated)); /// /// Also extends the range of the declarator. - void takeAttributes(ParsedAttributes &attrs) { - Attrs.takeAllFrom(attrs); + void takeAttributesAppending(ParsedAttributes &attrs) { + Attrs.takeAllAppendingFrom(attrs); if (attrs.Range.getEnd().isValid()) SetRangeEnd(attrs.Range.getEnd()); diff --git a/clang/include/clang/Sema/ParsedAttr.h b/clang/include/clang/Sema/ParsedAttr.h index 2edee7e..5387f9f 100644 --- a/clang/include/clang/Sema/ParsedAttr.h +++ b/clang/include/clang/Sema/ParsedAttr.h @@ -856,19 +856,19 @@ public: friend class ParsedAttributesView; }; - void addAll(iterator B, iterator E) { + void prepend(iterator B, iterator E) { AttrList.insert(AttrList.begin(), B.I, E.I); } - void addAll(const_iterator B, const_iterator E) { + void prepend(const_iterator B, const_iterator E) { AttrList.insert(AttrList.begin(), B.I, E.I); } - void addAllAtEnd(iterator B, iterator E) { + void append(iterator B, iterator E) { AttrList.insert(AttrList.end(), B.I, E.I); } - void addAllAtEnd(const_iterator B, const_iterator E) { + void append(const_iterator B, const_iterator E) { AttrList.insert(AttrList.end(), B.I, E.I); } @@ -943,18 +943,18 @@ public: AttributePool &getPool() const { return pool; } - void takeAllFrom(ParsedAttributes &Other) { + void takeAllPrependingFrom(ParsedAttributes &Other) { assert(&Other != this && "ParsedAttributes can't take attributes from itself"); - addAll(Other.begin(), Other.end()); + prepend(Other.begin(), Other.end()); Other.clearListOnly(); pool.takeAllFrom(Other.pool); } - void takeAllAtEndFrom(ParsedAttributes &Other) { + void takeAllAppendingFrom(ParsedAttributes &Other) { assert(&Other != this && "ParsedAttributes can't take attributes from itself"); - addAllAtEnd(Other.begin(), Other.end()); + append(Other.begin(), Other.end()); Other.clearListOnly(); pool.takeAllFrom(Other.pool); } diff --git a/clang/include/clang/Sema/SemaOpenACC.h b/clang/include/clang/Sema/SemaOpenACC.h index 09fdf75..16e7f1b 100644 --- a/clang/include/clang/Sema/SemaOpenACC.h +++ b/clang/include/clang/Sema/SemaOpenACC.h @@ -228,6 +228,11 @@ private: bool DiagnoseAllowedClauses(OpenACCDirectiveKind DK, OpenACCClauseKind CK, SourceLocation ClauseLoc); + bool CreateReductionCombinerRecipe( + SourceLocation loc, OpenACCReductionOperator ReductionOperator, + QualType VarTy, + llvm::SmallVectorImpl<OpenACCReductionRecipe::CombinerRecipe> + &CombinerRecipes); public: // Needed from the visitor, so should be public. @@ -911,6 +916,7 @@ public: ExprResult CheckReductionVar(OpenACCDirectiveKind DirectiveKind, OpenACCReductionOperator ReductionOp, Expr *VarExpr); + bool CheckReductionVarType(Expr *VarExpr); /// Called to check the 'var' type is a variable of pointer type, necessary /// for 'deviceptr' and 'attach' clauses. Returns true on success. diff --git a/clang/include/clang/StaticAnalyzer/Core/PathSensitive/EntryPointStats.h b/clang/include/clang/StaticAnalyzer/Core/PathSensitive/EntryPointStats.h index 448e402..389f17d 100644 --- a/clang/include/clang/StaticAnalyzer/Core/PathSensitive/EntryPointStats.h +++ b/clang/include/clang/StaticAnalyzer/Core/PathSensitive/EntryPointStats.h @@ -42,19 +42,6 @@ private: llvm::StringLiteral Name; }; -class BoolEPStat : public EntryPointStat { - std::optional<bool> Value = {}; - -public: - explicit BoolEPStat(llvm::StringLiteral Name); - unsigned value() const { return Value && *Value; } - void set(bool V) { - assert(!Value.has_value()); - Value = V; - } - void reset() { Value = {}; } -}; - // used by CounterEntryPointTranslationUnitStat class CounterEPStat : public EntryPointStat { using EntryPointStat::EntryPointStat; diff --git a/clang/lib/AST/Expr.cpp b/clang/lib/AST/Expr.cpp index f899b3c..597cbd8 100644 --- a/clang/lib/AST/Expr.cpp +++ b/clang/lib/AST/Expr.cpp @@ -5290,6 +5290,33 @@ QualType ArraySectionExpr::getBaseOriginalType(const Expr *Base) { return OriginalTy; } +QualType ArraySectionExpr::getElementType() const { + QualType BaseTy = getBase()->IgnoreParenImpCasts()->getType(); + // We only have to look into the array section exprs, else we will get the + // type of the base, which should already be valid. + if (auto *ASE = dyn_cast<ArraySectionExpr>(getBase()->IgnoreParenImpCasts())) + BaseTy = ASE->getElementType(); + + if (BaseTy->isAnyPointerType()) + return BaseTy->getPointeeType(); + if (BaseTy->isArrayType()) + return BaseTy->castAsArrayTypeUnsafe()->getElementType(); + + // If this isn't a pointer or array, the base is a dependent expression, so + // just return the BaseTy anyway. + assert(BaseTy->isInstantiationDependentType()); + return BaseTy; +} + +QualType ArraySectionExpr::getBaseType() const { + // We only have to look into the array section exprs, else we will get the + // type of the base, which should already be valid. + if (auto *ASE = dyn_cast<ArraySectionExpr>(getBase()->IgnoreParenImpCasts())) + return ASE->getElementType(); + + return getBase()->IgnoreParenImpCasts()->getType(); +} + RecoveryExpr::RecoveryExpr(ASTContext &Ctx, QualType T, SourceLocation BeginLoc, SourceLocation EndLoc, ArrayRef<Expr *> SubExprs) : Expr(RecoveryExprClass, T.getNonReferenceType(), diff --git a/clang/lib/CIR/CodeGen/CIRGenBuilder.h b/clang/lib/CIR/CodeGen/CIRGenBuilder.h index 25afe8b..a6f10e6 100644 --- a/clang/lib/CIR/CodeGen/CIRGenBuilder.h +++ b/clang/lib/CIR/CodeGen/CIRGenBuilder.h @@ -319,12 +319,6 @@ public: return cir::ConstantOp::create(*this, loc, cir::IntAttr::get(sInt64Ty, c)); } - // Creates constant nullptr for pointer type ty. - cir::ConstantOp getNullPtr(mlir::Type ty, mlir::Location loc) { - assert(!cir::MissingFeatures::targetCodeGenInfoGetNullPointer()); - return cir::ConstantOp::create(*this, loc, getConstPtrAttr(ty, 0)); - } - mlir::Value createNeg(mlir::Value value) { if (auto intTy = mlir::dyn_cast<cir::IntType>(value.getType())) { diff --git a/clang/lib/CIR/CodeGen/CIRGenException.cpp b/clang/lib/CIR/CodeGen/CIRGenException.cpp index 6453843..f9ff37b 100644 --- a/clang/lib/CIR/CodeGen/CIRGenException.cpp +++ b/clang/lib/CIR/CodeGen/CIRGenException.cpp @@ -64,3 +64,11 @@ void CIRGenFunction::emitAnyExprToExn(const Expr *e, Address addr) { // Deactivate the cleanup block. assert(!cir::MissingFeatures::ehCleanupScope()); } + +mlir::LogicalResult CIRGenFunction::emitCXXTryStmt(const CXXTryStmt &s) { + if (s.getTryBlock()->body_empty()) + return mlir::LogicalResult::success(); + + cgm.errorNYI("exitCXXTryStmt: CXXTryStmt with non-empty body"); + return mlir::LogicalResult::success(); +} diff --git a/clang/lib/CIR/CodeGen/CIRGenFunction.h b/clang/lib/CIR/CodeGen/CIRGenFunction.h index 7a606ee..d71de2f 100644 --- a/clang/lib/CIR/CodeGen/CIRGenFunction.h +++ b/clang/lib/CIR/CodeGen/CIRGenFunction.h @@ -1297,6 +1297,8 @@ public: void emitCXXThrowExpr(const CXXThrowExpr *e); + mlir::LogicalResult emitCXXTryStmt(const clang::CXXTryStmt &s); + void emitCtorPrologue(const clang::CXXConstructorDecl *ctor, clang::CXXCtorType ctorType, FunctionArgList &args); diff --git a/clang/lib/CIR/CodeGen/CIRGenOpenACC.cpp b/clang/lib/CIR/CodeGen/CIRGenOpenACC.cpp index 4cf2237..5ba6bcb 100644 --- a/clang/lib/CIR/CodeGen/CIRGenOpenACC.cpp +++ b/clang/lib/CIR/CodeGen/CIRGenOpenACC.cpp @@ -73,7 +73,7 @@ CIRGenFunction::getOpenACCDataOperandInfo(const Expr *e) { // Array sections are special, and we have to treat them that way. if (const auto *section = dyn_cast<ArraySectionExpr>(curVarExpr->IgnoreParenImpCasts())) - origType = ArraySectionExpr::getBaseOriginalType(section); + origType = section->getElementType(); mlir::Location exprLoc = cgm.getLoc(curVarExpr->getBeginLoc()); llvm::SmallVector<mlir::Value> bounds; @@ -84,16 +84,10 @@ CIRGenFunction::getOpenACCDataOperandInfo(const Expr *e) { e->printPretty(os, nullptr, getContext().getPrintingPolicy()); auto addBoundType = [&](const Expr *e) { - if (const auto *section = dyn_cast<ArraySectionExpr>(curVarExpr)) { - QualType baseTy = ArraySectionExpr::getBaseOriginalType( - section->getBase()->IgnoreParenImpCasts()); - if (auto *at = getContext().getAsArrayType(baseTy)) - boundTypes.push_back(at->getElementType()); - else - boundTypes.push_back(baseTy->getPointeeType()); - } else { + if (const auto *section = dyn_cast<ArraySectionExpr>(curVarExpr)) + boundTypes.push_back(section->getElementType()); + else boundTypes.push_back(curVarExpr->getType()); - } }; addBoundType(curVarExpr); @@ -113,8 +107,7 @@ CIRGenFunction::getOpenACCDataOperandInfo(const Expr *e) { if (const Expr *len = section->getLength()) { extent = emitOpenACCIntExpr(len); } else { - QualType baseTy = ArraySectionExpr::getBaseOriginalType( - section->getBase()->IgnoreParenImpCasts()); + QualType baseTy = section->getBaseType(); // We know this is the case as implicit lengths are only allowed for // array types with a constant size, or a dependent size. AND since // we are codegen we know we're not dependent. diff --git a/clang/lib/CIR/CodeGen/CIRGenStmt.cpp b/clang/lib/CIR/CodeGen/CIRGenStmt.cpp index 0b8f8bf..cfd48a2 100644 --- a/clang/lib/CIR/CodeGen/CIRGenStmt.cpp +++ b/clang/lib/CIR/CodeGen/CIRGenStmt.cpp @@ -154,6 +154,8 @@ mlir::LogicalResult CIRGenFunction::emitStmt(const Stmt *s, return emitWhileStmt(cast<WhileStmt>(*s)); case Stmt::DoStmtClass: return emitDoStmt(cast<DoStmt>(*s)); + case Stmt::CXXTryStmtClass: + return emitCXXTryStmt(cast<CXXTryStmt>(*s)); case Stmt::CXXForRangeStmtClass: return emitCXXForRangeStmt(cast<CXXForRangeStmt>(*s), attr); case Stmt::OpenACCComputeConstructClass: @@ -199,7 +201,6 @@ mlir::LogicalResult CIRGenFunction::emitStmt(const Stmt *s, case Stmt::CoroutineBodyStmtClass: return emitCoroutineBody(cast<CoroutineBodyStmt>(*s)); case Stmt::CoreturnStmtClass: - case Stmt::CXXTryStmtClass: case Stmt::IndirectGotoStmtClass: case Stmt::OMPParallelDirectiveClass: case Stmt::OMPTaskwaitDirectiveClass: diff --git a/clang/lib/CIR/Dialect/Transforms/CMakeLists.txt b/clang/lib/CIR/Dialect/Transforms/CMakeLists.txt index df7a1a3..3fc5b06 100644 --- a/clang/lib/CIR/Dialect/Transforms/CMakeLists.txt +++ b/clang/lib/CIR/Dialect/Transforms/CMakeLists.txt @@ -4,6 +4,7 @@ add_clang_library(MLIRCIRTransforms FlattenCFG.cpp HoistAllocas.cpp LoweringPrepare.cpp + LoweringPrepareItaniumCXXABI.cpp GotoSolver.cpp DEPENDS diff --git a/clang/lib/CIR/Dialect/Transforms/LoweringPrepare.cpp b/clang/lib/CIR/Dialect/Transforms/LoweringPrepare.cpp index 706e54f..dbff0b9 100644 --- a/clang/lib/CIR/Dialect/Transforms/LoweringPrepare.cpp +++ b/clang/lib/CIR/Dialect/Transforms/LoweringPrepare.cpp @@ -6,6 +6,7 @@ // //===----------------------------------------------------------------------===// +#include "LoweringPrepareCXXABI.h" #include "PassDetail.h" #include "clang/AST/ASTContext.h" #include "clang/Basic/Module.h" @@ -62,6 +63,7 @@ struct LoweringPreparePass : public LoweringPrepareBase<LoweringPreparePass> { void lowerComplexMulOp(cir::ComplexMulOp op); void lowerUnaryOp(cir::UnaryOp op); void lowerGlobalOp(cir::GlobalOp op); + void lowerDynamicCastOp(cir::DynamicCastOp op); void lowerArrayDtor(cir::ArrayDtor op); void lowerArrayCtor(cir::ArrayCtor op); @@ -91,6 +93,9 @@ struct LoweringPreparePass : public LoweringPrepareBase<LoweringPreparePass> { clang::ASTContext *astCtx; + // Helper for lowering C++ ABI specific operations. + std::shared_ptr<cir::LoweringPrepareCXXABI> cxxABI; + /// Tracks current module. mlir::ModuleOp mlirModule; @@ -101,7 +106,24 @@ struct LoweringPreparePass : public LoweringPrepareBase<LoweringPreparePass> { /// 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; } + void setASTContext(clang::ASTContext *c) { + astCtx = c; + switch (c->getCXXABIKind()) { + case clang::TargetCXXABI::GenericItanium: + // We'll need X86-specific support for handling vaargs lowering, but for + // now the Itanium ABI will work. + assert(!cir::MissingFeatures::loweringPrepareX86CXXABI()); + cxxABI.reset(cir::LoweringPrepareCXXABI::createItaniumABI()); + break; + case clang::TargetCXXABI::GenericAArch64: + case clang::TargetCXXABI::AppleARM64: + assert(!cir::MissingFeatures::loweringPrepareAArch64XXABI()); + cxxABI.reset(cir::LoweringPrepareCXXABI::createItaniumABI()); + break; + default: + llvm_unreachable("NYI"); + } + } }; } // namespace @@ -850,6 +872,17 @@ void LoweringPreparePass::buildCXXGlobalInitFunc() { cir::ReturnOp::create(builder, f.getLoc()); } +void LoweringPreparePass::lowerDynamicCastOp(DynamicCastOp op) { + CIRBaseBuilderTy builder(getContext()); + builder.setInsertionPointAfter(op); + + assert(astCtx && "AST context is not available during lowering prepare"); + auto loweredValue = cxxABI->lowerDynamicCast(builder, *astCtx, op); + + op.replaceAllUsesWith(loweredValue); + op.erase(); +} + static void lowerArrayDtorCtorIntoLoop(cir::CIRBaseBuilderTy &builder, clang::ASTContext *astCtx, mlir::Operation *op, mlir::Type eltTy, @@ -954,6 +987,8 @@ void LoweringPreparePass::runOnOp(mlir::Operation *op) { lowerComplexMulOp(complexMul); else if (auto glob = mlir::dyn_cast<cir::GlobalOp>(op)) lowerGlobalOp(glob); + else if (auto dynamicCast = mlir::dyn_cast<cir::DynamicCastOp>(op)) + lowerDynamicCastOp(dynamicCast); else if (auto unary = mlir::dyn_cast<cir::UnaryOp>(op)) lowerUnaryOp(unary); } @@ -967,8 +1002,8 @@ void LoweringPreparePass::runOnOperation() { op->walk([&](mlir::Operation *op) { if (mlir::isa<cir::ArrayCtor, cir::ArrayDtor, cir::CastOp, - cir::ComplexMulOp, cir::ComplexDivOp, cir::GlobalOp, - cir::UnaryOp>(op)) + cir::ComplexMulOp, cir::ComplexDivOp, cir::DynamicCastOp, + cir::GlobalOp, cir::UnaryOp>(op)) opsToTransform.push_back(op); }); diff --git a/clang/lib/CIR/Dialect/Transforms/LoweringPrepareCXXABI.h b/clang/lib/CIR/Dialect/Transforms/LoweringPrepareCXXABI.h new file mode 100644 index 0000000..2582c332 --- /dev/null +++ b/clang/lib/CIR/Dialect/Transforms/LoweringPrepareCXXABI.h @@ -0,0 +1,38 @@ +//===----------------------------------------------------------------------===// +// +// 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 provides the LoweringPrepareCXXABI class, which is the base class +// for ABI specific functionalities that are required during LLVM lowering +// prepare. +// +//===----------------------------------------------------------------------===// + +#ifndef CIR_DIALECT_TRANSFORMS__LOWERINGPREPARECXXABI_H +#define CIR_DIALECT_TRANSFORMS__LOWERINGPREPARECXXABI_H + +#include "mlir/IR/Value.h" +#include "clang/AST/ASTContext.h" +#include "clang/CIR/Dialect/Builder/CIRBaseBuilder.h" +#include "clang/CIR/Dialect/IR/CIRDialect.h" + +namespace cir { + +class LoweringPrepareCXXABI { +public: + static LoweringPrepareCXXABI *createItaniumABI(); + + virtual ~LoweringPrepareCXXABI() {} + + virtual mlir::Value lowerDynamicCast(CIRBaseBuilderTy &builder, + clang::ASTContext &astCtx, + cir::DynamicCastOp op) = 0; +}; + +} // namespace cir + +#endif // CIR_DIALECT_TRANSFORMS__LOWERINGPREPARECXXABI_H diff --git a/clang/lib/CIR/Dialect/Transforms/LoweringPrepareItaniumCXXABI.cpp b/clang/lib/CIR/Dialect/Transforms/LoweringPrepareItaniumCXXABI.cpp new file mode 100644 index 0000000..7d3c711 --- /dev/null +++ b/clang/lib/CIR/Dialect/Transforms/LoweringPrepareItaniumCXXABI.cpp @@ -0,0 +1,126 @@ +//===--------------------------------------------------------------------===// +// +// 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 provides Itanium C++ ABI specific code +// that is used during LLVMIR lowering prepare. +// +//===--------------------------------------------------------------------===// + +#include "LoweringPrepareCXXABI.h" +#include "mlir/IR/BuiltinAttributes.h" +#include "mlir/IR/Value.h" +#include "mlir/IR/ValueRange.h" +#include "clang/Basic/TargetInfo.h" +#include "clang/CIR/Dialect/Builder/CIRBaseBuilder.h" +#include "clang/CIR/Dialect/IR/CIRAttrs.h" +#include "clang/CIR/Dialect/IR/CIRDataLayout.h" +#include "clang/CIR/Dialect/IR/CIRDialect.h" +#include "clang/CIR/MissingFeatures.h" + +class LoweringPrepareItaniumCXXABI : public cir::LoweringPrepareCXXABI { +public: + mlir::Value lowerDynamicCast(cir::CIRBaseBuilderTy &builder, + clang::ASTContext &astCtx, + cir::DynamicCastOp op) override; +}; + +cir::LoweringPrepareCXXABI *cir::LoweringPrepareCXXABI::createItaniumABI() { + return new LoweringPrepareItaniumCXXABI(); +} + +static void buildBadCastCall(cir::CIRBaseBuilderTy &builder, mlir::Location loc, + mlir::FlatSymbolRefAttr badCastFuncRef) { + builder.createCallOp(loc, badCastFuncRef, cir::VoidType(), + mlir::ValueRange{}); + // TODO(cir): Set the 'noreturn' attribute on the function. + assert(!cir::MissingFeatures::opFuncNoReturn()); + cir::UnreachableOp::create(builder, loc); + builder.clearInsertionPoint(); +} + +static mlir::Value +buildDynamicCastAfterNullCheck(cir::CIRBaseBuilderTy &builder, + cir::DynamicCastOp op) { + mlir::Location loc = op->getLoc(); + mlir::Value srcValue = op.getSrc(); + cir::DynamicCastInfoAttr castInfo = op.getInfo().value(); + + // TODO(cir): consider address space + assert(!cir::MissingFeatures::addressSpace()); + + mlir::Value srcPtr = builder.createBitcast(srcValue, builder.getVoidPtrTy()); + cir::ConstantOp srcRtti = builder.getConstant(loc, castInfo.getSrcRtti()); + cir::ConstantOp destRtti = builder.getConstant(loc, castInfo.getDestRtti()); + cir::ConstantOp offsetHint = + builder.getConstant(loc, castInfo.getOffsetHint()); + + mlir::FlatSymbolRefAttr dynCastFuncRef = castInfo.getRuntimeFunc(); + mlir::Value dynCastFuncArgs[4] = {srcPtr, srcRtti, destRtti, offsetHint}; + + mlir::Value castedPtr = + builder + .createCallOp(loc, dynCastFuncRef, builder.getVoidPtrTy(), + dynCastFuncArgs) + .getResult(); + + assert(mlir::isa<cir::PointerType>(castedPtr.getType()) && + "the return value of __dynamic_cast should be a ptr"); + + /// C++ [expr.dynamic.cast]p9: + /// A failed cast to reference type throws std::bad_cast + if (op.isRefCast()) { + // Emit a cir.if that checks the casted value. + mlir::Value castedValueIsNull = builder.createPtrIsNull(castedPtr); + builder.create<cir::IfOp>( + loc, castedValueIsNull, false, [&](mlir::OpBuilder &, mlir::Location) { + buildBadCastCall(builder, loc, castInfo.getBadCastFunc()); + }); + } + + // Note that castedPtr is a void*. Cast it to a pointer to the destination + // type before return. + return builder.createBitcast(castedPtr, op.getType()); +} + +static mlir::Value +buildDynamicCastToVoidAfterNullCheck(cir::CIRBaseBuilderTy &builder, + clang::ASTContext &astCtx, + cir::DynamicCastOp op) { + llvm_unreachable("dynamic cast to void is NYI"); +} + +mlir::Value +LoweringPrepareItaniumCXXABI::lowerDynamicCast(cir::CIRBaseBuilderTy &builder, + clang::ASTContext &astCtx, + cir::DynamicCastOp op) { + mlir::Location loc = op->getLoc(); + mlir::Value srcValue = op.getSrc(); + + assert(!cir::MissingFeatures::emitTypeCheck()); + + if (op.isRefCast()) + return buildDynamicCastAfterNullCheck(builder, op); + + mlir::Value srcValueIsNotNull = builder.createPtrToBoolCast(srcValue); + return builder + .create<cir::TernaryOp>( + loc, srcValueIsNotNull, + [&](mlir::OpBuilder &, mlir::Location) { + mlir::Value castedValue = + op.isCastToVoid() + ? buildDynamicCastToVoidAfterNullCheck(builder, astCtx, op) + : buildDynamicCastAfterNullCheck(builder, op); + builder.createYield(loc, castedValue); + }, + [&](mlir::OpBuilder &, mlir::Location) { + builder.createYield( + loc, builder.getNullPtr(op.getType(), loc).getResult()); + }) + .getResult(); +} diff --git a/clang/lib/CIR/Lowering/DirectToLLVM/LowerToLLVM.cpp b/clang/lib/CIR/Lowering/DirectToLLVM/LowerToLLVM.cpp index a1ecfc7..26e0ba9 100644 --- a/clang/lib/CIR/Lowering/DirectToLLVM/LowerToLLVM.cpp +++ b/clang/lib/CIR/Lowering/DirectToLLVM/LowerToLLVM.cpp @@ -1739,7 +1739,6 @@ mlir::LogicalResult CIRToLLVMGlobalOpLowering::matchAndRewrite( const mlir::LLVM::Linkage linkage = convertLinkage(op.getLinkage()); const StringRef symbol = op.getSymName(); SmallVector<mlir::NamedAttribute> attributes; - mlir::SymbolRefAttr comdatAttr = getComdatAttr(op, rewriter); if (init.has_value()) { if (mlir::isa<cir::FPAttr, cir::IntAttr, cir::BoolAttr>(init.value())) { @@ -1771,6 +1770,7 @@ mlir::LogicalResult CIRToLLVMGlobalOpLowering::matchAndRewrite( } // Rewrite op. + mlir::SymbolRefAttr comdatAttr = getComdatAttr(op, rewriter); auto newOp = rewriter.replaceOpWithNewOp<mlir::LLVM::GlobalOp>( op, llvmType, isConst, linkage, symbol, init.value_or(mlir::Attribute()), alignment, addrSpace, isDsoLocal, isThreadLocal, comdatAttr, attributes); diff --git a/clang/lib/CodeGen/CGCall.cpp b/clang/lib/CodeGen/CGCall.cpp index c5371e4..df28641 100644 --- a/clang/lib/CodeGen/CGCall.cpp +++ b/clang/lib/CodeGen/CGCall.cpp @@ -2012,13 +2012,6 @@ static void getTrivialDefaultFunctionAttributes( FuncAttrs.addAttribute("no-infs-fp-math", "true"); if (LangOpts.NoHonorNaNs) FuncAttrs.addAttribute("no-nans-fp-math", "true"); - if (LangOpts.AllowFPReassoc && LangOpts.AllowRecip && - LangOpts.NoSignedZero && LangOpts.ApproxFunc && - (LangOpts.getDefaultFPContractMode() == - LangOptions::FPModeKind::FPM_Fast || - LangOpts.getDefaultFPContractMode() == - LangOptions::FPModeKind::FPM_FastHonorPragmas)) - FuncAttrs.addAttribute("unsafe-fp-math", "true"); if (CodeGenOpts.SoftFloat) FuncAttrs.addAttribute("use-soft-float", "true"); FuncAttrs.addAttribute("stack-protector-buffer-size", diff --git a/clang/lib/CodeGen/CGCall.h b/clang/lib/CodeGen/CGCall.h index 935b508..1ef8a3f 100644 --- a/clang/lib/CodeGen/CGCall.h +++ b/clang/lib/CodeGen/CGCall.h @@ -410,10 +410,10 @@ public: /// This is useful for adding attrs to bitcode modules that you want to link /// with but don't control, such as CUDA's libdevice. When linking with such /// a bitcode library, you might want to set e.g. its functions' -/// "unsafe-fp-math" attribute to match the attr of the functions you're +/// "denormal-fp-math" attribute to match the attr of the functions you're /// codegen'ing. Otherwise, LLVM will interpret the bitcode module's lack of -/// unsafe-fp-math attrs as tantamount to unsafe-fp-math=false, and then LLVM -/// will propagate unsafe-fp-math=false up to every transitive caller of a +/// denormal-fp-math attrs as tantamount to denormal-fp-math=ieee, and then LLVM +/// will propagate denormal-fp-math=ieee up to every transitive caller of a /// function in the bitcode library! /// /// With the exception of fast-math attrs, this will only make the attributes diff --git a/clang/lib/CodeGen/CodeGenFunction.cpp b/clang/lib/CodeGen/CodeGenFunction.cpp index acf8de4..8862853 100644 --- a/clang/lib/CodeGen/CodeGenFunction.cpp +++ b/clang/lib/CodeGen/CodeGenFunction.cpp @@ -183,11 +183,6 @@ void CodeGenFunction::CGFPOptionsRAII::ConstructorHelper(FPOptions FPFeatures) { mergeFnAttrValue("no-infs-fp-math", FPFeatures.getNoHonorInfs()); mergeFnAttrValue("no-nans-fp-math", FPFeatures.getNoHonorNaNs()); mergeFnAttrValue("no-signed-zeros-fp-math", FPFeatures.getNoSignedZero()); - mergeFnAttrValue( - "unsafe-fp-math", - FPFeatures.getAllowFPReassociate() && FPFeatures.getAllowReciprocal() && - FPFeatures.getAllowApproxFunc() && FPFeatures.getNoSignedZero() && - FPFeatures.allowFPContractAcrossStatement()); } CodeGenFunction::CGFPOptionsRAII::~CGFPOptionsRAII() { diff --git a/clang/lib/CodeGen/TargetBuiltins/AMDGPU.cpp b/clang/lib/CodeGen/TargetBuiltins/AMDGPU.cpp index 6596ec0..5049a0a 100644 --- a/clang/lib/CodeGen/TargetBuiltins/AMDGPU.cpp +++ b/clang/lib/CodeGen/TargetBuiltins/AMDGPU.cpp @@ -11,8 +11,11 @@ //===----------------------------------------------------------------------===// #include "CGBuiltin.h" +#include "CodeGenFunction.h" #include "clang/Basic/TargetBuiltins.h" +#include "clang/Frontend/FrontendDiagnostic.h" #include "llvm/Analysis/ValueTracking.h" +#include "llvm/CodeGen/MachineFunction.h" #include "llvm/IR/IntrinsicsAMDGPU.h" #include "llvm/IR/IntrinsicsR600.h" #include "llvm/IR/MemoryModelRelaxationAnnotations.h" @@ -181,6 +184,74 @@ static Value *EmitAMDGCNBallotForExec(CodeGenFunction &CGF, const CallExpr *E, return Call; } +static llvm::Value *loadTextureDescPtorAsVec8I32(CodeGenFunction &CGF, + llvm::Value *RsrcPtr) { + auto &B = CGF.Builder; + auto *VecTy = llvm::FixedVectorType::get(B.getInt32Ty(), 8); + + if (RsrcPtr->getType() == VecTy) + return RsrcPtr; + + if (RsrcPtr->getType()->isIntegerTy(32)) { + llvm::PointerType *VecPtrTy = + llvm::PointerType::get(CGF.getLLVMContext(), 8); + llvm::Value *Ptr = B.CreateIntToPtr(RsrcPtr, VecPtrTy, "tex.rsrc.from.int"); + return B.CreateAlignedLoad(VecTy, Ptr, llvm::Align(32), "tex.rsrc.val"); + } + + if (RsrcPtr->getType()->isPointerTy()) { + auto *VecPtrTy = llvm::PointerType::get( + CGF.getLLVMContext(), RsrcPtr->getType()->getPointerAddressSpace()); + llvm::Value *Typed = B.CreateBitCast(RsrcPtr, VecPtrTy, "tex.rsrc.typed"); + return B.CreateAlignedLoad(VecTy, Typed, llvm::Align(32), "tex.rsrc.val"); + } + + const auto &DL = CGF.CGM.getDataLayout(); + if (DL.getTypeSizeInBits(RsrcPtr->getType()) == 256) + return B.CreateBitCast(RsrcPtr, VecTy, "tex.rsrc.val"); + + llvm::report_fatal_error("Unexpected texture resource argument form"); +} + +llvm::CallInst * +emitAMDGCNImageOverloadedReturnType(clang::CodeGen::CodeGenFunction &CGF, + const clang::CallExpr *E, + unsigned IntrinsicID, bool IsImageStore) { + auto findTextureDescIndex = [&CGF](const CallExpr *E) -> unsigned { + QualType TexQT = CGF.getContext().AMDGPUTextureTy; + for (unsigned I = 0, N = E->getNumArgs(); I < N; ++I) { + QualType ArgTy = E->getArg(I)->getType(); + if (ArgTy == TexQT) { + return I; + } + + if (ArgTy.getCanonicalType() == TexQT.getCanonicalType()) { + return I; + } + } + + return ~0U; + }; + + clang::SmallVector<llvm::Value *, 10> Args; + unsigned RsrcIndex = findTextureDescIndex(E); + + if (RsrcIndex == ~0U) { + llvm::report_fatal_error("Invalid argument count for image builtin"); + } + + for (unsigned I = 0; I < E->getNumArgs(); ++I) { + llvm::Value *V = CGF.EmitScalarExpr(E->getArg(I)); + if (I == RsrcIndex) + V = loadTextureDescPtorAsVec8I32(CGF, V); + Args.push_back(V); + } + + llvm::Type *RetTy = IsImageStore ? CGF.VoidTy : CGF.ConvertType(E->getType()); + llvm::CallInst *Call = CGF.Builder.CreateIntrinsic(RetTy, IntrinsicID, Args); + return Call; +} + // Emit an intrinsic that has 1 float or double operand, and 1 integer. static Value *emitFPIntBuiltin(CodeGenFunction &CGF, const CallExpr *E, @@ -937,6 +1008,136 @@ Value *CodeGenFunction::EmitAMDGPUBuiltinExpr(unsigned BuiltinID, return Builder.CreateInsertElement(I0, A, 1); } + case AMDGPU::BI__builtin_amdgcn_image_load_1d_v4f32_i32: + case AMDGPU::BI__builtin_amdgcn_image_load_1d_v4f16_i32: + return emitAMDGCNImageOverloadedReturnType( + *this, E, Intrinsic::amdgcn_image_load_1d, false); + case AMDGPU::BI__builtin_amdgcn_image_load_1darray_v4f32_i32: + case AMDGPU::BI__builtin_amdgcn_image_load_1darray_v4f16_i32: + return emitAMDGCNImageOverloadedReturnType( + *this, E, Intrinsic::amdgcn_image_load_1darray, false); + case AMDGPU::BI__builtin_amdgcn_image_load_2d_f32_i32: + case AMDGPU::BI__builtin_amdgcn_image_load_2d_v4f32_i32: + case AMDGPU::BI__builtin_amdgcn_image_load_2d_v4f16_i32: + return emitAMDGCNImageOverloadedReturnType( + *this, E, Intrinsic::amdgcn_image_load_2d, false); + case AMDGPU::BI__builtin_amdgcn_image_load_2darray_f32_i32: + case AMDGPU::BI__builtin_amdgcn_image_load_2darray_v4f32_i32: + case AMDGPU::BI__builtin_amdgcn_image_load_2darray_v4f16_i32: + return emitAMDGCNImageOverloadedReturnType( + *this, E, Intrinsic::amdgcn_image_load_2darray, false); + case AMDGPU::BI__builtin_amdgcn_image_load_3d_v4f32_i32: + case AMDGPU::BI__builtin_amdgcn_image_load_3d_v4f16_i32: + return emitAMDGCNImageOverloadedReturnType( + *this, E, Intrinsic::amdgcn_image_load_3d, false); + case AMDGPU::BI__builtin_amdgcn_image_load_cube_v4f32_i32: + case AMDGPU::BI__builtin_amdgcn_image_load_cube_v4f16_i32: + return emitAMDGCNImageOverloadedReturnType( + *this, E, Intrinsic::amdgcn_image_load_cube, false); + case AMDGPU::BI__builtin_amdgcn_image_load_mip_1d_v4f32_i32: + case AMDGPU::BI__builtin_amdgcn_image_load_mip_1d_v4f16_i32: + return emitAMDGCNImageOverloadedReturnType( + *this, E, Intrinsic::amdgcn_image_load_mip_1d, false); + case AMDGPU::BI__builtin_amdgcn_image_load_mip_1darray_v4f32_i32: + case AMDGPU::BI__builtin_amdgcn_image_load_mip_1darray_v4f16_i32: + return emitAMDGCNImageOverloadedReturnType( + *this, E, Intrinsic::amdgcn_image_load_mip_1darray, false); + case AMDGPU::BI__builtin_amdgcn_image_load_mip_2d_f32_i32: + case AMDGPU::BI__builtin_amdgcn_image_load_mip_2d_v4f32_i32: + case AMDGPU::BI__builtin_amdgcn_image_load_mip_2d_v4f16_i32: + return emitAMDGCNImageOverloadedReturnType( + *this, E, Intrinsic::amdgcn_image_load_mip_2d, false); + case AMDGPU::BI__builtin_amdgcn_image_load_mip_2darray_f32_i32: + case AMDGPU::BI__builtin_amdgcn_image_load_mip_2darray_v4f32_i32: + case AMDGPU::BI__builtin_amdgcn_image_load_mip_2darray_v4f16_i32: + return emitAMDGCNImageOverloadedReturnType( + *this, E, Intrinsic::amdgcn_image_load_mip_2darray, false); + case AMDGPU::BI__builtin_amdgcn_image_load_mip_3d_v4f32_i32: + case AMDGPU::BI__builtin_amdgcn_image_load_mip_3d_v4f16_i32: + return emitAMDGCNImageOverloadedReturnType( + *this, E, Intrinsic::amdgcn_image_load_mip_3d, false); + case AMDGPU::BI__builtin_amdgcn_image_load_mip_cube_v4f32_i32: + case AMDGPU::BI__builtin_amdgcn_image_load_mip_cube_v4f16_i32: + return emitAMDGCNImageOverloadedReturnType( + *this, E, Intrinsic::amdgcn_image_load_mip_cube, false); + case AMDGPU::BI__builtin_amdgcn_image_store_1d_v4f32_i32: + case AMDGPU::BI__builtin_amdgcn_image_store_1d_v4f16_i32: + return emitAMDGCNImageOverloadedReturnType( + *this, E, Intrinsic::amdgcn_image_store_1d, true); + case AMDGPU::BI__builtin_amdgcn_image_store_1darray_v4f32_i32: + case AMDGPU::BI__builtin_amdgcn_image_store_1darray_v4f16_i32: + return emitAMDGCNImageOverloadedReturnType( + *this, E, Intrinsic::amdgcn_image_store_1darray, true); + case AMDGPU::BI__builtin_amdgcn_image_store_2d_f32_i32: + case AMDGPU::BI__builtin_amdgcn_image_store_2d_v4f32_i32: + case AMDGPU::BI__builtin_amdgcn_image_store_2d_v4f16_i32: + return emitAMDGCNImageOverloadedReturnType( + *this, E, Intrinsic::amdgcn_image_store_2d, true); + case AMDGPU::BI__builtin_amdgcn_image_store_2darray_f32_i32: + case AMDGPU::BI__builtin_amdgcn_image_store_2darray_v4f32_i32: + case AMDGPU::BI__builtin_amdgcn_image_store_2darray_v4f16_i32: + return emitAMDGCNImageOverloadedReturnType( + *this, E, Intrinsic::amdgcn_image_store_2darray, true); + case AMDGPU::BI__builtin_amdgcn_image_store_3d_v4f32_i32: + case AMDGPU::BI__builtin_amdgcn_image_store_3d_v4f16_i32: + return emitAMDGCNImageOverloadedReturnType( + *this, E, Intrinsic::amdgcn_image_store_3d, true); + case AMDGPU::BI__builtin_amdgcn_image_store_cube_v4f32_i32: + case AMDGPU::BI__builtin_amdgcn_image_store_cube_v4f16_i32: + return emitAMDGCNImageOverloadedReturnType( + *this, E, Intrinsic::amdgcn_image_store_cube, true); + case AMDGPU::BI__builtin_amdgcn_image_store_mip_1d_v4f32_i32: + case AMDGPU::BI__builtin_amdgcn_image_store_mip_1d_v4f16_i32: + return emitAMDGCNImageOverloadedReturnType( + *this, E, Intrinsic::amdgcn_image_store_mip_1d, true); + case AMDGPU::BI__builtin_amdgcn_image_store_mip_1darray_v4f32_i32: + case AMDGPU::BI__builtin_amdgcn_image_store_mip_1darray_v4f16_i32: + return emitAMDGCNImageOverloadedReturnType( + *this, E, Intrinsic::amdgcn_image_store_mip_1darray, true); + case AMDGPU::BI__builtin_amdgcn_image_store_mip_2d_f32_i32: + case AMDGPU::BI__builtin_amdgcn_image_store_mip_2d_v4f32_i32: + case AMDGPU::BI__builtin_amdgcn_image_store_mip_2d_v4f16_i32: + return emitAMDGCNImageOverloadedReturnType( + *this, E, Intrinsic::amdgcn_image_store_mip_2d, true); + case AMDGPU::BI__builtin_amdgcn_image_store_mip_2darray_f32_i32: + case AMDGPU::BI__builtin_amdgcn_image_store_mip_2darray_v4f32_i32: + case AMDGPU::BI__builtin_amdgcn_image_store_mip_2darray_v4f16_i32: + return emitAMDGCNImageOverloadedReturnType( + *this, E, Intrinsic::amdgcn_image_store_mip_2darray, true); + case AMDGPU::BI__builtin_amdgcn_image_store_mip_3d_v4f32_i32: + case AMDGPU::BI__builtin_amdgcn_image_store_mip_3d_v4f16_i32: + return emitAMDGCNImageOverloadedReturnType( + *this, E, Intrinsic::amdgcn_image_store_mip_3d, true); + case AMDGPU::BI__builtin_amdgcn_image_store_mip_cube_v4f32_i32: + case AMDGPU::BI__builtin_amdgcn_image_store_mip_cube_v4f16_i32: + return emitAMDGCNImageOverloadedReturnType( + *this, E, Intrinsic::amdgcn_image_store_mip_cube, true); + case AMDGPU::BI__builtin_amdgcn_image_sample_1d_v4f32_f32: + case AMDGPU::BI__builtin_amdgcn_image_sample_1d_v4f16_f32: + return emitAMDGCNImageOverloadedReturnType( + *this, E, Intrinsic::amdgcn_image_sample_1d, false); + case AMDGPU::BI__builtin_amdgcn_image_sample_1darray_v4f32_f32: + case AMDGPU::BI__builtin_amdgcn_image_sample_1darray_v4f16_f32: + return emitAMDGCNImageOverloadedReturnType( + *this, E, Intrinsic::amdgcn_image_sample_1darray, false); + case AMDGPU::BI__builtin_amdgcn_image_sample_2d_f32_f32: + case AMDGPU::BI__builtin_amdgcn_image_sample_2d_v4f32_f32: + case AMDGPU::BI__builtin_amdgcn_image_sample_2d_v4f16_f32: + return emitAMDGCNImageOverloadedReturnType( + *this, E, Intrinsic::amdgcn_image_sample_2d, false); + case AMDGPU::BI__builtin_amdgcn_image_sample_2darray_f32_f32: + case AMDGPU::BI__builtin_amdgcn_image_sample_2darray_v4f32_f32: + case AMDGPU::BI__builtin_amdgcn_image_sample_2darray_v4f16_f32: + return emitAMDGCNImageOverloadedReturnType( + *this, E, Intrinsic::amdgcn_image_sample_2darray, false); + case AMDGPU::BI__builtin_amdgcn_image_sample_3d_v4f32_f32: + case AMDGPU::BI__builtin_amdgcn_image_sample_3d_v4f16_f32: + return emitAMDGCNImageOverloadedReturnType( + *this, E, Intrinsic::amdgcn_image_sample_3d, false); + case AMDGPU::BI__builtin_amdgcn_image_sample_cube_v4f32_f32: + case AMDGPU::BI__builtin_amdgcn_image_sample_cube_v4f16_f32: + return emitAMDGCNImageOverloadedReturnType( + *this, E, Intrinsic::amdgcn_image_sample_cube, false); case AMDGPU::BI__builtin_amdgcn_mfma_scale_f32_16x16x128_f8f6f4: case AMDGPU::BI__builtin_amdgcn_mfma_scale_f32_32x32x64_f8f6f4: { llvm::FixedVectorType *VT = FixedVectorType::get(Builder.getInt32Ty(), 8); diff --git a/clang/lib/Driver/Distro.cpp b/clang/lib/Driver/Distro.cpp index 90e5a39..8a5a9fc 100644 --- a/clang/lib/Driver/Distro.cpp +++ b/clang/lib/Driver/Distro.cpp @@ -61,11 +61,6 @@ static Distro::DistroType DetectLsbRelease(llvm::vfs::FileSystem &VFS) { if (Version == Distro::UnknownDistro && Line.starts_with("DISTRIB_CODENAME=")) Version = llvm::StringSwitch<Distro::DistroType>(Line.substr(17)) - .Case("hardy", Distro::UbuntuHardy) - .Case("intrepid", Distro::UbuntuIntrepid) - .Case("jaunty", Distro::UbuntuJaunty) - .Case("karmic", Distro::UbuntuKarmic) - .Case("lucid", Distro::UbuntuLucid) .Case("maverick", Distro::UbuntuMaverick) .Case("natty", Distro::UbuntuNatty) .Case("oneiric", Distro::UbuntuOneiric) diff --git a/clang/lib/Driver/ToolChains/Linux.cpp b/clang/lib/Driver/ToolChains/Linux.cpp index 16e35b0..8eb4d34e 100644 --- a/clang/lib/Driver/ToolChains/Linux.cpp +++ b/clang/lib/Driver/ToolChains/Linux.cpp @@ -301,11 +301,10 @@ Linux::Linux(const Driver &D, const llvm::Triple &Triple, const ArgList &Args) // .gnu.hash needs symbols to be grouped by hash code whereas the MIPS // ABI requires a mapping between the GOT and the symbol table. // Android loader does not support .gnu.hash until API 23. - // Hexagon linker/loader does not support .gnu.hash + // Hexagon linker/loader does not support .gnu.hash. + // SUSE SLES 11 will stop being supported Mar 2028. if (!IsMips && !IsHexagon) { - if (Distro.IsOpenSUSE() || Distro == Distro::UbuntuLucid || - Distro == Distro::UbuntuJaunty || Distro == Distro::UbuntuKarmic || - (IsAndroid && Triple.isAndroidVersionLT(23))) + if (Distro.IsOpenSUSE() || (IsAndroid && Triple.isAndroidVersionLT(23))) ExtraOpts.push_back("--hash-style=both"); else ExtraOpts.push_back("--hash-style=gnu"); diff --git a/clang/lib/Parse/ParseDecl.cpp b/clang/lib/Parse/ParseDecl.cpp index d6cd7eb..e4b158e 100644 --- a/clang/lib/Parse/ParseDecl.cpp +++ b/clang/lib/Parse/ParseDecl.cpp @@ -1934,12 +1934,12 @@ Parser::DeclGroupPtrTy Parser::ParseSimpleDeclaration( bool RequireSemi, ForRangeInit *FRI, SourceLocation *DeclSpecStart) { // Need to retain these for diagnostics before we add them to the DeclSepc. ParsedAttributesView OriginalDeclSpecAttrs; - OriginalDeclSpecAttrs.addAll(DeclSpecAttrs.begin(), DeclSpecAttrs.end()); + OriginalDeclSpecAttrs.prepend(DeclSpecAttrs.begin(), DeclSpecAttrs.end()); OriginalDeclSpecAttrs.Range = DeclSpecAttrs.Range; // Parse the common declaration-specifiers piece. ParsingDeclSpec DS(*this); - DS.takeAttributesFrom(DeclSpecAttrs); + DS.takeAttributesAppendingingFrom(DeclSpecAttrs); ParsedTemplateInfo TemplateInfo; DeclSpecContext DSContext = getDeclSpecContextFromDeclaratorContext(Context); @@ -2135,7 +2135,7 @@ Parser::DeclGroupPtrTy Parser::ParseDeclGroup(ParsingDeclSpec &DS, // list. This ensures that we will not attempt to interpret them as statement // attributes higher up the callchain. ParsedAttributes LocalAttrs(AttrFactory); - LocalAttrs.takeAllFrom(Attrs); + LocalAttrs.takeAllPrependingFrom(Attrs); ParsingDeclarator D(*this, DS, LocalAttrs, Context); if (TemplateInfo.TemplateParams) D.setTemplateParameterLists(*TemplateInfo.TemplateParams); @@ -3462,7 +3462,7 @@ void Parser::ParseDeclarationSpecifiers( PA.setInvalid(); } - DS.takeAttributesFrom(attrs); + DS.takeAttributesAppendingingFrom(attrs); } // If this is not a declaration specifier token, we're done reading decl @@ -3689,7 +3689,7 @@ void Parser::ParseDeclarationSpecifiers( if (ParseImplicitInt(DS, &SS, TemplateInfo, AS, DSContext, Attrs)) { if (!Attrs.empty()) { AttrsLastTime = true; - attrs.takeAllFrom(Attrs); + attrs.takeAllAppendingFrom(Attrs); } continue; } @@ -3854,7 +3854,7 @@ void Parser::ParseDeclarationSpecifiers( if (ParseImplicitInt(DS, nullptr, TemplateInfo, AS, DSContext, Attrs)) { if (!Attrs.empty()) { AttrsLastTime = true; - attrs.takeAllFrom(Attrs); + attrs.takeAllAppendingFrom(Attrs); } continue; } @@ -4463,7 +4463,7 @@ void Parser::ParseDeclarationSpecifiers( // take them over and handle them here. if (!Attributes.empty()) { AttrsLastTime = true; - attrs.takeAllFrom(Attributes); + attrs.takeAllAppendingFrom(Attributes); } continue; } @@ -4830,7 +4830,7 @@ void Parser::ParseLexedCAttribute(LateParsedAttribute &LA, bool EnterScope, ConsumeAnyToken(); if (OutAttrs) { - OutAttrs->takeAllFrom(Attrs); + OutAttrs->takeAllAppendingFrom(Attrs); } } @@ -6122,7 +6122,7 @@ void Parser::ParseTypeQualifierListOpt( isAllowedCXX11AttributeSpecifier()) { ParsedAttributes Attrs(AttrFactory); ParseCXX11Attributes(Attrs); - DS.takeAttributesFrom(Attrs); + DS.takeAttributesAppendingingFrom(Attrs); } SourceLocation EndLoc; @@ -7483,7 +7483,7 @@ void Parser::ParseParameterDeclarationClause( // Take them so that we only apply the attributes to the first parameter. // We have already started parsing the decl-specifier sequence, so don't // parse any parameter-declaration pieces that precede it. - ArgDeclSpecAttrs.takeAllFrom(FirstArgAttrs); + ArgDeclSpecAttrs.takeAllPrependingFrom(FirstArgAttrs); } else { // Parse any C++11 attributes. MaybeParseCXX11Attributes(ArgDeclAttrs); @@ -7505,7 +7505,7 @@ void Parser::ParseParameterDeclarationClause( DeclSpecContext::DSC_normal, /*LateAttrs=*/nullptr, AllowImplicitTypename); - DS.takeAttributesFrom(ArgDeclSpecAttrs); + DS.takeAttributesAppendingingFrom(ArgDeclSpecAttrs); // Parse the declarator. This is "PrototypeContext" or // "LambdaExprParameterContext", because we must accept either diff --git a/clang/lib/Parse/ParseDeclCXX.cpp b/clang/lib/Parse/ParseDeclCXX.cpp index 19f9412..b96968d 100644 --- a/clang/lib/Parse/ParseDeclCXX.cpp +++ b/clang/lib/Parse/ParseDeclCXX.cpp @@ -739,7 +739,7 @@ Parser::DeclGroupPtrTy Parser::ParseUsingDeclaration( << FixItHint::CreateInsertionFromRange( Tok.getLocation(), CharSourceRange::getTokenRange(Range)) << FixItHint::CreateRemoval(Range); - Attrs.takeAllFrom(MisplacedAttrs); + Attrs.takeAllPrependingFrom(MisplacedAttrs); } // Maybe this is an alias-declaration. @@ -787,7 +787,7 @@ Parser::DeclGroupPtrTy Parser::ParseUsingDeclaration( // Parse (optional) attributes. MaybeParseAttributes(PAKM_GNU | PAKM_CXX11, Attrs); DiagnoseCXX11AttributeExtension(Attrs); - Attrs.addAll(PrefixAttrs.begin(), PrefixAttrs.end()); + Attrs.prepend(PrefixAttrs.begin(), PrefixAttrs.end()); if (InvalidDeclarator) SkipUntil(tok::comma, tok::semi, StopBeforeMatch); @@ -1948,7 +1948,7 @@ void Parser::ParseClassSpecifier(tok::TokenKind TagTokKind, // Recover by adding misplaced attributes to the attribute list // of the class so they can be applied on the class later. - attrs.takeAllFrom(Attributes); + attrs.takeAllAppendingFrom(Attributes); } } @@ -2842,7 +2842,7 @@ Parser::DeclGroupPtrTy Parser::ParseCXXClassMemberDeclaration( // decl-specifier-seq: // Parse the common declaration-specifiers piece. ParsingDeclSpec DS(*this, TemplateDiags); - DS.takeAttributesFrom(DeclSpecAttrs); + DS.takeAttributesAppendingingFrom(DeclSpecAttrs); if (MalformedTypeSpec) DS.SetTypeSpecError(); diff --git a/clang/lib/Parse/ParseExprCXX.cpp b/clang/lib/Parse/ParseExprCXX.cpp index 90191b0..74f87a8 100644 --- a/clang/lib/Parse/ParseExprCXX.cpp +++ b/clang/lib/Parse/ParseExprCXX.cpp @@ -1244,7 +1244,7 @@ ExprResult Parser::ParseLambdaExpressionAfterIntroducer( break; } - D.takeAttributes(Attributes); + D.takeAttributesAppending(Attributes); } MultiParseScope TemplateParamScope(*this); diff --git a/clang/lib/Parse/ParseObjc.cpp b/clang/lib/Parse/ParseObjc.cpp index a64fb02..0b9f113 100644 --- a/clang/lib/Parse/ParseObjc.cpp +++ b/clang/lib/Parse/ParseObjc.cpp @@ -43,7 +43,7 @@ void Parser::MaybeSkipAttributes(tok::ObjCKeywordKind Kind) { Parser::DeclGroupPtrTy Parser::ParseObjCAtDirectives(ParsedAttributes &DeclAttrs, ParsedAttributes &DeclSpecAttrs) { - DeclAttrs.takeAllFrom(DeclSpecAttrs); + DeclAttrs.takeAllPrependingFrom(DeclSpecAttrs); SourceLocation AtLoc = ConsumeToken(); // the "@" @@ -1065,8 +1065,8 @@ void Parser::ParseObjCTypeQualifierList(ObjCDeclSpec &DS, /// Take all the decl attributes out of the given list and add /// them to the given attribute set. -static void takeDeclAttributes(ParsedAttributesView &attrs, - ParsedAttributesView &from) { +static void takeDeclAttributesAppend(ParsedAttributesView &attrs, + ParsedAttributesView &from) { for (auto &AL : llvm::reverse(from)) { if (!AL.isUsedAsTypeAttr()) { from.remove(&AL); @@ -1088,10 +1088,10 @@ static void takeDeclAttributes(ParsedAttributes &attrs, attrs.getPool().takeAllFrom(D.getDeclSpec().getAttributePool()); // Now actually move the attributes over. - takeDeclAttributes(attrs, D.getMutableDeclSpec().getAttributes()); - takeDeclAttributes(attrs, D.getAttributes()); + takeDeclAttributesAppend(attrs, D.getMutableDeclSpec().getAttributes()); + takeDeclAttributesAppend(attrs, D.getAttributes()); for (unsigned i = 0, e = D.getNumTypeObjects(); i != e; ++i) - takeDeclAttributes(attrs, D.getTypeObject(i).getAttrs()); + takeDeclAttributesAppend(attrs, D.getTypeObject(i).getAttrs()); } ParsedType Parser::ParseObjCTypeName(ObjCDeclSpec &DS, diff --git a/clang/lib/Parse/ParseStmt.cpp b/clang/lib/Parse/ParseStmt.cpp index 2e7af12..9203898 100644 --- a/clang/lib/Parse/ParseStmt.cpp +++ b/clang/lib/Parse/ParseStmt.cpp @@ -718,7 +718,7 @@ StmtResult Parser::ParseLabeledStatement(ParsedAttributes &Attrs, // and followed by a semicolon, GCC will reject (it appears to parse the // attributes as part of a statement in that case). That looks like a bug. if (!getLangOpts().CPlusPlus || Tok.is(tok::semi)) - Attrs.takeAllFrom(TempAttrs); + Attrs.takeAllAppendingFrom(TempAttrs); else { StmtVector Stmts; ParsedAttributes EmptyCXX11Attrs(AttrFactory); @@ -2407,7 +2407,7 @@ StmtResult Parser::ParsePragmaLoopHint(StmtVector &Stmts, Stmts, StmtCtx, TrailingElseLoc, Attrs, EmptyDeclSpecAttrs, PrecedingLabel); - Attrs.takeAllFrom(TempAttrs); + Attrs.takeAllPrependingFrom(TempAttrs); // Start of attribute range may already be set for some invalid input. // See PR46336. diff --git a/clang/lib/Parse/ParseTemplate.cpp b/clang/lib/Parse/ParseTemplate.cpp index 74aff0b..dbc7cbc 100644 --- a/clang/lib/Parse/ParseTemplate.cpp +++ b/clang/lib/Parse/ParseTemplate.cpp @@ -196,7 +196,7 @@ Parser::DeclGroupPtrTy Parser::ParseDeclarationAfterTemplate( ParsingDeclSpec DS(*this, &DiagsFromTParams); DS.SetRangeStart(DeclSpecAttrs.Range.getBegin()); DS.SetRangeEnd(DeclSpecAttrs.Range.getEnd()); - DS.takeAttributesFrom(DeclSpecAttrs); + DS.takeAttributesAppendingingFrom(DeclSpecAttrs); ParseDeclarationSpecifiers(DS, TemplateInfo, AS, getDeclSpecContextFromDeclaratorContext(Context)); diff --git a/clang/lib/Parse/Parser.cpp b/clang/lib/Parse/Parser.cpp index a17398b..bbff627 100644 --- a/clang/lib/Parse/Parser.cpp +++ b/clang/lib/Parse/Parser.cpp @@ -1083,7 +1083,7 @@ Parser::DeclGroupPtrTy Parser::ParseDeclOrFunctionDefInternal( "expected uninitialised source range"); DS.SetRangeStart(DeclSpecAttrs.Range.getBegin()); DS.SetRangeEnd(DeclSpecAttrs.Range.getEnd()); - DS.takeAttributesFrom(DeclSpecAttrs); + DS.takeAttributesAppendingingFrom(DeclSpecAttrs); ParsedTemplateInfo TemplateInfo; MaybeParseMicrosoftAttributes(DS.getAttributes()); @@ -1155,7 +1155,7 @@ Parser::DeclGroupPtrTy Parser::ParseDeclOrFunctionDefInternal( } DS.abort(); - DS.takeAttributesFrom(Attrs); + DS.takeAttributesAppendingingFrom(Attrs); const char *PrevSpec = nullptr; unsigned DiagID; diff --git a/clang/lib/Sema/DeclSpec.cpp b/clang/lib/Sema/DeclSpec.cpp index 8756ce5..184d31e 100644 --- a/clang/lib/Sema/DeclSpec.cpp +++ b/clang/lib/Sema/DeclSpec.cpp @@ -197,7 +197,7 @@ DeclaratorChunk DeclaratorChunk::getFunction(bool hasProto, [&](DeclSpec::TQ TypeQual, StringRef PrintName, SourceLocation SL) { I.Fun.MethodQualifiers->SetTypeQual(TypeQual, SL); }); - I.Fun.MethodQualifiers->getAttributes().takeAllFrom(attrs); + I.Fun.MethodQualifiers->getAttributes().takeAllPrependingFrom(attrs); I.Fun.MethodQualifiers->getAttributePool().takeAllFrom(attrs.getPool()); } diff --git a/clang/lib/Sema/ParsedAttr.cpp b/clang/lib/Sema/ParsedAttr.cpp index 294f88e..2b5ad33 100644 --- a/clang/lib/Sema/ParsedAttr.cpp +++ b/clang/lib/Sema/ParsedAttr.cpp @@ -304,7 +304,7 @@ bool ParsedAttr::checkAtMostNumArgs(Sema &S, unsigned Num) const { void clang::takeAndConcatenateAttrs(ParsedAttributes &First, ParsedAttributes &&Second) { - First.takeAllAtEndFrom(Second); + First.takeAllAppendingFrom(Second); if (!First.Range.getBegin().isValid()) First.Range.setBegin(Second.Range.getBegin()); diff --git a/clang/lib/Sema/SemaAMDGPU.cpp b/clang/lib/Sema/SemaAMDGPU.cpp index 3a0c231..e32f437 100644 --- a/clang/lib/Sema/SemaAMDGPU.cpp +++ b/clang/lib/Sema/SemaAMDGPU.cpp @@ -11,6 +11,7 @@ //===----------------------------------------------------------------------===// #include "clang/Sema/SemaAMDGPU.h" +#include "clang/Basic/DiagnosticFrontend.h" #include "clang/Basic/DiagnosticSema.h" #include "clang/Basic/TargetBuiltins.h" #include "clang/Sema/Ownership.h" @@ -111,6 +112,108 @@ bool SemaAMDGPU::CheckAMDGCNBuiltinFunctionCall(unsigned BuiltinID, case AMDGPU::BI__builtin_amdgcn_cooperative_atomic_store_16x8B: case AMDGPU::BI__builtin_amdgcn_cooperative_atomic_store_8x16B: return checkCoopAtomicFunctionCall(TheCall, /*IsStore=*/true); + case AMDGPU::BI__builtin_amdgcn_image_load_1d_v4f32_i32: + case AMDGPU::BI__builtin_amdgcn_image_load_1darray_v4f32_i32: + case AMDGPU::BI__builtin_amdgcn_image_load_1d_v4f16_i32: + case AMDGPU::BI__builtin_amdgcn_image_load_1darray_v4f16_i32: + case AMDGPU::BI__builtin_amdgcn_image_load_2d_f32_i32: + case AMDGPU::BI__builtin_amdgcn_image_load_2d_v4f32_i32: + case AMDGPU::BI__builtin_amdgcn_image_load_2d_v4f16_i32: + case AMDGPU::BI__builtin_amdgcn_image_load_2darray_f32_i32: + case AMDGPU::BI__builtin_amdgcn_image_load_2darray_v4f32_i32: + case AMDGPU::BI__builtin_amdgcn_image_load_2darray_v4f16_i32: + case AMDGPU::BI__builtin_amdgcn_image_load_3d_v4f32_i32: + case AMDGPU::BI__builtin_amdgcn_image_load_3d_v4f16_i32: + case AMDGPU::BI__builtin_amdgcn_image_load_cube_v4f32_i32: + case AMDGPU::BI__builtin_amdgcn_image_load_cube_v4f16_i32: + case AMDGPU::BI__builtin_amdgcn_image_load_mip_1d_v4f32_i32: + case AMDGPU::BI__builtin_amdgcn_image_load_mip_1d_v4f16_i32: + case AMDGPU::BI__builtin_amdgcn_image_load_mip_1darray_v4f32_i32: + case AMDGPU::BI__builtin_amdgcn_image_load_mip_1darray_v4f16_i32: + case AMDGPU::BI__builtin_amdgcn_image_load_mip_2d_f32_i32: + case AMDGPU::BI__builtin_amdgcn_image_load_mip_2d_v4f32_i32: + case AMDGPU::BI__builtin_amdgcn_image_load_mip_2d_v4f16_i32: + case AMDGPU::BI__builtin_amdgcn_image_load_mip_2darray_f32_i32: + case AMDGPU::BI__builtin_amdgcn_image_load_mip_2darray_v4f32_i32: + case AMDGPU::BI__builtin_amdgcn_image_load_mip_2darray_v4f16_i32: + case AMDGPU::BI__builtin_amdgcn_image_load_mip_3d_v4f32_i32: + case AMDGPU::BI__builtin_amdgcn_image_load_mip_3d_v4f16_i32: + case AMDGPU::BI__builtin_amdgcn_image_load_mip_cube_v4f32_i32: + case AMDGPU::BI__builtin_amdgcn_image_load_mip_cube_v4f16_i32: + case AMDGPU::BI__builtin_amdgcn_image_sample_1d_v4f32_f32: + case AMDGPU::BI__builtin_amdgcn_image_sample_1darray_v4f32_f32: + case AMDGPU::BI__builtin_amdgcn_image_sample_1d_v4f16_f32: + case AMDGPU::BI__builtin_amdgcn_image_sample_1darray_v4f16_f32: + case AMDGPU::BI__builtin_amdgcn_image_sample_2d_f32_f32: + case AMDGPU::BI__builtin_amdgcn_image_sample_2d_v4f32_f32: + case AMDGPU::BI__builtin_amdgcn_image_sample_2d_v4f16_f32: + case AMDGPU::BI__builtin_amdgcn_image_sample_2darray_f32_f32: + case AMDGPU::BI__builtin_amdgcn_image_sample_2darray_v4f32_f32: + case AMDGPU::BI__builtin_amdgcn_image_sample_2darray_v4f16_f32: + case AMDGPU::BI__builtin_amdgcn_image_sample_3d_v4f32_f32: + case AMDGPU::BI__builtin_amdgcn_image_sample_3d_v4f16_f32: + case AMDGPU::BI__builtin_amdgcn_image_sample_cube_v4f32_f32: + case AMDGPU::BI__builtin_amdgcn_image_sample_cube_v4f16_f32: { + StringRef FeatureList( + getASTContext().BuiltinInfo.getRequiredFeatures(BuiltinID)); + if (!Builtin::evaluateRequiredTargetFeatures(FeatureList, + CallerFeatureMap)) { + Diag(TheCall->getBeginLoc(), diag::err_builtin_needs_feature) + << FD->getDeclName() << FeatureList; + return false; + } + + unsigned ArgCount = TheCall->getNumArgs() - 1; + llvm::APSInt Result; + + return (SemaRef.BuiltinConstantArg(TheCall, 0, Result)) || + (SemaRef.BuiltinConstantArg(TheCall, ArgCount, Result)) || + (SemaRef.BuiltinConstantArg(TheCall, (ArgCount - 1), Result)); + } + case AMDGPU::BI__builtin_amdgcn_image_store_1d_v4f32_i32: + case AMDGPU::BI__builtin_amdgcn_image_store_1darray_v4f32_i32: + case AMDGPU::BI__builtin_amdgcn_image_store_1d_v4f16_i32: + case AMDGPU::BI__builtin_amdgcn_image_store_1darray_v4f16_i32: + case AMDGPU::BI__builtin_amdgcn_image_store_2d_f32_i32: + case AMDGPU::BI__builtin_amdgcn_image_store_2d_v4f32_i32: + case AMDGPU::BI__builtin_amdgcn_image_store_2d_v4f16_i32: + case AMDGPU::BI__builtin_amdgcn_image_store_2darray_f32_i32: + case AMDGPU::BI__builtin_amdgcn_image_store_2darray_v4f32_i32: + case AMDGPU::BI__builtin_amdgcn_image_store_2darray_v4f16_i32: + case AMDGPU::BI__builtin_amdgcn_image_store_3d_v4f32_i32: + case AMDGPU::BI__builtin_amdgcn_image_store_3d_v4f16_i32: + case AMDGPU::BI__builtin_amdgcn_image_store_cube_v4f32_i32: + case AMDGPU::BI__builtin_amdgcn_image_store_cube_v4f16_i32: + case AMDGPU::BI__builtin_amdgcn_image_store_mip_1d_v4f32_i32: + case AMDGPU::BI__builtin_amdgcn_image_store_mip_1d_v4f16_i32: + case AMDGPU::BI__builtin_amdgcn_image_store_mip_1darray_v4f32_i32: + case AMDGPU::BI__builtin_amdgcn_image_store_mip_1darray_v4f16_i32: + case AMDGPU::BI__builtin_amdgcn_image_store_mip_2d_f32_i32: + case AMDGPU::BI__builtin_amdgcn_image_store_mip_2d_v4f32_i32: + case AMDGPU::BI__builtin_amdgcn_image_store_mip_2d_v4f16_i32: + case AMDGPU::BI__builtin_amdgcn_image_store_mip_2darray_f32_i32: + case AMDGPU::BI__builtin_amdgcn_image_store_mip_2darray_v4f32_i32: + case AMDGPU::BI__builtin_amdgcn_image_store_mip_2darray_v4f16_i32: + case AMDGPU::BI__builtin_amdgcn_image_store_mip_3d_v4f32_i32: + case AMDGPU::BI__builtin_amdgcn_image_store_mip_3d_v4f16_i32: + case AMDGPU::BI__builtin_amdgcn_image_store_mip_cube_v4f32_i32: + case AMDGPU::BI__builtin_amdgcn_image_store_mip_cube_v4f16_i32: { + StringRef FeatureList( + getASTContext().BuiltinInfo.getRequiredFeatures(BuiltinID)); + if (!Builtin::evaluateRequiredTargetFeatures(FeatureList, + CallerFeatureMap)) { + Diag(TheCall->getBeginLoc(), diag::err_builtin_needs_feature) + << FD->getDeclName() << FeatureList; + return false; + } + + unsigned ArgCount = TheCall->getNumArgs() - 1; + llvm::APSInt Result; + + return (SemaRef.BuiltinConstantArg(TheCall, 1, Result)) || + (SemaRef.BuiltinConstantArg(TheCall, ArgCount, Result)) || + (SemaRef.BuiltinConstantArg(TheCall, (ArgCount - 1), Result)); + } default: return false; } diff --git a/clang/lib/Sema/SemaDecl.cpp b/clang/lib/Sema/SemaDecl.cpp index 6eaf7b9..0e83c20 100644 --- a/clang/lib/Sema/SemaDecl.cpp +++ b/clang/lib/Sema/SemaDecl.cpp @@ -14637,7 +14637,7 @@ StmtResult Sema::ActOnCXXForRangeIdentifier(Scope *S, SourceLocation IdentLoc, Declarator D(DS, ParsedAttributesView::none(), DeclaratorContext::ForInit); D.SetIdentifier(Ident, IdentLoc); - D.takeAttributes(Attrs); + D.takeAttributesAppending(Attrs); D.AddTypeInfo(DeclaratorChunk::getReference(0, IdentLoc, /*lvalue*/ false), IdentLoc); diff --git a/clang/lib/Sema/SemaExpr.cpp b/clang/lib/Sema/SemaExpr.cpp index 4230ea7..01abc1f 100644 --- a/clang/lib/Sema/SemaExpr.cpp +++ b/clang/lib/Sema/SemaExpr.cpp @@ -166,6 +166,11 @@ static void diagnoseUseOfInternalDeclInInlineFunction(Sema &S, // This is disabled under C++; there are too many ways for this to fire in // contexts where the warning is a false positive, or where it is technically // correct but benign. + // + // WG14 N3622 which removed the constraint entirely in C2y. It is left + // enabled in earlier language modes because this is a constraint in those + // language modes. But in C2y mode, we still want to issue the "incompatible + // with previous standards" diagnostic, too. if (S.getLangOpts().CPlusPlus) return; @@ -190,16 +195,17 @@ static void diagnoseUseOfInternalDeclInInlineFunction(Sema &S, // This last can give us false negatives, but it's better than warning on // wrappers for simple C library functions. const FunctionDecl *UsedFn = dyn_cast<FunctionDecl>(D); - bool DowngradeWarning = S.getSourceManager().isInMainFile(Loc); - if (!DowngradeWarning && UsedFn) - DowngradeWarning = UsedFn->isInlined() || UsedFn->hasAttr<ConstAttr>(); - - S.Diag(Loc, DowngradeWarning ? diag::ext_internal_in_extern_inline_quiet - : diag::ext_internal_in_extern_inline) - << /*IsVar=*/!UsedFn << D; + unsigned DiagID; + if (S.getLangOpts().C2y) + DiagID = diag::warn_c2y_compat_internal_in_extern_inline; + else if ((UsedFn && (UsedFn->isInlined() || UsedFn->hasAttr<ConstAttr>())) || + S.getSourceManager().isInMainFile(Loc)) + DiagID = diag::ext_internal_in_extern_inline_quiet; + else + DiagID = diag::ext_internal_in_extern_inline; + S.Diag(Loc, DiagID) << /*IsVar=*/!UsedFn << D; S.MaybeSuggestAddingStaticToDecl(Current); - S.Diag(D->getCanonicalDecl()->getLocation(), diag::note_entity_declared_at) << D; } diff --git a/clang/lib/Sema/SemaOpenACC.cpp b/clang/lib/Sema/SemaOpenACC.cpp index 4824b5a..779b6e9 100644 --- a/clang/lib/Sema/SemaOpenACC.cpp +++ b/clang/lib/Sema/SemaOpenACC.cpp @@ -2759,7 +2759,7 @@ OpenACCPrivateRecipe SemaOpenACC::CreatePrivateInitRecipe(const Expr *VarExpr) { // Array sections are special, and we have to treat them that way. if (const auto *ASE = dyn_cast<ArraySectionExpr>(VarExpr->IgnoreParenImpCasts())) - VarTy = ArraySectionExpr::getBaseOriginalType(ASE); + VarTy = ASE->getElementType(); VarDecl *AllocaDecl = CreateAllocaDecl( getASTContext(), SemaRef.getCurContext(), VarExpr->getBeginLoc(), @@ -2795,7 +2795,7 @@ SemaOpenACC::CreateFirstPrivateInitRecipe(const Expr *VarExpr) { // Array sections are special, and we have to treat them that way. if (const auto *ASE = dyn_cast<ArraySectionExpr>(VarExpr->IgnoreParenImpCasts())) - VarTy = ArraySectionExpr::getBaseOriginalType(ASE); + VarTy = ASE->getElementType(); VarDecl *AllocaDecl = CreateAllocaDecl( getASTContext(), SemaRef.getCurContext(), VarExpr->getBeginLoc(), @@ -2896,7 +2896,16 @@ OpenACCReductionRecipe SemaOpenACC::CreateReductionInitRecipe( // Array sections are special, and we have to treat them that way. if (const auto *ASE = dyn_cast<ArraySectionExpr>(VarExpr->IgnoreParenImpCasts())) - VarTy = ArraySectionExpr::getBaseOriginalType(ASE); + VarTy = ASE->getElementType(); + + llvm::SmallVector<OpenACCReductionRecipe::CombinerRecipe, 1> CombinerRecipes; + + // We use the 'set-ness' of the alloca-decl to determine whether the combiner + // is 'set' or not, so we can skip any attempts at it if we're going to fail + // at any of the combiners. + if (CreateReductionCombinerRecipe(VarExpr->getBeginLoc(), ReductionOperator, + VarTy, CombinerRecipes)) + return OpenACCReductionRecipe::Empty(); VarDecl *AllocaDecl = CreateAllocaDecl( getASTContext(), SemaRef.getCurContext(), VarExpr->getBeginLoc(), @@ -2946,5 +2955,163 @@ OpenACCReductionRecipe SemaOpenACC::CreateReductionInitRecipe( AllocaDecl->setInit(Init.get()); AllocaDecl->setInitStyle(VarDecl::CallInit); } - return OpenACCReductionRecipe(AllocaDecl, {}); + + return OpenACCReductionRecipe(AllocaDecl, CombinerRecipes); +} + +bool SemaOpenACC::CreateReductionCombinerRecipe( + SourceLocation Loc, OpenACCReductionOperator ReductionOperator, + QualType VarTy, + llvm::SmallVectorImpl<OpenACCReductionRecipe::CombinerRecipe> + &CombinerRecipes) { + // Now we can try to generate the 'combiner' recipe. This is a little + // complicated in that if the 'VarTy' is an array type, we want to take its + // element type so we can generate that. Additionally, if this is a struct, + // we have two options: If there is overloaded operators, we want to take + // THOSE, else we want to do the individual elements. + + BinaryOperatorKind BinOp; + switch (ReductionOperator) { + case OpenACCReductionOperator::Invalid: + // This can only happen when there is an error, and since these inits + // are used for code generation, we can just ignore/not bother doing any + // initialization here. + CombinerRecipes.push_back({nullptr, nullptr, nullptr}); + return false; + case OpenACCReductionOperator::Addition: + BinOp = BinaryOperatorKind::BO_AddAssign; + break; + case OpenACCReductionOperator::Multiplication: + BinOp = BinaryOperatorKind::BO_MulAssign; + break; + case OpenACCReductionOperator::BitwiseAnd: + BinOp = BinaryOperatorKind::BO_AndAssign; + break; + case OpenACCReductionOperator::BitwiseOr: + BinOp = BinaryOperatorKind::BO_OrAssign; + break; + case OpenACCReductionOperator::BitwiseXOr: + BinOp = BinaryOperatorKind::BO_XorAssign; + break; + + case OpenACCReductionOperator::Max: + case OpenACCReductionOperator::Min: + case OpenACCReductionOperator::And: + case OpenACCReductionOperator::Or: + // We just want a 'NYI' error in the backend, so leave an empty combiner + // recipe, and claim success. + CombinerRecipes.push_back({nullptr, nullptr, nullptr}); + return false; + } + + // If VarTy is an array type, at the top level only, we want to do our + // compares/decomp/etc at the element level. + if (auto *AT = getASTContext().getAsArrayType(VarTy)) + VarTy = AT->getElementType(); + + assert(!VarTy->isArrayType() && "Only 1 level of array allowed"); + + auto tryCombiner = [&, this](DeclRefExpr *LHSDRE, DeclRefExpr *RHSDRE, + bool IncludeTrap) { + // TODO: OpenACC: we have to figure out based on the bin-op how to do the + // ones that we can't just use compound operators for. So &&, ||, max, and + // min aren't really clear what we could do here. + if (IncludeTrap) { + // Trap all of the errors here, we'll emit our own at the end. + Sema::TentativeAnalysisScope Trap{SemaRef}; + + return SemaRef.BuildBinOp(SemaRef.getCurScope(), Loc, BinOp, LHSDRE, + RHSDRE, + /*ForFoldExpr=*/false); + } else { + return SemaRef.BuildBinOp(SemaRef.getCurScope(), Loc, BinOp, LHSDRE, + RHSDRE, + /*ForFoldExpr=*/false); + } + }; + + struct CombinerAttemptTy { + VarDecl *LHS; + DeclRefExpr *LHSDRE; + VarDecl *RHS; + DeclRefExpr *RHSDRE; + Expr *Op; + }; + + auto formCombiner = [&, this](QualType Ty) -> CombinerAttemptTy { + VarDecl *LHSDecl = CreateAllocaDecl( + getASTContext(), SemaRef.getCurContext(), Loc, + &getASTContext().Idents.get("openacc.reduction.combiner.lhs"), Ty); + auto *LHSDRE = DeclRefExpr::Create( + getASTContext(), NestedNameSpecifierLoc{}, SourceLocation{}, LHSDecl, + /*ReferstoEnclosingVariableOrCapture=*/false, + DeclarationNameInfo{DeclarationName{LHSDecl->getDeclName()}, + LHSDecl->getBeginLoc()}, + Ty, clang::VK_LValue, LHSDecl, nullptr, NOUR_None); + VarDecl *RHSDecl = CreateAllocaDecl( + getASTContext(), SemaRef.getCurContext(), Loc, + &getASTContext().Idents.get("openacc.reduction.combiner.lhs"), Ty); + auto *RHSDRE = DeclRefExpr::Create( + getASTContext(), NestedNameSpecifierLoc{}, SourceLocation{}, RHSDecl, + /*ReferstoEnclosingVariableOrCapture=*/false, + DeclarationNameInfo{DeclarationName{RHSDecl->getDeclName()}, + RHSDecl->getBeginLoc()}, + Ty, clang::VK_LValue, RHSDecl, nullptr, NOUR_None); + + ExprResult BinOpResult = tryCombiner(LHSDRE, RHSDRE, /*IncludeTrap=*/true); + + return {LHSDecl, LHSDRE, RHSDecl, RHSDRE, BinOpResult.get()}; + }; + + CombinerAttemptTy TopLevelCombinerInfo = formCombiner(VarTy); + + if (TopLevelCombinerInfo.Op) { + if (!TopLevelCombinerInfo.Op->containsErrors() && + TopLevelCombinerInfo.Op->isInstantiationDependent()) { + // If this is instantiation dependent, we're just going to 'give up' here + // and count on us to get it right during instantaition. + CombinerRecipes.push_back({nullptr, nullptr, nullptr}); + return false; + } else if (!TopLevelCombinerInfo.Op->containsErrors()) { + // Else, we succeeded, we can just return this combiner. + CombinerRecipes.push_back({TopLevelCombinerInfo.LHS, + TopLevelCombinerInfo.RHS, + TopLevelCombinerInfo.Op}); + return false; + } + } + + // Since the 'root' level didn't fail, the only thing that could be successful + // is a struct that we decompose on its individual fields. + + RecordDecl *RD = VarTy->getAsRecordDecl(); + if (!RD) { + Diag(Loc, diag::err_acc_reduction_recipe_no_op) << VarTy; + tryCombiner(TopLevelCombinerInfo.LHSDRE, TopLevelCombinerInfo.RHSDRE, + /*IncludeTrap=*/false); + return true; + } + + for (const FieldDecl *FD : RD->fields()) { + CombinerAttemptTy FieldCombinerInfo = formCombiner(FD->getType()); + + if (!FieldCombinerInfo.Op || FieldCombinerInfo.Op->containsErrors()) { + Diag(Loc, diag::err_acc_reduction_recipe_no_op) << FD->getType(); + Diag(FD->getBeginLoc(), diag::note_acc_reduction_recipe_noop_field) << RD; + tryCombiner(FieldCombinerInfo.LHSDRE, FieldCombinerInfo.RHSDRE, + /*IncludeTrap=*/false); + return true; + } + + if (FieldCombinerInfo.Op->isInstantiationDependent()) { + // If this is instantiation dependent, we're just going to 'give up' here + // and count on us to get it right during instantaition. + CombinerRecipes.push_back({nullptr, nullptr, nullptr}); + } else { + CombinerRecipes.push_back( + {FieldCombinerInfo.LHS, FieldCombinerInfo.RHS, FieldCombinerInfo.Op}); + } + } + + return false; } diff --git a/clang/lib/Sema/SemaOpenACCClause.cpp b/clang/lib/Sema/SemaOpenACCClause.cpp index b086929..881e960 100644 --- a/clang/lib/Sema/SemaOpenACCClause.cpp +++ b/clang/lib/Sema/SemaOpenACCClause.cpp @@ -1915,51 +1915,34 @@ SemaOpenACC::ActOnClause(ArrayRef<const OpenACCClause *> ExistingClauses, return Result; } -/// OpenACC 3.3 section 2.5.15: -/// At a mininmum, the supported data types include ... the numerical data types -/// in C, C++, and Fortran. -/// -/// If the reduction var is a composite variable, each -/// member of the composite variable must be a supported datatype for the -/// reduction operation. -ExprResult SemaOpenACC::CheckReductionVar(OpenACCDirectiveKind DirectiveKind, - OpenACCReductionOperator ReductionOp, - Expr *VarExpr) { - // For now, we only support 'scalar' types, or composites/arrays of scalar - // types. - VarExpr = VarExpr->IgnoreParenCasts(); +bool SemaOpenACC::CheckReductionVarType(Expr *VarExpr) { SourceLocation VarLoc = VarExpr->getBeginLoc(); SmallVector<PartialDiagnosticAt> Notes; - QualType CurType = VarExpr->getType(); - - // For array like things, the expression can either be an array element - // (subscript expr), array section, or array type. Peel those off, and add - // notes in case we find an illegal kind. We'll allow scalar or composite of - // scalars inside of this. - if (auto *ASE = dyn_cast<ArraySectionExpr>(VarExpr)) { - QualType BaseType = ArraySectionExpr::getBaseOriginalType(ASE); + // The standard isn't clear how many levels of 'array element' or 'subarray' + // are permitted, but we can handle as many as we need, so we'll strip them + // off here. This will result in CurType being the actual 'type' of the + // expression, which is what we are looking to check. + QualType CurType = isa<ArraySectionExpr>(VarExpr) + ? ArraySectionExpr::getBaseOriginalType(VarExpr) + : VarExpr->getType(); + + // This can happen when we have a dependent type in an array element that the + // above function has tried to 'unwrap'. Since this can only happen with + // dependence, just let it go. + if (CurType.isNull()) + return false; - PartialDiagnostic PD = PDiag(diag::note_acc_reduction_array) - << diag::OACCReductionArray::Section << BaseType; - Notes.push_back({ASE->getBeginLoc(), PD}); - - CurType = getASTContext().getBaseElementType(BaseType); - } else if (auto *SubExpr = dyn_cast<ArraySubscriptExpr>(VarExpr)) { - // Array subscript already results in the type of the thing as its type, so - // there is no type to change here. - PartialDiagnostic PD = - PDiag(diag::note_acc_reduction_array) - << diag::OACCReductionArray::Subscript - << SubExpr->getBase()->IgnoreParenImpCasts()->getType(); - Notes.push_back({SubExpr->getBeginLoc(), PD}); - } else if (auto *AT = getASTContext().getAsArrayType(CurType)) { + // If we are still an array type, we allow 1 level of 'unpeeling' of the + // array. The standard isn't clear here whether this is allowed, but + // array-of-valid-things makes sense. + if (auto *AT = getASTContext().getAsArrayType(CurType)) { // If we're already the array type, peel off the array and leave the element // type. - CurType = getASTContext().getBaseElementType(AT); PartialDiagnostic PD = PDiag(diag::note_acc_reduction_array) << diag::OACCReductionArray::ArrayTy << CurType; Notes.push_back({VarLoc, PD}); + CurType = AT->getElementType(); } auto IsValidMemberOfComposite = [](QualType Ty) { @@ -1974,31 +1957,26 @@ ExprResult SemaOpenACC::CheckReductionVar(OpenACCDirectiveKind DirectiveKind, for (auto [Loc, PD] : Notes) Diag(Loc, PD); - Diag(VarLoc, diag::note_acc_reduction_type_summary); + return Diag(VarLoc, diag::note_acc_reduction_type_summary); }; // If the type is already scalar, or is dependent, just give up. if (IsValidMemberOfComposite(CurType)) { // Nothing to do here, is valid. } else if (auto *RD = CurType->getAsRecordDecl()) { - if (!RD->isStruct() && !RD->isClass()) { - EmitDiags(VarLoc, PDiag(diag::err_acc_reduction_type) - << RD << diag::OACCReductionTy::NotClassStruct); - return ExprError(); - } + if (!RD->isStruct() && !RD->isClass()) + return EmitDiags(VarLoc, PDiag(diag::err_acc_reduction_type) + << RD + << diag::OACCReductionTy::NotClassStruct); - if (!RD->isCompleteDefinition()) { - EmitDiags(VarLoc, PDiag(diag::err_acc_reduction_type) - << RD << diag::OACCReductionTy::NotComplete); - return ExprError(); - } + if (!RD->isCompleteDefinition()) + return EmitDiags(VarLoc, PDiag(diag::err_acc_reduction_type) + << RD << diag::OACCReductionTy::NotComplete); if (const auto *CXXRD = dyn_cast<CXXRecordDecl>(RD); - CXXRD && !CXXRD->isAggregate()) { - EmitDiags(VarLoc, PDiag(diag::err_acc_reduction_type) - << CXXRD << diag::OACCReductionTy::NotAgg); - return ExprError(); - } + CXXRD && !CXXRD->isAggregate()) + return EmitDiags(VarLoc, PDiag(diag::err_acc_reduction_type) + << CXXRD << diag::OACCReductionTy::NotAgg); for (FieldDecl *FD : RD->fields()) { if (!IsValidMemberOfComposite(FD->getType())) { @@ -2007,17 +1985,37 @@ ExprResult SemaOpenACC::CheckReductionVar(OpenACCDirectiveKind DirectiveKind, << FD->getName() << RD->getName(); Notes.push_back({FD->getBeginLoc(), PD}); // TODO: member here.note_acc_reduction_member_of_composite - EmitDiags(VarLoc, PDiag(diag::err_acc_reduction_type) - << FD->getType() - << diag::OACCReductionTy::MemberNotScalar); - return ExprError(); + return EmitDiags(VarLoc, PDiag(diag::err_acc_reduction_type) + << FD->getType() + << diag::OACCReductionTy::MemberNotScalar); } } } else { - EmitDiags(VarLoc, PDiag(diag::err_acc_reduction_type) - << CurType << diag::OACCReductionTy::NotScalar); + return EmitDiags(VarLoc, PDiag(diag::err_acc_reduction_type) + << CurType + << diag::OACCReductionTy::NotScalar); } + return false; +} + +/// OpenACC 3.3 section 2.5.15: +/// At a mininmum, the supported data types include ... the numerical data types +/// in C, C++, and Fortran. +/// +/// If the reduction var is a composite variable, each +/// member of the composite variable must be a supported datatype for the +/// reduction operation. +ExprResult SemaOpenACC::CheckReductionVar(OpenACCDirectiveKind DirectiveKind, + OpenACCReductionOperator ReductionOp, + Expr *VarExpr) { + // For now, we only support 'scalar' types, or composites/arrays of scalar + // types. + VarExpr = VarExpr->IgnoreParenCasts(); + + if (CheckReductionVarType(VarExpr)) + return ExprError(); + // OpenACC3.3: 2.9.11: Reduction clauses on nested constructs for the same // reduction 'var' must have the same reduction operator. if (!VarExpr->isInstantiationDependent()) { diff --git a/clang/lib/StaticAnalyzer/Core/EntryPointStats.cpp b/clang/lib/StaticAnalyzer/Core/EntryPointStats.cpp index 62ae62f2f..abfb176 100644 --- a/clang/lib/StaticAnalyzer/Core/EntryPointStats.cpp +++ b/clang/lib/StaticAnalyzer/Core/EntryPointStats.cpp @@ -24,7 +24,6 @@ using namespace ento; namespace { struct Registry { - std::vector<BoolEPStat *> BoolStats; std::vector<CounterEPStat *> CounterStats; std::vector<UnsignedMaxEPStat *> UnsignedMaxStats; std::vector<UnsignedEPStat *> UnsignedStats; @@ -33,7 +32,6 @@ struct Registry { struct Snapshot { const Decl *EntryPoint; - std::vector<bool> BoolStatValues; std::vector<unsigned> UnsignedStatValues; void dumpAsCSV(llvm::raw_ostream &OS) const; @@ -48,7 +46,6 @@ static llvm::ManagedStatic<Registry> StatsRegistry; namespace { template <typename Callback> void enumerateStatVectors(const Callback &Fn) { - Fn(StatsRegistry->BoolStats); Fn(StatsRegistry->CounterStats); Fn(StatsRegistry->UnsignedMaxStats); Fn(StatsRegistry->UnsignedStats); @@ -94,12 +91,6 @@ void EntryPointStat::lockRegistry(llvm::StringRef CPPFileName) { return Result; } -BoolEPStat::BoolEPStat(llvm::StringLiteral Name) : EntryPointStat(Name) { - assert(!StatsRegistry->IsLocked); - assert(!isRegistered(Name)); - StatsRegistry->BoolStats.push_back(this); -} - CounterEPStat::CounterEPStat(llvm::StringLiteral Name) : EntryPointStat(Name) { assert(!StatsRegistry->IsLocked); assert(!isRegistered(Name)); @@ -165,28 +156,14 @@ void Registry::Snapshot::dumpAsCSV(llvm::raw_ostream &OS) const { OS << StatsRegistry->EscapedCPPFileName << "\",\""; llvm::printEscapedString( clang::AnalysisDeclContext::getFunctionName(EntryPoint), OS); - OS << "\","; - auto PrintAsBool = [&OS](bool B) { OS << (B ? "true" : "false"); }; - llvm::interleave(BoolStatValues, OS, PrintAsBool, ","); - OS << ((BoolStatValues.empty() || UnsignedStatValues.empty()) ? "" : ","); + OS << "\""; + OS << (UnsignedStatValues.empty() ? "" : ","); llvm::interleave(UnsignedStatValues, OS, [&OS](unsigned U) { OS << U; }, ","); } -static std::vector<bool> consumeBoolStats() { - std::vector<bool> Result; - Result.reserve(StatsRegistry->BoolStats.size()); - for (auto *M : StatsRegistry->BoolStats) { - Result.push_back(M->value()); - M->reset(); - } - return Result; -} - void EntryPointStat::takeSnapshot(const Decl *EntryPoint) { - auto BoolValues = consumeBoolStats(); auto UnsignedValues = consumeUnsignedStats(); - StatsRegistry->Snapshots.push_back( - {EntryPoint, std::move(BoolValues), std::move(UnsignedValues)}); + StatsRegistry->Snapshots.push_back({EntryPoint, std::move(UnsignedValues)}); } void EntryPointStat::dumpStatsAsCSV(llvm::StringRef FileName) { diff --git a/clang/test/C/C2y/n3532.c b/clang/test/C/C2y/n3532.c new file mode 100644 index 0000000..c481b58 --- /dev/null +++ b/clang/test/C/C2y/n3532.c @@ -0,0 +1,53 @@ +// RUN: %clang_cc1 -verify -std=c2y %s +// RUN: %clang_cc1 -verify -std=c23 %s +// RUN: %clang_cc1 -verify -std=c17 %s +// RUN: %clang_cc1 -verify -std=c11 %s +// RUN: %clang_cc1 -verify -std=c99 %s +// RUN: %clang_cc1 -verify -std=c89 %s + +/* WG14 N3532: Yes + * Member access of an incomplete object + * + * Verify that the first operand to the . or -> operators is a complete object + * type. + */ + +struct S { + int i; +}; + +union U { + int i; +}; + +void good_test(void) { + struct S s; + struct S *s_ptr = &s; + union U u; + union U *u_ptr = &u; + + // Complete object type, correctly named member. + s.i = 10; + s_ptr->i = 10; + u.i = 10; + u_ptr->i = 10; +} + +void bad_test(void) { + struct Incomplete *s_ptr; /* expected-note 2 {{forward declaration of 'struct Incomplete'}} */ + union AlsoIncomplete *u_ptr; /* expected-note 2 {{forward declaration of 'union AlsoIncomplete'}} */ + struct S s; + union U u; + + // Incomplete object type. + s_ptr->i = 10; /* expected-error {{incomplete definition of type 'struct Incomplete'}} */ + u_ptr->i = 10; /* expected-error {{incomplete definition of type 'union AlsoIncomplete'}} */ + + (*s_ptr).i = 10; /* expected-error {{incomplete definition of type 'struct Incomplete'}} */ + (*u_ptr).i = 10; /* expected-error {{incomplete definition of type 'union AlsoIncomplete'}} */ + + // Complete object type, no named member. + s.f = "test"; /* expected-error {{no member named 'f' in 'struct S'}} */ + u.f = "test"; /* expected-error {{no member named 'f' in 'union U'}} */ +} + diff --git a/clang/test/C/C2y/n3622.c b/clang/test/C/C2y/n3622.c new file mode 100644 index 0000000..95b92e8 --- /dev/null +++ b/clang/test/C/C2y/n3622.c @@ -0,0 +1,25 @@ +// RUN: %clang_cc1 -verify=good -pedantic -Wall -std=c2y %s +// RUN: %clang_cc1 -verify=compat,expected -pedantic -Wall -Wpre-c2y-compat -std=c2y %s +// RUN: %clang_cc1 -verify=ped,expected -pedantic -Wall -std=c23 %s +// RUN: %clang_cc1 -verify=ped,expected -pedantic -Wall -std=c17 %s +// good-no-diagnostics + +/* WG14 N3622: Clang 22 + * Allow calling static inline within extern inline + * + * This verifies that a constraint from previous standards is no longer + * triggered in C2y mode. The constraint is with calling a static function + * or using a static variable from an inline function with external linkage. + */ + +static void static_func(void) {} // expected-note {{declared here}} +static int static_var; // expected-note {{declared here}} + +extern inline void test(void) { + static_func(); /* ped-warning {{using static function 'static_func' in an inline function with external linkage is a C2y extension}} + compat-warning {{using static function 'static_func' in an inline function with external linkage is incompatible with standards before C2y}} + */ + static_var = 12; /* ped-warning {{using static variable 'static_var' in an inline function with external linkage is a C2y extension}} + compat-warning {{using static variable 'static_var' in an inline function with external linkage is incompatible with standards before C2y}} + */ +} diff --git a/clang/test/C/C2y/n3623.c b/clang/test/C/C2y/n3623.c new file mode 100644 index 0000000..5e004c1 --- /dev/null +++ b/clang/test/C/C2y/n3623.c @@ -0,0 +1,77 @@ +// RUN: %clang_cc1 -verify -std=c2y -DSTD1 %s +// RUN: %clang_cc1 -verify -std=c2y -DSTD2 %s +// RUN: %clang_cc1 -verify=gnu1 -std=gnu2y -DGNU1 %s +// RUN: %clang_cc1 -verify -std=gnu2y -DGNU2 %s +// RUN: %clang_cc1 -verify=gnu3 -std=gnu2y -DGNU3 %s +// RUN: %clang_cc1 -verify -std=gnu2y -DGNU4 %s +// RUN: %clang_cc1 -verify -std=gnu2y -DGNU5 %s +// RUN: %clang_cc1 -verify -std=gnu2y -DGNU6 %s +// RUN: %clang_cc1 -verify=gnu7 -std=gnu2y -DGNU7 %s +// RUN: %clang_cc1 -triple x86_64-apple-darwin12 -verify -std=c2y -DDARWIN1 %s +// RUN: %clang_cc1 -triple x86_64-pc-win32-mscv -verify -std=c2y -fms-compatibility -DMS1 %s +// RUN: %clang_cc1 -triple x86_64-pc-win32-mscv -verify -std=c2y -fms-compatibility -DMS2 %s +// RUN: %clang_cc1 -verify=invalid -std=c2y -DINVALID1 %s +// RUN: %clang_cc1 -verify=invalid -std=c2y -DINVALID2 %s +// expected-no-diagnostics + +/* WG14 N3623: Yes + * Earthly Demon XV: Definition of Main + * + * This validates that we accept the standard type definitions of main or some + * other implementation-defined type. + */ + +typedef __WCHAR_TYPE__ wchar_t; + +// These are the signatures required by the standard. +#if defined(STD1) +int main(void) {} +#elif defined(STD2) +int main(int argc, char *argv[]) {} +#endif + +// GNU extensions. +#if defined(GNU1) +void main(void) {} /* gnu1-warning {{return type of 'main' is not 'int'}} + gnu1-note {{change return type to 'int'}} + */ +#elif defined(GNU2) +const int main(void) {} +#elif defined(GNU3) +int main(...) {} /* gnu3-warning {{'main' is not allowed to be declared variadic}} */ +#elif defined(GNU4) +int main(int, const char **) {} +#elif defined(GNU5) +int main(int, char const * const *) {} +#elif defined(GNU6) +int main(int, char * const *) {} +#elif defined(GNU7) +int main(int) {} /* gnu7-warning {{only one parameter on 'main' declaration}} */ +#endif + +// Darwin extensions. +#if defined(DARWIN1) +int main(int argc, char *argv[], char *environ[], char **undocumented) {} +#endif + +// Microsoft extensions. +#if defined(MS1) +int wmain(int, wchar_t *[]) {} +#elif defined(MS2) +int wmain(int, wchar_t *[], wchar_t *[]) {} +#endif + +// Invalid signatures. +#if defined(INVALID1) +inline int main(int, char *[]); /* invalid-error {{'main' is not allowed to be declared inline}} */ +#if !__is_target_os(darwin) +// This test doesn't make sense on Darwin where four arguments are allowed. +int main(int, char *[], char *[], float); /* invalid-error {{too many parameters (4) for 'main': must be 0, 2, or 3}} */ +#endif +float main(int); /* invalid-error {{'main' must return 'int'}} */ +_Noreturn int main(int, char *[]); /* invalid-warning {{'main' is not allowed to be declared _Noreturn}} + invalid-note {{remove '_Noreturn'}} + */ +#elif defined(INVALID2) +static int main(void); /* invalid-warning {{'main' should not be declared static}} */ +#endif diff --git a/clang/test/CIR/CodeGen/dynamic-cast.cpp b/clang/test/CIR/CodeGen/dynamic-cast.cpp index e5244b2..b493840 100644 --- a/clang/test/CIR/CodeGen/dynamic-cast.cpp +++ b/clang/test/CIR/CodeGen/dynamic-cast.cpp @@ -1,5 +1,11 @@ // 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 +// RUN: %clang_cc1 -triple x86_64-unknown-linux-gnu -std=c++20 -fclangir -emit-cir -mmlir --mlir-print-ir-after=cir-lowering-prepare %s -o %t.cir 2> %t.after.log +// RUN: FileCheck %s --input-file=%t.after.log -check-prefix=CIR-AFTER +// RUN: %clang_cc1 -triple x86_64-unknown-linux-gnu -std=c++20 -fclangir -emit-llvm %s -o %t-cir.ll +// RUN: FileCheck %s --input-file=%t-cir.ll -check-prefix=LLVM +// RUN: %clang_cc1 -triple x86_64-unknown-linux-gnu -std=c++20 -emit-llvm %s -o %t.ll +// RUN: FileCheck %s --input-file=%t.ll -check-prefix=OGCG struct Base { virtual ~Base(); @@ -19,6 +25,46 @@ Derived *ptr_cast(Base *b) { // CIR-BEFORE: %{{.+}} = cir.dyn_cast ptr %{{.+}} : !cir.ptr<!rec_Base> -> !cir.ptr<!rec_Derived> #dyn_cast_info__ZTI4Base__ZTI7Derived // CIR-BEFORE: } +// CIR-AFTER: cir.func dso_local @_Z8ptr_castP4Base +// CIR-AFTER: %[[SRC:.*]] = cir.load{{.*}} %{{.+}} : !cir.ptr<!cir.ptr<!rec_Base>>, !cir.ptr<!rec_Base> +// CIR-AFTER-NEXT: %[[SRC_IS_NOT_NULL:.*]] = cir.cast ptr_to_bool %[[SRC]] : !cir.ptr<!rec_Base> -> !cir.bool +// CIR-AFTER-NEXT: %{{.+}} = cir.ternary(%[[SRC_IS_NOT_NULL]], true { +// CIR-AFTER-NEXT: %[[SRC_VOID_PTR:.*]] = cir.cast bitcast %[[SRC]] : !cir.ptr<!rec_Base> -> !cir.ptr<!void> +// CIR-AFTER-NEXT: %[[BASE_RTTI:.*]] = cir.const #cir.global_view<@_ZTI4Base> : !cir.ptr<!u8i> +// CIR-AFTER-NEXT: %[[DERIVED_RTTI:.*]] = cir.const #cir.global_view<@_ZTI7Derived> : !cir.ptr<!u8i> +// CIR-AFTER-NEXT: %[[HINT:.*]] = cir.const #cir.int<0> : !s64i +// CIR-AFTER-NEXT: %[[RT_CALL_RET:.*]] = cir.call @__dynamic_cast(%[[SRC_VOID_PTR]], %[[BASE_RTTI]], %[[DERIVED_RTTI]], %[[HINT]]) : (!cir.ptr<!void>, !cir.ptr<!u8i>, !cir.ptr<!u8i>, !s64i) -> !cir.ptr<!void> +// CIR-AFTER-NEXT: %[[CASTED:.*]] = cir.cast bitcast %[[RT_CALL_RET]] : !cir.ptr<!void> -> !cir.ptr<!rec_Derived> +// CIR-AFTER-NEXT: cir.yield %[[CASTED]] : !cir.ptr<!rec_Derived> +// CIR-AFTER-NEXT: }, false { +// CIR-AFTER-NEXT: %[[NULL_PTR:.*]] = cir.const #cir.ptr<null> : !cir.ptr<!rec_Derived> +// CIR-AFTER-NEXT: cir.yield %[[NULL_PTR]] : !cir.ptr<!rec_Derived> +// CIR-AFTER-NEXT: }) : (!cir.bool) -> !cir.ptr<!rec_Derived> +// CIR-AFTER: } + +// LLVM: define {{.*}} @_Z8ptr_castP4Base +// LLVM: %[[IS_NOT_NULL:.*]] = icmp ne ptr %[[PTR:.*]], null +// LLVM: br i1 %[[IS_NOT_NULL]], label %[[NOT_NULL:.*]], label %[[NULL:.*]] +// LLVM: [[NOT_NULL]]: +// LLVM: %[[RESULT:.*]] = call ptr @__dynamic_cast(ptr %[[PTR]], ptr @_ZTI4Base, ptr @_ZTI7Derived, i64 0) +// LLVM: br label %[[DONE:.*]] +// LLVM: [[NULL]]: +// LLVM: br label %[[DONE]] +// LLVM: [[DONE]]: +// LLVM: %[[RET:.*]] = phi ptr [ null, %[[NULL]] ], [ %[[RESULT]], %[[NOT_NULL]] ] + +// OGCG: define {{.*}} @_Z8ptr_castP4Base +// OGCG: %[[IS_NULL:.*]] = icmp eq ptr %[[PTR:.*]], null +// OGCG: br i1 %[[IS_NULL]], label %[[NULL:.*]], label %[[NOT_NULL:.*]] +// OGCG: [[NOT_NULL]]: +// OGCG: %[[RESULT:.*]] = call ptr @__dynamic_cast(ptr %[[PTR]], ptr @_ZTI4Base, ptr @_ZTI7Derived, i64 0) +// OGCG: br label %[[DONE:.*]] +// OGCG: [[NULL]]: +// OGCG: br label %[[DONE]] +// OGCG: [[DONE]]: +// OGCG: %[[RET:.*]] = phi ptr [ %[[RESULT]], %[[NOT_NULL]] ], [ null, %[[NULL]] ] + + Derived &ref_cast(Base &b) { return dynamic_cast<Derived &>(b); } @@ -26,3 +72,32 @@ Derived &ref_cast(Base &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: } + +// CIR-AFTER: cir.func dso_local @_Z8ref_castR4Base +// CIR-AFTER: %[[SRC_VOID_PTR:.*]] = cir.cast bitcast %{{.+}} : !cir.ptr<!rec_Base> -> !cir.ptr<!void> +// CIR-AFTER-NEXT: %[[SRC_RTTI:.*]] = cir.const #cir.global_view<@_ZTI4Base> : !cir.ptr<!u8i> +// CIR-AFTER-NEXT: %[[DEST_RTTI:.*]] = cir.const #cir.global_view<@_ZTI7Derived> : !cir.ptr<!u8i> +// CIR-AFTER-NEXT: %[[OFFSET_HINT:.*]] = cir.const #cir.int<0> : !s64i +// CIR-AFTER-NEXT: %[[CASTED_PTR:.*]] = cir.call @__dynamic_cast(%[[SRC_VOID_PTR]], %[[SRC_RTTI]], %[[DEST_RTTI]], %[[OFFSET_HINT]]) : (!cir.ptr<!void>, !cir.ptr<!u8i>, !cir.ptr<!u8i>, !s64i) -> !cir.ptr<!void> +// CIR-AFTER-NEXT: %[[NULL_PTR:.*]] = cir.const #cir.ptr<null> : !cir.ptr<!void> +// CIR-AFTER-NEXT: %[[CASTED_PTR_IS_NULL:.*]] = cir.cmp(eq, %[[CASTED_PTR]], %[[NULL_PTR]]) : !cir.ptr<!void>, !cir.bool +// CIR-AFTER-NEXT: cir.if %[[CASTED_PTR_IS_NULL]] { +// CIR-AFTER-NEXT: cir.call @__cxa_bad_cast() : () -> () +// CIR-AFTER-NEXT: cir.unreachable +// CIR-AFTER-NEXT: } +// CIR-AFTER-NEXT: %{{.+}} = cir.cast bitcast %[[CASTED_PTR]] : !cir.ptr<!void> -> !cir.ptr<!rec_Derived> +// CIR-AFTER: } + +// LLVM: define {{.*}} ptr @_Z8ref_castR4Base +// LLVM: %[[RESULT:.*]] = call ptr @__dynamic_cast(ptr %{{.*}}, ptr @_ZTI4Base, ptr @_ZTI7Derived, i64 0) +// LLVM: %[[IS_NULL:.*]] = icmp eq ptr %[[RESULT]], null +// LLVM: br i1 %[[IS_NULL]], label %[[BAD_CAST:.*]], label %[[DONE:.*]] +// LLVM: [[BAD_CAST]]: +// LLVM: call void @__cxa_bad_cast() + +// OGCG: define {{.*}} ptr @_Z8ref_castR4Base +// OGCG: %[[RESULT:.*]] = call ptr @__dynamic_cast(ptr %0, ptr @_ZTI4Base, ptr @_ZTI7Derived, i64 0) +// OGCG: %[[IS_NULL:.*]] = icmp eq ptr %[[RESULT]], null +// OGCG: br i1 %[[IS_NULL]], label %[[BAD_CAST:.*]], label %[[DONE:.*]] +// OGCG: [[BAD_CAST]]: +// OGCG: call void @__cxa_bad_cast() diff --git a/clang/test/CIR/CodeGen/try-catch.cpp b/clang/test/CIR/CodeGen/try-catch.cpp new file mode 100644 index 0000000..8f0b3c4 --- /dev/null +++ b/clang/test/CIR/CodeGen/try-catch.cpp @@ -0,0 +1,32 @@ +// RUN: %clang_cc1 -std=c++20 -triple x86_64-unknown-linux-gnu -fcxx-exceptions -fexceptions -fclangir -emit-cir %s -o %t.cir +// RUN: FileCheck --input-file=%t.cir %s -check-prefix=CIR +// RUN: %clang_cc1 -std=c++20 -triple x86_64-unknown-linux-gnu -fcxx-exceptions -fexceptions -fclangir -emit-llvm %s -o %t-cir.ll +// RUN: FileCheck --input-file=%t-cir.ll %s -check-prefix=LLVM +// RUN: %clang_cc1 -std=c++20 -triple x86_64-unknown-linux-gnu -fcxx-exceptions -fexceptions -emit-llvm %s -o %t.ll +// RUN: FileCheck --input-file=%t.ll %s -check-prefix=OGCG + +void empty_try_block_with_catch_all() { + try {} catch (...) {} +} + +// CIR: cir.func{{.*}} @_Z30empty_try_block_with_catch_allv() +// CIR: cir.return + +// LLVM: define{{.*}} void @_Z30empty_try_block_with_catch_allv() +// LLVM: ret void + +// OGCG: define{{.*}} void @_Z30empty_try_block_with_catch_allv() +// OGCG: ret void + +void empty_try_block_with_catch_with_int_exception() { + try {} catch (int e) {} +} + +// CIR: cir.func{{.*}} @_Z45empty_try_block_with_catch_with_int_exceptionv() +// CIR: cir.return + +// LLVM: define{{.*}} void @_Z45empty_try_block_with_catch_with_int_exceptionv() +// LLVM: ret void + +// OGCG: define{{.*}} void @_Z45empty_try_block_with_catch_with_int_exceptionv() +// OGCG: ret void diff --git a/clang/test/CIR/CodeGenOpenACC/combined-reduction-clause-default-ops.cpp b/clang/test/CIR/CodeGenOpenACC/combined-reduction-clause-default-ops.cpp index 7b74b7c..040ddd3 100644 --- a/clang/test/CIR/CodeGenOpenACC/combined-reduction-clause-default-ops.cpp +++ b/clang/test/CIR/CodeGenOpenACC/combined-reduction-clause-default-ops.cpp @@ -8,12 +8,19 @@ struct DefaultOperators { bool b; }; +struct DefaultOperatorsNoFloats { + int i; + unsigned int u; + bool b; +}; + template<typename T> void acc_combined() { T someVar; T someVarArr[5]; + struct DefaultOperatorsNoFloats someVarNoFloats; + struct DefaultOperatorsNoFloats someVarArrNoFloats[5]; #pragma acc parallel loop reduction(+:someVar) - for(int i=0;i < 5; ++i); // CHECK: acc.reduction.recipe @reduction_add__ZTS16DefaultOperators : !cir.ptr<!rec_DefaultOperators> reduction_operator <add> init { // CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!rec_DefaultOperators>{{.*}}) // CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !rec_DefaultOperators, !cir.ptr<!rec_DefaultOperators>, ["openacc.reduction.init", init] @@ -39,6 +46,7 @@ void acc_combined() { // TODO OpenACC: Expecting combination operation here // CHECK-NEXT: acc.yield %[[LHSARG]] : !cir.ptr<!rec_DefaultOperators> // CHECK-NEXT: } + for(int i=0;i < 5; ++i); #pragma acc parallel loop reduction(*:someVar) // CHECK-NEXT: acc.reduction.recipe @reduction_mul__ZTS16DefaultOperators : !cir.ptr<!rec_DefaultOperators> reduction_operator <mul> init { @@ -121,86 +129,67 @@ void acc_combined() { // CHECK-NEXT: acc.yield %[[LHSARG]] : !cir.ptr<!rec_DefaultOperators> // CHECK-NEXT: } for(int i=0;i < 5; ++i); -#pragma acc parallel loop reduction(&:someVar) - -// CHECK-NEXT: acc.reduction.recipe @reduction_iand__ZTS16DefaultOperators : !cir.ptr<!rec_DefaultOperators> reduction_operator <iand> init { -// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!rec_DefaultOperators>{{.*}}) -// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !rec_DefaultOperators, !cir.ptr<!rec_DefaultOperators>, ["openacc.reduction.init", init] -// CHECK-NEXT: %[[GET_I:.*]] = cir.get_member %[[ALLOCA]][0] {name = "i"} : !cir.ptr<!rec_DefaultOperators> -> !cir.ptr<!s32i> +#pragma acc parallel loop reduction(&:someVarNoFloats) +// CHECK-NEXT: acc.reduction.recipe @reduction_iand__ZTS24DefaultOperatorsNoFloats : !cir.ptr<!rec_DefaultOperatorsNoFloats> reduction_operator <iand> init { +// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!rec_DefaultOperatorsNoFloats>{{.*}}) +// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !rec_DefaultOperatorsNoFloats, !cir.ptr<!rec_DefaultOperatorsNoFloats>, ["openacc.reduction.init", init] +// CHECK-NEXT: %[[GET_I:.*]] = cir.get_member %[[ALLOCA]][0] {name = "i"} : !cir.ptr<!rec_DefaultOperatorsNoFloats> -> !cir.ptr<!s32i> // CHECK-NEXT: %[[ALL_ONES:.*]] = cir.const #cir.int<-1> : !s32i // CHECK-NEXT: cir.store {{.*}} %[[ALL_ONES]], %[[GET_I]] : !s32i, !cir.ptr<!s32i> -// CHECK-NEXT: %[[GET_U:.*]] = cir.get_member %[[ALLOCA]][1] {name = "u"} : !cir.ptr<!rec_DefaultOperators> -> !cir.ptr<!u32i> +// CHECK-NEXT: %[[GET_U:.*]] = cir.get_member %[[ALLOCA]][1] {name = "u"} : !cir.ptr<!rec_DefaultOperatorsNoFloats> -> !cir.ptr<!u32i> // CHECK-NEXT: %[[ALL_ONES:.*]] = cir.const #cir.int<4294967295> : !u32i // CHECK-NEXT: cir.store {{.*}} %[[ALL_ONES]], %[[GET_U]] : !u32i, !cir.ptr<!u32i> -// CHECK-NEXT: %[[GET_F:.*]] = cir.get_member %[[ALLOCA]][2] {name = "f"} : !cir.ptr<!rec_DefaultOperators> -> !cir.ptr<!cir.float> -// CHECK-NEXT: %[[ALL_ONES:.*]] = cir.const #cir.fp<0xFF{{.*}}> : !cir.float -// CHECK-NEXT: cir.store {{.*}} %[[ALL_ONES]], %[[GET_F]] : !cir.float, !cir.ptr<!cir.float> -// CHECK-NEXT: %[[GET_D:.*]] = cir.get_member %[[ALLOCA]][3] {name = "d"} : !cir.ptr<!rec_DefaultOperators> -> !cir.ptr<!cir.double> -// CHECK-NEXT: %[[ALL_ONES:.*]] = cir.const #cir.fp<0xFF{{.*}}> : !cir.double -// CHECK-NEXT: cir.store {{.*}} %[[ALL_ONES]], %[[GET_D]] : !cir.double, !cir.ptr<!cir.double> -// CHECK-NEXT: %[[GET_B:.*]] = cir.get_member %[[ALLOCA]][4] {name = "b"} : !cir.ptr<!rec_DefaultOperators> -> !cir.ptr<!cir.bool> +// CHECK-NEXT: %[[GET_B:.*]] = cir.get_member %[[ALLOCA]][2] {name = "b"} : !cir.ptr<!rec_DefaultOperatorsNoFloats> -> !cir.ptr<!cir.bool> // CHECK-NEXT: %[[ALL_ONES:.*]] = cir.const #true // CHECK-NEXT: cir.store {{.*}} %[[ALL_ONES]], %[[GET_B]] : !cir.bool, !cir.ptr<!cir.bool> // CHECK-NEXT: acc.yield // // CHECK-NEXT: } combiner { -// CHECK-NEXT: ^bb0(%[[LHSARG:.*]]: !cir.ptr<!rec_DefaultOperators> {{.*}}, %[[RHSARG:.*]]: !cir.ptr<!rec_DefaultOperators> {{.*}}) +// CHECK-NEXT: ^bb0(%[[LHSARG:.*]]: !cir.ptr<!rec_DefaultOperatorsNoFloats> {{.*}}, %[[RHSARG:.*]]: !cir.ptr<!rec_DefaultOperatorsNoFloats> {{.*}}) // TODO OpenACC: Expecting combination operation here -// CHECK-NEXT: acc.yield %[[LHSARG]] : !cir.ptr<!rec_DefaultOperators> +// CHECK-NEXT: acc.yield %[[LHSARG]] : !cir.ptr<!rec_DefaultOperatorsNoFloats> // CHECK-NEXT: } - for(int i=0;i < 5; ++i); -#pragma acc parallel loop reduction(|:someVar) -// CHECK-NEXT: acc.reduction.recipe @reduction_ior__ZTS16DefaultOperators : !cir.ptr<!rec_DefaultOperators> reduction_operator <ior> init { -// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!rec_DefaultOperators>{{.*}}) -// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !rec_DefaultOperators, !cir.ptr<!rec_DefaultOperators>, ["openacc.reduction.init", init] -// CHECK-NEXT: %[[GET_I:.*]] = cir.get_member %[[ALLOCA]][0] {name = "i"} : !cir.ptr<!rec_DefaultOperators> -> !cir.ptr<!s32i> + for(int i = 0; i < 5; ++i); +#pragma acc parallel loop reduction(|:someVarNoFloats) +// CHECK-NEXT: acc.reduction.recipe @reduction_ior__ZTS24DefaultOperatorsNoFloats : !cir.ptr<!rec_DefaultOperatorsNoFloats> reduction_operator <ior> init { +// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!rec_DefaultOperatorsNoFloats>{{.*}}) +// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !rec_DefaultOperatorsNoFloats, !cir.ptr<!rec_DefaultOperatorsNoFloats>, ["openacc.reduction.init", init] +// CHECK-NEXT: %[[GET_I:.*]] = cir.get_member %[[ALLOCA]][0] {name = "i"} : !cir.ptr<!rec_DefaultOperatorsNoFloats> -> !cir.ptr<!s32i> // CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !s32i // CHECK-NEXT: cir.store {{.*}} %[[ZERO]], %[[GET_I]] : !s32i, !cir.ptr<!s32i> -// CHECK-NEXT: %[[GET_U:.*]] = cir.get_member %[[ALLOCA]][1] {name = "u"} : !cir.ptr<!rec_DefaultOperators> -> !cir.ptr<!u32i> +// CHECK-NEXT: %[[GET_U:.*]] = cir.get_member %[[ALLOCA]][1] {name = "u"} : !cir.ptr<!rec_DefaultOperatorsNoFloats> -> !cir.ptr<!u32i> // CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !u32i // CHECK-NEXT: cir.store {{.*}} %[[ZERO]], %[[GET_U]] : !u32i, !cir.ptr<!u32i> -// CHECK-NEXT: %[[GET_F:.*]] = cir.get_member %[[ALLOCA]][2] {name = "f"} : !cir.ptr<!rec_DefaultOperators> -> !cir.ptr<!cir.float> -// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.fp<0{{.*}}> : !cir.float -// CHECK-NEXT: cir.store {{.*}} %[[ZERO]], %[[GET_F]] : !cir.float, !cir.ptr<!cir.float> -// CHECK-NEXT: %[[GET_D:.*]] = cir.get_member %[[ALLOCA]][3] {name = "d"} : !cir.ptr<!rec_DefaultOperators> -> !cir.ptr<!cir.double> -// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.fp<0{{.*}}> : !cir.double -// CHECK-NEXT: cir.store {{.*}} %[[ZERO]], %[[GET_D]] : !cir.double, !cir.ptr<!cir.double> -// CHECK-NEXT: %[[GET_B:.*]] = cir.get_member %[[ALLOCA]][4] {name = "b"} : !cir.ptr<!rec_DefaultOperators> -> !cir.ptr<!cir.bool> +// CHECK-NEXT: %[[GET_B:.*]] = cir.get_member %[[ALLOCA]][2] {name = "b"} : !cir.ptr<!rec_DefaultOperatorsNoFloats> -> !cir.ptr<!cir.bool> // CHECK-NEXT: %[[ZERO:.*]] = cir.const #false // CHECK-NEXT: cir.store {{.*}} %[[ZERO]], %[[GET_B]] : !cir.bool, !cir.ptr<!cir.bool> // CHECK-NEXT: acc.yield // // CHECK-NEXT: } combiner { -// CHECK-NEXT: ^bb0(%[[LHSARG:.*]]: !cir.ptr<!rec_DefaultOperators> {{.*}}, %[[RHSARG:.*]]: !cir.ptr<!rec_DefaultOperators> {{.*}}) +// CHECK-NEXT: ^bb0(%[[LHSARG:.*]]: !cir.ptr<!rec_DefaultOperatorsNoFloats> {{.*}}, %[[RHSARG:.*]]: !cir.ptr<!rec_DefaultOperatorsNoFloats> {{.*}}) // TODO OpenACC: Expecting combination operation here -// CHECK-NEXT: acc.yield %[[LHSARG]] : !cir.ptr<!rec_DefaultOperators> +// CHECK-NEXT: acc.yield %[[LHSARG]] : !cir.ptr<!rec_DefaultOperatorsNoFloats> // CHECK-NEXT: } - for(int i=0;i < 5; ++i); -#pragma acc parallel loop reduction(^:someVar) -// CHECK-NEXT: acc.reduction.recipe @reduction_xor__ZTS16DefaultOperators : !cir.ptr<!rec_DefaultOperators> reduction_operator <xor> init { -// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!rec_DefaultOperators>{{.*}}) -// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !rec_DefaultOperators, !cir.ptr<!rec_DefaultOperators>, ["openacc.reduction.init", init] -// CHECK-NEXT: %[[GET_I:.*]] = cir.get_member %[[ALLOCA]][0] {name = "i"} : !cir.ptr<!rec_DefaultOperators> -> !cir.ptr<!s32i> + for(int i = 0; i < 5; ++i); +#pragma acc parallel loop reduction(^:someVarNoFloats) +// CHECK-NEXT: acc.reduction.recipe @reduction_xor__ZTS24DefaultOperatorsNoFloats : !cir.ptr<!rec_DefaultOperatorsNoFloats> reduction_operator <xor> init { +// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!rec_DefaultOperatorsNoFloats>{{.*}}) +// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !rec_DefaultOperatorsNoFloats, !cir.ptr<!rec_DefaultOperatorsNoFloats>, ["openacc.reduction.init", init] +// CHECK-NEXT: %[[GET_I:.*]] = cir.get_member %[[ALLOCA]][0] {name = "i"} : !cir.ptr<!rec_DefaultOperatorsNoFloats> -> !cir.ptr<!s32i> // CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !s32i // CHECK-NEXT: cir.store {{.*}} %[[ZERO]], %[[GET_I]] : !s32i, !cir.ptr<!s32i> -// CHECK-NEXT: %[[GET_U:.*]] = cir.get_member %[[ALLOCA]][1] {name = "u"} : !cir.ptr<!rec_DefaultOperators> -> !cir.ptr<!u32i> +// CHECK-NEXT: %[[GET_U:.*]] = cir.get_member %[[ALLOCA]][1] {name = "u"} : !cir.ptr<!rec_DefaultOperatorsNoFloats> -> !cir.ptr<!u32i> // CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !u32i // CHECK-NEXT: cir.store {{.*}} %[[ZERO]], %[[GET_U]] : !u32i, !cir.ptr<!u32i> -// CHECK-NEXT: %[[GET_F:.*]] = cir.get_member %[[ALLOCA]][2] {name = "f"} : !cir.ptr<!rec_DefaultOperators> -> !cir.ptr<!cir.float> -// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.fp<0{{.*}}> : !cir.float -// CHECK-NEXT: cir.store {{.*}} %[[ZERO]], %[[GET_F]] : !cir.float, !cir.ptr<!cir.float> -// CHECK-NEXT: %[[GET_D:.*]] = cir.get_member %[[ALLOCA]][3] {name = "d"} : !cir.ptr<!rec_DefaultOperators> -> !cir.ptr<!cir.double> -// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.fp<0{{.*}}> : !cir.double -// CHECK-NEXT: cir.store {{.*}} %[[ZERO]], %[[GET_D]] : !cir.double, !cir.ptr<!cir.double> -// CHECK-NEXT: %[[GET_B:.*]] = cir.get_member %[[ALLOCA]][4] {name = "b"} : !cir.ptr<!rec_DefaultOperators> -> !cir.ptr<!cir.bool> +// CHECK-NEXT: %[[GET_B:.*]] = cir.get_member %[[ALLOCA]][2] {name = "b"} : !cir.ptr<!rec_DefaultOperatorsNoFloats> -> !cir.ptr<!cir.bool> // CHECK-NEXT: %[[ZERO:.*]] = cir.const #false // CHECK-NEXT: cir.store {{.*}} %[[ZERO]], %[[GET_B]] : !cir.bool, !cir.ptr<!cir.bool> // CHECK-NEXT: acc.yield // // CHECK-NEXT: } combiner { -// CHECK-NEXT: ^bb0(%[[LHSARG:.*]]: !cir.ptr<!rec_DefaultOperators> {{.*}}, %[[RHSARG:.*]]: !cir.ptr<!rec_DefaultOperators> {{.*}}) +// CHECK-NEXT: ^bb0(%[[LHSARG:.*]]: !cir.ptr<!rec_DefaultOperatorsNoFloats> {{.*}}, %[[RHSARG:.*]]: !cir.ptr<!rec_DefaultOperatorsNoFloats> {{.*}}) // TODO OpenACC: Expecting combination operation here -// CHECK-NEXT: acc.yield %[[LHSARG]] : !cir.ptr<!rec_DefaultOperators> +// CHECK-NEXT: acc.yield %[[LHSARG]] : !cir.ptr<!rec_DefaultOperatorsNoFloats> // CHECK-NEXT: } for(int i=0;i < 5; ++i); #pragma acc parallel loop reduction(&&:someVar) @@ -606,194 +595,152 @@ void acc_combined() { // TODO OpenACC: Expecting combination operation here // CHECK-NEXT: acc.yield %[[LHSARG]] : !cir.ptr<!cir.array<!rec_DefaultOperators x 5>> // CHECK-NEXT: } - for(int i=0;i < 5; ++i); -#pragma acc parallel loop reduction(&:someVarArr) -// CHECK-NEXT: acc.reduction.recipe @reduction_iand__ZTSA5_16DefaultOperators : !cir.ptr<!cir.array<!rec_DefaultOperators x 5>> reduction_operator <iand> init { -// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!rec_DefaultOperators x 5>>{{.*}}) -// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !cir.array<!rec_DefaultOperators x 5>, !cir.ptr<!cir.array<!rec_DefaultOperators x 5>>, ["openacc.reduction.init", init] -// CHECK-NEXT: %[[DECAY:.*]] = cir.cast array_to_ptrdecay %[[ALLOCA]] : !cir.ptr<!cir.array<!rec_DefaultOperators x 5>> -> !cir.ptr<!rec_DefaultOperators> -// CHECK-NEXT: %[[GET_I:.*]] = cir.get_member %[[DECAY]][0] {name = "i"} : !cir.ptr<!rec_DefaultOperators> -> !cir.ptr<!s32i> + for(int i = 0; i < 5; ++i); +#pragma acc parallel loop reduction(&:someVarArrNoFloats) +// CHECK-NEXT: acc.reduction.recipe @reduction_iand__ZTSA5_24DefaultOperatorsNoFloats : !cir.ptr<!cir.array<!rec_DefaultOperatorsNoFloats x 5>> reduction_operator <iand> init { +// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!rec_DefaultOperatorsNoFloats x 5>>{{.*}}) +// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !cir.array<!rec_DefaultOperatorsNoFloats x 5>, !cir.ptr<!cir.array<!rec_DefaultOperatorsNoFloats x 5>>, ["openacc.reduction.init", init] +// CHECK-NEXT: %[[DECAY:.*]] = cir.cast array_to_ptrdecay %[[ALLOCA]] : !cir.ptr<!cir.array<!rec_DefaultOperatorsNoFloats x 5>> -> !cir.ptr<!rec_DefaultOperatorsNoFloats> +// CHECK-NEXT: %[[GET_I:.*]] = cir.get_member %[[DECAY]][0] {name = "i"} : !cir.ptr<!rec_DefaultOperatorsNoFloats> -> !cir.ptr<!s32i> // CHECK-NEXT: %[[ALL_ONES:.*]] = cir.const #cir.int<-1> : !s32i // CHECK-NEXT: cir.store {{.*}} %[[ALL_ONES]], %[[GET_I]] : !s32i, !cir.ptr<!s32i> -// CHECK-NEXT: %[[GET_U:.*]] = cir.get_member %[[DECAY]][1] {name = "u"} : !cir.ptr<!rec_DefaultOperators> -> !cir.ptr<!u32i> +// CHECK-NEXT: %[[GET_U:.*]] = cir.get_member %[[DECAY]][1] {name = "u"} : !cir.ptr<!rec_DefaultOperatorsNoFloats> -> !cir.ptr<!u32i> // CHECK-NEXT: %[[ALL_ONES:.*]] = cir.const #cir.int<4294967295> : !u32i // CHECK-NEXT: cir.store {{.*}} %[[ALL_ONES]], %[[GET_U]] : !u32i, !cir.ptr<!u32i> -// CHECK-NEXT: %[[GET_F:.*]] = cir.get_member %[[DECAY]][2] {name = "f"} : !cir.ptr<!rec_DefaultOperators> -> !cir.ptr<!cir.float> -// CHECK-NEXT: %[[ALL_ONES:.*]] = cir.const #cir.fp<0xFF{{.*}}> : !cir.float -// CHECK-NEXT: cir.store {{.*}} %[[ALL_ONES]], %[[GET_F]] : !cir.float, !cir.ptr<!cir.float> -// CHECK-NEXT: %[[GET_D:.*]] = cir.get_member %[[DECAY]][3] {name = "d"} : !cir.ptr<!rec_DefaultOperators> -> !cir.ptr<!cir.double> -// CHECK-NEXT: %[[ALL_ONES:.*]] = cir.const #cir.fp<0xFF{{.*}}> : !cir.double -// CHECK-NEXT: cir.store {{.*}} %[[ALL_ONES]], %[[GET_D]] : !cir.double, !cir.ptr<!cir.double> -// CHECK-NEXT: %[[GET_B:.*]] = cir.get_member %[[DECAY]][4] {name = "b"} : !cir.ptr<!rec_DefaultOperators> -> !cir.ptr<!cir.bool> +// CHECK-NEXT: %[[GET_B:.*]] = cir.get_member %[[DECAY]][2] {name = "b"} : !cir.ptr<!rec_DefaultOperatorsNoFloats> -> !cir.ptr<!cir.bool> // CHECK-NEXT: %[[ALL_ONES:.*]] = cir.const #true // CHECK-NEXT: cir.store {{.*}} %[[ALL_ONES]], %[[GET_B]] : !cir.bool, !cir.ptr<!cir.bool> // // CHECK-NEXT: %[[ALL_ONES_IDX:.*]] = cir.const #cir.int<1> : !s64i -// CHECK-NEXT: %[[NEXT_ELT:.*]] = cir.ptr_stride %[[DECAY]], %[[ALL_ONES_IDX]] : (!cir.ptr<!rec_DefaultOperators>, !s64i) -> !cir.ptr<!rec_DefaultOperators> -// CHECK-NEXT: %[[GET_I:.*]] = cir.get_member %[[NEXT_ELT]][0] {name = "i"} : !cir.ptr<!rec_DefaultOperators> -> !cir.ptr<!s32i> +// CHECK-NEXT: %[[NEXT_ELT:.*]] = cir.ptr_stride %[[DECAY]], %[[ALL_ONES_IDX]] : (!cir.ptr<!rec_DefaultOperatorsNoFloats>, !s64i) -> !cir.ptr<!rec_DefaultOperatorsNoFloats> +// CHECK-NEXT: %[[GET_I:.*]] = cir.get_member %[[NEXT_ELT]][0] {name = "i"} : !cir.ptr<!rec_DefaultOperatorsNoFloats> -> !cir.ptr<!s32i> // CHECK-NEXT: %[[ALL_ONES:.*]] = cir.const #cir.int<-1> : !s32i // CHECK-NEXT: cir.store {{.*}} %[[ALL_ONES]], %[[GET_I]] : !s32i, !cir.ptr<!s32i> -// CHECK-NEXT: %[[GET_U:.*]] = cir.get_member %[[NEXT_ELT]][1] {name = "u"} : !cir.ptr<!rec_DefaultOperators> -> !cir.ptr<!u32i> +// CHECK-NEXT: %[[GET_U:.*]] = cir.get_member %[[NEXT_ELT]][1] {name = "u"} : !cir.ptr<!rec_DefaultOperatorsNoFloats> -> !cir.ptr<!u32i> // CHECK-NEXT: %[[ALL_ONES:.*]] = cir.const #cir.int<4294967295> : !u32i // CHECK-NEXT: cir.store {{.*}} %[[ALL_ONES]], %[[GET_U]] : !u32i, !cir.ptr<!u32i> -// CHECK-NEXT: %[[GET_F:.*]] = cir.get_member %[[NEXT_ELT]][2] {name = "f"} : !cir.ptr<!rec_DefaultOperators> -> !cir.ptr<!cir.float> -// CHECK-NEXT: %[[ALL_ONES:.*]] = cir.const #cir.fp<0xFF{{.*}}> : !cir.float -// CHECK-NEXT: cir.store {{.*}} %[[ALL_ONES]], %[[GET_F]] : !cir.float, !cir.ptr<!cir.float> -// CHECK-NEXT: %[[GET_D:.*]] = cir.get_member %[[NEXT_ELT]][3] {name = "d"} : !cir.ptr<!rec_DefaultOperators> -> !cir.ptr<!cir.double> -// CHECK-NEXT: %[[ALL_ONES:.*]] = cir.const #cir.fp<0xFF{{.*}}> : !cir.double -// CHECK-NEXT: cir.store {{.*}} %[[ALL_ONES]], %[[GET_D]] : !cir.double, !cir.ptr<!cir.double> -// CHECK-NEXT: %[[GET_B:.*]] = cir.get_member %[[NEXT_ELT]][4] {name = "b"} : !cir.ptr<!rec_DefaultOperators> -> !cir.ptr<!cir.bool> +// CHECK-NEXT: %[[GET_B:.*]] = cir.get_member %[[NEXT_ELT]][2] {name = "b"} : !cir.ptr<!rec_DefaultOperatorsNoFloats> -> !cir.ptr<!cir.bool> // CHECK-NEXT: %[[ALL_ONES:.*]] = cir.const #true // CHECK-NEXT: cir.store {{.*}} %[[ALL_ONES]], %[[GET_B]] : !cir.bool, !cir.ptr<!cir.bool> // // CHECK-NEXT: %[[TWO_IDX:.*]] = cir.const #cir.int<2> : !s64i -// CHECK-NEXT: %[[NEXT_ELT:.*]] = cir.ptr_stride %[[DECAY]], %[[TWO_IDX]] : (!cir.ptr<!rec_DefaultOperators>, !s64i) -> !cir.ptr<!rec_DefaultOperators> -// CHECK-NEXT: %[[GET_I:.*]] = cir.get_member %[[NEXT_ELT]][0] {name = "i"} : !cir.ptr<!rec_DefaultOperators> -> !cir.ptr<!s32i> +// CHECK-NEXT: %[[NEXT_ELT:.*]] = cir.ptr_stride %[[DECAY]], %[[TWO_IDX]] : (!cir.ptr<!rec_DefaultOperatorsNoFloats>, !s64i) -> !cir.ptr<!rec_DefaultOperatorsNoFloats> +// CHECK-NEXT: %[[GET_I:.*]] = cir.get_member %[[NEXT_ELT]][0] {name = "i"} : !cir.ptr<!rec_DefaultOperatorsNoFloats> -> !cir.ptr<!s32i> // CHECK-NEXT: %[[ALL_ONES:.*]] = cir.const #cir.int<-1> : !s32i // CHECK-NEXT: cir.store {{.*}} %[[ALL_ONES]], %[[GET_I]] : !s32i, !cir.ptr<!s32i> -// CHECK-NEXT: %[[GET_U:.*]] = cir.get_member %[[NEXT_ELT]][1] {name = "u"} : !cir.ptr<!rec_DefaultOperators> -> !cir.ptr<!u32i> +// CHECK-NEXT: %[[GET_U:.*]] = cir.get_member %[[NEXT_ELT]][1] {name = "u"} : !cir.ptr<!rec_DefaultOperatorsNoFloats> -> !cir.ptr<!u32i> // CHECK-NEXT: %[[ALL_ONES:.*]] = cir.const #cir.int<4294967295> : !u32i // CHECK-NEXT: cir.store {{.*}} %[[ALL_ONES]], %[[GET_U]] : !u32i, !cir.ptr<!u32i> -// CHECK-NEXT: %[[GET_F:.*]] = cir.get_member %[[NEXT_ELT]][2] {name = "f"} : !cir.ptr<!rec_DefaultOperators> -> !cir.ptr<!cir.float> -// CHECK-NEXT: %[[ALL_ONES:.*]] = cir.const #cir.fp<0xFF{{.*}}> : !cir.float -// CHECK-NEXT: cir.store {{.*}} %[[ALL_ONES]], %[[GET_F]] : !cir.float, !cir.ptr<!cir.float> -// CHECK-NEXT: %[[GET_D:.*]] = cir.get_member %[[NEXT_ELT]][3] {name = "d"} : !cir.ptr<!rec_DefaultOperators> -> !cir.ptr<!cir.double> -// CHECK-NEXT: %[[ALL_ONES:.*]] = cir.const #cir.fp<0xFF{{.*}}> : !cir.double -// CHECK-NEXT: cir.store {{.*}} %[[ALL_ONES]], %[[GET_D]] : !cir.double, !cir.ptr<!cir.double> -// CHECK-NEXT: %[[GET_B:.*]] = cir.get_member %[[NEXT_ELT]][4] {name = "b"} : !cir.ptr<!rec_DefaultOperators> -> !cir.ptr<!cir.bool> +// CHECK-NEXT: %[[GET_B:.*]] = cir.get_member %[[NEXT_ELT]][2] {name = "b"} : !cir.ptr<!rec_DefaultOperatorsNoFloats> -> !cir.ptr<!cir.bool> // CHECK-NEXT: %[[ALL_ONES:.*]] = cir.const #true // CHECK-NEXT: cir.store {{.*}} %[[ALL_ONES]], %[[GET_B]] : !cir.bool, !cir.ptr<!cir.bool> // // // CHECK-NEXT: %[[THREE_IDX:.*]] = cir.const #cir.int<3> : !s64i -// CHECK-NEXT: %[[NEXT_ELT:.*]] = cir.ptr_stride %[[DECAY]], %[[THREE_IDX]] : (!cir.ptr<!rec_DefaultOperators>, !s64i) -> !cir.ptr<!rec_DefaultOperators> -// CHECK-NEXT: %[[GET_I:.*]] = cir.get_member %[[NEXT_ELT]][0] {name = "i"} : !cir.ptr<!rec_DefaultOperators> -> !cir.ptr<!s32i> +// CHECK-NEXT: %[[NEXT_ELT:.*]] = cir.ptr_stride %[[DECAY]], %[[THREE_IDX]] : (!cir.ptr<!rec_DefaultOperatorsNoFloats>, !s64i) -> !cir.ptr<!rec_DefaultOperatorsNoFloats> +// CHECK-NEXT: %[[GET_I:.*]] = cir.get_member %[[NEXT_ELT]][0] {name = "i"} : !cir.ptr<!rec_DefaultOperatorsNoFloats> -> !cir.ptr<!s32i> // CHECK-NEXT: %[[ALL_ONES:.*]] = cir.const #cir.int<-1> : !s32i // CHECK-NEXT: cir.store {{.*}} %[[ALL_ONES]], %[[GET_I]] : !s32i, !cir.ptr<!s32i> -// CHECK-NEXT: %[[GET_U:.*]] = cir.get_member %[[NEXT_ELT]][1] {name = "u"} : !cir.ptr<!rec_DefaultOperators> -> !cir.ptr<!u32i> +// CHECK-NEXT: %[[GET_U:.*]] = cir.get_member %[[NEXT_ELT]][1] {name = "u"} : !cir.ptr<!rec_DefaultOperatorsNoFloats> -> !cir.ptr<!u32i> // CHECK-NEXT: %[[ALL_ONES:.*]] = cir.const #cir.int<4294967295> : !u32i // CHECK-NEXT: cir.store {{.*}} %[[ALL_ONES]], %[[GET_U]] : !u32i, !cir.ptr<!u32i> -// CHECK-NEXT: %[[GET_F:.*]] = cir.get_member %[[NEXT_ELT]][2] {name = "f"} : !cir.ptr<!rec_DefaultOperators> -> !cir.ptr<!cir.float> -// CHECK-NEXT: %[[ALL_ONES:.*]] = cir.const #cir.fp<0xFF{{.*}}> : !cir.float -// CHECK-NEXT: cir.store {{.*}} %[[ALL_ONES]], %[[GET_F]] : !cir.float, !cir.ptr<!cir.float> -// CHECK-NEXT: %[[GET_D:.*]] = cir.get_member %[[NEXT_ELT]][3] {name = "d"} : !cir.ptr<!rec_DefaultOperators> -> !cir.ptr<!cir.double> -// CHECK-NEXT: %[[ALL_ONES:.*]] = cir.const #cir.fp<0xFF{{.*}}> : !cir.double -// CHECK-NEXT: cir.store {{.*}} %[[ALL_ONES]], %[[GET_D]] : !cir.double, !cir.ptr<!cir.double> -// CHECK-NEXT: %[[GET_B:.*]] = cir.get_member %[[NEXT_ELT]][4] {name = "b"} : !cir.ptr<!rec_DefaultOperators> -> !cir.ptr<!cir.bool> +// CHECK-NEXT: %[[GET_B:.*]] = cir.get_member %[[NEXT_ELT]][2] {name = "b"} : !cir.ptr<!rec_DefaultOperatorsNoFloats> -> !cir.ptr<!cir.bool> // CHECK-NEXT: %[[ALL_ONES:.*]] = cir.const #true // CHECK-NEXT: cir.store {{.*}} %[[ALL_ONES]], %[[GET_B]] : !cir.bool, !cir.ptr<!cir.bool> // // CHECK-NEXT: %[[FOUR_IDX:.*]] = cir.const #cir.int<4> : !s64i -// CHECK-NEXT: %[[NEXT_ELT:.*]] = cir.ptr_stride %[[DECAY]], %[[FOUR_IDX]] : (!cir.ptr<!rec_DefaultOperators>, !s64i) -> !cir.ptr<!rec_DefaultOperators> -// CHECK-NEXT: %[[GET_I:.*]] = cir.get_member %[[NEXT_ELT]][0] {name = "i"} : !cir.ptr<!rec_DefaultOperators> -> !cir.ptr<!s32i> +// CHECK-NEXT: %[[NEXT_ELT:.*]] = cir.ptr_stride %[[DECAY]], %[[FOUR_IDX]] : (!cir.ptr<!rec_DefaultOperatorsNoFloats>, !s64i) -> !cir.ptr<!rec_DefaultOperatorsNoFloats> +// CHECK-NEXT: %[[GET_I:.*]] = cir.get_member %[[NEXT_ELT]][0] {name = "i"} : !cir.ptr<!rec_DefaultOperatorsNoFloats> -> !cir.ptr<!s32i> // CHECK-NEXT: %[[ALL_ONES:.*]] = cir.const #cir.int<-1> : !s32i // CHECK-NEXT: cir.store {{.*}} %[[ALL_ONES]], %[[GET_I]] : !s32i, !cir.ptr<!s32i> -// CHECK-NEXT: %[[GET_U:.*]] = cir.get_member %[[NEXT_ELT]][1] {name = "u"} : !cir.ptr<!rec_DefaultOperators> -> !cir.ptr<!u32i> +// CHECK-NEXT: %[[GET_U:.*]] = cir.get_member %[[NEXT_ELT]][1] {name = "u"} : !cir.ptr<!rec_DefaultOperatorsNoFloats> -> !cir.ptr<!u32i> // CHECK-NEXT: %[[ALL_ONES:.*]] = cir.const #cir.int<4294967295> : !u32i // CHECK-NEXT: cir.store {{.*}} %[[ALL_ONES]], %[[GET_U]] : !u32i, !cir.ptr<!u32i> -// CHECK-NEXT: %[[GET_F:.*]] = cir.get_member %[[NEXT_ELT]][2] {name = "f"} : !cir.ptr<!rec_DefaultOperators> -> !cir.ptr<!cir.float> -// CHECK-NEXT: %[[ALL_ONES:.*]] = cir.const #cir.fp<0xFF{{.*}}> : !cir.float -// CHECK-NEXT: cir.store {{.*}} %[[ALL_ONES]], %[[GET_F]] : !cir.float, !cir.ptr<!cir.float> -// CHECK-NEXT: %[[GET_D:.*]] = cir.get_member %[[NEXT_ELT]][3] {name = "d"} : !cir.ptr<!rec_DefaultOperators> -> !cir.ptr<!cir.double> -// CHECK-NEXT: %[[ALL_ONES:.*]] = cir.const #cir.fp<0xFF{{.*}}> : !cir.double -// CHECK-NEXT: cir.store {{.*}} %[[ALL_ONES]], %[[GET_D]] : !cir.double, !cir.ptr<!cir.double> -// CHECK-NEXT: %[[GET_B:.*]] = cir.get_member %[[NEXT_ELT]][4] {name = "b"} : !cir.ptr<!rec_DefaultOperators> -> !cir.ptr<!cir.bool> +// CHECK-NEXT: %[[GET_B:.*]] = cir.get_member %[[NEXT_ELT]][2] {name = "b"} : !cir.ptr<!rec_DefaultOperatorsNoFloats> -> !cir.ptr<!cir.bool> // CHECK-NEXT: %[[ALL_ONES:.*]] = cir.const #true // CHECK-NEXT: cir.store {{.*}} %[[ALL_ONES]], %[[GET_B]] : !cir.bool, !cir.ptr<!cir.bool> // // CHECK-NEXT: acc.yield // // CHECK-NEXT: } combiner { -// CHECK-NEXT: ^bb0(%[[LHSARG:.*]]: !cir.ptr<!cir.array<!rec_DefaultOperators x 5>> {{.*}}, %[[RHSARG:.*]]: !cir.ptr<!cir.array<!rec_DefaultOperators x 5>> {{.*}}) +// CHECK-NEXT: ^bb0(%[[LHSARG:.*]]: !cir.ptr<!cir.array<!rec_DefaultOperatorsNoFloats x 5>> {{.*}}, %[[RHSARG:.*]]: !cir.ptr<!cir.array<!rec_DefaultOperatorsNoFloats x 5>> {{.*}}) // TODO OpenACC: Expecting combination operation here -// CHECK-NEXT: acc.yield %[[LHSARG]] : !cir.ptr<!cir.array<!rec_DefaultOperators x 5>> +// CHECK-NEXT: acc.yield %[[LHSARG]] : !cir.ptr<!cir.array<!rec_DefaultOperatorsNoFloats x 5>> // CHECK-NEXT: } for(int i=0;i < 5; ++i); -#pragma acc parallel loop reduction(|:someVarArr) -// CHECK-NEXT: acc.reduction.recipe @reduction_ior__ZTSA5_16DefaultOperators : !cir.ptr<!cir.array<!rec_DefaultOperators x 5>> reduction_operator <ior> init { -// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!rec_DefaultOperators x 5>>{{.*}}) -// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !cir.array<!rec_DefaultOperators x 5>, !cir.ptr<!cir.array<!rec_DefaultOperators x 5>>, ["openacc.reduction.init", init] -// CHECK-NEXT: %[[TEMP_ITR:.*]] = cir.alloca !cir.ptr<!rec_DefaultOperators>, !cir.ptr<!cir.ptr<!rec_DefaultOperators>>, ["arrayinit.temp"] -// CHECK-NEXT: %[[DECAY:.*]] = cir.cast array_to_ptrdecay %[[ALLOCA]] : !cir.ptr<!cir.array<!rec_DefaultOperators x 5>> -> !cir.ptr<!rec_DefaultOperators> -// CHECK-NEXT: cir.store {{.*}} %[[DECAY]], %[[TEMP_ITR]] : !cir.ptr<!rec_DefaultOperators>, !cir.ptr<!cir.ptr<!rec_DefaultOperators>> +#pragma acc parallel loop reduction(|:someVarArrNoFloats) +// CHECK-NEXT: acc.reduction.recipe @reduction_ior__ZTSA5_24DefaultOperatorsNoFloats : !cir.ptr<!cir.array<!rec_DefaultOperatorsNoFloats x 5>> reduction_operator <ior> init { +// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!rec_DefaultOperatorsNoFloats x 5>>{{.*}}) +// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !cir.array<!rec_DefaultOperatorsNoFloats x 5>, !cir.ptr<!cir.array<!rec_DefaultOperatorsNoFloats x 5>>, ["openacc.reduction.init", init] +// CHECK-NEXT: %[[TEMP_ITR:.*]] = cir.alloca !cir.ptr<!rec_DefaultOperatorsNoFloats>, !cir.ptr<!cir.ptr<!rec_DefaultOperatorsNoFloats>>, ["arrayinit.temp"] +// CHECK-NEXT: %[[DECAY:.*]] = cir.cast array_to_ptrdecay %[[ALLOCA]] : !cir.ptr<!cir.array<!rec_DefaultOperatorsNoFloats x 5>> -> !cir.ptr<!rec_DefaultOperatorsNoFloats> +// CHECK-NEXT: cir.store {{.*}} %[[DECAY]], %[[TEMP_ITR]] : !cir.ptr<!rec_DefaultOperatorsNoFloats>, !cir.ptr<!cir.ptr<!rec_DefaultOperatorsNoFloats>> // CHECK-NEXT: %[[LAST_IDX:.*]] = cir.const #cir.int<5> : !s64i -// CHECK-NEXT: %[[END_ITR:.*]] = cir.ptr_stride %[[DECAY]], %[[LAST_IDX]] : (!cir.ptr<!rec_DefaultOperators>, !s64i) -> !cir.ptr<!rec_DefaultOperators> +// CHECK-NEXT: %[[END_ITR:.*]] = cir.ptr_stride %[[DECAY]], %[[LAST_IDX]] : (!cir.ptr<!rec_DefaultOperatorsNoFloats>, !s64i) -> !cir.ptr<!rec_DefaultOperatorsNoFloats> // CHECK-NEXT: cir.do { -// CHECK-NEXT: %[[TEMP_LOAD:.*]] = cir.load {{.*}} %[[TEMP_ITR]] : !cir.ptr<!cir.ptr<!rec_DefaultOperators>>, !cir.ptr<!rec_DefaultOperators> -// CHECK-NEXT: %[[GET_I:.*]] = cir.get_member %[[TEMP_LOAD]][0] {name = "i"} : !cir.ptr<!rec_DefaultOperators> -> !cir.ptr<!s32i> +// CHECK-NEXT: %[[TEMP_LOAD:.*]] = cir.load {{.*}} %[[TEMP_ITR]] : !cir.ptr<!cir.ptr<!rec_DefaultOperatorsNoFloats>>, !cir.ptr<!rec_DefaultOperatorsNoFloats> +// CHECK-NEXT: %[[GET_I:.*]] = cir.get_member %[[TEMP_LOAD]][0] {name = "i"} : !cir.ptr<!rec_DefaultOperatorsNoFloats> -> !cir.ptr<!s32i> // CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !s32i // CHECK-NEXT: cir.store {{.*}} %[[ZERO]], %[[GET_I]] : !s32i, !cir.ptr<!s32i> -// CHECK-NEXT: %[[GET_U:.*]] = cir.get_member %[[TEMP_LOAD]][1] {name = "u"} : !cir.ptr<!rec_DefaultOperators> -> !cir.ptr<!u32i> +// CHECK-NEXT: %[[GET_U:.*]] = cir.get_member %[[TEMP_LOAD]][1] {name = "u"} : !cir.ptr<!rec_DefaultOperatorsNoFloats> -> !cir.ptr<!u32i> // CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !u32i // CHECK-NEXT: cir.store {{.*}} %[[ZERO]], %[[GET_U]] : !u32i, !cir.ptr<!u32i> -// CHECK-NEXT: %[[GET_F:.*]] = cir.get_member %[[TEMP_LOAD]][2] {name = "f"} : !cir.ptr<!rec_DefaultOperators> -> !cir.ptr<!cir.float> -// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.fp<0{{.*}}> : !cir.float -// CHECK-NEXT: cir.store {{.*}} %[[ZERO]], %[[GET_F]] : !cir.float, !cir.ptr<!cir.float> -// CHECK-NEXT: %[[GET_D:.*]] = cir.get_member %[[TEMP_LOAD]][3] {name = "d"} : !cir.ptr<!rec_DefaultOperators> -> !cir.ptr<!cir.double> -// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.fp<0{{.*}}> : !cir.double -// CHECK-NEXT: cir.store {{.*}} %[[ZERO]], %[[GET_D]] : !cir.double, !cir.ptr<!cir.double> -// CHECK-NEXT: %[[GET_B:.*]] = cir.get_member %[[TEMP_LOAD]][4] {name = "b"} : !cir.ptr<!rec_DefaultOperators> -> !cir.ptr<!cir.bool> +// CHECK-NEXT: %[[GET_B:.*]] = cir.get_member %[[TEMP_LOAD]][2] {name = "b"} : !cir.ptr<!rec_DefaultOperatorsNoFloats> -> !cir.ptr<!cir.bool> // CHECK-NEXT: %[[ZERO:.*]] = cir.const #false // CHECK-NEXT: cir.store {{.*}} %[[ZERO]], %[[GET_B]] : !cir.bool, !cir.ptr<!cir.bool> // // CHECK-NEXT: %[[ONE:.*]] = cir.const #cir.int<1> : !s64i -// CHECK-NEXT: %[[NEXT_ITEM:.*]] = cir.ptr_stride %[[TEMP_LOAD]], %[[ONE]] : (!cir.ptr<!rec_DefaultOperators>, !s64i) -> !cir.ptr<!rec_DefaultOperators> -// CHECK-NEXT: cir.store {{.*}} %[[NEXT_ITEM]], %[[TEMP_ITR]] : !cir.ptr<!rec_DefaultOperators>, !cir.ptr<!cir.ptr<!rec_DefaultOperators>> +// CHECK-NEXT: %[[NEXT_ITEM:.*]] = cir.ptr_stride %[[TEMP_LOAD]], %[[ONE]] : (!cir.ptr<!rec_DefaultOperatorsNoFloats>, !s64i) -> !cir.ptr<!rec_DefaultOperatorsNoFloats> +// CHECK-NEXT: cir.store {{.*}} %[[NEXT_ITEM]], %[[TEMP_ITR]] : !cir.ptr<!rec_DefaultOperatorsNoFloats>, !cir.ptr<!cir.ptr<!rec_DefaultOperatorsNoFloats>> // CHECK-NEXT: cir.yield // CHECK-NEXT: } while { -// CHECK-NEXT: %[[TEMP_LOAD:.*]] = cir.load {{.*}} %[[TEMP_ITR]] : !cir.ptr<!cir.ptr<!rec_DefaultOperators>>, !cir.ptr<!rec_DefaultOperators> -// CHECK-NEXT: %[[CMP:.*]] = cir.cmp(ne, %[[TEMP_LOAD]], %[[END_ITR]]) : !cir.ptr<!rec_DefaultOperators>, !cir.bool +// CHECK-NEXT: %[[TEMP_LOAD:.*]] = cir.load {{.*}} %[[TEMP_ITR]] : !cir.ptr<!cir.ptr<!rec_DefaultOperatorsNoFloats>>, !cir.ptr<!rec_DefaultOperatorsNoFloats> +// CHECK-NEXT: %[[CMP:.*]] = cir.cmp(ne, %[[TEMP_LOAD]], %[[END_ITR]]) : !cir.ptr<!rec_DefaultOperatorsNoFloats>, !cir.bool // CHECK-NEXT: cir.condition(%[[CMP]]) // CHECK-NEXT: } // CHECK-NEXT: acc.yield // // CHECK-NEXT: } combiner { -// CHECK-NEXT: ^bb0(%[[LHSARG:.*]]: !cir.ptr<!cir.array<!rec_DefaultOperators x 5>> {{.*}}, %[[RHSARG:.*]]: !cir.ptr<!cir.array<!rec_DefaultOperators x 5>> {{.*}}) +// CHECK-NEXT: ^bb0(%[[LHSARG:.*]]: !cir.ptr<!cir.array<!rec_DefaultOperatorsNoFloats x 5>> {{.*}}, %[[RHSARG:.*]]: !cir.ptr<!cir.array<!rec_DefaultOperatorsNoFloats x 5>> {{.*}}) // TODO OpenACC: Expecting combination operation here -// CHECK-NEXT: acc.yield %[[LHSARG]] : !cir.ptr<!cir.array<!rec_DefaultOperators x 5>> +// CHECK-NEXT: acc.yield %[[LHSARG]] : !cir.ptr<!cir.array<!rec_DefaultOperatorsNoFloats x 5>> // CHECK-NEXT: } - for(int i=0;i < 5; ++i); -#pragma acc parallel loop reduction(^:someVarArr) -// CHECK-NEXT: acc.reduction.recipe @reduction_xor__ZTSA5_16DefaultOperators : !cir.ptr<!cir.array<!rec_DefaultOperators x 5>> reduction_operator <xor> init { -// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!rec_DefaultOperators x 5>>{{.*}}) -// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !cir.array<!rec_DefaultOperators x 5>, !cir.ptr<!cir.array<!rec_DefaultOperators x 5>>, ["openacc.reduction.init", init] -// CHECK-NEXT: %[[TEMP_ITR:.*]] = cir.alloca !cir.ptr<!rec_DefaultOperators>, !cir.ptr<!cir.ptr<!rec_DefaultOperators>>, ["arrayinit.temp"] -// CHECK-NEXT: %[[DECAY:.*]] = cir.cast array_to_ptrdecay %[[ALLOCA]] : !cir.ptr<!cir.array<!rec_DefaultOperators x 5>> -> !cir.ptr<!rec_DefaultOperators> -// CHECK-NEXT: cir.store {{.*}} %[[DECAY]], %[[TEMP_ITR]] : !cir.ptr<!rec_DefaultOperators>, !cir.ptr<!cir.ptr<!rec_DefaultOperators>> + for(int i = 0; i < 5; ++i); +#pragma acc parallel loop reduction(^:someVarArrNoFloats) +// CHECK-NEXT: acc.reduction.recipe @reduction_xor__ZTSA5_24DefaultOperatorsNoFloats : !cir.ptr<!cir.array<!rec_DefaultOperatorsNoFloats x 5>> reduction_operator <xor> init { +// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!rec_DefaultOperatorsNoFloats x 5>>{{.*}}) +// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !cir.array<!rec_DefaultOperatorsNoFloats x 5>, !cir.ptr<!cir.array<!rec_DefaultOperatorsNoFloats x 5>>, ["openacc.reduction.init", init] +// CHECK-NEXT: %[[TEMP_ITR:.*]] = cir.alloca !cir.ptr<!rec_DefaultOperatorsNoFloats>, !cir.ptr<!cir.ptr<!rec_DefaultOperatorsNoFloats>>, ["arrayinit.temp"] +// CHECK-NEXT: %[[DECAY:.*]] = cir.cast array_to_ptrdecay %[[ALLOCA]] : !cir.ptr<!cir.array<!rec_DefaultOperatorsNoFloats x 5>> -> !cir.ptr<!rec_DefaultOperatorsNoFloats> +// CHECK-NEXT: cir.store {{.*}} %[[DECAY]], %[[TEMP_ITR]] : !cir.ptr<!rec_DefaultOperatorsNoFloats>, !cir.ptr<!cir.ptr<!rec_DefaultOperatorsNoFloats>> // CHECK-NEXT: %[[LAST_IDX:.*]] = cir.const #cir.int<5> : !s64i -// CHECK-NEXT: %[[END_ITR:.*]] = cir.ptr_stride %[[DECAY]], %[[LAST_IDX]] : (!cir.ptr<!rec_DefaultOperators>, !s64i) -> !cir.ptr<!rec_DefaultOperators> +// CHECK-NEXT: %[[END_ITR:.*]] = cir.ptr_stride %[[DECAY]], %[[LAST_IDX]] : (!cir.ptr<!rec_DefaultOperatorsNoFloats>, !s64i) -> !cir.ptr<!rec_DefaultOperatorsNoFloats> // CHECK-NEXT: cir.do { -// CHECK-NEXT: %[[TEMP_LOAD:.*]] = cir.load {{.*}} %[[TEMP_ITR]] : !cir.ptr<!cir.ptr<!rec_DefaultOperators>>, !cir.ptr<!rec_DefaultOperators> -// CHECK-NEXT: %[[GET_I:.*]] = cir.get_member %[[TEMP_LOAD]][0] {name = "i"} : !cir.ptr<!rec_DefaultOperators> -> !cir.ptr<!s32i> +// CHECK-NEXT: %[[TEMP_LOAD:.*]] = cir.load {{.*}} %[[TEMP_ITR]] : !cir.ptr<!cir.ptr<!rec_DefaultOperatorsNoFloats>>, !cir.ptr<!rec_DefaultOperatorsNoFloats> +// CHECK-NEXT: %[[GET_I:.*]] = cir.get_member %[[TEMP_LOAD]][0] {name = "i"} : !cir.ptr<!rec_DefaultOperatorsNoFloats> -> !cir.ptr<!s32i> // CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !s32i // CHECK-NEXT: cir.store {{.*}} %[[ZERO]], %[[GET_I]] : !s32i, !cir.ptr<!s32i> -// CHECK-NEXT: %[[GET_U:.*]] = cir.get_member %[[TEMP_LOAD]][1] {name = "u"} : !cir.ptr<!rec_DefaultOperators> -> !cir.ptr<!u32i> +// CHECK-NEXT: %[[GET_U:.*]] = cir.get_member %[[TEMP_LOAD]][1] {name = "u"} : !cir.ptr<!rec_DefaultOperatorsNoFloats> -> !cir.ptr<!u32i> // CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !u32i // CHECK-NEXT: cir.store {{.*}} %[[ZERO]], %[[GET_U]] : !u32i, !cir.ptr<!u32i> -// CHECK-NEXT: %[[GET_F:.*]] = cir.get_member %[[TEMP_LOAD]][2] {name = "f"} : !cir.ptr<!rec_DefaultOperators> -> !cir.ptr<!cir.float> -// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.fp<0{{.*}}> : !cir.float -// CHECK-NEXT: cir.store {{.*}} %[[ZERO]], %[[GET_F]] : !cir.float, !cir.ptr<!cir.float> -// CHECK-NEXT: %[[GET_D:.*]] = cir.get_member %[[TEMP_LOAD]][3] {name = "d"} : !cir.ptr<!rec_DefaultOperators> -> !cir.ptr<!cir.double> -// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.fp<0{{.*}}> : !cir.double -// CHECK-NEXT: cir.store {{.*}} %[[ZERO]], %[[GET_D]] : !cir.double, !cir.ptr<!cir.double> -// CHECK-NEXT: %[[GET_B:.*]] = cir.get_member %[[TEMP_LOAD]][4] {name = "b"} : !cir.ptr<!rec_DefaultOperators> -> !cir.ptr<!cir.bool> +// CHECK-NEXT: %[[GET_B:.*]] = cir.get_member %[[TEMP_LOAD]][2] {name = "b"} : !cir.ptr<!rec_DefaultOperatorsNoFloats> -> !cir.ptr<!cir.bool> // CHECK-NEXT: %[[ZERO:.*]] = cir.const #false // CHECK-NEXT: cir.store {{.*}} %[[ZERO]], %[[GET_B]] : !cir.bool, !cir.ptr<!cir.bool> // CHECK-NEXT: %[[ONE:.*]] = cir.const #cir.int<1> : !s64i -// CHECK-NEXT: %[[NEXT_ITEM:.*]] = cir.ptr_stride %[[TEMP_LOAD]], %[[ONE]] : (!cir.ptr<!rec_DefaultOperators>, !s64i) -> !cir.ptr<!rec_DefaultOperators> -// CHECK-NEXT: cir.store {{.*}} %[[NEXT_ITEM]], %[[TEMP_ITR]] : !cir.ptr<!rec_DefaultOperators>, !cir.ptr<!cir.ptr<!rec_DefaultOperators>> +// CHECK-NEXT: %[[NEXT_ITEM:.*]] = cir.ptr_stride %[[TEMP_LOAD]], %[[ONE]] : (!cir.ptr<!rec_DefaultOperatorsNoFloats>, !s64i) -> !cir.ptr<!rec_DefaultOperatorsNoFloats> +// CHECK-NEXT: cir.store {{.*}} %[[NEXT_ITEM]], %[[TEMP_ITR]] : !cir.ptr<!rec_DefaultOperatorsNoFloats>, !cir.ptr<!cir.ptr<!rec_DefaultOperatorsNoFloats>> // CHECK-NEXT: cir.yield // CHECK-NEXT: } while { -// CHECK-NEXT: %[[TEMP_LOAD:.*]] = cir.load {{.*}} %[[TEMP_ITR]] : !cir.ptr<!cir.ptr<!rec_DefaultOperators>>, !cir.ptr<!rec_DefaultOperators> -// CHECK-NEXT: %[[CMP:.*]] = cir.cmp(ne, %[[TEMP_LOAD]], %[[END_ITR]]) : !cir.ptr<!rec_DefaultOperators>, !cir.bool +// CHECK-NEXT: %[[TEMP_LOAD:.*]] = cir.load {{.*}} %[[TEMP_ITR]] : !cir.ptr<!cir.ptr<!rec_DefaultOperatorsNoFloats>>, !cir.ptr<!rec_DefaultOperatorsNoFloats> +// CHECK-NEXT: %[[CMP:.*]] = cir.cmp(ne, %[[TEMP_LOAD]], %[[END_ITR]]) : !cir.ptr<!rec_DefaultOperatorsNoFloats>, !cir.bool // CHECK-NEXT: cir.condition(%[[CMP]]) // CHECK-NEXT: } // CHECK-NEXT: acc.yield // // CHECK-NEXT: } combiner { -// CHECK-NEXT: ^bb0(%[[LHSARG:.*]]: !cir.ptr<!cir.array<!rec_DefaultOperators x 5>> {{.*}}, %[[RHSARG:.*]]: !cir.ptr<!cir.array<!rec_DefaultOperators x 5>> {{.*}}) +// CHECK-NEXT: ^bb0(%[[LHSARG:.*]]: !cir.ptr<!cir.array<!rec_DefaultOperatorsNoFloats x 5>> {{.*}}, %[[RHSARG:.*]]: !cir.ptr<!cir.array<!rec_DefaultOperatorsNoFloats x 5>> {{.*}}) // TODO OpenACC: Expecting combination operation here -// CHECK-NEXT: acc.yield %[[LHSARG]] : !cir.ptr<!cir.array<!rec_DefaultOperators x 5>> +// CHECK-NEXT: acc.yield %[[LHSARG]] : !cir.ptr<!cir.array<!rec_DefaultOperatorsNoFloats x 5>> // CHECK-NEXT: } for(int i=0;i < 5; ++i); #pragma acc parallel loop reduction(&&:someVarArr) @@ -1135,10 +1082,10 @@ void acc_combined() { // CHECK-NEXT: acc.yield %[[LHSARG]] : !cir.ptr<!cir.array<!rec_DefaultOperators x 5>> // CHECK-NEXT: } for(int i=0;i < 5; ++i); -#pragma acc parallel loop reduction(&:someVarArr[2]) -// CHECK-NEXT: acc.reduction.recipe @reduction_iand__Bcnt1__ZTSA5_16DefaultOperators : !cir.ptr<!cir.array<!rec_DefaultOperators x 5>> reduction_operator <iand> init { -// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!rec_DefaultOperators x 5>>{{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty{{.*}})) -// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !cir.array<!rec_DefaultOperators x 5>, !cir.ptr<!cir.array<!rec_DefaultOperators x 5>>, ["openacc.reduction.init"] +#pragma acc parallel loop reduction(&:someVarArrNoFloats[2]) +// CHECK-NEXT: acc.reduction.recipe @reduction_iand__Bcnt1__ZTSA5_24DefaultOperatorsNoFloats : !cir.ptr<!cir.array<!rec_DefaultOperatorsNoFloats x 5>> reduction_operator <iand> init { +// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!rec_DefaultOperatorsNoFloats x 5>>{{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty{{.*}})) +// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !cir.array<!rec_DefaultOperatorsNoFloats x 5>, !cir.ptr<!cir.array<!rec_DefaultOperatorsNoFloats x 5>>, ["openacc.reduction.init"] // CHECK-NEXT: cir.scope { // CHECK-NEXT: %[[LB:.*]] = acc.get_lowerbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index // CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i @@ -1152,21 +1099,15 @@ void acc_combined() { // CHECK-NEXT: cir.condition(%[[COND]]) // CHECK-NEXT: } body { // CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i -// CHECK-NEXT: %[[DECAY:.*]] = cir.cast array_to_ptrdecay %[[ALLOCA]] : !cir.ptr<!cir.array<!rec_DefaultOperators x 5>> -> !cir.ptr<!rec_DefaultOperators> -// CHECK-NEXT: %[[STRIDE:.*]] = cir.ptr_stride %[[DECAY]], %[[ITR_LOAD]] : (!cir.ptr<!rec_DefaultOperators>, !u64i) -> !cir.ptr<!rec_DefaultOperators> -// CHECK-NEXT: %[[GET_I:.*]] = cir.get_member %[[STRIDE]][0] {name = "i"} : !cir.ptr<!rec_DefaultOperators> -> !cir.ptr<!s32i> +// CHECK-NEXT: %[[DECAY:.*]] = cir.cast array_to_ptrdecay %[[ALLOCA]] : !cir.ptr<!cir.array<!rec_DefaultOperatorsNoFloats x 5>> -> !cir.ptr<!rec_DefaultOperatorsNoFloats> +// CHECK-NEXT: %[[STRIDE:.*]] = cir.ptr_stride %[[DECAY]], %[[ITR_LOAD]] : (!cir.ptr<!rec_DefaultOperatorsNoFloats>, !u64i) -> !cir.ptr<!rec_DefaultOperatorsNoFloats> +// CHECK-NEXT: %[[GET_I:.*]] = cir.get_member %[[STRIDE]][0] {name = "i"} : !cir.ptr<!rec_DefaultOperatorsNoFloats> -> !cir.ptr<!s32i> // CHECK-NEXT: %[[ALL_ONES:.*]] = cir.const #cir.int<-1> : !s32i // CHECK-NEXT: cir.store {{.*}} %[[ALL_ONES]], %[[GET_I]] : !s32i, !cir.ptr<!s32i> -// CHECK-NEXT: %[[GET_U:.*]] = cir.get_member %[[STRIDE]][1] {name = "u"} : !cir.ptr<!rec_DefaultOperators> -> !cir.ptr<!u32i> +// CHECK-NEXT: %[[GET_U:.*]] = cir.get_member %[[STRIDE]][1] {name = "u"} : !cir.ptr<!rec_DefaultOperatorsNoFloats> -> !cir.ptr<!u32i> // CHECK-NEXT: %[[ALL_ONES:.*]] = cir.const #cir.int<4294967295> : !u32i // CHECK-NEXT: cir.store {{.*}} %[[ALL_ONES]], %[[GET_U]] : !u32i, !cir.ptr<!u32i> -// CHECK-NEXT: %[[GET_F:.*]] = cir.get_member %[[STRIDE]][2] {name = "f"} : !cir.ptr<!rec_DefaultOperators> -> !cir.ptr<!cir.float> -// CHECK-NEXT: %[[ALL_ONES:.*]] = cir.const #cir.fp<0xFF{{.*}}> : !cir.float -// CHECK-NEXT: cir.store {{.*}} %[[ALL_ONES]], %[[GET_F]] : !cir.float, !cir.ptr<!cir.float> -// CHECK-NEXT: %[[GET_D:.*]] = cir.get_member %[[STRIDE]][3] {name = "d"} : !cir.ptr<!rec_DefaultOperators> -> !cir.ptr<!cir.double> -// CHECK-NEXT: %[[ALL_ONES:.*]] = cir.const #cir.fp<0xFF{{.*}}> : !cir.double -// CHECK-NEXT: cir.store {{.*}} %[[ALL_ONES]], %[[GET_D]] : !cir.double, !cir.ptr<!cir.double> -// CHECK-NEXT: %[[GET_B:.*]] = cir.get_member %[[STRIDE]][4] {name = "b"} : !cir.ptr<!rec_DefaultOperators> -> !cir.ptr<!cir.bool> +// CHECK-NEXT: %[[GET_B:.*]] = cir.get_member %[[STRIDE]][2] {name = "b"} : !cir.ptr<!rec_DefaultOperatorsNoFloats> -> !cir.ptr<!cir.bool> // CHECK-NEXT: %[[ALL_ONES:.*]] = cir.const #true // CHECK-NEXT: cir.store {{.*}} %[[ALL_ONES]], %[[GET_B]] : !cir.bool, !cir.ptr<!cir.bool> // CHECK-NEXT: cir.yield @@ -1179,14 +1120,14 @@ void acc_combined() { // CHECK-NEXT: } // CHECK-NEXT: acc.yield // CHECK-NEXT: } combiner { -// CHECK-NEXT: ^bb0(%[[LHSARG:.*]]: !cir.ptr<!cir.array<!rec_DefaultOperators x 5>> {{.*}}, %[[RHSARG:.*]]: !cir.ptr<!cir.array<!rec_DefaultOperators x 5>> {{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty{{.*}})) -// CHECK-NEXT: acc.yield %[[LHSARG]] : !cir.ptr<!cir.array<!rec_DefaultOperators x 5>> +// CHECK-NEXT: ^bb0(%[[LHSARG:.*]]: !cir.ptr<!cir.array<!rec_DefaultOperatorsNoFloats x 5>> {{.*}}, %[[RHSARG:.*]]: !cir.ptr<!cir.array<!rec_DefaultOperatorsNoFloats x 5>> {{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty{{.*}})) +// CHECK-NEXT: acc.yield %[[LHSARG]] : !cir.ptr<!cir.array<!rec_DefaultOperatorsNoFloats x 5>> // CHECK-NEXT: } for(int i=0;i < 5; ++i); -#pragma acc parallel loop reduction(|:someVarArr[2]) -// CHECK-NEXT: acc.reduction.recipe @reduction_ior__Bcnt1__ZTSA5_16DefaultOperators : !cir.ptr<!cir.array<!rec_DefaultOperators x 5>> reduction_operator <ior> init { -// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!rec_DefaultOperators x 5>>{{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty{{.*}})) -// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !cir.array<!rec_DefaultOperators x 5>, !cir.ptr<!cir.array<!rec_DefaultOperators x 5>>, ["openacc.reduction.init"] +#pragma acc parallel loop reduction(|:someVarArrNoFloats[2]) +// CHECK-NEXT: acc.reduction.recipe @reduction_ior__Bcnt1__ZTSA5_24DefaultOperatorsNoFloats : !cir.ptr<!cir.array<!rec_DefaultOperatorsNoFloats x 5>> reduction_operator <ior> init { +// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!rec_DefaultOperatorsNoFloats x 5>>{{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty{{.*}})) +// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !cir.array<!rec_DefaultOperatorsNoFloats x 5>, !cir.ptr<!cir.array<!rec_DefaultOperatorsNoFloats x 5>>, ["openacc.reduction.init"] // CHECK-NEXT: cir.scope { // CHECK-NEXT: %[[LB:.*]] = acc.get_lowerbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index // CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i @@ -1200,21 +1141,15 @@ void acc_combined() { // CHECK-NEXT: cir.condition(%[[COND]]) // CHECK-NEXT: } body { // CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i -// CHECK-NEXT: %[[DECAY:.*]] = cir.cast array_to_ptrdecay %[[ALLOCA]] : !cir.ptr<!cir.array<!rec_DefaultOperators x 5>> -> !cir.ptr<!rec_DefaultOperators> -// CHECK-NEXT: %[[STRIDE:.*]] = cir.ptr_stride %[[DECAY]], %[[ITR_LOAD]] : (!cir.ptr<!rec_DefaultOperators>, !u64i) -> !cir.ptr<!rec_DefaultOperators> -// CHECK-NEXT: %[[GET_I:.*]] = cir.get_member %[[STRIDE]][0] {name = "i"} : !cir.ptr<!rec_DefaultOperators> -> !cir.ptr<!s32i> +// CHECK-NEXT: %[[DECAY:.*]] = cir.cast array_to_ptrdecay %[[ALLOCA]] : !cir.ptr<!cir.array<!rec_DefaultOperatorsNoFloats x 5>> -> !cir.ptr<!rec_DefaultOperatorsNoFloats> +// CHECK-NEXT: %[[STRIDE:.*]] = cir.ptr_stride %[[DECAY]], %[[ITR_LOAD]] : (!cir.ptr<!rec_DefaultOperatorsNoFloats>, !u64i) -> !cir.ptr<!rec_DefaultOperatorsNoFloats> +// CHECK-NEXT: %[[GET_I:.*]] = cir.get_member %[[STRIDE]][0] {name = "i"} : !cir.ptr<!rec_DefaultOperatorsNoFloats> -> !cir.ptr<!s32i> // CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !s32i // CHECK-NEXT: cir.store {{.*}} %[[ZERO]], %[[GET_I]] : !s32i, !cir.ptr<!s32i> -// CHECK-NEXT: %[[GET_U:.*]] = cir.get_member %[[STRIDE]][1] {name = "u"} : !cir.ptr<!rec_DefaultOperators> -> !cir.ptr<!u32i> +// CHECK-NEXT: %[[GET_U:.*]] = cir.get_member %[[STRIDE]][1] {name = "u"} : !cir.ptr<!rec_DefaultOperatorsNoFloats> -> !cir.ptr<!u32i> // CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !u32i // CHECK-NEXT: cir.store {{.*}} %[[ZERO]], %[[GET_U]] : !u32i, !cir.ptr<!u32i> -// CHECK-NEXT: %[[GET_F:.*]] = cir.get_member %[[STRIDE]][2] {name = "f"} : !cir.ptr<!rec_DefaultOperators> -> !cir.ptr<!cir.float> -// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.fp<0{{.*}}> : !cir.float -// CHECK-NEXT: cir.store {{.*}} %[[ZERO]], %[[GET_F]] : !cir.float, !cir.ptr<!cir.float> -// CHECK-NEXT: %[[GET_D:.*]] = cir.get_member %[[STRIDE]][3] {name = "d"} : !cir.ptr<!rec_DefaultOperators> -> !cir.ptr<!cir.double> -// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.fp<0{{.*}}> : !cir.double -// CHECK-NEXT: cir.store {{.*}} %[[ZERO]], %[[GET_D]] : !cir.double, !cir.ptr<!cir.double> -// CHECK-NEXT: %[[GET_B:.*]] = cir.get_member %[[STRIDE]][4] {name = "b"} : !cir.ptr<!rec_DefaultOperators> -> !cir.ptr<!cir.bool> +// CHECK-NEXT: %[[GET_B:.*]] = cir.get_member %[[STRIDE]][2] {name = "b"} : !cir.ptr<!rec_DefaultOperatorsNoFloats> -> !cir.ptr<!cir.bool> // CHECK-NEXT: %[[ZERO:.*]] = cir.const #false // CHECK-NEXT: cir.store {{.*}} %[[ZERO]], %[[GET_B]] : !cir.bool, !cir.ptr<!cir.bool> // CHECK-NEXT: cir.yield @@ -1227,14 +1162,14 @@ void acc_combined() { // CHECK-NEXT: } // CHECK-NEXT: acc.yield // CHECK-NEXT: } combiner { -// CHECK-NEXT: ^bb0(%[[LHSARG:.*]]: !cir.ptr<!cir.array<!rec_DefaultOperators x 5>> {{.*}}, %[[RHSARG:.*]]: !cir.ptr<!cir.array<!rec_DefaultOperators x 5>> {{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty{{.*}})) -// CHECK-NEXT: acc.yield %[[LHSARG]] : !cir.ptr<!cir.array<!rec_DefaultOperators x 5>> +// CHECK-NEXT: ^bb0(%[[LHSARG:.*]]: !cir.ptr<!cir.array<!rec_DefaultOperatorsNoFloats x 5>> {{.*}}, %[[RHSARG:.*]]: !cir.ptr<!cir.array<!rec_DefaultOperatorsNoFloats x 5>> {{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty{{.*}})) +// CHECK-NEXT: acc.yield %[[LHSARG]] : !cir.ptr<!cir.array<!rec_DefaultOperatorsNoFloats x 5>> // CHECK-NEXT: } for(int i=0;i < 5; ++i); -#pragma acc parallel loop reduction(^:someVarArr[2]) -// CHECK-NEXT: acc.reduction.recipe @reduction_xor__Bcnt1__ZTSA5_16DefaultOperators : !cir.ptr<!cir.array<!rec_DefaultOperators x 5>> reduction_operator <xor> init { -// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!rec_DefaultOperators x 5>>{{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty{{.*}})) -// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !cir.array<!rec_DefaultOperators x 5>, !cir.ptr<!cir.array<!rec_DefaultOperators x 5>>, ["openacc.reduction.init"] +#pragma acc parallel loop reduction(^:someVarArrNoFloats[2]) +// CHECK-NEXT: acc.reduction.recipe @reduction_xor__Bcnt1__ZTSA5_24DefaultOperatorsNoFloats : !cir.ptr<!cir.array<!rec_DefaultOperatorsNoFloats x 5>> reduction_operator <xor> init { +// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!rec_DefaultOperatorsNoFloats x 5>>{{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty{{.*}})) +// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !cir.array<!rec_DefaultOperatorsNoFloats x 5>, !cir.ptr<!cir.array<!rec_DefaultOperatorsNoFloats x 5>>, ["openacc.reduction.init"] // CHECK-NEXT: cir.scope { // CHECK-NEXT: %[[LB:.*]] = acc.get_lowerbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index // CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i @@ -1248,21 +1183,15 @@ void acc_combined() { // CHECK-NEXT: cir.condition(%[[COND]]) // CHECK-NEXT: } body { // CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i -// CHECK-NEXT: %[[DECAY:.*]] = cir.cast array_to_ptrdecay %[[ALLOCA]] : !cir.ptr<!cir.array<!rec_DefaultOperators x 5>> -> !cir.ptr<!rec_DefaultOperators> -// CHECK-NEXT: %[[STRIDE:.*]] = cir.ptr_stride %[[DECAY]], %[[ITR_LOAD]] : (!cir.ptr<!rec_DefaultOperators>, !u64i) -> !cir.ptr<!rec_DefaultOperators> -// CHECK-NEXT: %[[GET_I:.*]] = cir.get_member %[[STRIDE]][0] {name = "i"} : !cir.ptr<!rec_DefaultOperators> -> !cir.ptr<!s32i> +// CHECK-NEXT: %[[DECAY:.*]] = cir.cast array_to_ptrdecay %[[ALLOCA]] : !cir.ptr<!cir.array<!rec_DefaultOperatorsNoFloats x 5>> -> !cir.ptr<!rec_DefaultOperatorsNoFloats> +// CHECK-NEXT: %[[STRIDE:.*]] = cir.ptr_stride %[[DECAY]], %[[ITR_LOAD]] : (!cir.ptr<!rec_DefaultOperatorsNoFloats>, !u64i) -> !cir.ptr<!rec_DefaultOperatorsNoFloats> +// CHECK-NEXT: %[[GET_I:.*]] = cir.get_member %[[STRIDE]][0] {name = "i"} : !cir.ptr<!rec_DefaultOperatorsNoFloats> -> !cir.ptr<!s32i> // CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !s32i // CHECK-NEXT: cir.store {{.*}} %[[ZERO]], %[[GET_I]] : !s32i, !cir.ptr<!s32i> -// CHECK-NEXT: %[[GET_U:.*]] = cir.get_member %[[STRIDE]][1] {name = "u"} : !cir.ptr<!rec_DefaultOperators> -> !cir.ptr<!u32i> +// CHECK-NEXT: %[[GET_U:.*]] = cir.get_member %[[STRIDE]][1] {name = "u"} : !cir.ptr<!rec_DefaultOperatorsNoFloats> -> !cir.ptr<!u32i> // CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !u32i // CHECK-NEXT: cir.store {{.*}} %[[ZERO]], %[[GET_U]] : !u32i, !cir.ptr<!u32i> -// CHECK-NEXT: %[[GET_F:.*]] = cir.get_member %[[STRIDE]][2] {name = "f"} : !cir.ptr<!rec_DefaultOperators> -> !cir.ptr<!cir.float> -// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.fp<0{{.*}}> : !cir.float -// CHECK-NEXT: cir.store {{.*}} %[[ZERO]], %[[GET_F]] : !cir.float, !cir.ptr<!cir.float> -// CHECK-NEXT: %[[GET_D:.*]] = cir.get_member %[[STRIDE]][3] {name = "d"} : !cir.ptr<!rec_DefaultOperators> -> !cir.ptr<!cir.double> -// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.fp<0{{.*}}> : !cir.double -// CHECK-NEXT: cir.store {{.*}} %[[ZERO]], %[[GET_D]] : !cir.double, !cir.ptr<!cir.double> -// CHECK-NEXT: %[[GET_B:.*]] = cir.get_member %[[STRIDE]][4] {name = "b"} : !cir.ptr<!rec_DefaultOperators> -> !cir.ptr<!cir.bool> +// CHECK-NEXT: %[[GET_B:.*]] = cir.get_member %[[STRIDE]][2] {name = "b"} : !cir.ptr<!rec_DefaultOperatorsNoFloats> -> !cir.ptr<!cir.bool> // CHECK-NEXT: %[[ZERO:.*]] = cir.const #false // CHECK-NEXT: cir.store {{.*}} %[[ZERO]], %[[GET_B]] : !cir.bool, !cir.ptr<!cir.bool> // CHECK-NEXT: cir.yield @@ -1275,8 +1204,8 @@ void acc_combined() { // CHECK-NEXT: } // CHECK-NEXT: acc.yield // CHECK-NEXT: } combiner { -// CHECK-NEXT: ^bb0(%[[LHSARG:.*]]: !cir.ptr<!cir.array<!rec_DefaultOperators x 5>> {{.*}}, %[[RHSARG:.*]]: !cir.ptr<!cir.array<!rec_DefaultOperators x 5>> {{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty{{.*}})) -// CHECK-NEXT: acc.yield %[[LHSARG]] : !cir.ptr<!cir.array<!rec_DefaultOperators x 5>> +// CHECK-NEXT: ^bb0(%[[LHSARG:.*]]: !cir.ptr<!cir.array<!rec_DefaultOperatorsNoFloats x 5>> {{.*}}, %[[RHSARG:.*]]: !cir.ptr<!cir.array<!rec_DefaultOperatorsNoFloats x 5>> {{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty{{.*}})) +// CHECK-NEXT: acc.yield %[[LHSARG]] : !cir.ptr<!cir.array<!rec_DefaultOperatorsNoFloats x 5>> // CHECK-NEXT: } for(int i=0;i < 5; ++i); #pragma acc parallel loop reduction(&&:someVarArr[2]) @@ -1384,11 +1313,11 @@ void acc_combined() { for(int i=0;i < 5; ++i); #pragma acc parallel loop reduction(min:someVarArr[1:1]) for(int i=0;i < 5; ++i); -#pragma acc parallel loop reduction(&:someVarArr[1:1]) - for(int i=0;i < 5; ++i); -#pragma acc parallel loop reduction(|:someVarArr[1:1]) - for(int i=0;i < 5; ++i); -#pragma acc parallel loop reduction(^:someVarArr[1:1]) +#pragma acc parallel loop reduction(&:someVarArrNoFloats[1:1]) + for(int i = 0; i < 5; ++i); +#pragma acc parallel loop reduction(|:someVarArrNoFloats[1:1]) + for(int i = 0; i < 5; ++i); +#pragma acc parallel loop reduction(^:someVarArrNoFloats[1:1]) for(int i=0;i < 5; ++i); #pragma acc parallel loop reduction(&&:someVarArr[1:1]) for(int i=0;i < 5; ++i); diff --git a/clang/test/CIR/CodeGenOpenACC/combined-reduction-clause-float.cpp b/clang/test/CIR/CodeGenOpenACC/combined-reduction-clause-float.cpp index 001c2fc..6e885cc 100644 --- a/clang/test/CIR/CodeGenOpenACC/combined-reduction-clause-float.cpp +++ b/clang/test/CIR/CodeGenOpenACC/combined-reduction-clause-float.cpp @@ -57,47 +57,6 @@ void acc_combined() { // CHECK-NEXT: acc.yield %[[LHSARG]] : !cir.ptr<!cir.float> // CHECK-NEXT: } for(int i=0;i < 5; ++i); -#pragma acc parallel loop reduction(&:someVar) -// CHECK-NEXT: acc.reduction.recipe @reduction_iand__ZTSf : !cir.ptr<!cir.float> reduction_operator <iand> init { -// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.float>{{.*}}) -// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !cir.float, !cir.ptr<!cir.float>, ["openacc.reduction.init", init] -// CHECK-NEXT: %[[ALL_ONES:.*]] = cir.const #cir.fp<0xF{{.*}}> : !cir.float -// CHECK-NEXT: cir.store {{.*}} %[[ALL_ONES]], %[[ALLOCA]] : !cir.float, !cir.ptr<!cir.float> -// CHECK-NEXT: acc.yield -// CHECK-NEXT: } combiner { -// CHECK-NEXT: ^bb0(%[[LHSARG:.*]]: !cir.ptr<!cir.float> {{.*}}, %[[RHSARG:.*]]: !cir.ptr<!cir.float> {{.*}}) -// TODO OpenACC: Expecting combination operation here -// CHECK-NEXT: acc.yield %[[LHSARG]] : !cir.ptr<!cir.float> -// CHECK-NEXT: } - for(int i=0;i < 5; ++i); -#pragma acc parallel loop reduction(|:someVar) -// CHECK-NEXT: acc.reduction.recipe @reduction_ior__ZTSf : !cir.ptr<!cir.float> reduction_operator <ior> init { -// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.float>{{.*}}) -// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !cir.float, !cir.ptr<!cir.float>, ["openacc.reduction.init", init] -// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.fp<0{{.*}}> : !cir.float -// CHECK-NEXT: cir.store {{.*}} %[[ZERO]], %[[ALLOCA]] : !cir.float, !cir.ptr<!cir.float> -// CHECK-NEXT: acc.yield -// -// CHECK-NEXT: } combiner { -// CHECK-NEXT: ^bb0(%[[LHSARG:.*]]: !cir.ptr<!cir.float> {{.*}}, %[[RHSARG:.*]]: !cir.ptr<!cir.float> {{.*}}) -// TODO OpenACC: Expecting combination operation here -// CHECK-NEXT: acc.yield %[[LHSARG]] : !cir.ptr<!cir.float> -// CHECK-NEXT: } - for(int i=0;i < 5; ++i); -#pragma acc parallel loop reduction(^:someVar) -// CHECK-NEXT: acc.reduction.recipe @reduction_xor__ZTSf : !cir.ptr<!cir.float> reduction_operator <xor> init { -// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.float>{{.*}}) -// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !cir.float, !cir.ptr<!cir.float>, ["openacc.reduction.init", init] -// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.fp<0{{.*}}> : !cir.float -// CHECK-NEXT: cir.store {{.*}} %[[ZERO]], %[[ALLOCA]] : !cir.float, !cir.ptr<!cir.float> -// CHECK-NEXT: acc.yield -// -// CHECK-NEXT: } combiner { -// CHECK-NEXT: ^bb0(%[[LHSARG:.*]]: !cir.ptr<!cir.float> {{.*}}, %[[RHSARG:.*]]: !cir.ptr<!cir.float> {{.*}}) -// TODO OpenACC: Expecting combination operation here -// CHECK-NEXT: acc.yield %[[LHSARG]] : !cir.ptr<!cir.float> -// CHECK-NEXT: } - for(int i=0;i < 5; ++i); #pragma acc parallel loop reduction(&&:someVar) // CHECK-NEXT: acc.reduction.recipe @reduction_land__ZTSf : !cir.ptr<!cir.float> reduction_operator <land> init { // CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.float>{{.*}}) @@ -249,97 +208,6 @@ void acc_combined() { // CHECK-NEXT: acc.yield %[[LHSARG]] : !cir.ptr<!cir.array<!cir.float x 5>> // CHECK-NEXT: } for(int i=0;i < 5; ++i); -#pragma acc parallel loop reduction(&:someVarArr) -// CHECK-NEXT: acc.reduction.recipe @reduction_iand__ZTSA5_f : !cir.ptr<!cir.array<!cir.float x 5>> reduction_operator <iand> init { -// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!cir.float x 5>>{{.*}}) -// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !cir.array<!cir.float x 5>, !cir.ptr<!cir.array<!cir.float x 5>>, ["openacc.reduction.init", init] -// CHECK-NEXT: %[[DECAY:.*]] = cir.cast array_to_ptrdecay %[[ALLOCA]] : !cir.ptr<!cir.array<!cir.float x 5>> -> !cir.ptr<!cir.float> -// CHECK-NEXT: %[[ALL_ONES:.*]] = cir.const #cir.fp<0xF{{.*}}> : !cir.float -// CHECK-NEXT: cir.store{{.*}} %[[ALL_ONES]], %[[DECAY]] : !cir.float, !cir.ptr<!cir.float> -// CHECK-NEXT: %[[ONE_IDX:.*]] = cir.const #cir.int<1> : !s64i -// CHECK-NEXT: %[[NEXT_ELT:.*]] = cir.ptr_stride %[[DECAY]], %[[ONE_IDX]] : (!cir.ptr<!cir.float>, !s64i) -> !cir.ptr<!cir.float> -// CHECK-NEXT: %[[ALL_ONES:.*]] = cir.const #cir.fp<0xF{{.*}}> : !cir.float -// CHECK-NEXT: cir.store{{.*}} %[[ALL_ONES]], %[[NEXT_ELT]] : !cir.float, !cir.ptr<!cir.float> -// CHECK-NEXT: %[[TWO_IDX:.*]] = cir.const #cir.int<2> : !s64i -// CHECK-NEXT: %[[NEXT_ELT:.*]] = cir.ptr_stride %[[DECAY]], %[[TWO_IDX]] : (!cir.ptr<!cir.float>, !s64i) -> !cir.ptr<!cir.float> -// CHECK-NEXT: %[[ALL_ONES:.*]] = cir.const #cir.fp<0xF{{.*}}> : !cir.float -// CHECK-NEXT: cir.store{{.*}} %[[ALL_ONES]], %[[NEXT_ELT]] : !cir.float, !cir.ptr<!cir.float> -// CHECK-NEXT: %[[THREE_IDX:.*]] = cir.const #cir.int<3> : !s64i -// CHECK-NEXT: %[[NEXT_ELT:.*]] = cir.ptr_stride %[[DECAY]], %[[THREE_IDX]] : (!cir.ptr<!cir.float>, !s64i) -> !cir.ptr<!cir.float> -// CHECK-NEXT: %[[ALL_ONES:.*]] = cir.const #cir.fp<0xF{{.*}}> : !cir.float -// CHECK-NEXT: cir.store{{.*}} %[[ALL_ONES]], %[[NEXT_ELT]] : !cir.float, !cir.ptr<!cir.float> -// CHECK-NEXT: %[[FOUR_IDX:.*]] = cir.const #cir.int<4> : !s64i -// CHECK-NEXT: %[[NEXT_ELT:.*]] = cir.ptr_stride %[[DECAY]], %[[FOUR_IDX]] : (!cir.ptr<!cir.float>, !s64i) -> !cir.ptr<!cir.float> -// CHECK-NEXT: %[[ALL_ONES:.*]] = cir.const #cir.fp<0xF{{.*}}> : !cir.float -// CHECK-NEXT: cir.store{{.*}} %[[ALL_ONES]], %[[NEXT_ELT]] : !cir.float, !cir.ptr<!cir.float> -// CHECK-NEXT: acc.yield -// -// CHECK-NEXT: } combiner { -// CHECK-NEXT: ^bb0(%[[LHSARG:.*]]: !cir.ptr<!cir.array<!cir.float x 5>> {{.*}}, %[[RHSARG:.*]]: !cir.ptr<!cir.array<!cir.float x 5>> {{.*}}) -// TODO OpenACC: Expecting combination operation here -// CHECK-NEXT: acc.yield %[[LHSARG]] : !cir.ptr<!cir.array<!cir.float x 5>> -// CHECK-NEXT: } - for(int i=0;i < 5; ++i); -#pragma acc parallel loop reduction(|:someVarArr) -// CHECK-NEXT: acc.reduction.recipe @reduction_ior__ZTSA5_f : !cir.ptr<!cir.array<!cir.float x 5>> reduction_operator <ior> init { -// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!cir.float x 5>>{{.*}}) -// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !cir.array<!cir.float x 5>, !cir.ptr<!cir.array<!cir.float x 5>>, ["openacc.reduction.init", init] -// CHECK-NEXT: %[[TEMP_ITR:.*]] = cir.alloca !cir.ptr<!cir.float>, !cir.ptr<!cir.ptr<!cir.float>>, ["arrayinit.temp"] -// CHECK-NEXT: %[[DECAY:.*]] = cir.cast array_to_ptrdecay %[[ALLOCA]] : !cir.ptr<!cir.array<!cir.float x 5>> -> !cir.ptr<!cir.float> -// CHECK-NEXT: cir.store {{.*}} %[[DECAY]], %[[TEMP_ITR]] : !cir.ptr<!cir.float>, !cir.ptr<!cir.ptr<!cir.float>> -// CHECK-NEXT: %[[LAST_IDX:.*]] = cir.const #cir.int<5> : !s64i -// CHECK-NEXT: %[[END_ITR:.*]] = cir.ptr_stride %[[DECAY]], %[[LAST_IDX]] : (!cir.ptr<!cir.float>, !s64i) -> !cir.ptr<!cir.float> -// CHECK-NEXT: cir.do { -// CHECK-NEXT: %[[TEMP_LOAD:.*]] = cir.load {{.*}} %[[TEMP_ITR]] : !cir.ptr<!cir.ptr<!cir.float>>, !cir.ptr<!cir.float> -// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.fp<0{{.*}}> : !cir.float -// CHECK-NEXT: cir.store {{.*}} %[[ZERO]], %[[TEMP_LOAD]] : !cir.float, !cir.ptr<!cir.float> -// CHECK-NEXT: %[[ONE:.*]] = cir.const #cir.int<1> : !s64i -// CHECK-NEXT: %[[NEXT_ITEM:.*]] = cir.ptr_stride %[[TEMP_LOAD]], %[[ONE]] : (!cir.ptr<!cir.float>, !s64i) -> !cir.ptr<!cir.float> -// CHECK-NEXT: cir.store {{.*}} %[[NEXT_ITEM]], %[[TEMP_ITR]] : !cir.ptr<!cir.float>, !cir.ptr<!cir.ptr<!cir.float>> -// CHECK-NEXT: cir.yield -// CHECK-NEXT: } while { -// CHECK-NEXT: %[[TEMP_LOAD:.*]] = cir.load {{.*}} %[[TEMP_ITR]] : !cir.ptr<!cir.ptr<!cir.float>>, !cir.ptr<!cir.float> -// CHECK-NEXT: %[[CMP:.*]] = cir.cmp(ne, %[[TEMP_LOAD]], %[[END_ITR]]) : !cir.ptr<!cir.float>, !cir.bool -// CHECK-NEXT: cir.condition(%[[CMP]]) -// CHECK-NEXT: } -// CHECK-NEXT: acc.yield -// -// CHECK-NEXT: } combiner { -// CHECK-NEXT: ^bb0(%[[LHSARG:.*]]: !cir.ptr<!cir.array<!cir.float x 5>> {{.*}}, %[[RHSARG:.*]]: !cir.ptr<!cir.array<!cir.float x 5>> {{.*}}) -// TODO OpenACC: Expecting combination operation here -// CHECK-NEXT: acc.yield %[[LHSARG]] : !cir.ptr<!cir.array<!cir.float x 5>> -// CHECK-NEXT: } - for(int i=0;i < 5; ++i); -#pragma acc parallel loop reduction(^:someVarArr) -// CHECK-NEXT: acc.reduction.recipe @reduction_xor__ZTSA5_f : !cir.ptr<!cir.array<!cir.float x 5>> reduction_operator <xor> init { -// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!cir.float x 5>>{{.*}}) -// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !cir.array<!cir.float x 5>, !cir.ptr<!cir.array<!cir.float x 5>>, ["openacc.reduction.init", init] -// CHECK-NEXT: %[[TEMP_ITR:.*]] = cir.alloca !cir.ptr<!cir.float>, !cir.ptr<!cir.ptr<!cir.float>>, ["arrayinit.temp"] -// CHECK-NEXT: %[[DECAY:.*]] = cir.cast array_to_ptrdecay %[[ALLOCA]] : !cir.ptr<!cir.array<!cir.float x 5>> -> !cir.ptr<!cir.float> -// CHECK-NEXT: cir.store {{.*}} %[[DECAY]], %[[TEMP_ITR]] : !cir.ptr<!cir.float>, !cir.ptr<!cir.ptr<!cir.float>> -// CHECK-NEXT: %[[LAST_IDX:.*]] = cir.const #cir.int<5> : !s64i -// CHECK-NEXT: %[[END_ITR:.*]] = cir.ptr_stride %[[DECAY]], %[[LAST_IDX]] : (!cir.ptr<!cir.float>, !s64i) -> !cir.ptr<!cir.float> -// CHECK-NEXT: cir.do { -// CHECK-NEXT: %[[TEMP_LOAD:.*]] = cir.load {{.*}} %[[TEMP_ITR]] : !cir.ptr<!cir.ptr<!cir.float>>, !cir.ptr<!cir.float> -// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.fp<0{{.*}}> : !cir.float -// CHECK-NEXT: cir.store {{.*}} %[[ZERO]], %[[TEMP_LOAD]] : !cir.float, !cir.ptr<!cir.float> -// CHECK-NEXT: %[[ONE:.*]] = cir.const #cir.int<1> : !s64i -// CHECK-NEXT: %[[NEXT_ITEM:.*]] = cir.ptr_stride %[[TEMP_LOAD]], %[[ONE]] : (!cir.ptr<!cir.float>, !s64i) -> !cir.ptr<!cir.float> -// CHECK-NEXT: cir.store {{.*}} %[[NEXT_ITEM]], %[[TEMP_ITR]] : !cir.ptr<!cir.float>, !cir.ptr<!cir.ptr<!cir.float>> -// CHECK-NEXT: cir.yield -// CHECK-NEXT: } while { -// CHECK-NEXT: %[[TEMP_LOAD:.*]] = cir.load {{.*}} %[[TEMP_ITR]] : !cir.ptr<!cir.ptr<!cir.float>>, !cir.ptr<!cir.float> -// CHECK-NEXT: %[[CMP:.*]] = cir.cmp(ne, %[[TEMP_LOAD]], %[[END_ITR]]) : !cir.ptr<!cir.float>, !cir.bool -// CHECK-NEXT: cir.condition(%[[CMP]]) -// CHECK-NEXT: } -// CHECK-NEXT: acc.yield -// -// CHECK-NEXT: } combiner { -// CHECK-NEXT: ^bb0(%[[LHSARG:.*]]: !cir.ptr<!cir.array<!cir.float x 5>> {{.*}}, %[[RHSARG:.*]]: !cir.ptr<!cir.array<!cir.float x 5>> {{.*}}) -// TODO OpenACC: Expecting combination operation here -// CHECK-NEXT: acc.yield %[[LHSARG]] : !cir.ptr<!cir.array<!cir.float x 5>> -// CHECK-NEXT: } - for(int i=0;i < 5; ++i); #pragma acc parallel loop reduction(&&:someVarArr) // CHECK-NEXT: acc.reduction.recipe @reduction_land__ZTSA5_f : !cir.ptr<!cir.array<!cir.float x 5>> reduction_operator <land> init { // CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!cir.float x 5>>{{.*}}) @@ -542,111 +410,6 @@ void acc_combined() { // CHECK-NEXT: acc.yield %[[LHSARG]] : !cir.ptr<!cir.array<!cir.float x 5>> // CHECK-NEXT: } for(int i=0;i < 5; ++i); -#pragma acc parallel loop reduction(&:someVarArr[2]) -// CHECK-NEXT: acc.reduction.recipe @reduction_iand__Bcnt1__ZTSA5_f : !cir.ptr<!cir.array<!cir.float x 5>> reduction_operator <iand> init { -// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!cir.float x 5>>{{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty{{.*}})) -// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !cir.array<!cir.float x 5>, !cir.ptr<!cir.array<!cir.float x 5>>, ["openacc.reduction.init"] -// CHECK-NEXT: cir.scope { -// CHECK-NEXT: %[[LB:.*]] = acc.get_lowerbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index -// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i -// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index -// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i -// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"] {alignment = 8 : i64} -// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i> -// CHECK-NEXT: cir.for : cond { -// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i -// CHECK-NEXT: %[[COND:.*]] = cir.cmp(lt, %[[ITR_LOAD]], %[[UB_CAST]]) : !u64i, !cir.bool -// CHECK-NEXT: cir.condition(%[[COND]]) -// CHECK-NEXT: } body { -// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i -// CHECK-NEXT: %[[DECAY:.*]] = cir.cast array_to_ptrdecay %[[ALLOCA]] : !cir.ptr<!cir.array<!cir.float x 5>> -> !cir.ptr<!cir.float> -// CHECK-NEXT: %[[STRIDE:.*]] = cir.ptr_stride %[[DECAY]], %[[ITR_LOAD]] : (!cir.ptr<!cir.float>, !u64i) -> !cir.ptr<!cir.float> -// CHECK-NEXT: %[[ALL_ONES:.*]] = cir.const #cir.fp<0xF{{.*}}> : !cir.float -// CHECK-NEXT: cir.store{{.*}} %[[ALL_ONES]], %[[STRIDE]] : !cir.float, !cir.ptr<!cir.float> -// CHECK-NEXT: cir.yield -// CHECK-NEXT: } step { -// CHECK-NEXT: %[[ITR_LOAD]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i -// CHECK-NEXT: %[[INC:.*]] = cir.unary(inc, %[[ITR_LOAD]]) : !u64i, !u64i -// CHECK-NEXT: cir.store %[[INC]], %[[ITR]] : !u64i, !cir.ptr<!u64i> -// CHECK-NEXT: cir.yield -// CHECK-NEXT: } -// CHECK-NEXT: } -// CHECK-NEXT: acc.yield -// CHECK-NEXT: } combiner { -// CHECK-NEXT: ^bb0(%[[LHSARG:.*]]: !cir.ptr<!cir.array<!cir.float x 5>> {{.*}}, %[[RHSARG:.*]]: !cir.ptr<!cir.array<!cir.float x 5>> {{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty{{.*}})) -// CHECK-NEXT: acc.yield %[[LHSARG]] : !cir.ptr<!cir.array<!cir.float x 5>> -// CHECK-NEXT: } - for(int i=0;i < 5; ++i); -#pragma acc parallel loop reduction(|:someVarArr[2]) -// CHECK-NEXT: acc.reduction.recipe @reduction_ior__Bcnt1__ZTSA5_f : !cir.ptr<!cir.array<!cir.float x 5>> reduction_operator <ior> init { -// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!cir.float x 5>>{{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty{{.*}})) -// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !cir.array<!cir.float x 5>, !cir.ptr<!cir.array<!cir.float x 5>>, ["openacc.reduction.init"] -// CHECK-NEXT: cir.scope { -// CHECK-NEXT: %[[LB:.*]] = acc.get_lowerbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index -// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i -// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index -// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i -// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"] {alignment = 8 : i64} -// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i> -// CHECK-NEXT: cir.for : cond { -// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i -// CHECK-NEXT: %[[COND:.*]] = cir.cmp(lt, %[[ITR_LOAD]], %[[UB_CAST]]) : !u64i, !cir.bool -// CHECK-NEXT: cir.condition(%[[COND]]) -// CHECK-NEXT: } body { -// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i -// CHECK-NEXT: %[[DECAY:.*]] = cir.cast array_to_ptrdecay %[[ALLOCA]] : !cir.ptr<!cir.array<!cir.float x 5>> -> !cir.ptr<!cir.float> -// CHECK-NEXT: %[[STRIDE:.*]] = cir.ptr_stride %[[DECAY]], %[[ITR_LOAD]] : (!cir.ptr<!cir.float>, !u64i) -> !cir.ptr<!cir.float> -// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.fp<0{{.*}}> : !cir.float -// CHECK-NEXT: cir.store{{.*}} %[[ZERO]], %[[STRIDE]] : !cir.float, !cir.ptr<!cir.float> -// CHECK-NEXT: cir.yield -// CHECK-NEXT: } step { -// CHECK-NEXT: %[[ITR_LOAD]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i -// CHECK-NEXT: %[[INC:.*]] = cir.unary(inc, %[[ITR_LOAD]]) : !u64i, !u64i -// CHECK-NEXT: cir.store %[[INC]], %[[ITR]] : !u64i, !cir.ptr<!u64i> -// CHECK-NEXT: cir.yield -// CHECK-NEXT: } -// CHECK-NEXT: } -// CHECK-NEXT: acc.yield -// CHECK-NEXT: } combiner { -// CHECK-NEXT: ^bb0(%[[LHSARG:.*]]: !cir.ptr<!cir.array<!cir.float x 5>> {{.*}}, %[[RHSARG:.*]]: !cir.ptr<!cir.array<!cir.float x 5>> {{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty{{.*}})) -// CHECK-NEXT: acc.yield %[[LHSARG]] : !cir.ptr<!cir.array<!cir.float x 5>> -// CHECK-NEXT: } - for(int i=0;i < 5; ++i); -#pragma acc parallel loop reduction(^:someVarArr[2]) -// CHECK-NEXT: acc.reduction.recipe @reduction_xor__Bcnt1__ZTSA5_f : !cir.ptr<!cir.array<!cir.float x 5>> reduction_operator <xor> init { -// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!cir.float x 5>>{{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty{{.*}})) -// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !cir.array<!cir.float x 5>, !cir.ptr<!cir.array<!cir.float x 5>>, ["openacc.reduction.init"] -// CHECK-NEXT: cir.scope { -// CHECK-NEXT: %[[LB:.*]] = acc.get_lowerbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index -// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i -// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index -// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i -// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"] {alignment = 8 : i64} -// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i> -// CHECK-NEXT: cir.for : cond { -// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i -// CHECK-NEXT: %[[COND:.*]] = cir.cmp(lt, %[[ITR_LOAD]], %[[UB_CAST]]) : !u64i, !cir.bool -// CHECK-NEXT: cir.condition(%[[COND]]) -// CHECK-NEXT: } body { -// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i -// CHECK-NEXT: %[[DECAY:.*]] = cir.cast array_to_ptrdecay %[[ALLOCA]] : !cir.ptr<!cir.array<!cir.float x 5>> -> !cir.ptr<!cir.float> -// CHECK-NEXT: %[[STRIDE:.*]] = cir.ptr_stride %[[DECAY]], %[[ITR_LOAD]] : (!cir.ptr<!cir.float>, !u64i) -> !cir.ptr<!cir.float> -// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.fp<0{{.*}}> : !cir.float -// CHECK-NEXT: cir.store{{.*}} %[[ZERO]], %[[STRIDE]] : !cir.float, !cir.ptr<!cir.float> -// CHECK-NEXT: cir.yield -// CHECK-NEXT: } step { -// CHECK-NEXT: %[[ITR_LOAD]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i -// CHECK-NEXT: %[[INC:.*]] = cir.unary(inc, %[[ITR_LOAD]]) : !u64i, !u64i -// CHECK-NEXT: cir.store %[[INC]], %[[ITR]] : !u64i, !cir.ptr<!u64i> -// CHECK-NEXT: cir.yield -// CHECK-NEXT: } -// CHECK-NEXT: } -// CHECK-NEXT: acc.yield -// CHECK-NEXT: } combiner { -// CHECK-NEXT: ^bb0(%[[LHSARG:.*]]: !cir.ptr<!cir.array<!cir.float x 5>> {{.*}}, %[[RHSARG:.*]]: !cir.ptr<!cir.array<!cir.float x 5>> {{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty{{.*}})) -// CHECK-NEXT: acc.yield %[[LHSARG]] : !cir.ptr<!cir.array<!cir.float x 5>> -// CHECK-NEXT: } - for(int i=0;i < 5; ++i); #pragma acc parallel loop reduction(&&:someVarArr[2]) // CHECK-NEXT: acc.reduction.recipe @reduction_land__Bcnt1__ZTSA5_f : !cir.ptr<!cir.array<!cir.float x 5>> reduction_operator <land> init { // CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!cir.float x 5>>{{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty{{.*}})) @@ -726,12 +489,6 @@ void acc_combined() { for(int i=0;i < 5; ++i); #pragma acc parallel loop reduction(min:someVarArr[1:1]) for(int i=0;i < 5; ++i); -#pragma acc parallel loop reduction(&:someVarArr[1:1]) - for(int i=0;i < 5; ++i); -#pragma acc parallel loop reduction(|:someVarArr[1:1]) - for(int i=0;i < 5; ++i); -#pragma acc parallel loop reduction(^:someVarArr[1:1]) - for(int i=0;i < 5; ++i); #pragma acc parallel loop reduction(&&:someVarArr[1:1]) for(int i=0;i < 5; ++i); #pragma acc parallel loop reduction(||:someVarArr[1:1]) diff --git a/clang/test/CIR/CodeGenOpenACC/compute-reduction-clause-default-ops.c b/clang/test/CIR/CodeGenOpenACC/compute-reduction-clause-default-ops.c index f70113e..c99dc09 100644 --- a/clang/test/CIR/CodeGenOpenACC/compute-reduction-clause-default-ops.c +++ b/clang/test/CIR/CodeGenOpenACC/compute-reduction-clause-default-ops.c @@ -8,9 +8,17 @@ struct DefaultOperators { bool b; }; +struct DefaultOperatorsNoFloats { + int i; + unsigned int u; + bool b; +}; + void acc_compute() { struct DefaultOperators someVar; struct DefaultOperators someVarArr[5]; + struct DefaultOperatorsNoFloats someVarNoFloats; + struct DefaultOperatorsNoFloats someVarArrNoFloats[5]; #pragma acc parallel reduction(+:someVar) // CHECK: acc.reduction.recipe @reduction_add__ZTS16DefaultOperators : !cir.ptr<!rec_DefaultOperators> reduction_operator <add> init { // CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!rec_DefaultOperators>{{.*}}) @@ -119,85 +127,67 @@ void acc_compute() { // CHECK-NEXT: acc.yield %[[LHSARG]] : !cir.ptr<!rec_DefaultOperators> // CHECK-NEXT: } ; -#pragma acc parallel reduction(&:someVar) -// CHECK-NEXT: acc.reduction.recipe @reduction_iand__ZTS16DefaultOperators : !cir.ptr<!rec_DefaultOperators> reduction_operator <iand> init { -// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!rec_DefaultOperators>{{.*}}) -// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !rec_DefaultOperators, !cir.ptr<!rec_DefaultOperators>, ["openacc.reduction.init", init] -// CHECK-NEXT: %[[GET_I:.*]] = cir.get_member %[[ALLOCA]][0] {name = "i"} : !cir.ptr<!rec_DefaultOperators> -> !cir.ptr<!s32i> +#pragma acc parallel reduction(&:someVarNoFloats) +// CHECK-NEXT: acc.reduction.recipe @reduction_iand__ZTS24DefaultOperatorsNoFloats : !cir.ptr<!rec_DefaultOperatorsNoFloats> reduction_operator <iand> init { +// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!rec_DefaultOperatorsNoFloats>{{.*}}) +// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !rec_DefaultOperatorsNoFloats, !cir.ptr<!rec_DefaultOperatorsNoFloats>, ["openacc.reduction.init", init] +// CHECK-NEXT: %[[GET_I:.*]] = cir.get_member %[[ALLOCA]][0] {name = "i"} : !cir.ptr<!rec_DefaultOperatorsNoFloats> -> !cir.ptr<!s32i> // CHECK-NEXT: %[[ALL_ONES:.*]] = cir.const #cir.int<-1> : !s32i // CHECK-NEXT: cir.store {{.*}} %[[ALL_ONES]], %[[GET_I]] : !s32i, !cir.ptr<!s32i> -// CHECK-NEXT: %[[GET_U:.*]] = cir.get_member %[[ALLOCA]][1] {name = "u"} : !cir.ptr<!rec_DefaultOperators> -> !cir.ptr<!u32i> +// CHECK-NEXT: %[[GET_U:.*]] = cir.get_member %[[ALLOCA]][1] {name = "u"} : !cir.ptr<!rec_DefaultOperatorsNoFloats> -> !cir.ptr<!u32i> // CHECK-NEXT: %[[ALL_ONES:.*]] = cir.const #cir.int<4294967295> : !u32i // CHECK-NEXT: cir.store {{.*}} %[[ALL_ONES]], %[[GET_U]] : !u32i, !cir.ptr<!u32i> -// CHECK-NEXT: %[[GET_F:.*]] = cir.get_member %[[ALLOCA]][2] {name = "f"} : !cir.ptr<!rec_DefaultOperators> -> !cir.ptr<!cir.float> -// CHECK-NEXT: %[[ALL_ONES:.*]] = cir.const #cir.fp<0xFF{{.*}}> : !cir.float -// CHECK-NEXT: cir.store {{.*}} %[[ALL_ONES]], %[[GET_F]] : !cir.float, !cir.ptr<!cir.float> -// CHECK-NEXT: %[[GET_D:.*]] = cir.get_member %[[ALLOCA]][3] {name = "d"} : !cir.ptr<!rec_DefaultOperators> -> !cir.ptr<!cir.double> -// CHECK-NEXT: %[[ALL_ONES:.*]] = cir.const #cir.fp<0xFF{{.*}}> : !cir.double -// CHECK-NEXT: cir.store {{.*}} %[[ALL_ONES]], %[[GET_D]] : !cir.double, !cir.ptr<!cir.double> -// CHECK-NEXT: %[[GET_B:.*]] = cir.get_member %[[ALLOCA]][4] {name = "b"} : !cir.ptr<!rec_DefaultOperators> -> !cir.ptr<!cir.bool> +// CHECK-NEXT: %[[GET_B:.*]] = cir.get_member %[[ALLOCA]][2] {name = "b"} : !cir.ptr<!rec_DefaultOperatorsNoFloats> -> !cir.ptr<!cir.bool> // CHECK-NEXT: %[[ALL_ONES:.*]] = cir.const #true // CHECK-NEXT: cir.store {{.*}} %[[ALL_ONES]], %[[GET_B]] : !cir.bool, !cir.ptr<!cir.bool> // CHECK-NEXT: acc.yield // // CHECK-NEXT: } combiner { -// CHECK-NEXT: ^bb0(%[[LHSARG:.*]]: !cir.ptr<!rec_DefaultOperators> {{.*}}, %[[RHSARG:.*]]: !cir.ptr<!rec_DefaultOperators> {{.*}}) +// CHECK-NEXT: ^bb0(%[[LHSARG:.*]]: !cir.ptr<!rec_DefaultOperatorsNoFloats> {{.*}}, %[[RHSARG:.*]]: !cir.ptr<!rec_DefaultOperatorsNoFloats> {{.*}}) // TODO OpenACC: Expecting combination operation here -// CHECK-NEXT: acc.yield %[[LHSARG]] : !cir.ptr<!rec_DefaultOperators> +// CHECK-NEXT: acc.yield %[[LHSARG]] : !cir.ptr<!rec_DefaultOperatorsNoFloats> // CHECK-NEXT: } ; -#pragma acc parallel reduction(|:someVar) -// CHECK-NEXT: acc.reduction.recipe @reduction_ior__ZTS16DefaultOperators : !cir.ptr<!rec_DefaultOperators> reduction_operator <ior> init { -// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!rec_DefaultOperators>{{.*}}) -// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !rec_DefaultOperators, !cir.ptr<!rec_DefaultOperators>, ["openacc.reduction.init", init] -// CHECK-NEXT: %[[GET_I:.*]] = cir.get_member %[[ALLOCA]][0] {name = "i"} : !cir.ptr<!rec_DefaultOperators> -> !cir.ptr<!s32i> +#pragma acc parallel reduction(|:someVarNoFloats) +// CHECK-NEXT: acc.reduction.recipe @reduction_ior__ZTS24DefaultOperatorsNoFloats : !cir.ptr<!rec_DefaultOperatorsNoFloats> reduction_operator <ior> init { +// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!rec_DefaultOperatorsNoFloats>{{.*}}) +// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !rec_DefaultOperatorsNoFloats, !cir.ptr<!rec_DefaultOperatorsNoFloats>, ["openacc.reduction.init", init] +// CHECK-NEXT: %[[GET_I:.*]] = cir.get_member %[[ALLOCA]][0] {name = "i"} : !cir.ptr<!rec_DefaultOperatorsNoFloats> -> !cir.ptr<!s32i> // CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !s32i // CHECK-NEXT: cir.store {{.*}} %[[ZERO]], %[[GET_I]] : !s32i, !cir.ptr<!s32i> -// CHECK-NEXT: %[[GET_U:.*]] = cir.get_member %[[ALLOCA]][1] {name = "u"} : !cir.ptr<!rec_DefaultOperators> -> !cir.ptr<!u32i> +// CHECK-NEXT: %[[GET_U:.*]] = cir.get_member %[[ALLOCA]][1] {name = "u"} : !cir.ptr<!rec_DefaultOperatorsNoFloats> -> !cir.ptr<!u32i> // CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !u32i // CHECK-NEXT: cir.store {{.*}} %[[ZERO]], %[[GET_U]] : !u32i, !cir.ptr<!u32i> -// CHECK-NEXT: %[[GET_F:.*]] = cir.get_member %[[ALLOCA]][2] {name = "f"} : !cir.ptr<!rec_DefaultOperators> -> !cir.ptr<!cir.float> -// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.fp<0{{.*}}> : !cir.float -// CHECK-NEXT: cir.store {{.*}} %[[ZERO]], %[[GET_F]] : !cir.float, !cir.ptr<!cir.float> -// CHECK-NEXT: %[[GET_D:.*]] = cir.get_member %[[ALLOCA]][3] {name = "d"} : !cir.ptr<!rec_DefaultOperators> -> !cir.ptr<!cir.double> -// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.fp<0{{.*}}> : !cir.double -// CHECK-NEXT: cir.store {{.*}} %[[ZERO]], %[[GET_D]] : !cir.double, !cir.ptr<!cir.double> -// CHECK-NEXT: %[[GET_B:.*]] = cir.get_member %[[ALLOCA]][4] {name = "b"} : !cir.ptr<!rec_DefaultOperators> -> !cir.ptr<!cir.bool> +// CHECK-NEXT: %[[GET_B:.*]] = cir.get_member %[[ALLOCA]][2] {name = "b"} : !cir.ptr<!rec_DefaultOperatorsNoFloats> -> !cir.ptr<!cir.bool> // CHECK-NEXT: %[[ZERO:.*]] = cir.const #false // CHECK-NEXT: cir.store {{.*}} %[[ZERO]], %[[GET_B]] : !cir.bool, !cir.ptr<!cir.bool> // CHECK-NEXT: acc.yield // // CHECK-NEXT: } combiner { -// CHECK-NEXT: ^bb0(%[[LHSARG:.*]]: !cir.ptr<!rec_DefaultOperators> {{.*}}, %[[RHSARG:.*]]: !cir.ptr<!rec_DefaultOperators> {{.*}}) +// CHECK-NEXT: ^bb0(%[[LHSARG:.*]]: !cir.ptr<!rec_DefaultOperatorsNoFloats> {{.*}}, %[[RHSARG:.*]]: !cir.ptr<!rec_DefaultOperatorsNoFloats> {{.*}}) // TODO OpenACC: Expecting combination operation here -// CHECK-NEXT: acc.yield %[[LHSARG]] : !cir.ptr<!rec_DefaultOperators> +// CHECK-NEXT: acc.yield %[[LHSARG]] : !cir.ptr<!rec_DefaultOperatorsNoFloats> // CHECK-NEXT: } ; -#pragma acc parallel reduction(^:someVar) -// CHECK-NEXT: acc.reduction.recipe @reduction_xor__ZTS16DefaultOperators : !cir.ptr<!rec_DefaultOperators> reduction_operator <xor> init { -// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!rec_DefaultOperators>{{.*}}) -// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !rec_DefaultOperators, !cir.ptr<!rec_DefaultOperators>, ["openacc.reduction.init", init] -// CHECK-NEXT: %[[GET_I:.*]] = cir.get_member %[[ALLOCA]][0] {name = "i"} : !cir.ptr<!rec_DefaultOperators> -> !cir.ptr<!s32i> +#pragma acc parallel reduction(^:someVarNoFloats) +// CHECK-NEXT: acc.reduction.recipe @reduction_xor__ZTS24DefaultOperatorsNoFloats : !cir.ptr<!rec_DefaultOperatorsNoFloats> reduction_operator <xor> init { +// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!rec_DefaultOperatorsNoFloats>{{.*}}) +// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !rec_DefaultOperatorsNoFloats, !cir.ptr<!rec_DefaultOperatorsNoFloats>, ["openacc.reduction.init", init] +// CHECK-NEXT: %[[GET_I:.*]] = cir.get_member %[[ALLOCA]][0] {name = "i"} : !cir.ptr<!rec_DefaultOperatorsNoFloats> -> !cir.ptr<!s32i> // CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !s32i // CHECK-NEXT: cir.store {{.*}} %[[ZERO]], %[[GET_I]] : !s32i, !cir.ptr<!s32i> -// CHECK-NEXT: %[[GET_U:.*]] = cir.get_member %[[ALLOCA]][1] {name = "u"} : !cir.ptr<!rec_DefaultOperators> -> !cir.ptr<!u32i> +// CHECK-NEXT: %[[GET_U:.*]] = cir.get_member %[[ALLOCA]][1] {name = "u"} : !cir.ptr<!rec_DefaultOperatorsNoFloats> -> !cir.ptr<!u32i> // CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !u32i // CHECK-NEXT: cir.store {{.*}} %[[ZERO]], %[[GET_U]] : !u32i, !cir.ptr<!u32i> -// CHECK-NEXT: %[[GET_F:.*]] = cir.get_member %[[ALLOCA]][2] {name = "f"} : !cir.ptr<!rec_DefaultOperators> -> !cir.ptr<!cir.float> -// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.fp<0{{.*}}> : !cir.float -// CHECK-NEXT: cir.store {{.*}} %[[ZERO]], %[[GET_F]] : !cir.float, !cir.ptr<!cir.float> -// CHECK-NEXT: %[[GET_D:.*]] = cir.get_member %[[ALLOCA]][3] {name = "d"} : !cir.ptr<!rec_DefaultOperators> -> !cir.ptr<!cir.double> -// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.fp<0{{.*}}> : !cir.double -// CHECK-NEXT: cir.store {{.*}} %[[ZERO]], %[[GET_D]] : !cir.double, !cir.ptr<!cir.double> -// CHECK-NEXT: %[[GET_B:.*]] = cir.get_member %[[ALLOCA]][4] {name = "b"} : !cir.ptr<!rec_DefaultOperators> -> !cir.ptr<!cir.bool> +// CHECK-NEXT: %[[GET_B:.*]] = cir.get_member %[[ALLOCA]][2] {name = "b"} : !cir.ptr<!rec_DefaultOperatorsNoFloats> -> !cir.ptr<!cir.bool> // CHECK-NEXT: %[[ZERO:.*]] = cir.const #false // CHECK-NEXT: cir.store {{.*}} %[[ZERO]], %[[GET_B]] : !cir.bool, !cir.ptr<!cir.bool> // CHECK-NEXT: acc.yield // // CHECK-NEXT: } combiner { -// CHECK-NEXT: ^bb0(%[[LHSARG:.*]]: !cir.ptr<!rec_DefaultOperators> {{.*}}, %[[RHSARG:.*]]: !cir.ptr<!rec_DefaultOperators> {{.*}}) +// CHECK-NEXT: ^bb0(%[[LHSARG:.*]]: !cir.ptr<!rec_DefaultOperatorsNoFloats> {{.*}}, %[[RHSARG:.*]]: !cir.ptr<!rec_DefaultOperatorsNoFloats> {{.*}}) // TODO OpenACC: Expecting combination operation here -// CHECK-NEXT: acc.yield %[[LHSARG]] : !cir.ptr<!rec_DefaultOperators> +// CHECK-NEXT: acc.yield %[[LHSARG]] : !cir.ptr<!rec_DefaultOperatorsNoFloats> // CHECK-NEXT: } ; #pragma acc parallel reduction(&&:someVar) @@ -592,166 +582,136 @@ void acc_compute() { // CHECK-NEXT: acc.yield %[[LHSARG]] : !cir.ptr<!cir.array<!rec_DefaultOperators x 5>> // CHECK-NEXT: } ; -#pragma acc parallel reduction(&:someVarArr) -// CHECK-NEXT: acc.reduction.recipe @reduction_iand__ZTSA5_16DefaultOperators : !cir.ptr<!cir.array<!rec_DefaultOperators x 5>> reduction_operator <iand> init { -// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!rec_DefaultOperators x 5>>{{.*}}) -// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !cir.array<!rec_DefaultOperators x 5>, !cir.ptr<!cir.array<!rec_DefaultOperators x 5>>, ["openacc.reduction.init", init] -// CHECK-NEXT: %[[DECAY:.*]] = cir.cast array_to_ptrdecay %[[ALLOCA]] : !cir.ptr<!cir.array<!rec_DefaultOperators x 5>> -> !cir.ptr<!rec_DefaultOperators> -// CHECK-NEXT: %[[GET_I:.*]] = cir.get_member %[[DECAY]][0] {name = "i"} : !cir.ptr<!rec_DefaultOperators> -> !cir.ptr<!s32i> +#pragma acc parallel reduction(&:someVarArrNoFloats) +// CHECK-NEXT: acc.reduction.recipe @reduction_iand__ZTSA5_24DefaultOperatorsNoFloats : !cir.ptr<!cir.array<!rec_DefaultOperatorsNoFloats x 5>> reduction_operator <iand> init { +// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!rec_DefaultOperatorsNoFloats x 5>>{{.*}}) +// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !cir.array<!rec_DefaultOperatorsNoFloats x 5>, !cir.ptr<!cir.array<!rec_DefaultOperatorsNoFloats x 5>>, ["openacc.reduction.init", init] +// CHECK-NEXT: %[[DECAY:.*]] = cir.cast array_to_ptrdecay %[[ALLOCA]] : !cir.ptr<!cir.array<!rec_DefaultOperatorsNoFloats x 5>> -> !cir.ptr<!rec_DefaultOperatorsNoFloats> +// CHECK-NEXT: %[[GET_I:.*]] = cir.get_member %[[DECAY]][0] {name = "i"} : !cir.ptr<!rec_DefaultOperatorsNoFloats> -> !cir.ptr<!s32i> // CHECK-NEXT: %[[ALL_ONES:.*]] = cir.const #cir.int<-1> : !s32i // CHECK-NEXT: cir.store {{.*}} %[[ALL_ONES]], %[[GET_I]] : !s32i, !cir.ptr<!s32i> -// CHECK-NEXT: %[[GET_U:.*]] = cir.get_member %[[DECAY]][1] {name = "u"} : !cir.ptr<!rec_DefaultOperators> -> !cir.ptr<!u32i> +// CHECK-NEXT: %[[GET_U:.*]] = cir.get_member %[[DECAY]][1] {name = "u"} : !cir.ptr<!rec_DefaultOperatorsNoFloats> -> !cir.ptr<!u32i> // CHECK-NEXT: %[[ALL_ONES:.*]] = cir.const #cir.int<4294967295> : !u32i // CHECK-NEXT: cir.store {{.*}} %[[ALL_ONES]], %[[GET_U]] : !u32i, !cir.ptr<!u32i> -// CHECK-NEXT: %[[GET_F:.*]] = cir.get_member %[[DECAY]][2] {name = "f"} : !cir.ptr<!rec_DefaultOperators> -> !cir.ptr<!cir.float> -// CHECK-NEXT: %[[ALL_ONES:.*]] = cir.const #cir.fp<0xFF{{.*}}> : !cir.float -// CHECK-NEXT: cir.store {{.*}} %[[ALL_ONES]], %[[GET_F]] : !cir.float, !cir.ptr<!cir.float> -// CHECK-NEXT: %[[GET_D:.*]] = cir.get_member %[[DECAY]][3] {name = "d"} : !cir.ptr<!rec_DefaultOperators> -> !cir.ptr<!cir.double> -// CHECK-NEXT: %[[ALL_ONES:.*]] = cir.const #cir.fp<0xFF{{.*}}> : !cir.double -// CHECK-NEXT: cir.store {{.*}} %[[ALL_ONES]], %[[GET_D]] : !cir.double, !cir.ptr<!cir.double> -// CHECK-NEXT: %[[GET_B:.*]] = cir.get_member %[[DECAY]][4] {name = "b"} : !cir.ptr<!rec_DefaultOperators> -> !cir.ptr<!cir.bool> +// CHECK-NEXT: %[[GET_B:.*]] = cir.get_member %[[DECAY]][2] {name = "b"} : !cir.ptr<!rec_DefaultOperatorsNoFloats> -> !cir.ptr<!cir.bool> // CHECK-NEXT: %[[ALL_ONES:.*]] = cir.const #true // CHECK-NEXT: cir.store {{.*}} %[[ALL_ONES]], %[[GET_B]] : !cir.bool, !cir.ptr<!cir.bool> // // CHECK-NEXT: %[[ALL_ONES_IDX:.*]] = cir.const #cir.int<1> : !s64i -// CHECK-NEXT: %[[NEXT_ELT:.*]] = cir.ptr_stride %[[DECAY]], %[[ALL_ONES_IDX]] : (!cir.ptr<!rec_DefaultOperators>, !s64i) -> !cir.ptr<!rec_DefaultOperators> -// CHECK-NEXT: %[[GET_I:.*]] = cir.get_member %[[NEXT_ELT]][0] {name = "i"} : !cir.ptr<!rec_DefaultOperators> -> !cir.ptr<!s32i> +// CHECK-NEXT: %[[NEXT_ELT:.*]] = cir.ptr_stride %[[DECAY]], %[[ALL_ONES_IDX]] : (!cir.ptr<!rec_DefaultOperatorsNoFloats>, !s64i) -> !cir.ptr<!rec_DefaultOperatorsNoFloats> +// CHECK-NEXT: %[[GET_I:.*]] = cir.get_member %[[NEXT_ELT]][0] {name = "i"} : !cir.ptr<!rec_DefaultOperatorsNoFloats> -> !cir.ptr<!s32i> // CHECK-NEXT: %[[ALL_ONES:.*]] = cir.const #cir.int<-1> : !s32i // CHECK-NEXT: cir.store {{.*}} %[[ALL_ONES]], %[[GET_I]] : !s32i, !cir.ptr<!s32i> -// CHECK-NEXT: %[[GET_U:.*]] = cir.get_member %[[NEXT_ELT]][1] {name = "u"} : !cir.ptr<!rec_DefaultOperators> -> !cir.ptr<!u32i> +// CHECK-NEXT: %[[GET_U:.*]] = cir.get_member %[[NEXT_ELT]][1] {name = "u"} : !cir.ptr<!rec_DefaultOperatorsNoFloats> -> !cir.ptr<!u32i> // CHECK-NEXT: %[[ALL_ONES:.*]] = cir.const #cir.int<4294967295> : !u32i // CHECK-NEXT: cir.store {{.*}} %[[ALL_ONES]], %[[GET_U]] : !u32i, !cir.ptr<!u32i> -// CHECK-NEXT: %[[GET_F:.*]] = cir.get_member %[[NEXT_ELT]][2] {name = "f"} : !cir.ptr<!rec_DefaultOperators> -> !cir.ptr<!cir.float> -// CHECK-NEXT: %[[ALL_ONES:.*]] = cir.const #cir.fp<0xFF{{.*}}> : !cir.float -// CHECK-NEXT: cir.store {{.*}} %[[ALL_ONES]], %[[GET_F]] : !cir.float, !cir.ptr<!cir.float> -// CHECK-NEXT: %[[GET_D:.*]] = cir.get_member %[[NEXT_ELT]][3] {name = "d"} : !cir.ptr<!rec_DefaultOperators> -> !cir.ptr<!cir.double> -// CHECK-NEXT: %[[ALL_ONES:.*]] = cir.const #cir.fp<0xFF{{.*}}> : !cir.double -// CHECK-NEXT: cir.store {{.*}} %[[ALL_ONES]], %[[GET_D]] : !cir.double, !cir.ptr<!cir.double> -// CHECK-NEXT: %[[GET_B:.*]] = cir.get_member %[[NEXT_ELT]][4] {name = "b"} : !cir.ptr<!rec_DefaultOperators> -> !cir.ptr<!cir.bool> +// CHECK-NEXT: %[[GET_B:.*]] = cir.get_member %[[NEXT_ELT]][2] {name = "b"} : !cir.ptr<!rec_DefaultOperatorsNoFloats> -> !cir.ptr<!cir.bool> // CHECK-NEXT: %[[ALL_ONES:.*]] = cir.const #true // CHECK-NEXT: cir.store {{.*}} %[[ALL_ONES]], %[[GET_B]] : !cir.bool, !cir.ptr<!cir.bool> // // CHECK-NEXT: %[[TWO_IDX:.*]] = cir.const #cir.int<2> : !s64i -// CHECK-NEXT: %[[NEXT_ELT:.*]] = cir.ptr_stride %[[DECAY]], %[[TWO_IDX]] : (!cir.ptr<!rec_DefaultOperators>, !s64i) -> !cir.ptr<!rec_DefaultOperators> -// CHECK-NEXT: %[[GET_I:.*]] = cir.get_member %[[NEXT_ELT]][0] {name = "i"} : !cir.ptr<!rec_DefaultOperators> -> !cir.ptr<!s32i> +// CHECK-NEXT: %[[NEXT_ELT:.*]] = cir.ptr_stride %[[DECAY]], %[[TWO_IDX]] : (!cir.ptr<!rec_DefaultOperatorsNoFloats>, !s64i) -> !cir.ptr<!rec_DefaultOperatorsNoFloats> +// CHECK-NEXT: %[[GET_I:.*]] = cir.get_member %[[NEXT_ELT]][0] {name = "i"} : !cir.ptr<!rec_DefaultOperatorsNoFloats> -> !cir.ptr<!s32i> // CHECK-NEXT: %[[ALL_ONES:.*]] = cir.const #cir.int<-1> : !s32i // CHECK-NEXT: cir.store {{.*}} %[[ALL_ONES]], %[[GET_I]] : !s32i, !cir.ptr<!s32i> -// CHECK-NEXT: %[[GET_U:.*]] = cir.get_member %[[NEXT_ELT]][1] {name = "u"} : !cir.ptr<!rec_DefaultOperators> -> !cir.ptr<!u32i> +// CHECK-NEXT: %[[GET_U:.*]] = cir.get_member %[[NEXT_ELT]][1] {name = "u"} : !cir.ptr<!rec_DefaultOperatorsNoFloats> -> !cir.ptr<!u32i> // CHECK-NEXT: %[[ALL_ONES:.*]] = cir.const #cir.int<4294967295> : !u32i // CHECK-NEXT: cir.store {{.*}} %[[ALL_ONES]], %[[GET_U]] : !u32i, !cir.ptr<!u32i> -// CHECK-NEXT: %[[GET_F:.*]] = cir.get_member %[[NEXT_ELT]][2] {name = "f"} : !cir.ptr<!rec_DefaultOperators> -> !cir.ptr<!cir.float> -// CHECK-NEXT: %[[ALL_ONES:.*]] = cir.const #cir.fp<0xFF{{.*}}> : !cir.float -// CHECK-NEXT: cir.store {{.*}} %[[ALL_ONES]], %[[GET_F]] : !cir.float, !cir.ptr<!cir.float> -// CHECK-NEXT: %[[GET_D:.*]] = cir.get_member %[[NEXT_ELT]][3] {name = "d"} : !cir.ptr<!rec_DefaultOperators> -> !cir.ptr<!cir.double> -// CHECK-NEXT: %[[ALL_ONES:.*]] = cir.const #cir.fp<0xFF{{.*}}> : !cir.double -// CHECK-NEXT: cir.store {{.*}} %[[ALL_ONES]], %[[GET_D]] : !cir.double, !cir.ptr<!cir.double> -// CHECK-NEXT: %[[GET_B:.*]] = cir.get_member %[[NEXT_ELT]][4] {name = "b"} : !cir.ptr<!rec_DefaultOperators> -> !cir.ptr<!cir.bool> +// CHECK-NEXT: %[[GET_B:.*]] = cir.get_member %[[NEXT_ELT]][2] {name = "b"} : !cir.ptr<!rec_DefaultOperatorsNoFloats> -> !cir.ptr<!cir.bool> // CHECK-NEXT: %[[ALL_ONES:.*]] = cir.const #true // CHECK-NEXT: cir.store {{.*}} %[[ALL_ONES]], %[[GET_B]] : !cir.bool, !cir.ptr<!cir.bool> // // // CHECK-NEXT: %[[THREE_IDX:.*]] = cir.const #cir.int<3> : !s64i -// CHECK-NEXT: %[[NEXT_ELT:.*]] = cir.ptr_stride %[[DECAY]], %[[THREE_IDX]] : (!cir.ptr<!rec_DefaultOperators>, !s64i) -> !cir.ptr<!rec_DefaultOperators> -// CHECK-NEXT: %[[GET_I:.*]] = cir.get_member %[[NEXT_ELT]][0] {name = "i"} : !cir.ptr<!rec_DefaultOperators> -> !cir.ptr<!s32i> +// CHECK-NEXT: %[[NEXT_ELT:.*]] = cir.ptr_stride %[[DECAY]], %[[THREE_IDX]] : (!cir.ptr<!rec_DefaultOperatorsNoFloats>, !s64i) -> !cir.ptr<!rec_DefaultOperatorsNoFloats> +// CHECK-NEXT: %[[GET_I:.*]] = cir.get_member %[[NEXT_ELT]][0] {name = "i"} : !cir.ptr<!rec_DefaultOperatorsNoFloats> -> !cir.ptr<!s32i> // CHECK-NEXT: %[[ALL_ONES:.*]] = cir.const #cir.int<-1> : !s32i // CHECK-NEXT: cir.store {{.*}} %[[ALL_ONES]], %[[GET_I]] : !s32i, !cir.ptr<!s32i> -// CHECK-NEXT: %[[GET_U:.*]] = cir.get_member %[[NEXT_ELT]][1] {name = "u"} : !cir.ptr<!rec_DefaultOperators> -> !cir.ptr<!u32i> +// CHECK-NEXT: %[[GET_U:.*]] = cir.get_member %[[NEXT_ELT]][1] {name = "u"} : !cir.ptr<!rec_DefaultOperatorsNoFloats> -> !cir.ptr<!u32i> // CHECK-NEXT: %[[ALL_ONES:.*]] = cir.const #cir.int<4294967295> : !u32i // CHECK-NEXT: cir.store {{.*}} %[[ALL_ONES]], %[[GET_U]] : !u32i, !cir.ptr<!u32i> -// CHECK-NEXT: %[[GET_F:.*]] = cir.get_member %[[NEXT_ELT]][2] {name = "f"} : !cir.ptr<!rec_DefaultOperators> -> !cir.ptr<!cir.float> -// CHECK-NEXT: %[[ALL_ONES:.*]] = cir.const #cir.fp<0xFF{{.*}}> : !cir.float -// CHECK-NEXT: cir.store {{.*}} %[[ALL_ONES]], %[[GET_F]] : !cir.float, !cir.ptr<!cir.float> -// CHECK-NEXT: %[[GET_D:.*]] = cir.get_member %[[NEXT_ELT]][3] {name = "d"} : !cir.ptr<!rec_DefaultOperators> -> !cir.ptr<!cir.double> -// CHECK-NEXT: %[[ALL_ONES:.*]] = cir.const #cir.fp<0xFF{{.*}}> : !cir.double -// CHECK-NEXT: cir.store {{.*}} %[[ALL_ONES]], %[[GET_D]] : !cir.double, !cir.ptr<!cir.double> -// CHECK-NEXT: %[[GET_B:.*]] = cir.get_member %[[NEXT_ELT]][4] {name = "b"} : !cir.ptr<!rec_DefaultOperators> -> !cir.ptr<!cir.bool> +// CHECK-NEXT: %[[GET_B:.*]] = cir.get_member %[[NEXT_ELT]][2] {name = "b"} : !cir.ptr<!rec_DefaultOperatorsNoFloats> -> !cir.ptr<!cir.bool> // CHECK-NEXT: %[[ALL_ONES:.*]] = cir.const #true // CHECK-NEXT: cir.store {{.*}} %[[ALL_ONES]], %[[GET_B]] : !cir.bool, !cir.ptr<!cir.bool> // // CHECK-NEXT: %[[FOUR_IDX:.*]] = cir.const #cir.int<4> : !s64i -// CHECK-NEXT: %[[NEXT_ELT:.*]] = cir.ptr_stride %[[DECAY]], %[[FOUR_IDX]] : (!cir.ptr<!rec_DefaultOperators>, !s64i) -> !cir.ptr<!rec_DefaultOperators> -// CHECK-NEXT: %[[GET_I:.*]] = cir.get_member %[[NEXT_ELT]][0] {name = "i"} : !cir.ptr<!rec_DefaultOperators> -> !cir.ptr<!s32i> +// CHECK-NEXT: %[[NEXT_ELT:.*]] = cir.ptr_stride %[[DECAY]], %[[FOUR_IDX]] : (!cir.ptr<!rec_DefaultOperatorsNoFloats>, !s64i) -> !cir.ptr<!rec_DefaultOperatorsNoFloats> +// CHECK-NEXT: %[[GET_I:.*]] = cir.get_member %[[NEXT_ELT]][0] {name = "i"} : !cir.ptr<!rec_DefaultOperatorsNoFloats> -> !cir.ptr<!s32i> // CHECK-NEXT: %[[ALL_ONES:.*]] = cir.const #cir.int<-1> : !s32i // CHECK-NEXT: cir.store {{.*}} %[[ALL_ONES]], %[[GET_I]] : !s32i, !cir.ptr<!s32i> -// CHECK-NEXT: %[[GET_U:.*]] = cir.get_member %[[NEXT_ELT]][1] {name = "u"} : !cir.ptr<!rec_DefaultOperators> -> !cir.ptr<!u32i> +// CHECK-NEXT: %[[GET_U:.*]] = cir.get_member %[[NEXT_ELT]][1] {name = "u"} : !cir.ptr<!rec_DefaultOperatorsNoFloats> -> !cir.ptr<!u32i> // CHECK-NEXT: %[[ALL_ONES:.*]] = cir.const #cir.int<4294967295> : !u32i // CHECK-NEXT: cir.store {{.*}} %[[ALL_ONES]], %[[GET_U]] : !u32i, !cir.ptr<!u32i> -// CHECK-NEXT: %[[GET_F:.*]] = cir.get_member %[[NEXT_ELT]][2] {name = "f"} : !cir.ptr<!rec_DefaultOperators> -> !cir.ptr<!cir.float> -// CHECK-NEXT: %[[ALL_ONES:.*]] = cir.const #cir.fp<0xFF{{.*}}> : !cir.float -// CHECK-NEXT: cir.store {{.*}} %[[ALL_ONES]], %[[GET_F]] : !cir.float, !cir.ptr<!cir.float> -// CHECK-NEXT: %[[GET_D:.*]] = cir.get_member %[[NEXT_ELT]][3] {name = "d"} : !cir.ptr<!rec_DefaultOperators> -> !cir.ptr<!cir.double> -// CHECK-NEXT: %[[ALL_ONES:.*]] = cir.const #cir.fp<0xFF{{.*}}> : !cir.double -// CHECK-NEXT: cir.store {{.*}} %[[ALL_ONES]], %[[GET_D]] : !cir.double, !cir.ptr<!cir.double> -// CHECK-NEXT: %[[GET_B:.*]] = cir.get_member %[[NEXT_ELT]][4] {name = "b"} : !cir.ptr<!rec_DefaultOperators> -> !cir.ptr<!cir.bool> +// CHECK-NEXT: %[[GET_B:.*]] = cir.get_member %[[NEXT_ELT]][2] {name = "b"} : !cir.ptr<!rec_DefaultOperatorsNoFloats> -> !cir.ptr<!cir.bool> // CHECK-NEXT: %[[ALL_ONES:.*]] = cir.const #true // CHECK-NEXT: cir.store {{.*}} %[[ALL_ONES]], %[[GET_B]] : !cir.bool, !cir.ptr<!cir.bool> // // CHECK-NEXT: acc.yield // // CHECK-NEXT: } combiner { -// CHECK-NEXT: ^bb0(%[[LHSARG:.*]]: !cir.ptr<!cir.array<!rec_DefaultOperators x 5>> {{.*}}, %[[RHSARG:.*]]: !cir.ptr<!cir.array<!rec_DefaultOperators x 5>> {{.*}}) +// CHECK-NEXT: ^bb0(%[[LHSARG:.*]]: !cir.ptr<!cir.array<!rec_DefaultOperatorsNoFloats x 5>> {{.*}}, %[[RHSARG:.*]]: !cir.ptr<!cir.array<!rec_DefaultOperatorsNoFloats x 5>> {{.*}}) // TODO OpenACC: Expecting combination operation here -// CHECK-NEXT: acc.yield %[[LHSARG]] : !cir.ptr<!cir.array<!rec_DefaultOperators x 5>> +// CHECK-NEXT: acc.yield %[[LHSARG]] : !cir.ptr<!cir.array<!rec_DefaultOperatorsNoFloats x 5>> // CHECK-NEXT: } ; -#pragma acc parallel reduction(|:someVarArr) -// CHECK-NEXT: acc.reduction.recipe @reduction_ior__ZTSA5_16DefaultOperators : !cir.ptr<!cir.array<!rec_DefaultOperators x 5>> reduction_operator <ior> init { -// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!rec_DefaultOperators x 5>>{{.*}}) -// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !cir.array<!rec_DefaultOperators x 5>, !cir.ptr<!cir.array<!rec_DefaultOperators x 5>>, ["openacc.reduction.init", init] -// CHECK-NEXT: %[[TEMP_ITR:.*]] = cir.alloca !cir.ptr<!rec_DefaultOperators>, !cir.ptr<!cir.ptr<!rec_DefaultOperators>>, ["arrayinit.temp"] -// CHECK-NEXT: %[[DECAY:.*]] = cir.cast array_to_ptrdecay %[[ALLOCA]] : !cir.ptr<!cir.array<!rec_DefaultOperators x 5>> -> !cir.ptr<!rec_DefaultOperators> -// CHECK-NEXT: cir.store {{.*}} %[[DECAY]], %[[TEMP_ITR]] : !cir.ptr<!rec_DefaultOperators>, !cir.ptr<!cir.ptr<!rec_DefaultOperators>> +#pragma acc parallel reduction(|:someVarArrNoFloats) +// CHECK-NEXT: acc.reduction.recipe @reduction_ior__ZTSA5_24DefaultOperatorsNoFloats : !cir.ptr<!cir.array<!rec_DefaultOperatorsNoFloats x 5>> reduction_operator <ior> init { +// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!rec_DefaultOperatorsNoFloats x 5>>{{.*}}) +// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !cir.array<!rec_DefaultOperatorsNoFloats x 5>, !cir.ptr<!cir.array<!rec_DefaultOperatorsNoFloats x 5>>, ["openacc.reduction.init", init] +// CHECK-NEXT: %[[TEMP_ITR:.*]] = cir.alloca !cir.ptr<!rec_DefaultOperatorsNoFloats>, !cir.ptr<!cir.ptr<!rec_DefaultOperatorsNoFloats>>, ["arrayinit.temp"] +// CHECK-NEXT: %[[DECAY:.*]] = cir.cast array_to_ptrdecay %[[ALLOCA]] : !cir.ptr<!cir.array<!rec_DefaultOperatorsNoFloats x 5>> -> !cir.ptr<!rec_DefaultOperatorsNoFloats> +// CHECK-NEXT: cir.store {{.*}} %[[DECAY]], %[[TEMP_ITR]] : !cir.ptr<!rec_DefaultOperatorsNoFloats>, !cir.ptr<!cir.ptr<!rec_DefaultOperatorsNoFloats>> // CHECK-NEXT: %[[LAST_IDX:.*]] = cir.const #cir.int<5> : !s64i -// CHECK-NEXT: %[[END_ITR:.*]] = cir.ptr_stride %[[DECAY]], %[[LAST_IDX]] : (!cir.ptr<!rec_DefaultOperators>, !s64i) -> !cir.ptr<!rec_DefaultOperators> +// CHECK-NEXT: %[[END_ITR:.*]] = cir.ptr_stride %[[DECAY]], %[[LAST_IDX]] : (!cir.ptr<!rec_DefaultOperatorsNoFloats>, !s64i) -> !cir.ptr<!rec_DefaultOperatorsNoFloats> // CHECK-NEXT: cir.do { -// CHECK-NEXT: %[[TEMP_LOAD:.*]] = cir.load {{.*}} %[[TEMP_ITR]] : !cir.ptr<!cir.ptr<!rec_DefaultOperators>>, !cir.ptr<!rec_DefaultOperators> -// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.zero : !rec_DefaultOperators +// CHECK-NEXT: %[[TEMP_LOAD:.*]] = cir.load {{.*}} %[[TEMP_ITR]] : !cir.ptr<!cir.ptr<!rec_DefaultOperatorsNoFloats>>, !cir.ptr<!rec_DefaultOperatorsNoFloats> +// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.zero : !rec_DefaultOperatorsNoFloats // CHECK-NEXT: cir.store{{.*}} %[[ZERO]], %[[TEMP_LOAD]] // CHECK-NEXT: %[[ONE:.*]] = cir.const #cir.int<1> : !s64i -// CHECK-NEXT: %[[NEXT_ITEM:.*]] = cir.ptr_stride %[[TEMP_LOAD]], %[[ONE]] : (!cir.ptr<!rec_DefaultOperators>, !s64i) -> !cir.ptr<!rec_DefaultOperators> -// CHECK-NEXT: cir.store {{.*}} %[[NEXT_ITEM]], %[[TEMP_ITR]] : !cir.ptr<!rec_DefaultOperators>, !cir.ptr<!cir.ptr<!rec_DefaultOperators>> +// CHECK-NEXT: %[[NEXT_ITEM:.*]] = cir.ptr_stride %[[TEMP_LOAD]], %[[ONE]] : (!cir.ptr<!rec_DefaultOperatorsNoFloats>, !s64i) -> !cir.ptr<!rec_DefaultOperatorsNoFloats> +// CHECK-NEXT: cir.store {{.*}} %[[NEXT_ITEM]], %[[TEMP_ITR]] : !cir.ptr<!rec_DefaultOperatorsNoFloats>, !cir.ptr<!cir.ptr<!rec_DefaultOperatorsNoFloats>> // CHECK-NEXT: cir.yield // CHECK-NEXT: } while { -// CHECK-NEXT: %[[TEMP_LOAD:.*]] = cir.load {{.*}} %[[TEMP_ITR]] : !cir.ptr<!cir.ptr<!rec_DefaultOperators>>, !cir.ptr<!rec_DefaultOperators> -// CHECK-NEXT: %[[CMP:.*]] = cir.cmp(ne, %[[TEMP_LOAD]], %[[END_ITR]]) : !cir.ptr<!rec_DefaultOperators>, !cir.bool +// CHECK-NEXT: %[[TEMP_LOAD:.*]] = cir.load {{.*}} %[[TEMP_ITR]] : !cir.ptr<!cir.ptr<!rec_DefaultOperatorsNoFloats>>, !cir.ptr<!rec_DefaultOperatorsNoFloats> +// CHECK-NEXT: %[[CMP:.*]] = cir.cmp(ne, %[[TEMP_LOAD]], %[[END_ITR]]) : !cir.ptr<!rec_DefaultOperatorsNoFloats>, !cir.bool // CHECK-NEXT: cir.condition(%[[CMP]]) // CHECK-NEXT: } // CHECK-NEXT: acc.yield // // CHECK-NEXT: } combiner { -// CHECK-NEXT: ^bb0(%[[LHSARG:.*]]: !cir.ptr<!cir.array<!rec_DefaultOperators x 5>> {{.*}}, %[[RHSARG:.*]]: !cir.ptr<!cir.array<!rec_DefaultOperators x 5>> {{.*}}) +// CHECK-NEXT: ^bb0(%[[LHSARG:.*]]: !cir.ptr<!cir.array<!rec_DefaultOperatorsNoFloats x 5>> {{.*}}, %[[RHSARG:.*]]: !cir.ptr<!cir.array<!rec_DefaultOperatorsNoFloats x 5>> {{.*}}) // TODO OpenACC: Expecting combination operation here -// CHECK-NEXT: acc.yield %[[LHSARG]] : !cir.ptr<!cir.array<!rec_DefaultOperators x 5>> +// CHECK-NEXT: acc.yield %[[LHSARG]] : !cir.ptr<!cir.array<!rec_DefaultOperatorsNoFloats x 5>> // CHECK-NEXT: } ; -#pragma acc parallel reduction(^:someVarArr) -// CHECK-NEXT: acc.reduction.recipe @reduction_xor__ZTSA5_16DefaultOperators : !cir.ptr<!cir.array<!rec_DefaultOperators x 5>> reduction_operator <xor> init { -// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!rec_DefaultOperators x 5>>{{.*}}) -// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !cir.array<!rec_DefaultOperators x 5>, !cir.ptr<!cir.array<!rec_DefaultOperators x 5>>, ["openacc.reduction.init", init] -// CHECK-NEXT: %[[TEMP_ITR:.*]] = cir.alloca !cir.ptr<!rec_DefaultOperators>, !cir.ptr<!cir.ptr<!rec_DefaultOperators>>, ["arrayinit.temp"] -// CHECK-NEXT: %[[DECAY:.*]] = cir.cast array_to_ptrdecay %[[ALLOCA]] : !cir.ptr<!cir.array<!rec_DefaultOperators x 5>> -> !cir.ptr<!rec_DefaultOperators> -// CHECK-NEXT: cir.store {{.*}} %[[DECAY]], %[[TEMP_ITR]] : !cir.ptr<!rec_DefaultOperators>, !cir.ptr<!cir.ptr<!rec_DefaultOperators>> +#pragma acc parallel reduction(^:someVarArrNoFloats) +// CHECK-NEXT: acc.reduction.recipe @reduction_xor__ZTSA5_24DefaultOperatorsNoFloats : !cir.ptr<!cir.array<!rec_DefaultOperatorsNoFloats x 5>> reduction_operator <xor> init { +// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!rec_DefaultOperatorsNoFloats x 5>>{{.*}}) +// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !cir.array<!rec_DefaultOperatorsNoFloats x 5>, !cir.ptr<!cir.array<!rec_DefaultOperatorsNoFloats x 5>>, ["openacc.reduction.init", init] +// CHECK-NEXT: %[[TEMP_ITR:.*]] = cir.alloca !cir.ptr<!rec_DefaultOperatorsNoFloats>, !cir.ptr<!cir.ptr<!rec_DefaultOperatorsNoFloats>>, ["arrayinit.temp"] +// CHECK-NEXT: %[[DECAY:.*]] = cir.cast array_to_ptrdecay %[[ALLOCA]] : !cir.ptr<!cir.array<!rec_DefaultOperatorsNoFloats x 5>> -> !cir.ptr<!rec_DefaultOperatorsNoFloats> +// CHECK-NEXT: cir.store {{.*}} %[[DECAY]], %[[TEMP_ITR]] : !cir.ptr<!rec_DefaultOperatorsNoFloats>, !cir.ptr<!cir.ptr<!rec_DefaultOperatorsNoFloats>> // CHECK-NEXT: %[[LAST_IDX:.*]] = cir.const #cir.int<5> : !s64i -// CHECK-NEXT: %[[END_ITR:.*]] = cir.ptr_stride %[[DECAY]], %[[LAST_IDX]] : (!cir.ptr<!rec_DefaultOperators>, !s64i) -> !cir.ptr<!rec_DefaultOperators> +// CHECK-NEXT: %[[END_ITR:.*]] = cir.ptr_stride %[[DECAY]], %[[LAST_IDX]] : (!cir.ptr<!rec_DefaultOperatorsNoFloats>, !s64i) -> !cir.ptr<!rec_DefaultOperatorsNoFloats> // CHECK-NEXT: cir.do { -// CHECK-NEXT: %[[TEMP_LOAD:.*]] = cir.load {{.*}} %[[TEMP_ITR]] : !cir.ptr<!cir.ptr<!rec_DefaultOperators>>, !cir.ptr<!rec_DefaultOperators> -// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.zero : !rec_DefaultOperators +// CHECK-NEXT: %[[TEMP_LOAD:.*]] = cir.load {{.*}} %[[TEMP_ITR]] : !cir.ptr<!cir.ptr<!rec_DefaultOperatorsNoFloats>>, !cir.ptr<!rec_DefaultOperatorsNoFloats> +// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.zero : !rec_DefaultOperatorsNoFloats // CHECK-NEXT: cir.store{{.*}} %[[ZERO]], %[[TEMP_LOAD]] // CHECK-NEXT: %[[ONE:.*]] = cir.const #cir.int<1> : !s64i -// CHECK-NEXT: %[[NEXT_ITEM:.*]] = cir.ptr_stride %[[TEMP_LOAD]], %[[ONE]] : (!cir.ptr<!rec_DefaultOperators>, !s64i) -> !cir.ptr<!rec_DefaultOperators> -// CHECK-NEXT: cir.store {{.*}} %[[NEXT_ITEM]], %[[TEMP_ITR]] : !cir.ptr<!rec_DefaultOperators>, !cir.ptr<!cir.ptr<!rec_DefaultOperators>> +// CHECK-NEXT: %[[NEXT_ITEM:.*]] = cir.ptr_stride %[[TEMP_LOAD]], %[[ONE]] : (!cir.ptr<!rec_DefaultOperatorsNoFloats>, !s64i) -> !cir.ptr<!rec_DefaultOperatorsNoFloats> +// CHECK-NEXT: cir.store {{.*}} %[[NEXT_ITEM]], %[[TEMP_ITR]] : !cir.ptr<!rec_DefaultOperatorsNoFloats>, !cir.ptr<!cir.ptr<!rec_DefaultOperatorsNoFloats>> // CHECK-NEXT: cir.yield // CHECK-NEXT: } while { -// CHECK-NEXT: %[[TEMP_LOAD:.*]] = cir.load {{.*}} %[[TEMP_ITR]] : !cir.ptr<!cir.ptr<!rec_DefaultOperators>>, !cir.ptr<!rec_DefaultOperators> -// CHECK-NEXT: %[[CMP:.*]] = cir.cmp(ne, %[[TEMP_LOAD]], %[[END_ITR]]) : !cir.ptr<!rec_DefaultOperators>, !cir.bool +// CHECK-NEXT: %[[TEMP_LOAD:.*]] = cir.load {{.*}} %[[TEMP_ITR]] : !cir.ptr<!cir.ptr<!rec_DefaultOperatorsNoFloats>>, !cir.ptr<!rec_DefaultOperatorsNoFloats> +// CHECK-NEXT: %[[CMP:.*]] = cir.cmp(ne, %[[TEMP_LOAD]], %[[END_ITR]]) : !cir.ptr<!rec_DefaultOperatorsNoFloats>, !cir.bool // CHECK-NEXT: cir.condition(%[[CMP]]) // CHECK-NEXT: } // CHECK-NEXT: acc.yield // // CHECK-NEXT: } combiner { -// CHECK-NEXT: ^bb0(%[[LHSARG:.*]]: !cir.ptr<!cir.array<!rec_DefaultOperators x 5>> {{.*}}, %[[RHSARG:.*]]: !cir.ptr<!cir.array<!rec_DefaultOperators x 5>> {{.*}}) +// CHECK-NEXT: ^bb0(%[[LHSARG:.*]]: !cir.ptr<!cir.array<!rec_DefaultOperatorsNoFloats x 5>> {{.*}}, %[[RHSARG:.*]]: !cir.ptr<!cir.array<!rec_DefaultOperatorsNoFloats x 5>> {{.*}}) // TODO OpenACC: Expecting combination operation here -// CHECK-NEXT: acc.yield %[[LHSARG]] : !cir.ptr<!cir.array<!rec_DefaultOperators x 5>> +// CHECK-NEXT: acc.yield %[[LHSARG]] : !cir.ptr<!cir.array<!rec_DefaultOperatorsNoFloats x 5>> // CHECK-NEXT: } ; #pragma acc parallel reduction(&&:someVarArr) @@ -1079,10 +1039,10 @@ void acc_compute() { // CHECK-NEXT: acc.yield %[[LHSARG]] : !cir.ptr<!cir.array<!rec_DefaultOperators x 5>> // CHECK-NEXT: } ; -#pragma acc parallel reduction(&:someVarArr[2]) -// CHECK-NEXT: acc.reduction.recipe @reduction_iand__Bcnt1__ZTSA5_16DefaultOperators : !cir.ptr<!cir.array<!rec_DefaultOperators x 5>> reduction_operator <iand> init { -// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!rec_DefaultOperators x 5>>{{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty{{.*}})) -// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !cir.array<!rec_DefaultOperators x 5>, !cir.ptr<!cir.array<!rec_DefaultOperators x 5>>, ["openacc.reduction.init"] +#pragma acc parallel reduction(&:someVarArrNoFloats[2]) +// CHECK-NEXT: acc.reduction.recipe @reduction_iand__Bcnt1__ZTSA5_24DefaultOperatorsNoFloats : !cir.ptr<!cir.array<!rec_DefaultOperatorsNoFloats x 5>> reduction_operator <iand> init { +// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!rec_DefaultOperatorsNoFloats x 5>>{{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty{{.*}})) +// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !cir.array<!rec_DefaultOperatorsNoFloats x 5>, !cir.ptr<!cir.array<!rec_DefaultOperatorsNoFloats x 5>>, ["openacc.reduction.init"] // CHECK-NEXT: cir.scope { // CHECK-NEXT: %[[LB:.*]] = acc.get_lowerbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index // CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i @@ -1096,21 +1056,16 @@ void acc_compute() { // CHECK-NEXT: cir.condition(%[[COND]]) // CHECK-NEXT: } body { // CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i -// CHECK-NEXT: %[[DECAY:.*]] = cir.cast array_to_ptrdecay %[[ALLOCA]] : !cir.ptr<!cir.array<!rec_DefaultOperators x 5>> -> !cir.ptr<!rec_DefaultOperators> -// CHECK-NEXT: %[[STRIDE:.*]] = cir.ptr_stride %[[DECAY]], %[[ITR_LOAD]] : (!cir.ptr<!rec_DefaultOperators>, !u64i) -> !cir.ptr<!rec_DefaultOperators> -// CHECK-NEXT: %[[GET_I:.*]] = cir.get_member %[[STRIDE]][0] {name = "i"} : !cir.ptr<!rec_DefaultOperators> -> !cir.ptr<!s32i> + +// CHECK-NEXT: %[[DECAY:.*]] = cir.cast array_to_ptrdecay %[[ALLOCA]] : !cir.ptr<!cir.array<!rec_DefaultOperatorsNoFloats x 5>> -> !cir.ptr<!rec_DefaultOperatorsNoFloats> +// CHECK-NEXT: %[[STRIDE:.*]] = cir.ptr_stride %[[DECAY]], %[[ITR_LOAD]] : (!cir.ptr<!rec_DefaultOperatorsNoFloats>, !u64i) -> !cir.ptr<!rec_DefaultOperatorsNoFloats> +// CHECK-NEXT: %[[GET_I:.*]] = cir.get_member %[[STRIDE]][0] {name = "i"} : !cir.ptr<!rec_DefaultOperatorsNoFloats> -> !cir.ptr<!s32i> // CHECK-NEXT: %[[ALL_ONES:.*]] = cir.const #cir.int<-1> : !s32i // CHECK-NEXT: cir.store {{.*}} %[[ALL_ONES]], %[[GET_I]] : !s32i, !cir.ptr<!s32i> -// CHECK-NEXT: %[[GET_U:.*]] = cir.get_member %[[STRIDE]][1] {name = "u"} : !cir.ptr<!rec_DefaultOperators> -> !cir.ptr<!u32i> +// CHECK-NEXT: %[[GET_U:.*]] = cir.get_member %[[STRIDE]][1] {name = "u"} : !cir.ptr<!rec_DefaultOperatorsNoFloats> -> !cir.ptr<!u32i> // CHECK-NEXT: %[[ALL_ONES:.*]] = cir.const #cir.int<4294967295> : !u32i // CHECK-NEXT: cir.store {{.*}} %[[ALL_ONES]], %[[GET_U]] : !u32i, !cir.ptr<!u32i> -// CHECK-NEXT: %[[GET_F:.*]] = cir.get_member %[[STRIDE]][2] {name = "f"} : !cir.ptr<!rec_DefaultOperators> -> !cir.ptr<!cir.float> -// CHECK-NEXT: %[[ALL_ONES:.*]] = cir.const #cir.fp<0xFF{{.*}}> : !cir.float -// CHECK-NEXT: cir.store {{.*}} %[[ALL_ONES]], %[[GET_F]] : !cir.float, !cir.ptr<!cir.float> -// CHECK-NEXT: %[[GET_D:.*]] = cir.get_member %[[STRIDE]][3] {name = "d"} : !cir.ptr<!rec_DefaultOperators> -> !cir.ptr<!cir.double> -// CHECK-NEXT: %[[ALL_ONES:.*]] = cir.const #cir.fp<0xFF{{.*}}> : !cir.double -// CHECK-NEXT: cir.store {{.*}} %[[ALL_ONES]], %[[GET_D]] : !cir.double, !cir.ptr<!cir.double> -// CHECK-NEXT: %[[GET_B:.*]] = cir.get_member %[[STRIDE]][4] {name = "b"} : !cir.ptr<!rec_DefaultOperators> -> !cir.ptr<!cir.bool> +// CHECK-NEXT: %[[GET_B:.*]] = cir.get_member %[[STRIDE]][2] {name = "b"} : !cir.ptr<!rec_DefaultOperatorsNoFloats> -> !cir.ptr<!cir.bool> // CHECK-NEXT: %[[ALL_ONES:.*]] = cir.const #true // CHECK-NEXT: cir.store {{.*}} %[[ALL_ONES]], %[[GET_B]] : !cir.bool, !cir.ptr<!cir.bool> // CHECK-NEXT: cir.yield @@ -1123,14 +1078,14 @@ void acc_compute() { // CHECK-NEXT: } // CHECK-NEXT: acc.yield // CHECK-NEXT: } combiner { -// CHECK-NEXT: ^bb0(%[[LHSARG:.*]]: !cir.ptr<!cir.array<!rec_DefaultOperators x 5>> {{.*}}, %[[RHSARG:.*]]: !cir.ptr<!cir.array<!rec_DefaultOperators x 5>> {{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty{{.*}})) -// CHECK-NEXT: acc.yield %[[LHSARG]] : !cir.ptr<!cir.array<!rec_DefaultOperators x 5>> +// CHECK-NEXT: ^bb0(%[[LHSARG:.*]]: !cir.ptr<!cir.array<!rec_DefaultOperatorsNoFloats x 5>> {{.*}}, %[[RHSARG:.*]]: !cir.ptr<!cir.array<!rec_DefaultOperatorsNoFloats x 5>> {{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty{{.*}})) +// CHECK-NEXT: acc.yield %[[LHSARG]] : !cir.ptr<!cir.array<!rec_DefaultOperatorsNoFloats x 5>> // CHECK-NEXT: } ; -#pragma acc parallel reduction(|:someVarArr[2]) -// CHECK-NEXT: acc.reduction.recipe @reduction_ior__Bcnt1__ZTSA5_16DefaultOperators : !cir.ptr<!cir.array<!rec_DefaultOperators x 5>> reduction_operator <ior> init { -// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!rec_DefaultOperators x 5>>{{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty{{.*}})) -// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !cir.array<!rec_DefaultOperators x 5>, !cir.ptr<!cir.array<!rec_DefaultOperators x 5>>, ["openacc.reduction.init"] +#pragma acc parallel reduction(|:someVarArrNoFloats[2]) +// CHECK-NEXT: acc.reduction.recipe @reduction_ior__Bcnt1__ZTSA5_24DefaultOperatorsNoFloats : !cir.ptr<!cir.array<!rec_DefaultOperatorsNoFloats x 5>> reduction_operator <ior> init { +// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!rec_DefaultOperatorsNoFloats x 5>>{{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty{{.*}})) +// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !cir.array<!rec_DefaultOperatorsNoFloats x 5>, !cir.ptr<!cir.array<!rec_DefaultOperatorsNoFloats x 5>>, ["openacc.reduction.init"] // CHECK-NEXT: cir.scope { // CHECK-NEXT: %[[LB:.*]] = acc.get_lowerbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index // CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i @@ -1144,21 +1099,15 @@ void acc_compute() { // CHECK-NEXT: cir.condition(%[[COND]]) // CHECK-NEXT: } body { // CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i -// CHECK-NEXT: %[[DECAY:.*]] = cir.cast array_to_ptrdecay %[[ALLOCA]] : !cir.ptr<!cir.array<!rec_DefaultOperators x 5>> -> !cir.ptr<!rec_DefaultOperators> -// CHECK-NEXT: %[[STRIDE:.*]] = cir.ptr_stride %[[DECAY]], %[[ITR_LOAD]] : (!cir.ptr<!rec_DefaultOperators>, !u64i) -> !cir.ptr<!rec_DefaultOperators> -// CHECK-NEXT: %[[GET_I:.*]] = cir.get_member %[[STRIDE]][0] {name = "i"} : !cir.ptr<!rec_DefaultOperators> -> !cir.ptr<!s32i> +// CHECK-NEXT: %[[DECAY:.*]] = cir.cast array_to_ptrdecay %[[ALLOCA]] : !cir.ptr<!cir.array<!rec_DefaultOperatorsNoFloats x 5>> -> !cir.ptr<!rec_DefaultOperatorsNoFloats> +// CHECK-NEXT: %[[STRIDE:.*]] = cir.ptr_stride %[[DECAY]], %[[ITR_LOAD]] : (!cir.ptr<!rec_DefaultOperatorsNoFloats>, !u64i) -> !cir.ptr<!rec_DefaultOperatorsNoFloats> +// CHECK-NEXT: %[[GET_I:.*]] = cir.get_member %[[STRIDE]][0] {name = "i"} : !cir.ptr<!rec_DefaultOperatorsNoFloats> -> !cir.ptr<!s32i> // CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !s32i // CHECK-NEXT: cir.store {{.*}} %[[ZERO]], %[[GET_I]] : !s32i, !cir.ptr<!s32i> -// CHECK-NEXT: %[[GET_U:.*]] = cir.get_member %[[STRIDE]][1] {name = "u"} : !cir.ptr<!rec_DefaultOperators> -> !cir.ptr<!u32i> +// CHECK-NEXT: %[[GET_U:.*]] = cir.get_member %[[STRIDE]][1] {name = "u"} : !cir.ptr<!rec_DefaultOperatorsNoFloats> -> !cir.ptr<!u32i> // CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !u32i // CHECK-NEXT: cir.store {{.*}} %[[ZERO]], %[[GET_U]] : !u32i, !cir.ptr<!u32i> -// CHECK-NEXT: %[[GET_F:.*]] = cir.get_member %[[STRIDE]][2] {name = "f"} : !cir.ptr<!rec_DefaultOperators> -> !cir.ptr<!cir.float> -// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.fp<0{{.*}}> : !cir.float -// CHECK-NEXT: cir.store {{.*}} %[[ZERO]], %[[GET_F]] : !cir.float, !cir.ptr<!cir.float> -// CHECK-NEXT: %[[GET_D:.*]] = cir.get_member %[[STRIDE]][3] {name = "d"} : !cir.ptr<!rec_DefaultOperators> -> !cir.ptr<!cir.double> -// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.fp<0{{.*}}> : !cir.double -// CHECK-NEXT: cir.store {{.*}} %[[ZERO]], %[[GET_D]] : !cir.double, !cir.ptr<!cir.double> -// CHECK-NEXT: %[[GET_B:.*]] = cir.get_member %[[STRIDE]][4] {name = "b"} : !cir.ptr<!rec_DefaultOperators> -> !cir.ptr<!cir.bool> +// CHECK-NEXT: %[[GET_B:.*]] = cir.get_member %[[STRIDE]][2] {name = "b"} : !cir.ptr<!rec_DefaultOperatorsNoFloats> -> !cir.ptr<!cir.bool> // CHECK-NEXT: %[[ZERO:.*]] = cir.const #false // CHECK-NEXT: cir.store {{.*}} %[[ZERO]], %[[GET_B]] : !cir.bool, !cir.ptr<!cir.bool> // CHECK-NEXT: cir.yield @@ -1171,14 +1120,14 @@ void acc_compute() { // CHECK-NEXT: } // CHECK-NEXT: acc.yield // CHECK-NEXT: } combiner { -// CHECK-NEXT: ^bb0(%[[LHSARG:.*]]: !cir.ptr<!cir.array<!rec_DefaultOperators x 5>> {{.*}}, %[[RHSARG:.*]]: !cir.ptr<!cir.array<!rec_DefaultOperators x 5>> {{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty{{.*}})) -// CHECK-NEXT: acc.yield %[[LHSARG]] : !cir.ptr<!cir.array<!rec_DefaultOperators x 5>> +// CHECK-NEXT: ^bb0(%[[LHSARG:.*]]: !cir.ptr<!cir.array<!rec_DefaultOperatorsNoFloats x 5>> {{.*}}, %[[RHSARG:.*]]: !cir.ptr<!cir.array<!rec_DefaultOperatorsNoFloats x 5>> {{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty{{.*}})) +// CHECK-NEXT: acc.yield %[[LHSARG]] : !cir.ptr<!cir.array<!rec_DefaultOperatorsNoFloats x 5>> // CHECK-NEXT: } ; -#pragma acc parallel reduction(^:someVarArr[2]) -// CHECK-NEXT: acc.reduction.recipe @reduction_xor__Bcnt1__ZTSA5_16DefaultOperators : !cir.ptr<!cir.array<!rec_DefaultOperators x 5>> reduction_operator <xor> init { -// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!rec_DefaultOperators x 5>>{{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty{{.*}})) -// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !cir.array<!rec_DefaultOperators x 5>, !cir.ptr<!cir.array<!rec_DefaultOperators x 5>>, ["openacc.reduction.init"] +#pragma acc parallel reduction(^:someVarArrNoFloats[2]) +// CHECK-NEXT: acc.reduction.recipe @reduction_xor__Bcnt1__ZTSA5_24DefaultOperatorsNoFloats : !cir.ptr<!cir.array<!rec_DefaultOperatorsNoFloats x 5>> reduction_operator <xor> init { +// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!rec_DefaultOperatorsNoFloats x 5>>{{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty{{.*}})) +// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !cir.array<!rec_DefaultOperatorsNoFloats x 5>, !cir.ptr<!cir.array<!rec_DefaultOperatorsNoFloats x 5>>, ["openacc.reduction.init"] // CHECK-NEXT: cir.scope { // CHECK-NEXT: %[[LB:.*]] = acc.get_lowerbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index // CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i @@ -1192,21 +1141,15 @@ void acc_compute() { // CHECK-NEXT: cir.condition(%[[COND]]) // CHECK-NEXT: } body { // CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i -// CHECK-NEXT: %[[DECAY:.*]] = cir.cast array_to_ptrdecay %[[ALLOCA]] : !cir.ptr<!cir.array<!rec_DefaultOperators x 5>> -> !cir.ptr<!rec_DefaultOperators> -// CHECK-NEXT: %[[STRIDE:.*]] = cir.ptr_stride %[[DECAY]], %[[ITR_LOAD]] : (!cir.ptr<!rec_DefaultOperators>, !u64i) -> !cir.ptr<!rec_DefaultOperators> -// CHECK-NEXT: %[[GET_I:.*]] = cir.get_member %[[STRIDE]][0] {name = "i"} : !cir.ptr<!rec_DefaultOperators> -> !cir.ptr<!s32i> +// CHECK-NEXT: %[[DECAY:.*]] = cir.cast array_to_ptrdecay %[[ALLOCA]] : !cir.ptr<!cir.array<!rec_DefaultOperatorsNoFloats x 5>> -> !cir.ptr<!rec_DefaultOperatorsNoFloats> +// CHECK-NEXT: %[[STRIDE:.*]] = cir.ptr_stride %[[DECAY]], %[[ITR_LOAD]] : (!cir.ptr<!rec_DefaultOperatorsNoFloats>, !u64i) -> !cir.ptr<!rec_DefaultOperatorsNoFloats> +// CHECK-NEXT: %[[GET_I:.*]] = cir.get_member %[[STRIDE]][0] {name = "i"} : !cir.ptr<!rec_DefaultOperatorsNoFloats> -> !cir.ptr<!s32i> // CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !s32i // CHECK-NEXT: cir.store {{.*}} %[[ZERO]], %[[GET_I]] : !s32i, !cir.ptr<!s32i> -// CHECK-NEXT: %[[GET_U:.*]] = cir.get_member %[[STRIDE]][1] {name = "u"} : !cir.ptr<!rec_DefaultOperators> -> !cir.ptr<!u32i> +// CHECK-NEXT: %[[GET_U:.*]] = cir.get_member %[[STRIDE]][1] {name = "u"} : !cir.ptr<!rec_DefaultOperatorsNoFloats> -> !cir.ptr<!u32i> // CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !u32i // CHECK-NEXT: cir.store {{.*}} %[[ZERO]], %[[GET_U]] : !u32i, !cir.ptr<!u32i> -// CHECK-NEXT: %[[GET_F:.*]] = cir.get_member %[[STRIDE]][2] {name = "f"} : !cir.ptr<!rec_DefaultOperators> -> !cir.ptr<!cir.float> -// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.fp<0{{.*}}> : !cir.float -// CHECK-NEXT: cir.store {{.*}} %[[ZERO]], %[[GET_F]] : !cir.float, !cir.ptr<!cir.float> -// CHECK-NEXT: %[[GET_D:.*]] = cir.get_member %[[STRIDE]][3] {name = "d"} : !cir.ptr<!rec_DefaultOperators> -> !cir.ptr<!cir.double> -// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.fp<0{{.*}}> : !cir.double -// CHECK-NEXT: cir.store {{.*}} %[[ZERO]], %[[GET_D]] : !cir.double, !cir.ptr<!cir.double> -// CHECK-NEXT: %[[GET_B:.*]] = cir.get_member %[[STRIDE]][4] {name = "b"} : !cir.ptr<!rec_DefaultOperators> -> !cir.ptr<!cir.bool> +// CHECK-NEXT: %[[GET_B:.*]] = cir.get_member %[[STRIDE]][2] {name = "b"} : !cir.ptr<!rec_DefaultOperatorsNoFloats> -> !cir.ptr<!cir.bool> // CHECK-NEXT: %[[ZERO:.*]] = cir.const #false // CHECK-NEXT: cir.store {{.*}} %[[ZERO]], %[[GET_B]] : !cir.bool, !cir.ptr<!cir.bool> // CHECK-NEXT: cir.yield @@ -1219,8 +1162,8 @@ void acc_compute() { // CHECK-NEXT: } // CHECK-NEXT: acc.yield // CHECK-NEXT: } combiner { -// CHECK-NEXT: ^bb0(%[[LHSARG:.*]]: !cir.ptr<!cir.array<!rec_DefaultOperators x 5>> {{.*}}, %[[RHSARG:.*]]: !cir.ptr<!cir.array<!rec_DefaultOperators x 5>> {{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty{{.*}})) -// CHECK-NEXT: acc.yield %[[LHSARG]] : !cir.ptr<!cir.array<!rec_DefaultOperators x 5>> +// CHECK-NEXT: ^bb0(%[[LHSARG:.*]]: !cir.ptr<!cir.array<!rec_DefaultOperatorsNoFloats x 5>> {{.*}}, %[[RHSARG:.*]]: !cir.ptr<!cir.array<!rec_DefaultOperatorsNoFloats x 5>> {{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty{{.*}})) +// CHECK-NEXT: acc.yield %[[LHSARG]] : !cir.ptr<!cir.array<!rec_DefaultOperatorsNoFloats x 5>> // CHECK-NEXT: } ; #pragma acc parallel reduction(&&:someVarArr[2]) @@ -1328,11 +1271,11 @@ void acc_compute() { ; #pragma acc parallel reduction(min:someVarArr[1:1]) ; -#pragma acc parallel reduction(&:someVarArr[1:1]) +#pragma acc parallel reduction(&:someVarArrNoFloats[1:1]) ; -#pragma acc parallel reduction(|:someVarArr[1:1]) +#pragma acc parallel reduction(|:someVarArrNoFloats[1:1]) ; -#pragma acc parallel reduction(^:someVarArr[1:1]) +#pragma acc parallel reduction(^:someVarArrNoFloats[1:1]) ; #pragma acc parallel reduction(&&:someVarArr[1:1]) ; diff --git a/clang/test/CIR/CodeGenOpenACC/compute-reduction-clause-default-ops.cpp b/clang/test/CIR/CodeGenOpenACC/compute-reduction-clause-default-ops.cpp index 6a987c2..b90a2fc 100644 --- a/clang/test/CIR/CodeGenOpenACC/compute-reduction-clause-default-ops.cpp +++ b/clang/test/CIR/CodeGenOpenACC/compute-reduction-clause-default-ops.cpp @@ -8,10 +8,18 @@ struct DefaultOperators { bool b; }; +struct DefaultOperatorsNoFloats { + int i; + unsigned int u; + bool b; +}; + template<typename T> void acc_compute() { T someVar; T someVarArr[5]; + struct DefaultOperatorsNoFloats someVarNoFloats; + struct DefaultOperatorsNoFloats someVarArrNoFloats[5]; #pragma acc parallel reduction(+:someVar) ; // CHECK: acc.reduction.recipe @reduction_add__ZTS16DefaultOperators : !cir.ptr<!rec_DefaultOperators> reduction_operator <add> init { @@ -121,86 +129,67 @@ void acc_compute() { // CHECK-NEXT: acc.yield %[[LHSARG]] : !cir.ptr<!rec_DefaultOperators> // CHECK-NEXT: } ; -#pragma acc parallel reduction(&:someVar) - -// CHECK-NEXT: acc.reduction.recipe @reduction_iand__ZTS16DefaultOperators : !cir.ptr<!rec_DefaultOperators> reduction_operator <iand> init { -// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!rec_DefaultOperators>{{.*}}) -// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !rec_DefaultOperators, !cir.ptr<!rec_DefaultOperators>, ["openacc.reduction.init", init] -// CHECK-NEXT: %[[GET_I:.*]] = cir.get_member %[[ALLOCA]][0] {name = "i"} : !cir.ptr<!rec_DefaultOperators> -> !cir.ptr<!s32i> +#pragma acc parallel reduction(&:someVarNoFloats) +// CHECK-NEXT: acc.reduction.recipe @reduction_iand__ZTS24DefaultOperatorsNoFloats : !cir.ptr<!rec_DefaultOperatorsNoFloats> reduction_operator <iand> init { +// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!rec_DefaultOperatorsNoFloats>{{.*}}) +// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !rec_DefaultOperatorsNoFloats, !cir.ptr<!rec_DefaultOperatorsNoFloats>, ["openacc.reduction.init", init] +// CHECK-NEXT: %[[GET_I:.*]] = cir.get_member %[[ALLOCA]][0] {name = "i"} : !cir.ptr<!rec_DefaultOperatorsNoFloats> -> !cir.ptr<!s32i> // CHECK-NEXT: %[[ALL_ONES:.*]] = cir.const #cir.int<-1> : !s32i // CHECK-NEXT: cir.store {{.*}} %[[ALL_ONES]], %[[GET_I]] : !s32i, !cir.ptr<!s32i> -// CHECK-NEXT: %[[GET_U:.*]] = cir.get_member %[[ALLOCA]][1] {name = "u"} : !cir.ptr<!rec_DefaultOperators> -> !cir.ptr<!u32i> +// CHECK-NEXT: %[[GET_U:.*]] = cir.get_member %[[ALLOCA]][1] {name = "u"} : !cir.ptr<!rec_DefaultOperatorsNoFloats> -> !cir.ptr<!u32i> // CHECK-NEXT: %[[ALL_ONES:.*]] = cir.const #cir.int<4294967295> : !u32i // CHECK-NEXT: cir.store {{.*}} %[[ALL_ONES]], %[[GET_U]] : !u32i, !cir.ptr<!u32i> -// CHECK-NEXT: %[[GET_F:.*]] = cir.get_member %[[ALLOCA]][2] {name = "f"} : !cir.ptr<!rec_DefaultOperators> -> !cir.ptr<!cir.float> -// CHECK-NEXT: %[[ALL_ONES:.*]] = cir.const #cir.fp<0xFF{{.*}}> : !cir.float -// CHECK-NEXT: cir.store {{.*}} %[[ALL_ONES]], %[[GET_F]] : !cir.float, !cir.ptr<!cir.float> -// CHECK-NEXT: %[[GET_D:.*]] = cir.get_member %[[ALLOCA]][3] {name = "d"} : !cir.ptr<!rec_DefaultOperators> -> !cir.ptr<!cir.double> -// CHECK-NEXT: %[[ALL_ONES:.*]] = cir.const #cir.fp<0xFF{{.*}}> : !cir.double -// CHECK-NEXT: cir.store {{.*}} %[[ALL_ONES]], %[[GET_D]] : !cir.double, !cir.ptr<!cir.double> -// CHECK-NEXT: %[[GET_B:.*]] = cir.get_member %[[ALLOCA]][4] {name = "b"} : !cir.ptr<!rec_DefaultOperators> -> !cir.ptr<!cir.bool> +// CHECK-NEXT: %[[GET_B:.*]] = cir.get_member %[[ALLOCA]][2] {name = "b"} : !cir.ptr<!rec_DefaultOperatorsNoFloats> -> !cir.ptr<!cir.bool> // CHECK-NEXT: %[[ALL_ONES:.*]] = cir.const #true // CHECK-NEXT: cir.store {{.*}} %[[ALL_ONES]], %[[GET_B]] : !cir.bool, !cir.ptr<!cir.bool> // CHECK-NEXT: acc.yield // // CHECK-NEXT: } combiner { -// CHECK-NEXT: ^bb0(%[[LHSARG:.*]]: !cir.ptr<!rec_DefaultOperators> {{.*}}, %[[RHSARG:.*]]: !cir.ptr<!rec_DefaultOperators> {{.*}}) +// CHECK-NEXT: ^bb0(%[[LHSARG:.*]]: !cir.ptr<!rec_DefaultOperatorsNoFloats> {{.*}}, %[[RHSARG:.*]]: !cir.ptr<!rec_DefaultOperatorsNoFloats> {{.*}}) // TODO OpenACC: Expecting combination operation here -// CHECK-NEXT: acc.yield %[[LHSARG]] : !cir.ptr<!rec_DefaultOperators> +// CHECK-NEXT: acc.yield %[[LHSARG]] : !cir.ptr<!rec_DefaultOperatorsNoFloats> // CHECK-NEXT: } ; -#pragma acc parallel reduction(|:someVar) -// CHECK-NEXT: acc.reduction.recipe @reduction_ior__ZTS16DefaultOperators : !cir.ptr<!rec_DefaultOperators> reduction_operator <ior> init { -// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!rec_DefaultOperators>{{.*}}) -// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !rec_DefaultOperators, !cir.ptr<!rec_DefaultOperators>, ["openacc.reduction.init", init] -// CHECK-NEXT: %[[GET_I:.*]] = cir.get_member %[[ALLOCA]][0] {name = "i"} : !cir.ptr<!rec_DefaultOperators> -> !cir.ptr<!s32i> +#pragma acc parallel reduction(|:someVarNoFloats) +// CHECK-NEXT: acc.reduction.recipe @reduction_ior__ZTS24DefaultOperatorsNoFloats : !cir.ptr<!rec_DefaultOperatorsNoFloats> reduction_operator <ior> init { +// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!rec_DefaultOperatorsNoFloats>{{.*}}) +// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !rec_DefaultOperatorsNoFloats, !cir.ptr<!rec_DefaultOperatorsNoFloats>, ["openacc.reduction.init", init] +// CHECK-NEXT: %[[GET_I:.*]] = cir.get_member %[[ALLOCA]][0] {name = "i"} : !cir.ptr<!rec_DefaultOperatorsNoFloats> -> !cir.ptr<!s32i> // CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !s32i // CHECK-NEXT: cir.store {{.*}} %[[ZERO]], %[[GET_I]] : !s32i, !cir.ptr<!s32i> -// CHECK-NEXT: %[[GET_U:.*]] = cir.get_member %[[ALLOCA]][1] {name = "u"} : !cir.ptr<!rec_DefaultOperators> -> !cir.ptr<!u32i> +// CHECK-NEXT: %[[GET_U:.*]] = cir.get_member %[[ALLOCA]][1] {name = "u"} : !cir.ptr<!rec_DefaultOperatorsNoFloats> -> !cir.ptr<!u32i> // CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !u32i // CHECK-NEXT: cir.store {{.*}} %[[ZERO]], %[[GET_U]] : !u32i, !cir.ptr<!u32i> -// CHECK-NEXT: %[[GET_F:.*]] = cir.get_member %[[ALLOCA]][2] {name = "f"} : !cir.ptr<!rec_DefaultOperators> -> !cir.ptr<!cir.float> -// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.fp<0{{.*}}> : !cir.float -// CHECK-NEXT: cir.store {{.*}} %[[ZERO]], %[[GET_F]] : !cir.float, !cir.ptr<!cir.float> -// CHECK-NEXT: %[[GET_D:.*]] = cir.get_member %[[ALLOCA]][3] {name = "d"} : !cir.ptr<!rec_DefaultOperators> -> !cir.ptr<!cir.double> -// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.fp<0{{.*}}> : !cir.double -// CHECK-NEXT: cir.store {{.*}} %[[ZERO]], %[[GET_D]] : !cir.double, !cir.ptr<!cir.double> -// CHECK-NEXT: %[[GET_B:.*]] = cir.get_member %[[ALLOCA]][4] {name = "b"} : !cir.ptr<!rec_DefaultOperators> -> !cir.ptr<!cir.bool> +// CHECK-NEXT: %[[GET_B:.*]] = cir.get_member %[[ALLOCA]][2] {name = "b"} : !cir.ptr<!rec_DefaultOperatorsNoFloats> -> !cir.ptr<!cir.bool> // CHECK-NEXT: %[[ZERO:.*]] = cir.const #false // CHECK-NEXT: cir.store {{.*}} %[[ZERO]], %[[GET_B]] : !cir.bool, !cir.ptr<!cir.bool> // CHECK-NEXT: acc.yield // // CHECK-NEXT: } combiner { -// CHECK-NEXT: ^bb0(%[[LHSARG:.*]]: !cir.ptr<!rec_DefaultOperators> {{.*}}, %[[RHSARG:.*]]: !cir.ptr<!rec_DefaultOperators> {{.*}}) +// CHECK-NEXT: ^bb0(%[[LHSARG:.*]]: !cir.ptr<!rec_DefaultOperatorsNoFloats> {{.*}}, %[[RHSARG:.*]]: !cir.ptr<!rec_DefaultOperatorsNoFloats> {{.*}}) // TODO OpenACC: Expecting combination operation here -// CHECK-NEXT: acc.yield %[[LHSARG]] : !cir.ptr<!rec_DefaultOperators> +// CHECK-NEXT: acc.yield %[[LHSARG]] : !cir.ptr<!rec_DefaultOperatorsNoFloats> // CHECK-NEXT: } ; -#pragma acc parallel reduction(^:someVar) -// CHECK-NEXT: acc.reduction.recipe @reduction_xor__ZTS16DefaultOperators : !cir.ptr<!rec_DefaultOperators> reduction_operator <xor> init { -// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!rec_DefaultOperators>{{.*}}) -// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !rec_DefaultOperators, !cir.ptr<!rec_DefaultOperators>, ["openacc.reduction.init", init] -// CHECK-NEXT: %[[GET_I:.*]] = cir.get_member %[[ALLOCA]][0] {name = "i"} : !cir.ptr<!rec_DefaultOperators> -> !cir.ptr<!s32i> +#pragma acc parallel reduction(^:someVarNoFloats) +// CHECK-NEXT: acc.reduction.recipe @reduction_xor__ZTS24DefaultOperatorsNoFloats : !cir.ptr<!rec_DefaultOperatorsNoFloats> reduction_operator <xor> init { +// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!rec_DefaultOperatorsNoFloats>{{.*}}) +// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !rec_DefaultOperatorsNoFloats, !cir.ptr<!rec_DefaultOperatorsNoFloats>, ["openacc.reduction.init", init] +// CHECK-NEXT: %[[GET_I:.*]] = cir.get_member %[[ALLOCA]][0] {name = "i"} : !cir.ptr<!rec_DefaultOperatorsNoFloats> -> !cir.ptr<!s32i> // CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !s32i // CHECK-NEXT: cir.store {{.*}} %[[ZERO]], %[[GET_I]] : !s32i, !cir.ptr<!s32i> -// CHECK-NEXT: %[[GET_U:.*]] = cir.get_member %[[ALLOCA]][1] {name = "u"} : !cir.ptr<!rec_DefaultOperators> -> !cir.ptr<!u32i> +// CHECK-NEXT: %[[GET_U:.*]] = cir.get_member %[[ALLOCA]][1] {name = "u"} : !cir.ptr<!rec_DefaultOperatorsNoFloats> -> !cir.ptr<!u32i> // CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !u32i // CHECK-NEXT: cir.store {{.*}} %[[ZERO]], %[[GET_U]] : !u32i, !cir.ptr<!u32i> -// CHECK-NEXT: %[[GET_F:.*]] = cir.get_member %[[ALLOCA]][2] {name = "f"} : !cir.ptr<!rec_DefaultOperators> -> !cir.ptr<!cir.float> -// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.fp<0{{.*}}> : !cir.float -// CHECK-NEXT: cir.store {{.*}} %[[ZERO]], %[[GET_F]] : !cir.float, !cir.ptr<!cir.float> -// CHECK-NEXT: %[[GET_D:.*]] = cir.get_member %[[ALLOCA]][3] {name = "d"} : !cir.ptr<!rec_DefaultOperators> -> !cir.ptr<!cir.double> -// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.fp<0{{.*}}> : !cir.double -// CHECK-NEXT: cir.store {{.*}} %[[ZERO]], %[[GET_D]] : !cir.double, !cir.ptr<!cir.double> -// CHECK-NEXT: %[[GET_B:.*]] = cir.get_member %[[ALLOCA]][4] {name = "b"} : !cir.ptr<!rec_DefaultOperators> -> !cir.ptr<!cir.bool> +// CHECK-NEXT: %[[GET_B:.*]] = cir.get_member %[[ALLOCA]][2] {name = "b"} : !cir.ptr<!rec_DefaultOperatorsNoFloats> -> !cir.ptr<!cir.bool> // CHECK-NEXT: %[[ZERO:.*]] = cir.const #false // CHECK-NEXT: cir.store {{.*}} %[[ZERO]], %[[GET_B]] : !cir.bool, !cir.ptr<!cir.bool> // CHECK-NEXT: acc.yield // // CHECK-NEXT: } combiner { -// CHECK-NEXT: ^bb0(%[[LHSARG:.*]]: !cir.ptr<!rec_DefaultOperators> {{.*}}, %[[RHSARG:.*]]: !cir.ptr<!rec_DefaultOperators> {{.*}}) +// CHECK-NEXT: ^bb0(%[[LHSARG:.*]]: !cir.ptr<!rec_DefaultOperatorsNoFloats> {{.*}}, %[[RHSARG:.*]]: !cir.ptr<!rec_DefaultOperatorsNoFloats> {{.*}}) // TODO OpenACC: Expecting combination operation here -// CHECK-NEXT: acc.yield %[[LHSARG]] : !cir.ptr<!rec_DefaultOperators> +// CHECK-NEXT: acc.yield %[[LHSARG]] : !cir.ptr<!rec_DefaultOperatorsNoFloats> // CHECK-NEXT: } ; #pragma acc parallel reduction(&&:someVar) @@ -607,193 +596,151 @@ void acc_compute() { // CHECK-NEXT: acc.yield %[[LHSARG]] : !cir.ptr<!cir.array<!rec_DefaultOperators x 5>> // CHECK-NEXT: } ; -#pragma acc parallel reduction(&:someVarArr) -// CHECK-NEXT: acc.reduction.recipe @reduction_iand__ZTSA5_16DefaultOperators : !cir.ptr<!cir.array<!rec_DefaultOperators x 5>> reduction_operator <iand> init { -// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!rec_DefaultOperators x 5>>{{.*}}) -// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !cir.array<!rec_DefaultOperators x 5>, !cir.ptr<!cir.array<!rec_DefaultOperators x 5>>, ["openacc.reduction.init", init] -// CHECK-NEXT: %[[DECAY:.*]] = cir.cast array_to_ptrdecay %[[ALLOCA]] : !cir.ptr<!cir.array<!rec_DefaultOperators x 5>> -> !cir.ptr<!rec_DefaultOperators> -// CHECK-NEXT: %[[GET_I:.*]] = cir.get_member %[[DECAY]][0] {name = "i"} : !cir.ptr<!rec_DefaultOperators> -> !cir.ptr<!s32i> +#pragma acc parallel reduction(&:someVarArrNoFloats) +// CHECK-NEXT: acc.reduction.recipe @reduction_iand__ZTSA5_24DefaultOperatorsNoFloats : !cir.ptr<!cir.array<!rec_DefaultOperatorsNoFloats x 5>> reduction_operator <iand> init { +// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!rec_DefaultOperatorsNoFloats x 5>>{{.*}}) +// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !cir.array<!rec_DefaultOperatorsNoFloats x 5>, !cir.ptr<!cir.array<!rec_DefaultOperatorsNoFloats x 5>>, ["openacc.reduction.init", init] +// CHECK-NEXT: %[[DECAY:.*]] = cir.cast array_to_ptrdecay %[[ALLOCA]] : !cir.ptr<!cir.array<!rec_DefaultOperatorsNoFloats x 5>> -> !cir.ptr<!rec_DefaultOperatorsNoFloats> +// CHECK-NEXT: %[[GET_I:.*]] = cir.get_member %[[DECAY]][0] {name = "i"} : !cir.ptr<!rec_DefaultOperatorsNoFloats> -> !cir.ptr<!s32i> // CHECK-NEXT: %[[ALL_ONES:.*]] = cir.const #cir.int<-1> : !s32i // CHECK-NEXT: cir.store {{.*}} %[[ALL_ONES]], %[[GET_I]] : !s32i, !cir.ptr<!s32i> -// CHECK-NEXT: %[[GET_U:.*]] = cir.get_member %[[DECAY]][1] {name = "u"} : !cir.ptr<!rec_DefaultOperators> -> !cir.ptr<!u32i> +// CHECK-NEXT: %[[GET_U:.*]] = cir.get_member %[[DECAY]][1] {name = "u"} : !cir.ptr<!rec_DefaultOperatorsNoFloats> -> !cir.ptr<!u32i> // CHECK-NEXT: %[[ALL_ONES:.*]] = cir.const #cir.int<4294967295> : !u32i // CHECK-NEXT: cir.store {{.*}} %[[ALL_ONES]], %[[GET_U]] : !u32i, !cir.ptr<!u32i> -// CHECK-NEXT: %[[GET_F:.*]] = cir.get_member %[[DECAY]][2] {name = "f"} : !cir.ptr<!rec_DefaultOperators> -> !cir.ptr<!cir.float> -// CHECK-NEXT: %[[ALL_ONES:.*]] = cir.const #cir.fp<0xFF{{.*}}> : !cir.float -// CHECK-NEXT: cir.store {{.*}} %[[ALL_ONES]], %[[GET_F]] : !cir.float, !cir.ptr<!cir.float> -// CHECK-NEXT: %[[GET_D:.*]] = cir.get_member %[[DECAY]][3] {name = "d"} : !cir.ptr<!rec_DefaultOperators> -> !cir.ptr<!cir.double> -// CHECK-NEXT: %[[ALL_ONES:.*]] = cir.const #cir.fp<0xFF{{.*}}> : !cir.double -// CHECK-NEXT: cir.store {{.*}} %[[ALL_ONES]], %[[GET_D]] : !cir.double, !cir.ptr<!cir.double> -// CHECK-NEXT: %[[GET_B:.*]] = cir.get_member %[[DECAY]][4] {name = "b"} : !cir.ptr<!rec_DefaultOperators> -> !cir.ptr<!cir.bool> +// CHECK-NEXT: %[[GET_B:.*]] = cir.get_member %[[DECAY]][2] {name = "b"} : !cir.ptr<!rec_DefaultOperatorsNoFloats> -> !cir.ptr<!cir.bool> // CHECK-NEXT: %[[ALL_ONES:.*]] = cir.const #true // CHECK-NEXT: cir.store {{.*}} %[[ALL_ONES]], %[[GET_B]] : !cir.bool, !cir.ptr<!cir.bool> // // CHECK-NEXT: %[[ALL_ONES_IDX:.*]] = cir.const #cir.int<1> : !s64i -// CHECK-NEXT: %[[NEXT_ELT:.*]] = cir.ptr_stride %[[DECAY]], %[[ALL_ONES_IDX]] : (!cir.ptr<!rec_DefaultOperators>, !s64i) -> !cir.ptr<!rec_DefaultOperators> -// CHECK-NEXT: %[[GET_I:.*]] = cir.get_member %[[NEXT_ELT]][0] {name = "i"} : !cir.ptr<!rec_DefaultOperators> -> !cir.ptr<!s32i> +// CHECK-NEXT: %[[NEXT_ELT:.*]] = cir.ptr_stride %[[DECAY]], %[[ALL_ONES_IDX]] : (!cir.ptr<!rec_DefaultOperatorsNoFloats>, !s64i) -> !cir.ptr<!rec_DefaultOperatorsNoFloats> +// CHECK-NEXT: %[[GET_I:.*]] = cir.get_member %[[NEXT_ELT]][0] {name = "i"} : !cir.ptr<!rec_DefaultOperatorsNoFloats> -> !cir.ptr<!s32i> // CHECK-NEXT: %[[ALL_ONES:.*]] = cir.const #cir.int<-1> : !s32i // CHECK-NEXT: cir.store {{.*}} %[[ALL_ONES]], %[[GET_I]] : !s32i, !cir.ptr<!s32i> -// CHECK-NEXT: %[[GET_U:.*]] = cir.get_member %[[NEXT_ELT]][1] {name = "u"} : !cir.ptr<!rec_DefaultOperators> -> !cir.ptr<!u32i> +// CHECK-NEXT: %[[GET_U:.*]] = cir.get_member %[[NEXT_ELT]][1] {name = "u"} : !cir.ptr<!rec_DefaultOperatorsNoFloats> -> !cir.ptr<!u32i> // CHECK-NEXT: %[[ALL_ONES:.*]] = cir.const #cir.int<4294967295> : !u32i // CHECK-NEXT: cir.store {{.*}} %[[ALL_ONES]], %[[GET_U]] : !u32i, !cir.ptr<!u32i> -// CHECK-NEXT: %[[GET_F:.*]] = cir.get_member %[[NEXT_ELT]][2] {name = "f"} : !cir.ptr<!rec_DefaultOperators> -> !cir.ptr<!cir.float> -// CHECK-NEXT: %[[ALL_ONES:.*]] = cir.const #cir.fp<0xFF{{.*}}> : !cir.float -// CHECK-NEXT: cir.store {{.*}} %[[ALL_ONES]], %[[GET_F]] : !cir.float, !cir.ptr<!cir.float> -// CHECK-NEXT: %[[GET_D:.*]] = cir.get_member %[[NEXT_ELT]][3] {name = "d"} : !cir.ptr<!rec_DefaultOperators> -> !cir.ptr<!cir.double> -// CHECK-NEXT: %[[ALL_ONES:.*]] = cir.const #cir.fp<0xFF{{.*}}> : !cir.double -// CHECK-NEXT: cir.store {{.*}} %[[ALL_ONES]], %[[GET_D]] : !cir.double, !cir.ptr<!cir.double> -// CHECK-NEXT: %[[GET_B:.*]] = cir.get_member %[[NEXT_ELT]][4] {name = "b"} : !cir.ptr<!rec_DefaultOperators> -> !cir.ptr<!cir.bool> +// CHECK-NEXT: %[[GET_B:.*]] = cir.get_member %[[NEXT_ELT]][2] {name = "b"} : !cir.ptr<!rec_DefaultOperatorsNoFloats> -> !cir.ptr<!cir.bool> // CHECK-NEXT: %[[ALL_ONES:.*]] = cir.const #true // CHECK-NEXT: cir.store {{.*}} %[[ALL_ONES]], %[[GET_B]] : !cir.bool, !cir.ptr<!cir.bool> // // CHECK-NEXT: %[[TWO_IDX:.*]] = cir.const #cir.int<2> : !s64i -// CHECK-NEXT: %[[NEXT_ELT:.*]] = cir.ptr_stride %[[DECAY]], %[[TWO_IDX]] : (!cir.ptr<!rec_DefaultOperators>, !s64i) -> !cir.ptr<!rec_DefaultOperators> -// CHECK-NEXT: %[[GET_I:.*]] = cir.get_member %[[NEXT_ELT]][0] {name = "i"} : !cir.ptr<!rec_DefaultOperators> -> !cir.ptr<!s32i> +// CHECK-NEXT: %[[NEXT_ELT:.*]] = cir.ptr_stride %[[DECAY]], %[[TWO_IDX]] : (!cir.ptr<!rec_DefaultOperatorsNoFloats>, !s64i) -> !cir.ptr<!rec_DefaultOperatorsNoFloats> +// CHECK-NEXT: %[[GET_I:.*]] = cir.get_member %[[NEXT_ELT]][0] {name = "i"} : !cir.ptr<!rec_DefaultOperatorsNoFloats> -> !cir.ptr<!s32i> // CHECK-NEXT: %[[ALL_ONES:.*]] = cir.const #cir.int<-1> : !s32i // CHECK-NEXT: cir.store {{.*}} %[[ALL_ONES]], %[[GET_I]] : !s32i, !cir.ptr<!s32i> -// CHECK-NEXT: %[[GET_U:.*]] = cir.get_member %[[NEXT_ELT]][1] {name = "u"} : !cir.ptr<!rec_DefaultOperators> -> !cir.ptr<!u32i> +// CHECK-NEXT: %[[GET_U:.*]] = cir.get_member %[[NEXT_ELT]][1] {name = "u"} : !cir.ptr<!rec_DefaultOperatorsNoFloats> -> !cir.ptr<!u32i> // CHECK-NEXT: %[[ALL_ONES:.*]] = cir.const #cir.int<4294967295> : !u32i // CHECK-NEXT: cir.store {{.*}} %[[ALL_ONES]], %[[GET_U]] : !u32i, !cir.ptr<!u32i> -// CHECK-NEXT: %[[GET_F:.*]] = cir.get_member %[[NEXT_ELT]][2] {name = "f"} : !cir.ptr<!rec_DefaultOperators> -> !cir.ptr<!cir.float> -// CHECK-NEXT: %[[ALL_ONES:.*]] = cir.const #cir.fp<0xFF{{.*}}> : !cir.float -// CHECK-NEXT: cir.store {{.*}} %[[ALL_ONES]], %[[GET_F]] : !cir.float, !cir.ptr<!cir.float> -// CHECK-NEXT: %[[GET_D:.*]] = cir.get_member %[[NEXT_ELT]][3] {name = "d"} : !cir.ptr<!rec_DefaultOperators> -> !cir.ptr<!cir.double> -// CHECK-NEXT: %[[ALL_ONES:.*]] = cir.const #cir.fp<0xFF{{.*}}> : !cir.double -// CHECK-NEXT: cir.store {{.*}} %[[ALL_ONES]], %[[GET_D]] : !cir.double, !cir.ptr<!cir.double> -// CHECK-NEXT: %[[GET_B:.*]] = cir.get_member %[[NEXT_ELT]][4] {name = "b"} : !cir.ptr<!rec_DefaultOperators> -> !cir.ptr<!cir.bool> +// CHECK-NEXT: %[[GET_B:.*]] = cir.get_member %[[NEXT_ELT]][2] {name = "b"} : !cir.ptr<!rec_DefaultOperatorsNoFloats> -> !cir.ptr<!cir.bool> // CHECK-NEXT: %[[ALL_ONES:.*]] = cir.const #true // CHECK-NEXT: cir.store {{.*}} %[[ALL_ONES]], %[[GET_B]] : !cir.bool, !cir.ptr<!cir.bool> // // // CHECK-NEXT: %[[THREE_IDX:.*]] = cir.const #cir.int<3> : !s64i -// CHECK-NEXT: %[[NEXT_ELT:.*]] = cir.ptr_stride %[[DECAY]], %[[THREE_IDX]] : (!cir.ptr<!rec_DefaultOperators>, !s64i) -> !cir.ptr<!rec_DefaultOperators> -// CHECK-NEXT: %[[GET_I:.*]] = cir.get_member %[[NEXT_ELT]][0] {name = "i"} : !cir.ptr<!rec_DefaultOperators> -> !cir.ptr<!s32i> +// CHECK-NEXT: %[[NEXT_ELT:.*]] = cir.ptr_stride %[[DECAY]], %[[THREE_IDX]] : (!cir.ptr<!rec_DefaultOperatorsNoFloats>, !s64i) -> !cir.ptr<!rec_DefaultOperatorsNoFloats> +// CHECK-NEXT: %[[GET_I:.*]] = cir.get_member %[[NEXT_ELT]][0] {name = "i"} : !cir.ptr<!rec_DefaultOperatorsNoFloats> -> !cir.ptr<!s32i> // CHECK-NEXT: %[[ALL_ONES:.*]] = cir.const #cir.int<-1> : !s32i // CHECK-NEXT: cir.store {{.*}} %[[ALL_ONES]], %[[GET_I]] : !s32i, !cir.ptr<!s32i> -// CHECK-NEXT: %[[GET_U:.*]] = cir.get_member %[[NEXT_ELT]][1] {name = "u"} : !cir.ptr<!rec_DefaultOperators> -> !cir.ptr<!u32i> +// CHECK-NEXT: %[[GET_U:.*]] = cir.get_member %[[NEXT_ELT]][1] {name = "u"} : !cir.ptr<!rec_DefaultOperatorsNoFloats> -> !cir.ptr<!u32i> // CHECK-NEXT: %[[ALL_ONES:.*]] = cir.const #cir.int<4294967295> : !u32i // CHECK-NEXT: cir.store {{.*}} %[[ALL_ONES]], %[[GET_U]] : !u32i, !cir.ptr<!u32i> -// CHECK-NEXT: %[[GET_F:.*]] = cir.get_member %[[NEXT_ELT]][2] {name = "f"} : !cir.ptr<!rec_DefaultOperators> -> !cir.ptr<!cir.float> -// CHECK-NEXT: %[[ALL_ONES:.*]] = cir.const #cir.fp<0xFF{{.*}}> : !cir.float -// CHECK-NEXT: cir.store {{.*}} %[[ALL_ONES]], %[[GET_F]] : !cir.float, !cir.ptr<!cir.float> -// CHECK-NEXT: %[[GET_D:.*]] = cir.get_member %[[NEXT_ELT]][3] {name = "d"} : !cir.ptr<!rec_DefaultOperators> -> !cir.ptr<!cir.double> -// CHECK-NEXT: %[[ALL_ONES:.*]] = cir.const #cir.fp<0xFF{{.*}}> : !cir.double -// CHECK-NEXT: cir.store {{.*}} %[[ALL_ONES]], %[[GET_D]] : !cir.double, !cir.ptr<!cir.double> -// CHECK-NEXT: %[[GET_B:.*]] = cir.get_member %[[NEXT_ELT]][4] {name = "b"} : !cir.ptr<!rec_DefaultOperators> -> !cir.ptr<!cir.bool> +// CHECK-NEXT: %[[GET_B:.*]] = cir.get_member %[[NEXT_ELT]][2] {name = "b"} : !cir.ptr<!rec_DefaultOperatorsNoFloats> -> !cir.ptr<!cir.bool> // CHECK-NEXT: %[[ALL_ONES:.*]] = cir.const #true // CHECK-NEXT: cir.store {{.*}} %[[ALL_ONES]], %[[GET_B]] : !cir.bool, !cir.ptr<!cir.bool> // // CHECK-NEXT: %[[FOUR_IDX:.*]] = cir.const #cir.int<4> : !s64i -// CHECK-NEXT: %[[NEXT_ELT:.*]] = cir.ptr_stride %[[DECAY]], %[[FOUR_IDX]] : (!cir.ptr<!rec_DefaultOperators>, !s64i) -> !cir.ptr<!rec_DefaultOperators> -// CHECK-NEXT: %[[GET_I:.*]] = cir.get_member %[[NEXT_ELT]][0] {name = "i"} : !cir.ptr<!rec_DefaultOperators> -> !cir.ptr<!s32i> +// CHECK-NEXT: %[[NEXT_ELT:.*]] = cir.ptr_stride %[[DECAY]], %[[FOUR_IDX]] : (!cir.ptr<!rec_DefaultOperatorsNoFloats>, !s64i) -> !cir.ptr<!rec_DefaultOperatorsNoFloats> +// CHECK-NEXT: %[[GET_I:.*]] = cir.get_member %[[NEXT_ELT]][0] {name = "i"} : !cir.ptr<!rec_DefaultOperatorsNoFloats> -> !cir.ptr<!s32i> // CHECK-NEXT: %[[ALL_ONES:.*]] = cir.const #cir.int<-1> : !s32i // CHECK-NEXT: cir.store {{.*}} %[[ALL_ONES]], %[[GET_I]] : !s32i, !cir.ptr<!s32i> -// CHECK-NEXT: %[[GET_U:.*]] = cir.get_member %[[NEXT_ELT]][1] {name = "u"} : !cir.ptr<!rec_DefaultOperators> -> !cir.ptr<!u32i> +// CHECK-NEXT: %[[GET_U:.*]] = cir.get_member %[[NEXT_ELT]][1] {name = "u"} : !cir.ptr<!rec_DefaultOperatorsNoFloats> -> !cir.ptr<!u32i> // CHECK-NEXT: %[[ALL_ONES:.*]] = cir.const #cir.int<4294967295> : !u32i // CHECK-NEXT: cir.store {{.*}} %[[ALL_ONES]], %[[GET_U]] : !u32i, !cir.ptr<!u32i> -// CHECK-NEXT: %[[GET_F:.*]] = cir.get_member %[[NEXT_ELT]][2] {name = "f"} : !cir.ptr<!rec_DefaultOperators> -> !cir.ptr<!cir.float> -// CHECK-NEXT: %[[ALL_ONES:.*]] = cir.const #cir.fp<0xFF{{.*}}> : !cir.float -// CHECK-NEXT: cir.store {{.*}} %[[ALL_ONES]], %[[GET_F]] : !cir.float, !cir.ptr<!cir.float> -// CHECK-NEXT: %[[GET_D:.*]] = cir.get_member %[[NEXT_ELT]][3] {name = "d"} : !cir.ptr<!rec_DefaultOperators> -> !cir.ptr<!cir.double> -// CHECK-NEXT: %[[ALL_ONES:.*]] = cir.const #cir.fp<0xFF{{.*}}> : !cir.double -// CHECK-NEXT: cir.store {{.*}} %[[ALL_ONES]], %[[GET_D]] : !cir.double, !cir.ptr<!cir.double> -// CHECK-NEXT: %[[GET_B:.*]] = cir.get_member %[[NEXT_ELT]][4] {name = "b"} : !cir.ptr<!rec_DefaultOperators> -> !cir.ptr<!cir.bool> +// CHECK-NEXT: %[[GET_B:.*]] = cir.get_member %[[NEXT_ELT]][2] {name = "b"} : !cir.ptr<!rec_DefaultOperatorsNoFloats> -> !cir.ptr<!cir.bool> // CHECK-NEXT: %[[ALL_ONES:.*]] = cir.const #true // CHECK-NEXT: cir.store {{.*}} %[[ALL_ONES]], %[[GET_B]] : !cir.bool, !cir.ptr<!cir.bool> // // CHECK-NEXT: acc.yield // // CHECK-NEXT: } combiner { -// CHECK-NEXT: ^bb0(%[[LHSARG:.*]]: !cir.ptr<!cir.array<!rec_DefaultOperators x 5>> {{.*}}, %[[RHSARG:.*]]: !cir.ptr<!cir.array<!rec_DefaultOperators x 5>> {{.*}}) +// CHECK-NEXT: ^bb0(%[[LHSARG:.*]]: !cir.ptr<!cir.array<!rec_DefaultOperatorsNoFloats x 5>> {{.*}}, %[[RHSARG:.*]]: !cir.ptr<!cir.array<!rec_DefaultOperatorsNoFloats x 5>> {{.*}}) // TODO OpenACC: Expecting combination operation here -// CHECK-NEXT: acc.yield %[[LHSARG]] : !cir.ptr<!cir.array<!rec_DefaultOperators x 5>> +// CHECK-NEXT: acc.yield %[[LHSARG]] : !cir.ptr<!cir.array<!rec_DefaultOperatorsNoFloats x 5>> // CHECK-NEXT: } ; -#pragma acc parallel reduction(|:someVarArr) -// CHECK-NEXT: acc.reduction.recipe @reduction_ior__ZTSA5_16DefaultOperators : !cir.ptr<!cir.array<!rec_DefaultOperators x 5>> reduction_operator <ior> init { -// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!rec_DefaultOperators x 5>>{{.*}}) -// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !cir.array<!rec_DefaultOperators x 5>, !cir.ptr<!cir.array<!rec_DefaultOperators x 5>>, ["openacc.reduction.init", init] -// CHECK-NEXT: %[[TEMP_ITR:.*]] = cir.alloca !cir.ptr<!rec_DefaultOperators>, !cir.ptr<!cir.ptr<!rec_DefaultOperators>>, ["arrayinit.temp"] -// CHECK-NEXT: %[[DECAY:.*]] = cir.cast array_to_ptrdecay %[[ALLOCA]] : !cir.ptr<!cir.array<!rec_DefaultOperators x 5>> -> !cir.ptr<!rec_DefaultOperators> -// CHECK-NEXT: cir.store {{.*}} %[[DECAY]], %[[TEMP_ITR]] : !cir.ptr<!rec_DefaultOperators>, !cir.ptr<!cir.ptr<!rec_DefaultOperators>> +#pragma acc parallel reduction(|:someVarArrNoFloats) +// CHECK-NEXT: acc.reduction.recipe @reduction_ior__ZTSA5_24DefaultOperatorsNoFloats : !cir.ptr<!cir.array<!rec_DefaultOperatorsNoFloats x 5>> reduction_operator <ior> init { +// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!rec_DefaultOperatorsNoFloats x 5>>{{.*}}) +// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !cir.array<!rec_DefaultOperatorsNoFloats x 5>, !cir.ptr<!cir.array<!rec_DefaultOperatorsNoFloats x 5>>, ["openacc.reduction.init", init] +// CHECK-NEXT: %[[TEMP_ITR:.*]] = cir.alloca !cir.ptr<!rec_DefaultOperatorsNoFloats>, !cir.ptr<!cir.ptr<!rec_DefaultOperatorsNoFloats>>, ["arrayinit.temp"] +// CHECK-NEXT: %[[DECAY:.*]] = cir.cast array_to_ptrdecay %[[ALLOCA]] : !cir.ptr<!cir.array<!rec_DefaultOperatorsNoFloats x 5>> -> !cir.ptr<!rec_DefaultOperatorsNoFloats> +// CHECK-NEXT: cir.store {{.*}} %[[DECAY]], %[[TEMP_ITR]] : !cir.ptr<!rec_DefaultOperatorsNoFloats>, !cir.ptr<!cir.ptr<!rec_DefaultOperatorsNoFloats>> // CHECK-NEXT: %[[LAST_IDX:.*]] = cir.const #cir.int<5> : !s64i -// CHECK-NEXT: %[[END_ITR:.*]] = cir.ptr_stride %[[DECAY]], %[[LAST_IDX]] : (!cir.ptr<!rec_DefaultOperators>, !s64i) -> !cir.ptr<!rec_DefaultOperators> +// CHECK-NEXT: %[[END_ITR:.*]] = cir.ptr_stride %[[DECAY]], %[[LAST_IDX]] : (!cir.ptr<!rec_DefaultOperatorsNoFloats>, !s64i) -> !cir.ptr<!rec_DefaultOperatorsNoFloats> // CHECK-NEXT: cir.do { -// CHECK-NEXT: %[[TEMP_LOAD:.*]] = cir.load {{.*}} %[[TEMP_ITR]] : !cir.ptr<!cir.ptr<!rec_DefaultOperators>>, !cir.ptr<!rec_DefaultOperators> -// CHECK-NEXT: %[[GET_I:.*]] = cir.get_member %[[TEMP_LOAD]][0] {name = "i"} : !cir.ptr<!rec_DefaultOperators> -> !cir.ptr<!s32i> +// CHECK-NEXT: %[[TEMP_LOAD:.*]] = cir.load {{.*}} %[[TEMP_ITR]] : !cir.ptr<!cir.ptr<!rec_DefaultOperatorsNoFloats>>, !cir.ptr<!rec_DefaultOperatorsNoFloats> +// CHECK-NEXT: %[[GET_I:.*]] = cir.get_member %[[TEMP_LOAD]][0] {name = "i"} : !cir.ptr<!rec_DefaultOperatorsNoFloats> -> !cir.ptr<!s32i> // CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !s32i // CHECK-NEXT: cir.store {{.*}} %[[ZERO]], %[[GET_I]] : !s32i, !cir.ptr<!s32i> -// CHECK-NEXT: %[[GET_U:.*]] = cir.get_member %[[TEMP_LOAD]][1] {name = "u"} : !cir.ptr<!rec_DefaultOperators> -> !cir.ptr<!u32i> +// CHECK-NEXT: %[[GET_U:.*]] = cir.get_member %[[TEMP_LOAD]][1] {name = "u"} : !cir.ptr<!rec_DefaultOperatorsNoFloats> -> !cir.ptr<!u32i> // CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !u32i // CHECK-NEXT: cir.store {{.*}} %[[ZERO]], %[[GET_U]] : !u32i, !cir.ptr<!u32i> -// CHECK-NEXT: %[[GET_F:.*]] = cir.get_member %[[TEMP_LOAD]][2] {name = "f"} : !cir.ptr<!rec_DefaultOperators> -> !cir.ptr<!cir.float> -// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.fp<0{{.*}}> : !cir.float -// CHECK-NEXT: cir.store {{.*}} %[[ZERO]], %[[GET_F]] : !cir.float, !cir.ptr<!cir.float> -// CHECK-NEXT: %[[GET_D:.*]] = cir.get_member %[[TEMP_LOAD]][3] {name = "d"} : !cir.ptr<!rec_DefaultOperators> -> !cir.ptr<!cir.double> -// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.fp<0{{.*}}> : !cir.double -// CHECK-NEXT: cir.store {{.*}} %[[ZERO]], %[[GET_D]] : !cir.double, !cir.ptr<!cir.double> -// CHECK-NEXT: %[[GET_B:.*]] = cir.get_member %[[TEMP_LOAD]][4] {name = "b"} : !cir.ptr<!rec_DefaultOperators> -> !cir.ptr<!cir.bool> +// CHECK-NEXT: %[[GET_B:.*]] = cir.get_member %[[TEMP_LOAD]][2] {name = "b"} : !cir.ptr<!rec_DefaultOperatorsNoFloats> -> !cir.ptr<!cir.bool> // CHECK-NEXT: %[[ZERO:.*]] = cir.const #false // CHECK-NEXT: cir.store {{.*}} %[[ZERO]], %[[GET_B]] : !cir.bool, !cir.ptr<!cir.bool> // // CHECK-NEXT: %[[ONE:.*]] = cir.const #cir.int<1> : !s64i -// CHECK-NEXT: %[[NEXT_ITEM:.*]] = cir.ptr_stride %[[TEMP_LOAD]], %[[ONE]] : (!cir.ptr<!rec_DefaultOperators>, !s64i) -> !cir.ptr<!rec_DefaultOperators> -// CHECK-NEXT: cir.store {{.*}} %[[NEXT_ITEM]], %[[TEMP_ITR]] : !cir.ptr<!rec_DefaultOperators>, !cir.ptr<!cir.ptr<!rec_DefaultOperators>> +// CHECK-NEXT: %[[NEXT_ITEM:.*]] = cir.ptr_stride %[[TEMP_LOAD]], %[[ONE]] : (!cir.ptr<!rec_DefaultOperatorsNoFloats>, !s64i) -> !cir.ptr<!rec_DefaultOperatorsNoFloats> +// CHECK-NEXT: cir.store {{.*}} %[[NEXT_ITEM]], %[[TEMP_ITR]] : !cir.ptr<!rec_DefaultOperatorsNoFloats>, !cir.ptr<!cir.ptr<!rec_DefaultOperatorsNoFloats>> // CHECK-NEXT: cir.yield // CHECK-NEXT: } while { -// CHECK-NEXT: %[[TEMP_LOAD:.*]] = cir.load {{.*}} %[[TEMP_ITR]] : !cir.ptr<!cir.ptr<!rec_DefaultOperators>>, !cir.ptr<!rec_DefaultOperators> -// CHECK-NEXT: %[[CMP:.*]] = cir.cmp(ne, %[[TEMP_LOAD]], %[[END_ITR]]) : !cir.ptr<!rec_DefaultOperators>, !cir.bool +// CHECK-NEXT: %[[TEMP_LOAD:.*]] = cir.load {{.*}} %[[TEMP_ITR]] : !cir.ptr<!cir.ptr<!rec_DefaultOperatorsNoFloats>>, !cir.ptr<!rec_DefaultOperatorsNoFloats> +// CHECK-NEXT: %[[CMP:.*]] = cir.cmp(ne, %[[TEMP_LOAD]], %[[END_ITR]]) : !cir.ptr<!rec_DefaultOperatorsNoFloats>, !cir.bool // CHECK-NEXT: cir.condition(%[[CMP]]) // CHECK-NEXT: } // CHECK-NEXT: acc.yield // // CHECK-NEXT: } combiner { -// CHECK-NEXT: ^bb0(%[[LHSARG:.*]]: !cir.ptr<!cir.array<!rec_DefaultOperators x 5>> {{.*}}, %[[RHSARG:.*]]: !cir.ptr<!cir.array<!rec_DefaultOperators x 5>> {{.*}}) +// CHECK-NEXT: ^bb0(%[[LHSARG:.*]]: !cir.ptr<!cir.array<!rec_DefaultOperatorsNoFloats x 5>> {{.*}}, %[[RHSARG:.*]]: !cir.ptr<!cir.array<!rec_DefaultOperatorsNoFloats x 5>> {{.*}}) // TODO OpenACC: Expecting combination operation here -// CHECK-NEXT: acc.yield %[[LHSARG]] : !cir.ptr<!cir.array<!rec_DefaultOperators x 5>> +// CHECK-NEXT: acc.yield %[[LHSARG]] : !cir.ptr<!cir.array<!rec_DefaultOperatorsNoFloats x 5>> // CHECK-NEXT: } ; -#pragma acc parallel reduction(^:someVarArr) -// CHECK-NEXT: acc.reduction.recipe @reduction_xor__ZTSA5_16DefaultOperators : !cir.ptr<!cir.array<!rec_DefaultOperators x 5>> reduction_operator <xor> init { -// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!rec_DefaultOperators x 5>>{{.*}}) -// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !cir.array<!rec_DefaultOperators x 5>, !cir.ptr<!cir.array<!rec_DefaultOperators x 5>>, ["openacc.reduction.init", init] -// CHECK-NEXT: %[[TEMP_ITR:.*]] = cir.alloca !cir.ptr<!rec_DefaultOperators>, !cir.ptr<!cir.ptr<!rec_DefaultOperators>>, ["arrayinit.temp"] -// CHECK-NEXT: %[[DECAY:.*]] = cir.cast array_to_ptrdecay %[[ALLOCA]] : !cir.ptr<!cir.array<!rec_DefaultOperators x 5>> -> !cir.ptr<!rec_DefaultOperators> -// CHECK-NEXT: cir.store {{.*}} %[[DECAY]], %[[TEMP_ITR]] : !cir.ptr<!rec_DefaultOperators>, !cir.ptr<!cir.ptr<!rec_DefaultOperators>> +#pragma acc parallel reduction(^:someVarArrNoFloats) +// CHECK-NEXT: acc.reduction.recipe @reduction_xor__ZTSA5_24DefaultOperatorsNoFloats : !cir.ptr<!cir.array<!rec_DefaultOperatorsNoFloats x 5>> reduction_operator <xor> init { +// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!rec_DefaultOperatorsNoFloats x 5>>{{.*}}) +// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !cir.array<!rec_DefaultOperatorsNoFloats x 5>, !cir.ptr<!cir.array<!rec_DefaultOperatorsNoFloats x 5>>, ["openacc.reduction.init", init] +// CHECK-NEXT: %[[TEMP_ITR:.*]] = cir.alloca !cir.ptr<!rec_DefaultOperatorsNoFloats>, !cir.ptr<!cir.ptr<!rec_DefaultOperatorsNoFloats>>, ["arrayinit.temp"] +// CHECK-NEXT: %[[DECAY:.*]] = cir.cast array_to_ptrdecay %[[ALLOCA]] : !cir.ptr<!cir.array<!rec_DefaultOperatorsNoFloats x 5>> -> !cir.ptr<!rec_DefaultOperatorsNoFloats> +// CHECK-NEXT: cir.store {{.*}} %[[DECAY]], %[[TEMP_ITR]] : !cir.ptr<!rec_DefaultOperatorsNoFloats>, !cir.ptr<!cir.ptr<!rec_DefaultOperatorsNoFloats>> // CHECK-NEXT: %[[LAST_IDX:.*]] = cir.const #cir.int<5> : !s64i -// CHECK-NEXT: %[[END_ITR:.*]] = cir.ptr_stride %[[DECAY]], %[[LAST_IDX]] : (!cir.ptr<!rec_DefaultOperators>, !s64i) -> !cir.ptr<!rec_DefaultOperators> +// CHECK-NEXT: %[[END_ITR:.*]] = cir.ptr_stride %[[DECAY]], %[[LAST_IDX]] : (!cir.ptr<!rec_DefaultOperatorsNoFloats>, !s64i) -> !cir.ptr<!rec_DefaultOperatorsNoFloats> // CHECK-NEXT: cir.do { -// CHECK-NEXT: %[[TEMP_LOAD:.*]] = cir.load {{.*}} %[[TEMP_ITR]] : !cir.ptr<!cir.ptr<!rec_DefaultOperators>>, !cir.ptr<!rec_DefaultOperators> -// CHECK-NEXT: %[[GET_I:.*]] = cir.get_member %[[TEMP_LOAD]][0] {name = "i"} : !cir.ptr<!rec_DefaultOperators> -> !cir.ptr<!s32i> +// CHECK-NEXT: %[[TEMP_LOAD:.*]] = cir.load {{.*}} %[[TEMP_ITR]] : !cir.ptr<!cir.ptr<!rec_DefaultOperatorsNoFloats>>, !cir.ptr<!rec_DefaultOperatorsNoFloats> +// CHECK-NEXT: %[[GET_I:.*]] = cir.get_member %[[TEMP_LOAD]][0] {name = "i"} : !cir.ptr<!rec_DefaultOperatorsNoFloats> -> !cir.ptr<!s32i> // CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !s32i // CHECK-NEXT: cir.store {{.*}} %[[ZERO]], %[[GET_I]] : !s32i, !cir.ptr<!s32i> -// CHECK-NEXT: %[[GET_U:.*]] = cir.get_member %[[TEMP_LOAD]][1] {name = "u"} : !cir.ptr<!rec_DefaultOperators> -> !cir.ptr<!u32i> +// CHECK-NEXT: %[[GET_U:.*]] = cir.get_member %[[TEMP_LOAD]][1] {name = "u"} : !cir.ptr<!rec_DefaultOperatorsNoFloats> -> !cir.ptr<!u32i> // CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !u32i // CHECK-NEXT: cir.store {{.*}} %[[ZERO]], %[[GET_U]] : !u32i, !cir.ptr<!u32i> -// CHECK-NEXT: %[[GET_F:.*]] = cir.get_member %[[TEMP_LOAD]][2] {name = "f"} : !cir.ptr<!rec_DefaultOperators> -> !cir.ptr<!cir.float> -// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.fp<0{{.*}}> : !cir.float -// CHECK-NEXT: cir.store {{.*}} %[[ZERO]], %[[GET_F]] : !cir.float, !cir.ptr<!cir.float> -// CHECK-NEXT: %[[GET_D:.*]] = cir.get_member %[[TEMP_LOAD]][3] {name = "d"} : !cir.ptr<!rec_DefaultOperators> -> !cir.ptr<!cir.double> -// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.fp<0{{.*}}> : !cir.double -// CHECK-NEXT: cir.store {{.*}} %[[ZERO]], %[[GET_D]] : !cir.double, !cir.ptr<!cir.double> -// CHECK-NEXT: %[[GET_B:.*]] = cir.get_member %[[TEMP_LOAD]][4] {name = "b"} : !cir.ptr<!rec_DefaultOperators> -> !cir.ptr<!cir.bool> +// CHECK-NEXT: %[[GET_B:.*]] = cir.get_member %[[TEMP_LOAD]][2] {name = "b"} : !cir.ptr<!rec_DefaultOperatorsNoFloats> -> !cir.ptr<!cir.bool> // CHECK-NEXT: %[[ZERO:.*]] = cir.const #false // CHECK-NEXT: cir.store {{.*}} %[[ZERO]], %[[GET_B]] : !cir.bool, !cir.ptr<!cir.bool> // CHECK-NEXT: %[[ONE:.*]] = cir.const #cir.int<1> : !s64i -// CHECK-NEXT: %[[NEXT_ITEM:.*]] = cir.ptr_stride %[[TEMP_LOAD]], %[[ONE]] : (!cir.ptr<!rec_DefaultOperators>, !s64i) -> !cir.ptr<!rec_DefaultOperators> -// CHECK-NEXT: cir.store {{.*}} %[[NEXT_ITEM]], %[[TEMP_ITR]] : !cir.ptr<!rec_DefaultOperators>, !cir.ptr<!cir.ptr<!rec_DefaultOperators>> +// CHECK-NEXT: %[[NEXT_ITEM:.*]] = cir.ptr_stride %[[TEMP_LOAD]], %[[ONE]] : (!cir.ptr<!rec_DefaultOperatorsNoFloats>, !s64i) -> !cir.ptr<!rec_DefaultOperatorsNoFloats> +// CHECK-NEXT: cir.store {{.*}} %[[NEXT_ITEM]], %[[TEMP_ITR]] : !cir.ptr<!rec_DefaultOperatorsNoFloats>, !cir.ptr<!cir.ptr<!rec_DefaultOperatorsNoFloats>> // CHECK-NEXT: cir.yield // CHECK-NEXT: } while { -// CHECK-NEXT: %[[TEMP_LOAD:.*]] = cir.load {{.*}} %[[TEMP_ITR]] : !cir.ptr<!cir.ptr<!rec_DefaultOperators>>, !cir.ptr<!rec_DefaultOperators> -// CHECK-NEXT: %[[CMP:.*]] = cir.cmp(ne, %[[TEMP_LOAD]], %[[END_ITR]]) : !cir.ptr<!rec_DefaultOperators>, !cir.bool +// CHECK-NEXT: %[[TEMP_LOAD:.*]] = cir.load {{.*}} %[[TEMP_ITR]] : !cir.ptr<!cir.ptr<!rec_DefaultOperatorsNoFloats>>, !cir.ptr<!rec_DefaultOperatorsNoFloats> +// CHECK-NEXT: %[[CMP:.*]] = cir.cmp(ne, %[[TEMP_LOAD]], %[[END_ITR]]) : !cir.ptr<!rec_DefaultOperatorsNoFloats>, !cir.bool // CHECK-NEXT: cir.condition(%[[CMP]]) // CHECK-NEXT: } // CHECK-NEXT: acc.yield // // CHECK-NEXT: } combiner { -// CHECK-NEXT: ^bb0(%[[LHSARG:.*]]: !cir.ptr<!cir.array<!rec_DefaultOperators x 5>> {{.*}}, %[[RHSARG:.*]]: !cir.ptr<!cir.array<!rec_DefaultOperators x 5>> {{.*}}) +// CHECK-NEXT: ^bb0(%[[LHSARG:.*]]: !cir.ptr<!cir.array<!rec_DefaultOperatorsNoFloats x 5>> {{.*}}, %[[RHSARG:.*]]: !cir.ptr<!cir.array<!rec_DefaultOperatorsNoFloats x 5>> {{.*}}) // TODO OpenACC: Expecting combination operation here -// CHECK-NEXT: acc.yield %[[LHSARG]] : !cir.ptr<!cir.array<!rec_DefaultOperators x 5>> +// CHECK-NEXT: acc.yield %[[LHSARG]] : !cir.ptr<!cir.array<!rec_DefaultOperatorsNoFloats x 5>> // CHECK-NEXT: } ; #pragma acc parallel reduction(&&:someVarArr) @@ -1135,10 +1082,10 @@ void acc_compute() { // CHECK-NEXT: acc.yield %[[LHSARG]] : !cir.ptr<!cir.array<!rec_DefaultOperators x 5>> // CHECK-NEXT: } ; -#pragma acc parallel reduction(&:someVarArr[2]) -// CHECK-NEXT: acc.reduction.recipe @reduction_iand__Bcnt1__ZTSA5_16DefaultOperators : !cir.ptr<!cir.array<!rec_DefaultOperators x 5>> reduction_operator <iand> init { -// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!rec_DefaultOperators x 5>>{{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty{{.*}})) -// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !cir.array<!rec_DefaultOperators x 5>, !cir.ptr<!cir.array<!rec_DefaultOperators x 5>>, ["openacc.reduction.init"] +#pragma acc parallel reduction(&:someVarArrNoFloats[2]) +// CHECK-NEXT: acc.reduction.recipe @reduction_iand__Bcnt1__ZTSA5_24DefaultOperatorsNoFloats : !cir.ptr<!cir.array<!rec_DefaultOperatorsNoFloats x 5>> reduction_operator <iand> init { +// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!rec_DefaultOperatorsNoFloats x 5>>{{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty{{.*}})) +// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !cir.array<!rec_DefaultOperatorsNoFloats x 5>, !cir.ptr<!cir.array<!rec_DefaultOperatorsNoFloats x 5>>, ["openacc.reduction.init"] // CHECK-NEXT: cir.scope { // CHECK-NEXT: %[[LB:.*]] = acc.get_lowerbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index // CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i @@ -1152,21 +1099,15 @@ void acc_compute() { // CHECK-NEXT: cir.condition(%[[COND]]) // CHECK-NEXT: } body { // CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i -// CHECK-NEXT: %[[DECAY:.*]] = cir.cast array_to_ptrdecay %[[ALLOCA]] : !cir.ptr<!cir.array<!rec_DefaultOperators x 5>> -> !cir.ptr<!rec_DefaultOperators> -// CHECK-NEXT: %[[STRIDE:.*]] = cir.ptr_stride %[[DECAY]], %[[ITR_LOAD]] : (!cir.ptr<!rec_DefaultOperators>, !u64i) -> !cir.ptr<!rec_DefaultOperators> -// CHECK-NEXT: %[[GET_I:.*]] = cir.get_member %[[STRIDE]][0] {name = "i"} : !cir.ptr<!rec_DefaultOperators> -> !cir.ptr<!s32i> +// CHECK-NEXT: %[[DECAY:.*]] = cir.cast array_to_ptrdecay %[[ALLOCA]] : !cir.ptr<!cir.array<!rec_DefaultOperatorsNoFloats x 5>> -> !cir.ptr<!rec_DefaultOperatorsNoFloats> +// CHECK-NEXT: %[[STRIDE:.*]] = cir.ptr_stride %[[DECAY]], %[[ITR_LOAD]] : (!cir.ptr<!rec_DefaultOperatorsNoFloats>, !u64i) -> !cir.ptr<!rec_DefaultOperatorsNoFloats> +// CHECK-NEXT: %[[GET_I:.*]] = cir.get_member %[[STRIDE]][0] {name = "i"} : !cir.ptr<!rec_DefaultOperatorsNoFloats> -> !cir.ptr<!s32i> // CHECK-NEXT: %[[ALL_ONES:.*]] = cir.const #cir.int<-1> : !s32i // CHECK-NEXT: cir.store {{.*}} %[[ALL_ONES]], %[[GET_I]] : !s32i, !cir.ptr<!s32i> -// CHECK-NEXT: %[[GET_U:.*]] = cir.get_member %[[STRIDE]][1] {name = "u"} : !cir.ptr<!rec_DefaultOperators> -> !cir.ptr<!u32i> +// CHECK-NEXT: %[[GET_U:.*]] = cir.get_member %[[STRIDE]][1] {name = "u"} : !cir.ptr<!rec_DefaultOperatorsNoFloats> -> !cir.ptr<!u32i> // CHECK-NEXT: %[[ALL_ONES:.*]] = cir.const #cir.int<4294967295> : !u32i // CHECK-NEXT: cir.store {{.*}} %[[ALL_ONES]], %[[GET_U]] : !u32i, !cir.ptr<!u32i> -// CHECK-NEXT: %[[GET_F:.*]] = cir.get_member %[[STRIDE]][2] {name = "f"} : !cir.ptr<!rec_DefaultOperators> -> !cir.ptr<!cir.float> -// CHECK-NEXT: %[[ALL_ONES:.*]] = cir.const #cir.fp<0xFF{{.*}}> : !cir.float -// CHECK-NEXT: cir.store {{.*}} %[[ALL_ONES]], %[[GET_F]] : !cir.float, !cir.ptr<!cir.float> -// CHECK-NEXT: %[[GET_D:.*]] = cir.get_member %[[STRIDE]][3] {name = "d"} : !cir.ptr<!rec_DefaultOperators> -> !cir.ptr<!cir.double> -// CHECK-NEXT: %[[ALL_ONES:.*]] = cir.const #cir.fp<0xFF{{.*}}> : !cir.double -// CHECK-NEXT: cir.store {{.*}} %[[ALL_ONES]], %[[GET_D]] : !cir.double, !cir.ptr<!cir.double> -// CHECK-NEXT: %[[GET_B:.*]] = cir.get_member %[[STRIDE]][4] {name = "b"} : !cir.ptr<!rec_DefaultOperators> -> !cir.ptr<!cir.bool> +// CHECK-NEXT: %[[GET_B:.*]] = cir.get_member %[[STRIDE]][2] {name = "b"} : !cir.ptr<!rec_DefaultOperatorsNoFloats> -> !cir.ptr<!cir.bool> // CHECK-NEXT: %[[ALL_ONES:.*]] = cir.const #true // CHECK-NEXT: cir.store {{.*}} %[[ALL_ONES]], %[[GET_B]] : !cir.bool, !cir.ptr<!cir.bool> // CHECK-NEXT: cir.yield @@ -1179,14 +1120,14 @@ void acc_compute() { // CHECK-NEXT: } // CHECK-NEXT: acc.yield // CHECK-NEXT: } combiner { -// CHECK-NEXT: ^bb0(%[[LHSARG:.*]]: !cir.ptr<!cir.array<!rec_DefaultOperators x 5>> {{.*}}, %[[RHSARG:.*]]: !cir.ptr<!cir.array<!rec_DefaultOperators x 5>> {{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty{{.*}})) -// CHECK-NEXT: acc.yield %[[LHSARG]] : !cir.ptr<!cir.array<!rec_DefaultOperators x 5>> +// CHECK-NEXT: ^bb0(%[[LHSARG:.*]]: !cir.ptr<!cir.array<!rec_DefaultOperatorsNoFloats x 5>> {{.*}}, %[[RHSARG:.*]]: !cir.ptr<!cir.array<!rec_DefaultOperatorsNoFloats x 5>> {{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty{{.*}})) +// CHECK-NEXT: acc.yield %[[LHSARG]] : !cir.ptr<!cir.array<!rec_DefaultOperatorsNoFloats x 5>> // CHECK-NEXT: } ; -#pragma acc parallel reduction(|:someVarArr[2]) -// CHECK-NEXT: acc.reduction.recipe @reduction_ior__Bcnt1__ZTSA5_16DefaultOperators : !cir.ptr<!cir.array<!rec_DefaultOperators x 5>> reduction_operator <ior> init { -// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!rec_DefaultOperators x 5>>{{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty{{.*}})) -// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !cir.array<!rec_DefaultOperators x 5>, !cir.ptr<!cir.array<!rec_DefaultOperators x 5>>, ["openacc.reduction.init"] +#pragma acc parallel reduction(|:someVarArrNoFloats[2]) +// CHECK-NEXT: acc.reduction.recipe @reduction_ior__Bcnt1__ZTSA5_24DefaultOperatorsNoFloats : !cir.ptr<!cir.array<!rec_DefaultOperatorsNoFloats x 5>> reduction_operator <ior> init { +// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!rec_DefaultOperatorsNoFloats x 5>>{{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty{{.*}})) +// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !cir.array<!rec_DefaultOperatorsNoFloats x 5>, !cir.ptr<!cir.array<!rec_DefaultOperatorsNoFloats x 5>>, ["openacc.reduction.init"] // CHECK-NEXT: cir.scope { // CHECK-NEXT: %[[LB:.*]] = acc.get_lowerbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index // CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i @@ -1200,21 +1141,15 @@ void acc_compute() { // CHECK-NEXT: cir.condition(%[[COND]]) // CHECK-NEXT: } body { // CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i -// CHECK-NEXT: %[[DECAY:.*]] = cir.cast array_to_ptrdecay %[[ALLOCA]] : !cir.ptr<!cir.array<!rec_DefaultOperators x 5>> -> !cir.ptr<!rec_DefaultOperators> -// CHECK-NEXT: %[[STRIDE:.*]] = cir.ptr_stride %[[DECAY]], %[[ITR_LOAD]] : (!cir.ptr<!rec_DefaultOperators>, !u64i) -> !cir.ptr<!rec_DefaultOperators> -// CHECK-NEXT: %[[GET_I:.*]] = cir.get_member %[[STRIDE]][0] {name = "i"} : !cir.ptr<!rec_DefaultOperators> -> !cir.ptr<!s32i> +// CHECK-NEXT: %[[DECAY:.*]] = cir.cast array_to_ptrdecay %[[ALLOCA]] : !cir.ptr<!cir.array<!rec_DefaultOperatorsNoFloats x 5>> -> !cir.ptr<!rec_DefaultOperatorsNoFloats> +// CHECK-NEXT: %[[STRIDE:.*]] = cir.ptr_stride %[[DECAY]], %[[ITR_LOAD]] : (!cir.ptr<!rec_DefaultOperatorsNoFloats>, !u64i) -> !cir.ptr<!rec_DefaultOperatorsNoFloats> +// CHECK-NEXT: %[[GET_I:.*]] = cir.get_member %[[STRIDE]][0] {name = "i"} : !cir.ptr<!rec_DefaultOperatorsNoFloats> -> !cir.ptr<!s32i> // CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !s32i // CHECK-NEXT: cir.store {{.*}} %[[ZERO]], %[[GET_I]] : !s32i, !cir.ptr<!s32i> -// CHECK-NEXT: %[[GET_U:.*]] = cir.get_member %[[STRIDE]][1] {name = "u"} : !cir.ptr<!rec_DefaultOperators> -> !cir.ptr<!u32i> +// CHECK-NEXT: %[[GET_U:.*]] = cir.get_member %[[STRIDE]][1] {name = "u"} : !cir.ptr<!rec_DefaultOperatorsNoFloats> -> !cir.ptr<!u32i> // CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !u32i // CHECK-NEXT: cir.store {{.*}} %[[ZERO]], %[[GET_U]] : !u32i, !cir.ptr<!u32i> -// CHECK-NEXT: %[[GET_F:.*]] = cir.get_member %[[STRIDE]][2] {name = "f"} : !cir.ptr<!rec_DefaultOperators> -> !cir.ptr<!cir.float> -// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.fp<0{{.*}}> : !cir.float -// CHECK-NEXT: cir.store {{.*}} %[[ZERO]], %[[GET_F]] : !cir.float, !cir.ptr<!cir.float> -// CHECK-NEXT: %[[GET_D:.*]] = cir.get_member %[[STRIDE]][3] {name = "d"} : !cir.ptr<!rec_DefaultOperators> -> !cir.ptr<!cir.double> -// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.fp<0{{.*}}> : !cir.double -// CHECK-NEXT: cir.store {{.*}} %[[ZERO]], %[[GET_D]] : !cir.double, !cir.ptr<!cir.double> -// CHECK-NEXT: %[[GET_B:.*]] = cir.get_member %[[STRIDE]][4] {name = "b"} : !cir.ptr<!rec_DefaultOperators> -> !cir.ptr<!cir.bool> +// CHECK-NEXT: %[[GET_B:.*]] = cir.get_member %[[STRIDE]][2] {name = "b"} : !cir.ptr<!rec_DefaultOperatorsNoFloats> -> !cir.ptr<!cir.bool> // CHECK-NEXT: %[[ZERO:.*]] = cir.const #false // CHECK-NEXT: cir.store {{.*}} %[[ZERO]], %[[GET_B]] : !cir.bool, !cir.ptr<!cir.bool> // CHECK-NEXT: cir.yield @@ -1227,14 +1162,14 @@ void acc_compute() { // CHECK-NEXT: } // CHECK-NEXT: acc.yield // CHECK-NEXT: } combiner { -// CHECK-NEXT: ^bb0(%[[LHSARG:.*]]: !cir.ptr<!cir.array<!rec_DefaultOperators x 5>> {{.*}}, %[[RHSARG:.*]]: !cir.ptr<!cir.array<!rec_DefaultOperators x 5>> {{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty{{.*}})) -// CHECK-NEXT: acc.yield %[[LHSARG]] : !cir.ptr<!cir.array<!rec_DefaultOperators x 5>> +// CHECK-NEXT: ^bb0(%[[LHSARG:.*]]: !cir.ptr<!cir.array<!rec_DefaultOperatorsNoFloats x 5>> {{.*}}, %[[RHSARG:.*]]: !cir.ptr<!cir.array<!rec_DefaultOperatorsNoFloats x 5>> {{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty{{.*}})) +// CHECK-NEXT: acc.yield %[[LHSARG]] : !cir.ptr<!cir.array<!rec_DefaultOperatorsNoFloats x 5>> // CHECK-NEXT: } ; -#pragma acc parallel reduction(^:someVarArr[2]) -// CHECK-NEXT: acc.reduction.recipe @reduction_xor__Bcnt1__ZTSA5_16DefaultOperators : !cir.ptr<!cir.array<!rec_DefaultOperators x 5>> reduction_operator <xor> init { -// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!rec_DefaultOperators x 5>>{{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty{{.*}})) -// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !cir.array<!rec_DefaultOperators x 5>, !cir.ptr<!cir.array<!rec_DefaultOperators x 5>>, ["openacc.reduction.init"] +#pragma acc parallel reduction(^:someVarArrNoFloats[2]) +// CHECK-NEXT: acc.reduction.recipe @reduction_xor__Bcnt1__ZTSA5_24DefaultOperatorsNoFloats : !cir.ptr<!cir.array<!rec_DefaultOperatorsNoFloats x 5>> reduction_operator <xor> init { +// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!rec_DefaultOperatorsNoFloats x 5>>{{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty{{.*}})) +// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !cir.array<!rec_DefaultOperatorsNoFloats x 5>, !cir.ptr<!cir.array<!rec_DefaultOperatorsNoFloats x 5>>, ["openacc.reduction.init"] // CHECK-NEXT: cir.scope { // CHECK-NEXT: %[[LB:.*]] = acc.get_lowerbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index // CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i @@ -1248,21 +1183,15 @@ void acc_compute() { // CHECK-NEXT: cir.condition(%[[COND]]) // CHECK-NEXT: } body { // CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i -// CHECK-NEXT: %[[DECAY:.*]] = cir.cast array_to_ptrdecay %[[ALLOCA]] : !cir.ptr<!cir.array<!rec_DefaultOperators x 5>> -> !cir.ptr<!rec_DefaultOperators> -// CHECK-NEXT: %[[STRIDE:.*]] = cir.ptr_stride %[[DECAY]], %[[ITR_LOAD]] : (!cir.ptr<!rec_DefaultOperators>, !u64i) -> !cir.ptr<!rec_DefaultOperators> -// CHECK-NEXT: %[[GET_I:.*]] = cir.get_member %[[STRIDE]][0] {name = "i"} : !cir.ptr<!rec_DefaultOperators> -> !cir.ptr<!s32i> +// CHECK-NEXT: %[[DECAY:.*]] = cir.cast array_to_ptrdecay %[[ALLOCA]] : !cir.ptr<!cir.array<!rec_DefaultOperatorsNoFloats x 5>> -> !cir.ptr<!rec_DefaultOperatorsNoFloats> +// CHECK-NEXT: %[[STRIDE:.*]] = cir.ptr_stride %[[DECAY]], %[[ITR_LOAD]] : (!cir.ptr<!rec_DefaultOperatorsNoFloats>, !u64i) -> !cir.ptr<!rec_DefaultOperatorsNoFloats> +// CHECK-NEXT: %[[GET_I:.*]] = cir.get_member %[[STRIDE]][0] {name = "i"} : !cir.ptr<!rec_DefaultOperatorsNoFloats> -> !cir.ptr<!s32i> // CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !s32i // CHECK-NEXT: cir.store {{.*}} %[[ZERO]], %[[GET_I]] : !s32i, !cir.ptr<!s32i> -// CHECK-NEXT: %[[GET_U:.*]] = cir.get_member %[[STRIDE]][1] {name = "u"} : !cir.ptr<!rec_DefaultOperators> -> !cir.ptr<!u32i> +// CHECK-NEXT: %[[GET_U:.*]] = cir.get_member %[[STRIDE]][1] {name = "u"} : !cir.ptr<!rec_DefaultOperatorsNoFloats> -> !cir.ptr<!u32i> // CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !u32i // CHECK-NEXT: cir.store {{.*}} %[[ZERO]], %[[GET_U]] : !u32i, !cir.ptr<!u32i> -// CHECK-NEXT: %[[GET_F:.*]] = cir.get_member %[[STRIDE]][2] {name = "f"} : !cir.ptr<!rec_DefaultOperators> -> !cir.ptr<!cir.float> -// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.fp<0{{.*}}> : !cir.float -// CHECK-NEXT: cir.store {{.*}} %[[ZERO]], %[[GET_F]] : !cir.float, !cir.ptr<!cir.float> -// CHECK-NEXT: %[[GET_D:.*]] = cir.get_member %[[STRIDE]][3] {name = "d"} : !cir.ptr<!rec_DefaultOperators> -> !cir.ptr<!cir.double> -// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.fp<0{{.*}}> : !cir.double -// CHECK-NEXT: cir.store {{.*}} %[[ZERO]], %[[GET_D]] : !cir.double, !cir.ptr<!cir.double> -// CHECK-NEXT: %[[GET_B:.*]] = cir.get_member %[[STRIDE]][4] {name = "b"} : !cir.ptr<!rec_DefaultOperators> -> !cir.ptr<!cir.bool> +// CHECK-NEXT: %[[GET_B:.*]] = cir.get_member %[[STRIDE]][2] {name = "b"} : !cir.ptr<!rec_DefaultOperatorsNoFloats> -> !cir.ptr<!cir.bool> // CHECK-NEXT: %[[ZERO:.*]] = cir.const #false // CHECK-NEXT: cir.store {{.*}} %[[ZERO]], %[[GET_B]] : !cir.bool, !cir.ptr<!cir.bool> // CHECK-NEXT: cir.yield @@ -1275,8 +1204,8 @@ void acc_compute() { // CHECK-NEXT: } // CHECK-NEXT: acc.yield // CHECK-NEXT: } combiner { -// CHECK-NEXT: ^bb0(%[[LHSARG:.*]]: !cir.ptr<!cir.array<!rec_DefaultOperators x 5>> {{.*}}, %[[RHSARG:.*]]: !cir.ptr<!cir.array<!rec_DefaultOperators x 5>> {{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty{{.*}})) -// CHECK-NEXT: acc.yield %[[LHSARG]] : !cir.ptr<!cir.array<!rec_DefaultOperators x 5>> +// CHECK-NEXT: ^bb0(%[[LHSARG:.*]]: !cir.ptr<!cir.array<!rec_DefaultOperatorsNoFloats x 5>> {{.*}}, %[[RHSARG:.*]]: !cir.ptr<!cir.array<!rec_DefaultOperatorsNoFloats x 5>> {{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty{{.*}})) +// CHECK-NEXT: acc.yield %[[LHSARG]] : !cir.ptr<!cir.array<!rec_DefaultOperatorsNoFloats x 5>> // CHECK-NEXT: } ; #pragma acc parallel reduction(&&:someVarArr[2]) @@ -1384,11 +1313,11 @@ void acc_compute() { ; #pragma acc parallel reduction(min:someVarArr[1:1]) ; -#pragma acc parallel reduction(&:someVarArr[1:1]) +#pragma acc parallel reduction(&:someVarArrNoFloats[1:1]) ; -#pragma acc parallel reduction(|:someVarArr[1:1]) +#pragma acc parallel reduction(|:someVarArrNoFloats[1:1]) ; -#pragma acc parallel reduction(^:someVarArr[1:1]) +#pragma acc parallel reduction(^:someVarArrNoFloats[1:1]) ; #pragma acc parallel reduction(&&:someVarArr[1:1]) ; diff --git a/clang/test/CIR/CodeGenOpenACC/compute-reduction-clause-float.c b/clang/test/CIR/CodeGenOpenACC/compute-reduction-clause-float.c index 1b969ac..0f7fd84 100644 --- a/clang/test/CIR/CodeGenOpenACC/compute-reduction-clause-float.c +++ b/clang/test/CIR/CodeGenOpenACC/compute-reduction-clause-float.c @@ -56,48 +56,6 @@ void acc_compute() { // CHECK-NEXT: acc.yield %[[LHSARG]] : !cir.ptr<!cir.float> // CHECK-NEXT: } ; -#pragma acc parallel reduction(&:someVar) -// CHECK-NEXT: acc.reduction.recipe @reduction_iand__ZTSf : !cir.ptr<!cir.float> reduction_operator <iand> init { -// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.float>{{.*}}) -// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !cir.float, !cir.ptr<!cir.float>, ["openacc.reduction.init", init] -// CHECK-NEXT: %[[ALL_ONES:.*]] = cir.const #cir.fp<0xF{{.*}}> : !cir.float -// CHECK-NEXT: cir.store {{.*}} %[[ALL_ONES]], %[[ALLOCA]] : !cir.float, !cir.ptr<!cir.float> -// CHECK-NEXT: acc.yield -// CHECK-NEXT: } combiner { -// CHECK-NEXT: ^bb0(%[[LHSARG:.*]]: !cir.ptr<!cir.float> {{.*}}, %[[RHSARG:.*]]: !cir.ptr<!cir.float> {{.*}}) -// TODO OpenACC: Expecting combination operation here -// CHECK-NEXT: acc.yield %[[LHSARG]] : !cir.ptr<!cir.float> -// CHECK-NEXT: } - ; -#pragma acc parallel reduction(|:someVar) - -// CHECK-NEXT: acc.reduction.recipe @reduction_ior__ZTSf : !cir.ptr<!cir.float> reduction_operator <ior> init { -// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.float>{{.*}}) -// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !cir.float, !cir.ptr<!cir.float>, ["openacc.reduction.init", init] -// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.fp<0{{.*}}> : !cir.float -// CHECK-NEXT: cir.store {{.*}} %[[ZERO]], %[[ALLOCA]] : !cir.float, !cir.ptr<!cir.float> -// CHECK-NEXT: acc.yield -// -// CHECK-NEXT: } combiner { -// CHECK-NEXT: ^bb0(%[[LHSARG:.*]]: !cir.ptr<!cir.float> {{.*}}, %[[RHSARG:.*]]: !cir.ptr<!cir.float> {{.*}}) -// TODO OpenACC: Expecting combination operation here -// CHECK-NEXT: acc.yield %[[LHSARG]] : !cir.ptr<!cir.float> -// CHECK-NEXT: } - ; -#pragma acc parallel reduction(^:someVar) -// CHECK-NEXT: acc.reduction.recipe @reduction_xor__ZTSf : !cir.ptr<!cir.float> reduction_operator <xor> init { -// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.float>{{.*}}) -// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !cir.float, !cir.ptr<!cir.float>, ["openacc.reduction.init", init] -// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.fp<0{{.*}}> : !cir.float -// CHECK-NEXT: cir.store {{.*}} %[[ZERO]], %[[ALLOCA]] : !cir.float, !cir.ptr<!cir.float> -// CHECK-NEXT: acc.yield -// -// CHECK-NEXT: } combiner { -// CHECK-NEXT: ^bb0(%[[LHSARG:.*]]: !cir.ptr<!cir.float> {{.*}}, %[[RHSARG:.*]]: !cir.ptr<!cir.float> {{.*}}) -// TODO OpenACC: Expecting combination operation here -// CHECK-NEXT: acc.yield %[[LHSARG]] : !cir.ptr<!cir.float> -// CHECK-NEXT: } - ; #pragma acc parallel reduction(&&:someVar) // CHECK-NEXT: acc.reduction.recipe @reduction_land__ZTSf : !cir.ptr<!cir.float> reduction_operator <land> init { // CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.float>{{.*}}) @@ -249,97 +207,6 @@ void acc_compute() { // CHECK-NEXT: acc.yield %[[LHSARG]] : !cir.ptr<!cir.array<!cir.float x 5>> // CHECK-NEXT: } ; -#pragma acc parallel reduction(&:someVarArr) -// CHECK-NEXT: acc.reduction.recipe @reduction_iand__ZTSA5_f : !cir.ptr<!cir.array<!cir.float x 5>> reduction_operator <iand> init { -// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!cir.float x 5>>{{.*}}) -// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !cir.array<!cir.float x 5>, !cir.ptr<!cir.array<!cir.float x 5>>, ["openacc.reduction.init", init] -// CHECK-NEXT: %[[DECAY:.*]] = cir.cast array_to_ptrdecay %[[ALLOCA]] : !cir.ptr<!cir.array<!cir.float x 5>> -> !cir.ptr<!cir.float> -// CHECK-NEXT: %[[ALL_ONES:.*]] = cir.const #cir.fp<0xF{{.*}}> : !cir.float -// CHECK-NEXT: cir.store{{.*}} %[[ALL_ONES]], %[[DECAY]] : !cir.float, !cir.ptr<!cir.float> -// CHECK-NEXT: %[[ONE_IDX:.*]] = cir.const #cir.int<1> : !s64i -// CHECK-NEXT: %[[NEXT_ELT:.*]] = cir.ptr_stride %[[DECAY]], %[[ONE_IDX]] : (!cir.ptr<!cir.float>, !s64i) -> !cir.ptr<!cir.float> -// CHECK-NEXT: %[[ALL_ONES:.*]] = cir.const #cir.fp<0xF{{.*}}> : !cir.float -// CHECK-NEXT: cir.store{{.*}} %[[ALL_ONES]], %[[NEXT_ELT]] : !cir.float, !cir.ptr<!cir.float> -// CHECK-NEXT: %[[TWO_IDX:.*]] = cir.const #cir.int<2> : !s64i -// CHECK-NEXT: %[[NEXT_ELT:.*]] = cir.ptr_stride %[[DECAY]], %[[TWO_IDX]] : (!cir.ptr<!cir.float>, !s64i) -> !cir.ptr<!cir.float> -// CHECK-NEXT: %[[ALL_ONES:.*]] = cir.const #cir.fp<0xF{{.*}}> : !cir.float -// CHECK-NEXT: cir.store{{.*}} %[[ALL_ONES]], %[[NEXT_ELT]] : !cir.float, !cir.ptr<!cir.float> -// CHECK-NEXT: %[[THREE_IDX:.*]] = cir.const #cir.int<3> : !s64i -// CHECK-NEXT: %[[NEXT_ELT:.*]] = cir.ptr_stride %[[DECAY]], %[[THREE_IDX]] : (!cir.ptr<!cir.float>, !s64i) -> !cir.ptr<!cir.float> -// CHECK-NEXT: %[[ALL_ONES:.*]] = cir.const #cir.fp<0xF{{.*}}> : !cir.float -// CHECK-NEXT: cir.store{{.*}} %[[ALL_ONES]], %[[NEXT_ELT]] : !cir.float, !cir.ptr<!cir.float> -// CHECK-NEXT: %[[FOUR_IDX:.*]] = cir.const #cir.int<4> : !s64i -// CHECK-NEXT: %[[NEXT_ELT:.*]] = cir.ptr_stride %[[DECAY]], %[[FOUR_IDX]] : (!cir.ptr<!cir.float>, !s64i) -> !cir.ptr<!cir.float> -// CHECK-NEXT: %[[ALL_ONES:.*]] = cir.const #cir.fp<0xF{{.*}}> : !cir.float -// CHECK-NEXT: cir.store{{.*}} %[[ALL_ONES]], %[[NEXT_ELT]] : !cir.float, !cir.ptr<!cir.float> -// CHECK-NEXT: acc.yield -// -// CHECK-NEXT: } combiner { -// CHECK-NEXT: ^bb0(%[[LHSARG:.*]]: !cir.ptr<!cir.array<!cir.float x 5>> {{.*}}, %[[RHSARG:.*]]: !cir.ptr<!cir.array<!cir.float x 5>> {{.*}}) -// TODO OpenACC: Expecting combination operation here -// CHECK-NEXT: acc.yield %[[LHSARG]] : !cir.ptr<!cir.array<!cir.float x 5>> -// CHECK-NEXT: } - ; -#pragma acc parallel reduction(|:someVarArr) -// CHECK-NEXT: acc.reduction.recipe @reduction_ior__ZTSA5_f : !cir.ptr<!cir.array<!cir.float x 5>> reduction_operator <ior> init { -// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!cir.float x 5>>{{.*}}) -// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !cir.array<!cir.float x 5>, !cir.ptr<!cir.array<!cir.float x 5>>, ["openacc.reduction.init", init] -// CHECK-NEXT: %[[TEMP_ITR:.*]] = cir.alloca !cir.ptr<!cir.float>, !cir.ptr<!cir.ptr<!cir.float>>, ["arrayinit.temp"] -// CHECK-NEXT: %[[DECAY:.*]] = cir.cast array_to_ptrdecay %[[ALLOCA]] : !cir.ptr<!cir.array<!cir.float x 5>> -> !cir.ptr<!cir.float> -// CHECK-NEXT: cir.store {{.*}} %[[DECAY]], %[[TEMP_ITR]] : !cir.ptr<!cir.float>, !cir.ptr<!cir.ptr<!cir.float>> -// CHECK-NEXT: %[[LAST_IDX:.*]] = cir.const #cir.int<5> : !s64i -// CHECK-NEXT: %[[END_ITR:.*]] = cir.ptr_stride %[[DECAY]], %[[LAST_IDX]] : (!cir.ptr<!cir.float>, !s64i) -> !cir.ptr<!cir.float> -// CHECK-NEXT: cir.do { -// CHECK-NEXT: %[[TEMP_LOAD:.*]] = cir.load {{.*}} %[[TEMP_ITR]] : !cir.ptr<!cir.ptr<!cir.float>>, !cir.ptr<!cir.float> -// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.fp<0{{.*}}> : !cir.float -// CHECK-NEXT: cir.store {{.*}} %[[ZERO]], %[[TEMP_LOAD]] : !cir.float, !cir.ptr<!cir.float> -// CHECK-NEXT: %[[ONE:.*]] = cir.const #cir.int<1> : !s64i -// CHECK-NEXT: %[[NEXT_ITEM:.*]] = cir.ptr_stride %[[TEMP_LOAD]], %[[ONE]] : (!cir.ptr<!cir.float>, !s64i) -> !cir.ptr<!cir.float> -// CHECK-NEXT: cir.store {{.*}} %[[NEXT_ITEM]], %[[TEMP_ITR]] : !cir.ptr<!cir.float>, !cir.ptr<!cir.ptr<!cir.float>> -// CHECK-NEXT: cir.yield -// CHECK-NEXT: } while { -// CHECK-NEXT: %[[TEMP_LOAD:.*]] = cir.load {{.*}} %[[TEMP_ITR]] : !cir.ptr<!cir.ptr<!cir.float>>, !cir.ptr<!cir.float> -// CHECK-NEXT: %[[CMP:.*]] = cir.cmp(ne, %[[TEMP_LOAD]], %[[END_ITR]]) : !cir.ptr<!cir.float>, !cir.bool -// CHECK-NEXT: cir.condition(%[[CMP]]) -// CHECK-NEXT: } -// CHECK-NEXT: acc.yield -// -// CHECK-NEXT: } combiner { -// CHECK-NEXT: ^bb0(%[[LHSARG:.*]]: !cir.ptr<!cir.array<!cir.float x 5>> {{.*}}, %[[RHSARG:.*]]: !cir.ptr<!cir.array<!cir.float x 5>> {{.*}}) -// TODO OpenACC: Expecting combination operation here -// CHECK-NEXT: acc.yield %[[LHSARG]] : !cir.ptr<!cir.array<!cir.float x 5>> -// CHECK-NEXT: } - ; -#pragma acc parallel reduction(^:someVarArr) -// CHECK-NEXT: acc.reduction.recipe @reduction_xor__ZTSA5_f : !cir.ptr<!cir.array<!cir.float x 5>> reduction_operator <xor> init { -// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!cir.float x 5>>{{.*}}) -// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !cir.array<!cir.float x 5>, !cir.ptr<!cir.array<!cir.float x 5>>, ["openacc.reduction.init", init] -// CHECK-NEXT: %[[TEMP_ITR:.*]] = cir.alloca !cir.ptr<!cir.float>, !cir.ptr<!cir.ptr<!cir.float>>, ["arrayinit.temp"] -// CHECK-NEXT: %[[DECAY:.*]] = cir.cast array_to_ptrdecay %[[ALLOCA]] : !cir.ptr<!cir.array<!cir.float x 5>> -> !cir.ptr<!cir.float> -// CHECK-NEXT: cir.store {{.*}} %[[DECAY]], %[[TEMP_ITR]] : !cir.ptr<!cir.float>, !cir.ptr<!cir.ptr<!cir.float>> -// CHECK-NEXT: %[[LAST_IDX:.*]] = cir.const #cir.int<5> : !s64i -// CHECK-NEXT: %[[END_ITR:.*]] = cir.ptr_stride %[[DECAY]], %[[LAST_IDX]] : (!cir.ptr<!cir.float>, !s64i) -> !cir.ptr<!cir.float> -// CHECK-NEXT: cir.do { -// CHECK-NEXT: %[[TEMP_LOAD:.*]] = cir.load {{.*}} %[[TEMP_ITR]] : !cir.ptr<!cir.ptr<!cir.float>>, !cir.ptr<!cir.float> -// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.fp<0{{.*}}> : !cir.float -// CHECK-NEXT: cir.store {{.*}} %[[ZERO]], %[[TEMP_LOAD]] : !cir.float, !cir.ptr<!cir.float> -// CHECK-NEXT: %[[ONE:.*]] = cir.const #cir.int<1> : !s64i -// CHECK-NEXT: %[[NEXT_ITEM:.*]] = cir.ptr_stride %[[TEMP_LOAD]], %[[ONE]] : (!cir.ptr<!cir.float>, !s64i) -> !cir.ptr<!cir.float> -// CHECK-NEXT: cir.store {{.*}} %[[NEXT_ITEM]], %[[TEMP_ITR]] : !cir.ptr<!cir.float>, !cir.ptr<!cir.ptr<!cir.float>> -// CHECK-NEXT: cir.yield -// CHECK-NEXT: } while { -// CHECK-NEXT: %[[TEMP_LOAD:.*]] = cir.load {{.*}} %[[TEMP_ITR]] : !cir.ptr<!cir.ptr<!cir.float>>, !cir.ptr<!cir.float> -// CHECK-NEXT: %[[CMP:.*]] = cir.cmp(ne, %[[TEMP_LOAD]], %[[END_ITR]]) : !cir.ptr<!cir.float>, !cir.bool -// CHECK-NEXT: cir.condition(%[[CMP]]) -// CHECK-NEXT: } -// CHECK-NEXT: acc.yield -// -// CHECK-NEXT: } combiner { -// CHECK-NEXT: ^bb0(%[[LHSARG:.*]]: !cir.ptr<!cir.array<!cir.float x 5>> {{.*}}, %[[RHSARG:.*]]: !cir.ptr<!cir.array<!cir.float x 5>> {{.*}}) -// TODO OpenACC: Expecting combination operation here -// CHECK-NEXT: acc.yield %[[LHSARG]] : !cir.ptr<!cir.array<!cir.float x 5>> -// CHECK-NEXT: } - ; #pragma acc parallel reduction(&&:someVarArr) // CHECK-NEXT: acc.reduction.recipe @reduction_land__ZTSA5_f : !cir.ptr<!cir.array<!cir.float x 5>> reduction_operator <land> init { // CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!cir.float x 5>>{{.*}}) @@ -542,111 +409,6 @@ void acc_compute() { // CHECK-NEXT: acc.yield %[[LHSARG]] : !cir.ptr<!cir.array<!cir.float x 5>> // CHECK-NEXT: } ; -#pragma acc parallel reduction(&:someVarArr[2]) -// CHECK-NEXT: acc.reduction.recipe @reduction_iand__Bcnt1__ZTSA5_f : !cir.ptr<!cir.array<!cir.float x 5>> reduction_operator <iand> init { -// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!cir.float x 5>>{{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty{{.*}})) -// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !cir.array<!cir.float x 5>, !cir.ptr<!cir.array<!cir.float x 5>>, ["openacc.reduction.init"] -// CHECK-NEXT: cir.scope { -// CHECK-NEXT: %[[LB:.*]] = acc.get_lowerbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index -// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i -// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index -// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i -// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"] {alignment = 8 : i64} -// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i> -// CHECK-NEXT: cir.for : cond { -// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i -// CHECK-NEXT: %[[COND:.*]] = cir.cmp(lt, %[[ITR_LOAD]], %[[UB_CAST]]) : !u64i, !cir.bool -// CHECK-NEXT: cir.condition(%[[COND]]) -// CHECK-NEXT: } body { -// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i -// CHECK-NEXT: %[[DECAY:.*]] = cir.cast array_to_ptrdecay %[[ALLOCA]] : !cir.ptr<!cir.array<!cir.float x 5>> -> !cir.ptr<!cir.float> -// CHECK-NEXT: %[[STRIDE:.*]] = cir.ptr_stride %[[DECAY]], %[[ITR_LOAD]] : (!cir.ptr<!cir.float>, !u64i) -> !cir.ptr<!cir.float> -// CHECK-NEXT: %[[ALL_ONES:.*]] = cir.const #cir.fp<0xF{{.*}}> : !cir.float -// CHECK-NEXT: cir.store{{.*}} %[[ALL_ONES]], %[[STRIDE]] : !cir.float, !cir.ptr<!cir.float> -// CHECK-NEXT: cir.yield -// CHECK-NEXT: } step { -// CHECK-NEXT: %[[ITR_LOAD]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i -// CHECK-NEXT: %[[INC:.*]] = cir.unary(inc, %[[ITR_LOAD]]) : !u64i, !u64i -// CHECK-NEXT: cir.store %[[INC]], %[[ITR]] : !u64i, !cir.ptr<!u64i> -// CHECK-NEXT: cir.yield -// CHECK-NEXT: } -// CHECK-NEXT: } -// CHECK-NEXT: acc.yield -// CHECK-NEXT: } combiner { -// CHECK-NEXT: ^bb0(%[[LHSARG:.*]]: !cir.ptr<!cir.array<!cir.float x 5>> {{.*}}, %[[RHSARG:.*]]: !cir.ptr<!cir.array<!cir.float x 5>> {{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty{{.*}})) -// CHECK-NEXT: acc.yield %[[LHSARG]] : !cir.ptr<!cir.array<!cir.float x 5>> -// CHECK-NEXT: } - ; -#pragma acc parallel reduction(|:someVarArr[2]) -// CHECK-NEXT: acc.reduction.recipe @reduction_ior__Bcnt1__ZTSA5_f : !cir.ptr<!cir.array<!cir.float x 5>> reduction_operator <ior> init { -// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!cir.float x 5>>{{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty{{.*}})) -// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !cir.array<!cir.float x 5>, !cir.ptr<!cir.array<!cir.float x 5>>, ["openacc.reduction.init"] -// CHECK-NEXT: cir.scope { -// CHECK-NEXT: %[[LB:.*]] = acc.get_lowerbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index -// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i -// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index -// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i -// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"] {alignment = 8 : i64} -// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i> -// CHECK-NEXT: cir.for : cond { -// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i -// CHECK-NEXT: %[[COND:.*]] = cir.cmp(lt, %[[ITR_LOAD]], %[[UB_CAST]]) : !u64i, !cir.bool -// CHECK-NEXT: cir.condition(%[[COND]]) -// CHECK-NEXT: } body { -// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i -// CHECK-NEXT: %[[DECAY:.*]] = cir.cast array_to_ptrdecay %[[ALLOCA]] : !cir.ptr<!cir.array<!cir.float x 5>> -> !cir.ptr<!cir.float> -// CHECK-NEXT: %[[STRIDE:.*]] = cir.ptr_stride %[[DECAY]], %[[ITR_LOAD]] : (!cir.ptr<!cir.float>, !u64i) -> !cir.ptr<!cir.float> -// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.fp<0{{.*}}> : !cir.float -// CHECK-NEXT: cir.store{{.*}} %[[ZERO]], %[[STRIDE]] : !cir.float, !cir.ptr<!cir.float> -// CHECK-NEXT: cir.yield -// CHECK-NEXT: } step { -// CHECK-NEXT: %[[ITR_LOAD]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i -// CHECK-NEXT: %[[INC:.*]] = cir.unary(inc, %[[ITR_LOAD]]) : !u64i, !u64i -// CHECK-NEXT: cir.store %[[INC]], %[[ITR]] : !u64i, !cir.ptr<!u64i> -// CHECK-NEXT: cir.yield -// CHECK-NEXT: } -// CHECK-NEXT: } -// CHECK-NEXT: acc.yield -// CHECK-NEXT: } combiner { -// CHECK-NEXT: ^bb0(%[[LHSARG:.*]]: !cir.ptr<!cir.array<!cir.float x 5>> {{.*}}, %[[RHSARG:.*]]: !cir.ptr<!cir.array<!cir.float x 5>> {{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty{{.*}})) -// CHECK-NEXT: acc.yield %[[LHSARG]] : !cir.ptr<!cir.array<!cir.float x 5>> -// CHECK-NEXT: } - ; -#pragma acc parallel reduction(^:someVarArr[2]) -// CHECK-NEXT: acc.reduction.recipe @reduction_xor__Bcnt1__ZTSA5_f : !cir.ptr<!cir.array<!cir.float x 5>> reduction_operator <xor> init { -// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!cir.float x 5>>{{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty{{.*}})) -// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !cir.array<!cir.float x 5>, !cir.ptr<!cir.array<!cir.float x 5>>, ["openacc.reduction.init"] -// CHECK-NEXT: cir.scope { -// CHECK-NEXT: %[[LB:.*]] = acc.get_lowerbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index -// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i -// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index -// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i -// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"] {alignment = 8 : i64} -// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i> -// CHECK-NEXT: cir.for : cond { -// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i -// CHECK-NEXT: %[[COND:.*]] = cir.cmp(lt, %[[ITR_LOAD]], %[[UB_CAST]]) : !u64i, !cir.bool -// CHECK-NEXT: cir.condition(%[[COND]]) -// CHECK-NEXT: } body { -// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i -// CHECK-NEXT: %[[DECAY:.*]] = cir.cast array_to_ptrdecay %[[ALLOCA]] : !cir.ptr<!cir.array<!cir.float x 5>> -> !cir.ptr<!cir.float> -// CHECK-NEXT: %[[STRIDE:.*]] = cir.ptr_stride %[[DECAY]], %[[ITR_LOAD]] : (!cir.ptr<!cir.float>, !u64i) -> !cir.ptr<!cir.float> -// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.fp<0{{.*}}> : !cir.float -// CHECK-NEXT: cir.store{{.*}} %[[ZERO]], %[[STRIDE]] : !cir.float, !cir.ptr<!cir.float> -// CHECK-NEXT: cir.yield -// CHECK-NEXT: } step { -// CHECK-NEXT: %[[ITR_LOAD]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i -// CHECK-NEXT: %[[INC:.*]] = cir.unary(inc, %[[ITR_LOAD]]) : !u64i, !u64i -// CHECK-NEXT: cir.store %[[INC]], %[[ITR]] : !u64i, !cir.ptr<!u64i> -// CHECK-NEXT: cir.yield -// CHECK-NEXT: } -// CHECK-NEXT: } -// CHECK-NEXT: acc.yield -// CHECK-NEXT: } combiner { -// CHECK-NEXT: ^bb0(%[[LHSARG:.*]]: !cir.ptr<!cir.array<!cir.float x 5>> {{.*}}, %[[RHSARG:.*]]: !cir.ptr<!cir.array<!cir.float x 5>> {{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty{{.*}})) -// CHECK-NEXT: acc.yield %[[LHSARG]] : !cir.ptr<!cir.array<!cir.float x 5>> -// CHECK-NEXT: } - ; #pragma acc parallel reduction(&&:someVarArr[2]) // CHECK-NEXT: acc.reduction.recipe @reduction_land__Bcnt1__ZTSA5_f : !cir.ptr<!cir.array<!cir.float x 5>> reduction_operator <land> init { // CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!cir.float x 5>>{{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty{{.*}})) @@ -726,12 +488,6 @@ void acc_compute() { ; #pragma acc parallel reduction(min:someVarArr[1:1]) ; -#pragma acc parallel reduction(&:someVarArr[1:1]) - ; -#pragma acc parallel reduction(|:someVarArr[1:1]) - ; -#pragma acc parallel reduction(^:someVarArr[1:1]) - ; #pragma acc parallel reduction(&&:someVarArr[1:1]) ; #pragma acc parallel reduction(||:someVarArr[1:1]) diff --git a/clang/test/CIR/CodeGenOpenACC/compute-reduction-clause-float.cpp b/clang/test/CIR/CodeGenOpenACC/compute-reduction-clause-float.cpp index b406bd5..4d99a43 100644 --- a/clang/test/CIR/CodeGenOpenACC/compute-reduction-clause-float.cpp +++ b/clang/test/CIR/CodeGenOpenACC/compute-reduction-clause-float.cpp @@ -58,47 +58,6 @@ void acc_compute() { // CHECK-NEXT: acc.yield %[[LHSARG]] : !cir.ptr<!cir.float> // CHECK-NEXT: } ; -#pragma acc parallel reduction(&:someVar) -// CHECK-NEXT: acc.reduction.recipe @reduction_iand__ZTSf : !cir.ptr<!cir.float> reduction_operator <iand> init { -// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.float>{{.*}}) -// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !cir.float, !cir.ptr<!cir.float>, ["openacc.reduction.init", init] -// CHECK-NEXT: %[[ALL_ONES:.*]] = cir.const #cir.fp<0xF{{.*}}> : !cir.float -// CHECK-NEXT: cir.store {{.*}} %[[ALL_ONES]], %[[ALLOCA]] : !cir.float, !cir.ptr<!cir.float> -// CHECK-NEXT: acc.yield -// CHECK-NEXT: } combiner { -// CHECK-NEXT: ^bb0(%[[LHSARG:.*]]: !cir.ptr<!cir.float> {{.*}}, %[[RHSARG:.*]]: !cir.ptr<!cir.float> {{.*}}) -// TODO OpenACC: Expecting combination operation here -// CHECK-NEXT: acc.yield %[[LHSARG]] : !cir.ptr<!cir.float> -// CHECK-NEXT: } - ; -#pragma acc parallel reduction(|:someVar) -// CHECK-NEXT: acc.reduction.recipe @reduction_ior__ZTSf : !cir.ptr<!cir.float> reduction_operator <ior> init { -// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.float>{{.*}}) -// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !cir.float, !cir.ptr<!cir.float>, ["openacc.reduction.init", init] -// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.fp<0{{.*}}> : !cir.float -// CHECK-NEXT: cir.store {{.*}} %[[ZERO]], %[[ALLOCA]] : !cir.float, !cir.ptr<!cir.float> -// CHECK-NEXT: acc.yield -// -// CHECK-NEXT: } combiner { -// CHECK-NEXT: ^bb0(%[[LHSARG:.*]]: !cir.ptr<!cir.float> {{.*}}, %[[RHSARG:.*]]: !cir.ptr<!cir.float> {{.*}}) -// TODO OpenACC: Expecting combination operation here -// CHECK-NEXT: acc.yield %[[LHSARG]] : !cir.ptr<!cir.float> -// CHECK-NEXT: } - ; -#pragma acc parallel reduction(^:someVar) -// CHECK-NEXT: acc.reduction.recipe @reduction_xor__ZTSf : !cir.ptr<!cir.float> reduction_operator <xor> init { -// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.float>{{.*}}) -// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !cir.float, !cir.ptr<!cir.float>, ["openacc.reduction.init", init] -// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.fp<0{{.*}}> : !cir.float -// CHECK-NEXT: cir.store {{.*}} %[[ZERO]], %[[ALLOCA]] : !cir.float, !cir.ptr<!cir.float> -// CHECK-NEXT: acc.yield -// -// CHECK-NEXT: } combiner { -// CHECK-NEXT: ^bb0(%[[LHSARG:.*]]: !cir.ptr<!cir.float> {{.*}}, %[[RHSARG:.*]]: !cir.ptr<!cir.float> {{.*}}) -// TODO OpenACC: Expecting combination operation here -// CHECK-NEXT: acc.yield %[[LHSARG]] : !cir.ptr<!cir.float> -// CHECK-NEXT: } - ; #pragma acc parallel reduction(&&:someVar) // CHECK-NEXT: acc.reduction.recipe @reduction_land__ZTSf : !cir.ptr<!cir.float> reduction_operator <land> init { // CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.float>{{.*}}) @@ -250,97 +209,6 @@ void acc_compute() { // CHECK-NEXT: acc.yield %[[LHSARG]] : !cir.ptr<!cir.array<!cir.float x 5>> // CHECK-NEXT: } ; -#pragma acc parallel reduction(&:someVarArr) -// CHECK-NEXT: acc.reduction.recipe @reduction_iand__ZTSA5_f : !cir.ptr<!cir.array<!cir.float x 5>> reduction_operator <iand> init { -// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!cir.float x 5>>{{.*}}) -// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !cir.array<!cir.float x 5>, !cir.ptr<!cir.array<!cir.float x 5>>, ["openacc.reduction.init", init] -// CHECK-NEXT: %[[DECAY:.*]] = cir.cast array_to_ptrdecay %[[ALLOCA]] : !cir.ptr<!cir.array<!cir.float x 5>> -> !cir.ptr<!cir.float> -// CHECK-NEXT: %[[ALL_ONES:.*]] = cir.const #cir.fp<0xF{{.*}}> : !cir.float -// CHECK-NEXT: cir.store{{.*}} %[[ALL_ONES]], %[[DECAY]] : !cir.float, !cir.ptr<!cir.float> -// CHECK-NEXT: %[[ONE_IDX:.*]] = cir.const #cir.int<1> : !s64i -// CHECK-NEXT: %[[NEXT_ELT:.*]] = cir.ptr_stride %[[DECAY]], %[[ONE_IDX]] : (!cir.ptr<!cir.float>, !s64i) -> !cir.ptr<!cir.float> -// CHECK-NEXT: %[[ALL_ONES:.*]] = cir.const #cir.fp<0xF{{.*}}> : !cir.float -// CHECK-NEXT: cir.store{{.*}} %[[ALL_ONES]], %[[NEXT_ELT]] : !cir.float, !cir.ptr<!cir.float> -// CHECK-NEXT: %[[TWO_IDX:.*]] = cir.const #cir.int<2> : !s64i -// CHECK-NEXT: %[[NEXT_ELT:.*]] = cir.ptr_stride %[[DECAY]], %[[TWO_IDX]] : (!cir.ptr<!cir.float>, !s64i) -> !cir.ptr<!cir.float> -// CHECK-NEXT: %[[ALL_ONES:.*]] = cir.const #cir.fp<0xF{{.*}}> : !cir.float -// CHECK-NEXT: cir.store{{.*}} %[[ALL_ONES]], %[[NEXT_ELT]] : !cir.float, !cir.ptr<!cir.float> -// CHECK-NEXT: %[[THREE_IDX:.*]] = cir.const #cir.int<3> : !s64i -// CHECK-NEXT: %[[NEXT_ELT:.*]] = cir.ptr_stride %[[DECAY]], %[[THREE_IDX]] : (!cir.ptr<!cir.float>, !s64i) -> !cir.ptr<!cir.float> -// CHECK-NEXT: %[[ALL_ONES:.*]] = cir.const #cir.fp<0xF{{.*}}> : !cir.float -// CHECK-NEXT: cir.store{{.*}} %[[ALL_ONES]], %[[NEXT_ELT]] : !cir.float, !cir.ptr<!cir.float> -// CHECK-NEXT: %[[FOUR_IDX:.*]] = cir.const #cir.int<4> : !s64i -// CHECK-NEXT: %[[NEXT_ELT:.*]] = cir.ptr_stride %[[DECAY]], %[[FOUR_IDX]] : (!cir.ptr<!cir.float>, !s64i) -> !cir.ptr<!cir.float> -// CHECK-NEXT: %[[ALL_ONES:.*]] = cir.const #cir.fp<0xF{{.*}}> : !cir.float -// CHECK-NEXT: cir.store{{.*}} %[[ALL_ONES]], %[[NEXT_ELT]] : !cir.float, !cir.ptr<!cir.float> -// CHECK-NEXT: acc.yield -// -// CHECK-NEXT: } combiner { -// CHECK-NEXT: ^bb0(%[[LHSARG:.*]]: !cir.ptr<!cir.array<!cir.float x 5>> {{.*}}, %[[RHSARG:.*]]: !cir.ptr<!cir.array<!cir.float x 5>> {{.*}}) -// TODO OpenACC: Expecting combination operation here -// CHECK-NEXT: acc.yield %[[LHSARG]] : !cir.ptr<!cir.array<!cir.float x 5>> -// CHECK-NEXT: } - ; -#pragma acc parallel reduction(|:someVarArr) -// CHECK-NEXT: acc.reduction.recipe @reduction_ior__ZTSA5_f : !cir.ptr<!cir.array<!cir.float x 5>> reduction_operator <ior> init { -// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!cir.float x 5>>{{.*}}) -// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !cir.array<!cir.float x 5>, !cir.ptr<!cir.array<!cir.float x 5>>, ["openacc.reduction.init", init] -// CHECK-NEXT: %[[TEMP_ITR:.*]] = cir.alloca !cir.ptr<!cir.float>, !cir.ptr<!cir.ptr<!cir.float>>, ["arrayinit.temp"] -// CHECK-NEXT: %[[DECAY:.*]] = cir.cast array_to_ptrdecay %[[ALLOCA]] : !cir.ptr<!cir.array<!cir.float x 5>> -> !cir.ptr<!cir.float> -// CHECK-NEXT: cir.store {{.*}} %[[DECAY]], %[[TEMP_ITR]] : !cir.ptr<!cir.float>, !cir.ptr<!cir.ptr<!cir.float>> -// CHECK-NEXT: %[[LAST_IDX:.*]] = cir.const #cir.int<5> : !s64i -// CHECK-NEXT: %[[END_ITR:.*]] = cir.ptr_stride %[[DECAY]], %[[LAST_IDX]] : (!cir.ptr<!cir.float>, !s64i) -> !cir.ptr<!cir.float> -// CHECK-NEXT: cir.do { -// CHECK-NEXT: %[[TEMP_LOAD:.*]] = cir.load {{.*}} %[[TEMP_ITR]] : !cir.ptr<!cir.ptr<!cir.float>>, !cir.ptr<!cir.float> -// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.fp<0{{.*}}> : !cir.float -// CHECK-NEXT: cir.store {{.*}} %[[ZERO]], %[[TEMP_LOAD]] : !cir.float, !cir.ptr<!cir.float> -// CHECK-NEXT: %[[ONE:.*]] = cir.const #cir.int<1> : !s64i -// CHECK-NEXT: %[[NEXT_ITEM:.*]] = cir.ptr_stride %[[TEMP_LOAD]], %[[ONE]] : (!cir.ptr<!cir.float>, !s64i) -> !cir.ptr<!cir.float> -// CHECK-NEXT: cir.store {{.*}} %[[NEXT_ITEM]], %[[TEMP_ITR]] : !cir.ptr<!cir.float>, !cir.ptr<!cir.ptr<!cir.float>> -// CHECK-NEXT: cir.yield -// CHECK-NEXT: } while { -// CHECK-NEXT: %[[TEMP_LOAD:.*]] = cir.load {{.*}} %[[TEMP_ITR]] : !cir.ptr<!cir.ptr<!cir.float>>, !cir.ptr<!cir.float> -// CHECK-NEXT: %[[CMP:.*]] = cir.cmp(ne, %[[TEMP_LOAD]], %[[END_ITR]]) : !cir.ptr<!cir.float>, !cir.bool -// CHECK-NEXT: cir.condition(%[[CMP]]) -// CHECK-NEXT: } -// CHECK-NEXT: acc.yield -// -// CHECK-NEXT: } combiner { -// CHECK-NEXT: ^bb0(%[[LHSARG:.*]]: !cir.ptr<!cir.array<!cir.float x 5>> {{.*}}, %[[RHSARG:.*]]: !cir.ptr<!cir.array<!cir.float x 5>> {{.*}}) -// TODO OpenACC: Expecting combination operation here -// CHECK-NEXT: acc.yield %[[LHSARG]] : !cir.ptr<!cir.array<!cir.float x 5>> -// CHECK-NEXT: } - ; -#pragma acc parallel reduction(^:someVarArr) -// CHECK-NEXT: acc.reduction.recipe @reduction_xor__ZTSA5_f : !cir.ptr<!cir.array<!cir.float x 5>> reduction_operator <xor> init { -// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!cir.float x 5>>{{.*}}) -// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !cir.array<!cir.float x 5>, !cir.ptr<!cir.array<!cir.float x 5>>, ["openacc.reduction.init", init] -// CHECK-NEXT: %[[TEMP_ITR:.*]] = cir.alloca !cir.ptr<!cir.float>, !cir.ptr<!cir.ptr<!cir.float>>, ["arrayinit.temp"] -// CHECK-NEXT: %[[DECAY:.*]] = cir.cast array_to_ptrdecay %[[ALLOCA]] : !cir.ptr<!cir.array<!cir.float x 5>> -> !cir.ptr<!cir.float> -// CHECK-NEXT: cir.store {{.*}} %[[DECAY]], %[[TEMP_ITR]] : !cir.ptr<!cir.float>, !cir.ptr<!cir.ptr<!cir.float>> -// CHECK-NEXT: %[[LAST_IDX:.*]] = cir.const #cir.int<5> : !s64i -// CHECK-NEXT: %[[END_ITR:.*]] = cir.ptr_stride %[[DECAY]], %[[LAST_IDX]] : (!cir.ptr<!cir.float>, !s64i) -> !cir.ptr<!cir.float> -// CHECK-NEXT: cir.do { -// CHECK-NEXT: %[[TEMP_LOAD:.*]] = cir.load {{.*}} %[[TEMP_ITR]] : !cir.ptr<!cir.ptr<!cir.float>>, !cir.ptr<!cir.float> -// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.fp<0{{.*}}> : !cir.float -// CHECK-NEXT: cir.store {{.*}} %[[ZERO]], %[[TEMP_LOAD]] : !cir.float, !cir.ptr<!cir.float> -// CHECK-NEXT: %[[ONE:.*]] = cir.const #cir.int<1> : !s64i -// CHECK-NEXT: %[[NEXT_ITEM:.*]] = cir.ptr_stride %[[TEMP_LOAD]], %[[ONE]] : (!cir.ptr<!cir.float>, !s64i) -> !cir.ptr<!cir.float> -// CHECK-NEXT: cir.store {{.*}} %[[NEXT_ITEM]], %[[TEMP_ITR]] : !cir.ptr<!cir.float>, !cir.ptr<!cir.ptr<!cir.float>> -// CHECK-NEXT: cir.yield -// CHECK-NEXT: } while { -// CHECK-NEXT: %[[TEMP_LOAD:.*]] = cir.load {{.*}} %[[TEMP_ITR]] : !cir.ptr<!cir.ptr<!cir.float>>, !cir.ptr<!cir.float> -// CHECK-NEXT: %[[CMP:.*]] = cir.cmp(ne, %[[TEMP_LOAD]], %[[END_ITR]]) : !cir.ptr<!cir.float>, !cir.bool -// CHECK-NEXT: cir.condition(%[[CMP]]) -// CHECK-NEXT: } -// CHECK-NEXT: acc.yield -// -// CHECK-NEXT: } combiner { -// CHECK-NEXT: ^bb0(%[[LHSARG:.*]]: !cir.ptr<!cir.array<!cir.float x 5>> {{.*}}, %[[RHSARG:.*]]: !cir.ptr<!cir.array<!cir.float x 5>> {{.*}}) -// TODO OpenACC: Expecting combination operation here -// CHECK-NEXT: acc.yield %[[LHSARG]] : !cir.ptr<!cir.array<!cir.float x 5>> -// CHECK-NEXT: } - ; #pragma acc parallel reduction(&&:someVarArr) // CHECK-NEXT: acc.reduction.recipe @reduction_land__ZTSA5_f : !cir.ptr<!cir.array<!cir.float x 5>> reduction_operator <land> init { // CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!cir.float x 5>>{{.*}}) @@ -543,111 +411,6 @@ void acc_compute() { // CHECK-NEXT: acc.yield %[[LHSARG]] : !cir.ptr<!cir.array<!cir.float x 5>> // CHECK-NEXT: } ; -#pragma acc parallel reduction(&:someVarArr[2]) -// CHECK-NEXT: acc.reduction.recipe @reduction_iand__Bcnt1__ZTSA5_f : !cir.ptr<!cir.array<!cir.float x 5>> reduction_operator <iand> init { -// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!cir.float x 5>>{{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty{{.*}})) -// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !cir.array<!cir.float x 5>, !cir.ptr<!cir.array<!cir.float x 5>>, ["openacc.reduction.init"] -// CHECK-NEXT: cir.scope { -// CHECK-NEXT: %[[LB:.*]] = acc.get_lowerbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index -// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i -// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index -// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i -// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"] {alignment = 8 : i64} -// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i> -// CHECK-NEXT: cir.for : cond { -// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i -// CHECK-NEXT: %[[COND:.*]] = cir.cmp(lt, %[[ITR_LOAD]], %[[UB_CAST]]) : !u64i, !cir.bool -// CHECK-NEXT: cir.condition(%[[COND]]) -// CHECK-NEXT: } body { -// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i -// CHECK-NEXT: %[[DECAY:.*]] = cir.cast array_to_ptrdecay %[[ALLOCA]] : !cir.ptr<!cir.array<!cir.float x 5>> -> !cir.ptr<!cir.float> -// CHECK-NEXT: %[[STRIDE:.*]] = cir.ptr_stride %[[DECAY]], %[[ITR_LOAD]] : (!cir.ptr<!cir.float>, !u64i) -> !cir.ptr<!cir.float> -// CHECK-NEXT: %[[ALL_ONES:.*]] = cir.const #cir.fp<0xF{{.*}}> : !cir.float -// CHECK-NEXT: cir.store{{.*}} %[[ALL_ONES]], %[[STRIDE]] : !cir.float, !cir.ptr<!cir.float> -// CHECK-NEXT: cir.yield -// CHECK-NEXT: } step { -// CHECK-NEXT: %[[ITR_LOAD]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i -// CHECK-NEXT: %[[INC:.*]] = cir.unary(inc, %[[ITR_LOAD]]) : !u64i, !u64i -// CHECK-NEXT: cir.store %[[INC]], %[[ITR]] : !u64i, !cir.ptr<!u64i> -// CHECK-NEXT: cir.yield -// CHECK-NEXT: } -// CHECK-NEXT: } -// CHECK-NEXT: acc.yield -// CHECK-NEXT: } combiner { -// CHECK-NEXT: ^bb0(%[[LHSARG:.*]]: !cir.ptr<!cir.array<!cir.float x 5>> {{.*}}, %[[RHSARG:.*]]: !cir.ptr<!cir.array<!cir.float x 5>> {{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty{{.*}})) -// CHECK-NEXT: acc.yield %[[LHSARG]] : !cir.ptr<!cir.array<!cir.float x 5>> -// CHECK-NEXT: } - ; -#pragma acc parallel reduction(|:someVarArr[2]) -// CHECK-NEXT: acc.reduction.recipe @reduction_ior__Bcnt1__ZTSA5_f : !cir.ptr<!cir.array<!cir.float x 5>> reduction_operator <ior> init { -// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!cir.float x 5>>{{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty{{.*}})) -// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !cir.array<!cir.float x 5>, !cir.ptr<!cir.array<!cir.float x 5>>, ["openacc.reduction.init"] -// CHECK-NEXT: cir.scope { -// CHECK-NEXT: %[[LB:.*]] = acc.get_lowerbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index -// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i -// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index -// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i -// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"] {alignment = 8 : i64} -// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i> -// CHECK-NEXT: cir.for : cond { -// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i -// CHECK-NEXT: %[[COND:.*]] = cir.cmp(lt, %[[ITR_LOAD]], %[[UB_CAST]]) : !u64i, !cir.bool -// CHECK-NEXT: cir.condition(%[[COND]]) -// CHECK-NEXT: } body { -// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i -// CHECK-NEXT: %[[DECAY:.*]] = cir.cast array_to_ptrdecay %[[ALLOCA]] : !cir.ptr<!cir.array<!cir.float x 5>> -> !cir.ptr<!cir.float> -// CHECK-NEXT: %[[STRIDE:.*]] = cir.ptr_stride %[[DECAY]], %[[ITR_LOAD]] : (!cir.ptr<!cir.float>, !u64i) -> !cir.ptr<!cir.float> -// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.fp<0{{.*}}> : !cir.float -// CHECK-NEXT: cir.store{{.*}} %[[ZERO]], %[[STRIDE]] : !cir.float, !cir.ptr<!cir.float> -// CHECK-NEXT: cir.yield -// CHECK-NEXT: } step { -// CHECK-NEXT: %[[ITR_LOAD]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i -// CHECK-NEXT: %[[INC:.*]] = cir.unary(inc, %[[ITR_LOAD]]) : !u64i, !u64i -// CHECK-NEXT: cir.store %[[INC]], %[[ITR]] : !u64i, !cir.ptr<!u64i> -// CHECK-NEXT: cir.yield -// CHECK-NEXT: } -// CHECK-NEXT: } -// CHECK-NEXT: acc.yield -// CHECK-NEXT: } combiner { -// CHECK-NEXT: ^bb0(%[[LHSARG:.*]]: !cir.ptr<!cir.array<!cir.float x 5>> {{.*}}, %[[RHSARG:.*]]: !cir.ptr<!cir.array<!cir.float x 5>> {{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty{{.*}})) -// CHECK-NEXT: acc.yield %[[LHSARG]] : !cir.ptr<!cir.array<!cir.float x 5>> -// CHECK-NEXT: } - ; -#pragma acc parallel reduction(^:someVarArr[2]) -// CHECK-NEXT: acc.reduction.recipe @reduction_xor__Bcnt1__ZTSA5_f : !cir.ptr<!cir.array<!cir.float x 5>> reduction_operator <xor> init { -// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!cir.float x 5>>{{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty{{.*}})) -// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !cir.array<!cir.float x 5>, !cir.ptr<!cir.array<!cir.float x 5>>, ["openacc.reduction.init"] -// CHECK-NEXT: cir.scope { -// CHECK-NEXT: %[[LB:.*]] = acc.get_lowerbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index -// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i -// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index -// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i -// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"] {alignment = 8 : i64} -// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i> -// CHECK-NEXT: cir.for : cond { -// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i -// CHECK-NEXT: %[[COND:.*]] = cir.cmp(lt, %[[ITR_LOAD]], %[[UB_CAST]]) : !u64i, !cir.bool -// CHECK-NEXT: cir.condition(%[[COND]]) -// CHECK-NEXT: } body { -// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i -// CHECK-NEXT: %[[DECAY:.*]] = cir.cast array_to_ptrdecay %[[ALLOCA]] : !cir.ptr<!cir.array<!cir.float x 5>> -> !cir.ptr<!cir.float> -// CHECK-NEXT: %[[STRIDE:.*]] = cir.ptr_stride %[[DECAY]], %[[ITR_LOAD]] : (!cir.ptr<!cir.float>, !u64i) -> !cir.ptr<!cir.float> -// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.fp<0{{.*}}> : !cir.float -// CHECK-NEXT: cir.store{{.*}} %[[ZERO]], %[[STRIDE]] : !cir.float, !cir.ptr<!cir.float> -// CHECK-NEXT: cir.yield -// CHECK-NEXT: } step { -// CHECK-NEXT: %[[ITR_LOAD]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i -// CHECK-NEXT: %[[INC:.*]] = cir.unary(inc, %[[ITR_LOAD]]) : !u64i, !u64i -// CHECK-NEXT: cir.store %[[INC]], %[[ITR]] : !u64i, !cir.ptr<!u64i> -// CHECK-NEXT: cir.yield -// CHECK-NEXT: } -// CHECK-NEXT: } -// CHECK-NEXT: acc.yield -// CHECK-NEXT: } combiner { -// CHECK-NEXT: ^bb0(%[[LHSARG:.*]]: !cir.ptr<!cir.array<!cir.float x 5>> {{.*}}, %[[RHSARG:.*]]: !cir.ptr<!cir.array<!cir.float x 5>> {{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty{{.*}})) -// CHECK-NEXT: acc.yield %[[LHSARG]] : !cir.ptr<!cir.array<!cir.float x 5>> -// CHECK-NEXT: } - ; #pragma acc parallel reduction(&&:someVarArr[2]) // CHECK-NEXT: acc.reduction.recipe @reduction_land__Bcnt1__ZTSA5_f : !cir.ptr<!cir.array<!cir.float x 5>> reduction_operator <land> init { // CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!cir.float x 5>>{{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty{{.*}})) @@ -727,12 +490,6 @@ void acc_compute() { ; #pragma acc parallel reduction(min:someVarArr[1:1]) ; -#pragma acc parallel reduction(&:someVarArr[1:1]) - ; -#pragma acc parallel reduction(|:someVarArr[1:1]) - ; -#pragma acc parallel reduction(^:someVarArr[1:1]) - ; #pragma acc parallel reduction(&&:someVarArr[1:1]) ; #pragma acc parallel reduction(||:someVarArr[1:1]) diff --git a/clang/test/CIR/CodeGenOpenACC/loop-reduction-clause-default-ops.cpp b/clang/test/CIR/CodeGenOpenACC/loop-reduction-clause-default-ops.cpp index 750c7b4..038afcaa 100644 --- a/clang/test/CIR/CodeGenOpenACC/loop-reduction-clause-default-ops.cpp +++ b/clang/test/CIR/CodeGenOpenACC/loop-reduction-clause-default-ops.cpp @@ -8,12 +8,19 @@ struct DefaultOperators { bool b; }; +struct DefaultOperatorsNoFloats { + int i; + unsigned int u; + bool b; +}; + template<typename T> -void acc_loop() { +void acc_combined() { T someVar; T someVarArr[5]; + struct DefaultOperatorsNoFloats someVarNoFloats; + struct DefaultOperatorsNoFloats someVarArrNoFloats[5]; #pragma acc loop reduction(+:someVar) - for(int i=0;i < 5; ++i); // CHECK: acc.reduction.recipe @reduction_add__ZTS16DefaultOperators : !cir.ptr<!rec_DefaultOperators> reduction_operator <add> init { // CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!rec_DefaultOperators>{{.*}}) // CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !rec_DefaultOperators, !cir.ptr<!rec_DefaultOperators>, ["openacc.reduction.init", init] @@ -39,6 +46,7 @@ void acc_loop() { // TODO OpenACC: Expecting combination operation here // CHECK-NEXT: acc.yield %[[LHSARG]] : !cir.ptr<!rec_DefaultOperators> // CHECK-NEXT: } + for(int i=0;i < 5; ++i); #pragma acc loop reduction(*:someVar) // CHECK-NEXT: acc.reduction.recipe @reduction_mul__ZTS16DefaultOperators : !cir.ptr<!rec_DefaultOperators> reduction_operator <mul> init { @@ -121,86 +129,67 @@ void acc_loop() { // CHECK-NEXT: acc.yield %[[LHSARG]] : !cir.ptr<!rec_DefaultOperators> // CHECK-NEXT: } for(int i=0;i < 5; ++i); -#pragma acc loop reduction(&:someVar) - -// CHECK-NEXT: acc.reduction.recipe @reduction_iand__ZTS16DefaultOperators : !cir.ptr<!rec_DefaultOperators> reduction_operator <iand> init { -// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!rec_DefaultOperators>{{.*}}) -// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !rec_DefaultOperators, !cir.ptr<!rec_DefaultOperators>, ["openacc.reduction.init", init] -// CHECK-NEXT: %[[GET_I:.*]] = cir.get_member %[[ALLOCA]][0] {name = "i"} : !cir.ptr<!rec_DefaultOperators> -> !cir.ptr<!s32i> +#pragma acc loop reduction(&:someVarNoFloats) +// CHECK-NEXT: acc.reduction.recipe @reduction_iand__ZTS24DefaultOperatorsNoFloats : !cir.ptr<!rec_DefaultOperatorsNoFloats> reduction_operator <iand> init { +// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!rec_DefaultOperatorsNoFloats>{{.*}}) +// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !rec_DefaultOperatorsNoFloats, !cir.ptr<!rec_DefaultOperatorsNoFloats>, ["openacc.reduction.init", init] +// CHECK-NEXT: %[[GET_I:.*]] = cir.get_member %[[ALLOCA]][0] {name = "i"} : !cir.ptr<!rec_DefaultOperatorsNoFloats> -> !cir.ptr<!s32i> // CHECK-NEXT: %[[ALL_ONES:.*]] = cir.const #cir.int<-1> : !s32i // CHECK-NEXT: cir.store {{.*}} %[[ALL_ONES]], %[[GET_I]] : !s32i, !cir.ptr<!s32i> -// CHECK-NEXT: %[[GET_U:.*]] = cir.get_member %[[ALLOCA]][1] {name = "u"} : !cir.ptr<!rec_DefaultOperators> -> !cir.ptr<!u32i> +// CHECK-NEXT: %[[GET_U:.*]] = cir.get_member %[[ALLOCA]][1] {name = "u"} : !cir.ptr<!rec_DefaultOperatorsNoFloats> -> !cir.ptr<!u32i> // CHECK-NEXT: %[[ALL_ONES:.*]] = cir.const #cir.int<4294967295> : !u32i // CHECK-NEXT: cir.store {{.*}} %[[ALL_ONES]], %[[GET_U]] : !u32i, !cir.ptr<!u32i> -// CHECK-NEXT: %[[GET_F:.*]] = cir.get_member %[[ALLOCA]][2] {name = "f"} : !cir.ptr<!rec_DefaultOperators> -> !cir.ptr<!cir.float> -// CHECK-NEXT: %[[ALL_ONES:.*]] = cir.const #cir.fp<0xFF{{.*}}> : !cir.float -// CHECK-NEXT: cir.store {{.*}} %[[ALL_ONES]], %[[GET_F]] : !cir.float, !cir.ptr<!cir.float> -// CHECK-NEXT: %[[GET_D:.*]] = cir.get_member %[[ALLOCA]][3] {name = "d"} : !cir.ptr<!rec_DefaultOperators> -> !cir.ptr<!cir.double> -// CHECK-NEXT: %[[ALL_ONES:.*]] = cir.const #cir.fp<0xFF{{.*}}> : !cir.double -// CHECK-NEXT: cir.store {{.*}} %[[ALL_ONES]], %[[GET_D]] : !cir.double, !cir.ptr<!cir.double> -// CHECK-NEXT: %[[GET_B:.*]] = cir.get_member %[[ALLOCA]][4] {name = "b"} : !cir.ptr<!rec_DefaultOperators> -> !cir.ptr<!cir.bool> +// CHECK-NEXT: %[[GET_B:.*]] = cir.get_member %[[ALLOCA]][2] {name = "b"} : !cir.ptr<!rec_DefaultOperatorsNoFloats> -> !cir.ptr<!cir.bool> // CHECK-NEXT: %[[ALL_ONES:.*]] = cir.const #true // CHECK-NEXT: cir.store {{.*}} %[[ALL_ONES]], %[[GET_B]] : !cir.bool, !cir.ptr<!cir.bool> // CHECK-NEXT: acc.yield // // CHECK-NEXT: } combiner { -// CHECK-NEXT: ^bb0(%[[LHSARG:.*]]: !cir.ptr<!rec_DefaultOperators> {{.*}}, %[[RHSARG:.*]]: !cir.ptr<!rec_DefaultOperators> {{.*}}) +// CHECK-NEXT: ^bb0(%[[LHSARG:.*]]: !cir.ptr<!rec_DefaultOperatorsNoFloats> {{.*}}, %[[RHSARG:.*]]: !cir.ptr<!rec_DefaultOperatorsNoFloats> {{.*}}) // TODO OpenACC: Expecting combination operation here -// CHECK-NEXT: acc.yield %[[LHSARG]] : !cir.ptr<!rec_DefaultOperators> +// CHECK-NEXT: acc.yield %[[LHSARG]] : !cir.ptr<!rec_DefaultOperatorsNoFloats> // CHECK-NEXT: } - for(int i=0;i < 5; ++i); -#pragma acc loop reduction(|:someVar) -// CHECK-NEXT: acc.reduction.recipe @reduction_ior__ZTS16DefaultOperators : !cir.ptr<!rec_DefaultOperators> reduction_operator <ior> init { -// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!rec_DefaultOperators>{{.*}}) -// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !rec_DefaultOperators, !cir.ptr<!rec_DefaultOperators>, ["openacc.reduction.init", init] -// CHECK-NEXT: %[[GET_I:.*]] = cir.get_member %[[ALLOCA]][0] {name = "i"} : !cir.ptr<!rec_DefaultOperators> -> !cir.ptr<!s32i> + for(int i = 0; i < 5; ++i); +#pragma acc loop reduction(|:someVarNoFloats) +// CHECK-NEXT: acc.reduction.recipe @reduction_ior__ZTS24DefaultOperatorsNoFloats : !cir.ptr<!rec_DefaultOperatorsNoFloats> reduction_operator <ior> init { +// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!rec_DefaultOperatorsNoFloats>{{.*}}) +// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !rec_DefaultOperatorsNoFloats, !cir.ptr<!rec_DefaultOperatorsNoFloats>, ["openacc.reduction.init", init] +// CHECK-NEXT: %[[GET_I:.*]] = cir.get_member %[[ALLOCA]][0] {name = "i"} : !cir.ptr<!rec_DefaultOperatorsNoFloats> -> !cir.ptr<!s32i> // CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !s32i // CHECK-NEXT: cir.store {{.*}} %[[ZERO]], %[[GET_I]] : !s32i, !cir.ptr<!s32i> -// CHECK-NEXT: %[[GET_U:.*]] = cir.get_member %[[ALLOCA]][1] {name = "u"} : !cir.ptr<!rec_DefaultOperators> -> !cir.ptr<!u32i> +// CHECK-NEXT: %[[GET_U:.*]] = cir.get_member %[[ALLOCA]][1] {name = "u"} : !cir.ptr<!rec_DefaultOperatorsNoFloats> -> !cir.ptr<!u32i> // CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !u32i // CHECK-NEXT: cir.store {{.*}} %[[ZERO]], %[[GET_U]] : !u32i, !cir.ptr<!u32i> -// CHECK-NEXT: %[[GET_F:.*]] = cir.get_member %[[ALLOCA]][2] {name = "f"} : !cir.ptr<!rec_DefaultOperators> -> !cir.ptr<!cir.float> -// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.fp<0{{.*}}> : !cir.float -// CHECK-NEXT: cir.store {{.*}} %[[ZERO]], %[[GET_F]] : !cir.float, !cir.ptr<!cir.float> -// CHECK-NEXT: %[[GET_D:.*]] = cir.get_member %[[ALLOCA]][3] {name = "d"} : !cir.ptr<!rec_DefaultOperators> -> !cir.ptr<!cir.double> -// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.fp<0{{.*}}> : !cir.double -// CHECK-NEXT: cir.store {{.*}} %[[ZERO]], %[[GET_D]] : !cir.double, !cir.ptr<!cir.double> -// CHECK-NEXT: %[[GET_B:.*]] = cir.get_member %[[ALLOCA]][4] {name = "b"} : !cir.ptr<!rec_DefaultOperators> -> !cir.ptr<!cir.bool> +// CHECK-NEXT: %[[GET_B:.*]] = cir.get_member %[[ALLOCA]][2] {name = "b"} : !cir.ptr<!rec_DefaultOperatorsNoFloats> -> !cir.ptr<!cir.bool> // CHECK-NEXT: %[[ZERO:.*]] = cir.const #false // CHECK-NEXT: cir.store {{.*}} %[[ZERO]], %[[GET_B]] : !cir.bool, !cir.ptr<!cir.bool> // CHECK-NEXT: acc.yield // // CHECK-NEXT: } combiner { -// CHECK-NEXT: ^bb0(%[[LHSARG:.*]]: !cir.ptr<!rec_DefaultOperators> {{.*}}, %[[RHSARG:.*]]: !cir.ptr<!rec_DefaultOperators> {{.*}}) +// CHECK-NEXT: ^bb0(%[[LHSARG:.*]]: !cir.ptr<!rec_DefaultOperatorsNoFloats> {{.*}}, %[[RHSARG:.*]]: !cir.ptr<!rec_DefaultOperatorsNoFloats> {{.*}}) // TODO OpenACC: Expecting combination operation here -// CHECK-NEXT: acc.yield %[[LHSARG]] : !cir.ptr<!rec_DefaultOperators> +// CHECK-NEXT: acc.yield %[[LHSARG]] : !cir.ptr<!rec_DefaultOperatorsNoFloats> // CHECK-NEXT: } - for(int i=0;i < 5; ++i); -#pragma acc loop reduction(^:someVar) -// CHECK-NEXT: acc.reduction.recipe @reduction_xor__ZTS16DefaultOperators : !cir.ptr<!rec_DefaultOperators> reduction_operator <xor> init { -// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!rec_DefaultOperators>{{.*}}) -// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !rec_DefaultOperators, !cir.ptr<!rec_DefaultOperators>, ["openacc.reduction.init", init] -// CHECK-NEXT: %[[GET_I:.*]] = cir.get_member %[[ALLOCA]][0] {name = "i"} : !cir.ptr<!rec_DefaultOperators> -> !cir.ptr<!s32i> + for(int i = 0; i < 5; ++i); +#pragma acc loop reduction(^:someVarNoFloats) +// CHECK-NEXT: acc.reduction.recipe @reduction_xor__ZTS24DefaultOperatorsNoFloats : !cir.ptr<!rec_DefaultOperatorsNoFloats> reduction_operator <xor> init { +// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!rec_DefaultOperatorsNoFloats>{{.*}}) +// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !rec_DefaultOperatorsNoFloats, !cir.ptr<!rec_DefaultOperatorsNoFloats>, ["openacc.reduction.init", init] +// CHECK-NEXT: %[[GET_I:.*]] = cir.get_member %[[ALLOCA]][0] {name = "i"} : !cir.ptr<!rec_DefaultOperatorsNoFloats> -> !cir.ptr<!s32i> // CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !s32i // CHECK-NEXT: cir.store {{.*}} %[[ZERO]], %[[GET_I]] : !s32i, !cir.ptr<!s32i> -// CHECK-NEXT: %[[GET_U:.*]] = cir.get_member %[[ALLOCA]][1] {name = "u"} : !cir.ptr<!rec_DefaultOperators> -> !cir.ptr<!u32i> +// CHECK-NEXT: %[[GET_U:.*]] = cir.get_member %[[ALLOCA]][1] {name = "u"} : !cir.ptr<!rec_DefaultOperatorsNoFloats> -> !cir.ptr<!u32i> // CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !u32i // CHECK-NEXT: cir.store {{.*}} %[[ZERO]], %[[GET_U]] : !u32i, !cir.ptr<!u32i> -// CHECK-NEXT: %[[GET_F:.*]] = cir.get_member %[[ALLOCA]][2] {name = "f"} : !cir.ptr<!rec_DefaultOperators> -> !cir.ptr<!cir.float> -// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.fp<0{{.*}}> : !cir.float -// CHECK-NEXT: cir.store {{.*}} %[[ZERO]], %[[GET_F]] : !cir.float, !cir.ptr<!cir.float> -// CHECK-NEXT: %[[GET_D:.*]] = cir.get_member %[[ALLOCA]][3] {name = "d"} : !cir.ptr<!rec_DefaultOperators> -> !cir.ptr<!cir.double> -// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.fp<0{{.*}}> : !cir.double -// CHECK-NEXT: cir.store {{.*}} %[[ZERO]], %[[GET_D]] : !cir.double, !cir.ptr<!cir.double> -// CHECK-NEXT: %[[GET_B:.*]] = cir.get_member %[[ALLOCA]][4] {name = "b"} : !cir.ptr<!rec_DefaultOperators> -> !cir.ptr<!cir.bool> +// CHECK-NEXT: %[[GET_B:.*]] = cir.get_member %[[ALLOCA]][2] {name = "b"} : !cir.ptr<!rec_DefaultOperatorsNoFloats> -> !cir.ptr<!cir.bool> // CHECK-NEXT: %[[ZERO:.*]] = cir.const #false // CHECK-NEXT: cir.store {{.*}} %[[ZERO]], %[[GET_B]] : !cir.bool, !cir.ptr<!cir.bool> // CHECK-NEXT: acc.yield // // CHECK-NEXT: } combiner { -// CHECK-NEXT: ^bb0(%[[LHSARG:.*]]: !cir.ptr<!rec_DefaultOperators> {{.*}}, %[[RHSARG:.*]]: !cir.ptr<!rec_DefaultOperators> {{.*}}) +// CHECK-NEXT: ^bb0(%[[LHSARG:.*]]: !cir.ptr<!rec_DefaultOperatorsNoFloats> {{.*}}, %[[RHSARG:.*]]: !cir.ptr<!rec_DefaultOperatorsNoFloats> {{.*}}) // TODO OpenACC: Expecting combination operation here -// CHECK-NEXT: acc.yield %[[LHSARG]] : !cir.ptr<!rec_DefaultOperators> +// CHECK-NEXT: acc.yield %[[LHSARG]] : !cir.ptr<!rec_DefaultOperatorsNoFloats> // CHECK-NEXT: } for(int i=0;i < 5; ++i); #pragma acc loop reduction(&&:someVar) @@ -606,194 +595,152 @@ void acc_loop() { // TODO OpenACC: Expecting combination operation here // CHECK-NEXT: acc.yield %[[LHSARG]] : !cir.ptr<!cir.array<!rec_DefaultOperators x 5>> // CHECK-NEXT: } - for(int i=0;i < 5; ++i); -#pragma acc loop reduction(&:someVarArr) -// CHECK-NEXT: acc.reduction.recipe @reduction_iand__ZTSA5_16DefaultOperators : !cir.ptr<!cir.array<!rec_DefaultOperators x 5>> reduction_operator <iand> init { -// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!rec_DefaultOperators x 5>>{{.*}}) -// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !cir.array<!rec_DefaultOperators x 5>, !cir.ptr<!cir.array<!rec_DefaultOperators x 5>>, ["openacc.reduction.init", init] -// CHECK-NEXT: %[[DECAY:.*]] = cir.cast array_to_ptrdecay %[[ALLOCA]] : !cir.ptr<!cir.array<!rec_DefaultOperators x 5>> -> !cir.ptr<!rec_DefaultOperators> -// CHECK-NEXT: %[[GET_I:.*]] = cir.get_member %[[DECAY]][0] {name = "i"} : !cir.ptr<!rec_DefaultOperators> -> !cir.ptr<!s32i> + for(int i = 0; i < 5; ++i); +#pragma acc loop reduction(&:someVarArrNoFloats) +// CHECK-NEXT: acc.reduction.recipe @reduction_iand__ZTSA5_24DefaultOperatorsNoFloats : !cir.ptr<!cir.array<!rec_DefaultOperatorsNoFloats x 5>> reduction_operator <iand> init { +// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!rec_DefaultOperatorsNoFloats x 5>>{{.*}}) +// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !cir.array<!rec_DefaultOperatorsNoFloats x 5>, !cir.ptr<!cir.array<!rec_DefaultOperatorsNoFloats x 5>>, ["openacc.reduction.init", init] +// CHECK-NEXT: %[[DECAY:.*]] = cir.cast array_to_ptrdecay %[[ALLOCA]] : !cir.ptr<!cir.array<!rec_DefaultOperatorsNoFloats x 5>> -> !cir.ptr<!rec_DefaultOperatorsNoFloats> +// CHECK-NEXT: %[[GET_I:.*]] = cir.get_member %[[DECAY]][0] {name = "i"} : !cir.ptr<!rec_DefaultOperatorsNoFloats> -> !cir.ptr<!s32i> // CHECK-NEXT: %[[ALL_ONES:.*]] = cir.const #cir.int<-1> : !s32i // CHECK-NEXT: cir.store {{.*}} %[[ALL_ONES]], %[[GET_I]] : !s32i, !cir.ptr<!s32i> -// CHECK-NEXT: %[[GET_U:.*]] = cir.get_member %[[DECAY]][1] {name = "u"} : !cir.ptr<!rec_DefaultOperators> -> !cir.ptr<!u32i> +// CHECK-NEXT: %[[GET_U:.*]] = cir.get_member %[[DECAY]][1] {name = "u"} : !cir.ptr<!rec_DefaultOperatorsNoFloats> -> !cir.ptr<!u32i> // CHECK-NEXT: %[[ALL_ONES:.*]] = cir.const #cir.int<4294967295> : !u32i // CHECK-NEXT: cir.store {{.*}} %[[ALL_ONES]], %[[GET_U]] : !u32i, !cir.ptr<!u32i> -// CHECK-NEXT: %[[GET_F:.*]] = cir.get_member %[[DECAY]][2] {name = "f"} : !cir.ptr<!rec_DefaultOperators> -> !cir.ptr<!cir.float> -// CHECK-NEXT: %[[ALL_ONES:.*]] = cir.const #cir.fp<0xFF{{.*}}> : !cir.float -// CHECK-NEXT: cir.store {{.*}} %[[ALL_ONES]], %[[GET_F]] : !cir.float, !cir.ptr<!cir.float> -// CHECK-NEXT: %[[GET_D:.*]] = cir.get_member %[[DECAY]][3] {name = "d"} : !cir.ptr<!rec_DefaultOperators> -> !cir.ptr<!cir.double> -// CHECK-NEXT: %[[ALL_ONES:.*]] = cir.const #cir.fp<0xFF{{.*}}> : !cir.double -// CHECK-NEXT: cir.store {{.*}} %[[ALL_ONES]], %[[GET_D]] : !cir.double, !cir.ptr<!cir.double> -// CHECK-NEXT: %[[GET_B:.*]] = cir.get_member %[[DECAY]][4] {name = "b"} : !cir.ptr<!rec_DefaultOperators> -> !cir.ptr<!cir.bool> +// CHECK-NEXT: %[[GET_B:.*]] = cir.get_member %[[DECAY]][2] {name = "b"} : !cir.ptr<!rec_DefaultOperatorsNoFloats> -> !cir.ptr<!cir.bool> // CHECK-NEXT: %[[ALL_ONES:.*]] = cir.const #true // CHECK-NEXT: cir.store {{.*}} %[[ALL_ONES]], %[[GET_B]] : !cir.bool, !cir.ptr<!cir.bool> // // CHECK-NEXT: %[[ALL_ONES_IDX:.*]] = cir.const #cir.int<1> : !s64i -// CHECK-NEXT: %[[NEXT_ELT:.*]] = cir.ptr_stride %[[DECAY]], %[[ALL_ONES_IDX]] : (!cir.ptr<!rec_DefaultOperators>, !s64i) -> !cir.ptr<!rec_DefaultOperators> -// CHECK-NEXT: %[[GET_I:.*]] = cir.get_member %[[NEXT_ELT]][0] {name = "i"} : !cir.ptr<!rec_DefaultOperators> -> !cir.ptr<!s32i> +// CHECK-NEXT: %[[NEXT_ELT:.*]] = cir.ptr_stride %[[DECAY]], %[[ALL_ONES_IDX]] : (!cir.ptr<!rec_DefaultOperatorsNoFloats>, !s64i) -> !cir.ptr<!rec_DefaultOperatorsNoFloats> +// CHECK-NEXT: %[[GET_I:.*]] = cir.get_member %[[NEXT_ELT]][0] {name = "i"} : !cir.ptr<!rec_DefaultOperatorsNoFloats> -> !cir.ptr<!s32i> // CHECK-NEXT: %[[ALL_ONES:.*]] = cir.const #cir.int<-1> : !s32i // CHECK-NEXT: cir.store {{.*}} %[[ALL_ONES]], %[[GET_I]] : !s32i, !cir.ptr<!s32i> -// CHECK-NEXT: %[[GET_U:.*]] = cir.get_member %[[NEXT_ELT]][1] {name = "u"} : !cir.ptr<!rec_DefaultOperators> -> !cir.ptr<!u32i> +// CHECK-NEXT: %[[GET_U:.*]] = cir.get_member %[[NEXT_ELT]][1] {name = "u"} : !cir.ptr<!rec_DefaultOperatorsNoFloats> -> !cir.ptr<!u32i> // CHECK-NEXT: %[[ALL_ONES:.*]] = cir.const #cir.int<4294967295> : !u32i // CHECK-NEXT: cir.store {{.*}} %[[ALL_ONES]], %[[GET_U]] : !u32i, !cir.ptr<!u32i> -// CHECK-NEXT: %[[GET_F:.*]] = cir.get_member %[[NEXT_ELT]][2] {name = "f"} : !cir.ptr<!rec_DefaultOperators> -> !cir.ptr<!cir.float> -// CHECK-NEXT: %[[ALL_ONES:.*]] = cir.const #cir.fp<0xFF{{.*}}> : !cir.float -// CHECK-NEXT: cir.store {{.*}} %[[ALL_ONES]], %[[GET_F]] : !cir.float, !cir.ptr<!cir.float> -// CHECK-NEXT: %[[GET_D:.*]] = cir.get_member %[[NEXT_ELT]][3] {name = "d"} : !cir.ptr<!rec_DefaultOperators> -> !cir.ptr<!cir.double> -// CHECK-NEXT: %[[ALL_ONES:.*]] = cir.const #cir.fp<0xFF{{.*}}> : !cir.double -// CHECK-NEXT: cir.store {{.*}} %[[ALL_ONES]], %[[GET_D]] : !cir.double, !cir.ptr<!cir.double> -// CHECK-NEXT: %[[GET_B:.*]] = cir.get_member %[[NEXT_ELT]][4] {name = "b"} : !cir.ptr<!rec_DefaultOperators> -> !cir.ptr<!cir.bool> +// CHECK-NEXT: %[[GET_B:.*]] = cir.get_member %[[NEXT_ELT]][2] {name = "b"} : !cir.ptr<!rec_DefaultOperatorsNoFloats> -> !cir.ptr<!cir.bool> // CHECK-NEXT: %[[ALL_ONES:.*]] = cir.const #true // CHECK-NEXT: cir.store {{.*}} %[[ALL_ONES]], %[[GET_B]] : !cir.bool, !cir.ptr<!cir.bool> // // CHECK-NEXT: %[[TWO_IDX:.*]] = cir.const #cir.int<2> : !s64i -// CHECK-NEXT: %[[NEXT_ELT:.*]] = cir.ptr_stride %[[DECAY]], %[[TWO_IDX]] : (!cir.ptr<!rec_DefaultOperators>, !s64i) -> !cir.ptr<!rec_DefaultOperators> -// CHECK-NEXT: %[[GET_I:.*]] = cir.get_member %[[NEXT_ELT]][0] {name = "i"} : !cir.ptr<!rec_DefaultOperators> -> !cir.ptr<!s32i> +// CHECK-NEXT: %[[NEXT_ELT:.*]] = cir.ptr_stride %[[DECAY]], %[[TWO_IDX]] : (!cir.ptr<!rec_DefaultOperatorsNoFloats>, !s64i) -> !cir.ptr<!rec_DefaultOperatorsNoFloats> +// CHECK-NEXT: %[[GET_I:.*]] = cir.get_member %[[NEXT_ELT]][0] {name = "i"} : !cir.ptr<!rec_DefaultOperatorsNoFloats> -> !cir.ptr<!s32i> // CHECK-NEXT: %[[ALL_ONES:.*]] = cir.const #cir.int<-1> : !s32i // CHECK-NEXT: cir.store {{.*}} %[[ALL_ONES]], %[[GET_I]] : !s32i, !cir.ptr<!s32i> -// CHECK-NEXT: %[[GET_U:.*]] = cir.get_member %[[NEXT_ELT]][1] {name = "u"} : !cir.ptr<!rec_DefaultOperators> -> !cir.ptr<!u32i> +// CHECK-NEXT: %[[GET_U:.*]] = cir.get_member %[[NEXT_ELT]][1] {name = "u"} : !cir.ptr<!rec_DefaultOperatorsNoFloats> -> !cir.ptr<!u32i> // CHECK-NEXT: %[[ALL_ONES:.*]] = cir.const #cir.int<4294967295> : !u32i // CHECK-NEXT: cir.store {{.*}} %[[ALL_ONES]], %[[GET_U]] : !u32i, !cir.ptr<!u32i> -// CHECK-NEXT: %[[GET_F:.*]] = cir.get_member %[[NEXT_ELT]][2] {name = "f"} : !cir.ptr<!rec_DefaultOperators> -> !cir.ptr<!cir.float> -// CHECK-NEXT: %[[ALL_ONES:.*]] = cir.const #cir.fp<0xFF{{.*}}> : !cir.float -// CHECK-NEXT: cir.store {{.*}} %[[ALL_ONES]], %[[GET_F]] : !cir.float, !cir.ptr<!cir.float> -// CHECK-NEXT: %[[GET_D:.*]] = cir.get_member %[[NEXT_ELT]][3] {name = "d"} : !cir.ptr<!rec_DefaultOperators> -> !cir.ptr<!cir.double> -// CHECK-NEXT: %[[ALL_ONES:.*]] = cir.const #cir.fp<0xFF{{.*}}> : !cir.double -// CHECK-NEXT: cir.store {{.*}} %[[ALL_ONES]], %[[GET_D]] : !cir.double, !cir.ptr<!cir.double> -// CHECK-NEXT: %[[GET_B:.*]] = cir.get_member %[[NEXT_ELT]][4] {name = "b"} : !cir.ptr<!rec_DefaultOperators> -> !cir.ptr<!cir.bool> +// CHECK-NEXT: %[[GET_B:.*]] = cir.get_member %[[NEXT_ELT]][2] {name = "b"} : !cir.ptr<!rec_DefaultOperatorsNoFloats> -> !cir.ptr<!cir.bool> // CHECK-NEXT: %[[ALL_ONES:.*]] = cir.const #true // CHECK-NEXT: cir.store {{.*}} %[[ALL_ONES]], %[[GET_B]] : !cir.bool, !cir.ptr<!cir.bool> // // // CHECK-NEXT: %[[THREE_IDX:.*]] = cir.const #cir.int<3> : !s64i -// CHECK-NEXT: %[[NEXT_ELT:.*]] = cir.ptr_stride %[[DECAY]], %[[THREE_IDX]] : (!cir.ptr<!rec_DefaultOperators>, !s64i) -> !cir.ptr<!rec_DefaultOperators> -// CHECK-NEXT: %[[GET_I:.*]] = cir.get_member %[[NEXT_ELT]][0] {name = "i"} : !cir.ptr<!rec_DefaultOperators> -> !cir.ptr<!s32i> +// CHECK-NEXT: %[[NEXT_ELT:.*]] = cir.ptr_stride %[[DECAY]], %[[THREE_IDX]] : (!cir.ptr<!rec_DefaultOperatorsNoFloats>, !s64i) -> !cir.ptr<!rec_DefaultOperatorsNoFloats> +// CHECK-NEXT: %[[GET_I:.*]] = cir.get_member %[[NEXT_ELT]][0] {name = "i"} : !cir.ptr<!rec_DefaultOperatorsNoFloats> -> !cir.ptr<!s32i> // CHECK-NEXT: %[[ALL_ONES:.*]] = cir.const #cir.int<-1> : !s32i // CHECK-NEXT: cir.store {{.*}} %[[ALL_ONES]], %[[GET_I]] : !s32i, !cir.ptr<!s32i> -// CHECK-NEXT: %[[GET_U:.*]] = cir.get_member %[[NEXT_ELT]][1] {name = "u"} : !cir.ptr<!rec_DefaultOperators> -> !cir.ptr<!u32i> +// CHECK-NEXT: %[[GET_U:.*]] = cir.get_member %[[NEXT_ELT]][1] {name = "u"} : !cir.ptr<!rec_DefaultOperatorsNoFloats> -> !cir.ptr<!u32i> // CHECK-NEXT: %[[ALL_ONES:.*]] = cir.const #cir.int<4294967295> : !u32i // CHECK-NEXT: cir.store {{.*}} %[[ALL_ONES]], %[[GET_U]] : !u32i, !cir.ptr<!u32i> -// CHECK-NEXT: %[[GET_F:.*]] = cir.get_member %[[NEXT_ELT]][2] {name = "f"} : !cir.ptr<!rec_DefaultOperators> -> !cir.ptr<!cir.float> -// CHECK-NEXT: %[[ALL_ONES:.*]] = cir.const #cir.fp<0xFF{{.*}}> : !cir.float -// CHECK-NEXT: cir.store {{.*}} %[[ALL_ONES]], %[[GET_F]] : !cir.float, !cir.ptr<!cir.float> -// CHECK-NEXT: %[[GET_D:.*]] = cir.get_member %[[NEXT_ELT]][3] {name = "d"} : !cir.ptr<!rec_DefaultOperators> -> !cir.ptr<!cir.double> -// CHECK-NEXT: %[[ALL_ONES:.*]] = cir.const #cir.fp<0xFF{{.*}}> : !cir.double -// CHECK-NEXT: cir.store {{.*}} %[[ALL_ONES]], %[[GET_D]] : !cir.double, !cir.ptr<!cir.double> -// CHECK-NEXT: %[[GET_B:.*]] = cir.get_member %[[NEXT_ELT]][4] {name = "b"} : !cir.ptr<!rec_DefaultOperators> -> !cir.ptr<!cir.bool> +// CHECK-NEXT: %[[GET_B:.*]] = cir.get_member %[[NEXT_ELT]][2] {name = "b"} : !cir.ptr<!rec_DefaultOperatorsNoFloats> -> !cir.ptr<!cir.bool> // CHECK-NEXT: %[[ALL_ONES:.*]] = cir.const #true // CHECK-NEXT: cir.store {{.*}} %[[ALL_ONES]], %[[GET_B]] : !cir.bool, !cir.ptr<!cir.bool> // // CHECK-NEXT: %[[FOUR_IDX:.*]] = cir.const #cir.int<4> : !s64i -// CHECK-NEXT: %[[NEXT_ELT:.*]] = cir.ptr_stride %[[DECAY]], %[[FOUR_IDX]] : (!cir.ptr<!rec_DefaultOperators>, !s64i) -> !cir.ptr<!rec_DefaultOperators> -// CHECK-NEXT: %[[GET_I:.*]] = cir.get_member %[[NEXT_ELT]][0] {name = "i"} : !cir.ptr<!rec_DefaultOperators> -> !cir.ptr<!s32i> +// CHECK-NEXT: %[[NEXT_ELT:.*]] = cir.ptr_stride %[[DECAY]], %[[FOUR_IDX]] : (!cir.ptr<!rec_DefaultOperatorsNoFloats>, !s64i) -> !cir.ptr<!rec_DefaultOperatorsNoFloats> +// CHECK-NEXT: %[[GET_I:.*]] = cir.get_member %[[NEXT_ELT]][0] {name = "i"} : !cir.ptr<!rec_DefaultOperatorsNoFloats> -> !cir.ptr<!s32i> // CHECK-NEXT: %[[ALL_ONES:.*]] = cir.const #cir.int<-1> : !s32i // CHECK-NEXT: cir.store {{.*}} %[[ALL_ONES]], %[[GET_I]] : !s32i, !cir.ptr<!s32i> -// CHECK-NEXT: %[[GET_U:.*]] = cir.get_member %[[NEXT_ELT]][1] {name = "u"} : !cir.ptr<!rec_DefaultOperators> -> !cir.ptr<!u32i> +// CHECK-NEXT: %[[GET_U:.*]] = cir.get_member %[[NEXT_ELT]][1] {name = "u"} : !cir.ptr<!rec_DefaultOperatorsNoFloats> -> !cir.ptr<!u32i> // CHECK-NEXT: %[[ALL_ONES:.*]] = cir.const #cir.int<4294967295> : !u32i // CHECK-NEXT: cir.store {{.*}} %[[ALL_ONES]], %[[GET_U]] : !u32i, !cir.ptr<!u32i> -// CHECK-NEXT: %[[GET_F:.*]] = cir.get_member %[[NEXT_ELT]][2] {name = "f"} : !cir.ptr<!rec_DefaultOperators> -> !cir.ptr<!cir.float> -// CHECK-NEXT: %[[ALL_ONES:.*]] = cir.const #cir.fp<0xFF{{.*}}> : !cir.float -// CHECK-NEXT: cir.store {{.*}} %[[ALL_ONES]], %[[GET_F]] : !cir.float, !cir.ptr<!cir.float> -// CHECK-NEXT: %[[GET_D:.*]] = cir.get_member %[[NEXT_ELT]][3] {name = "d"} : !cir.ptr<!rec_DefaultOperators> -> !cir.ptr<!cir.double> -// CHECK-NEXT: %[[ALL_ONES:.*]] = cir.const #cir.fp<0xFF{{.*}}> : !cir.double -// CHECK-NEXT: cir.store {{.*}} %[[ALL_ONES]], %[[GET_D]] : !cir.double, !cir.ptr<!cir.double> -// CHECK-NEXT: %[[GET_B:.*]] = cir.get_member %[[NEXT_ELT]][4] {name = "b"} : !cir.ptr<!rec_DefaultOperators> -> !cir.ptr<!cir.bool> +// CHECK-NEXT: %[[GET_B:.*]] = cir.get_member %[[NEXT_ELT]][2] {name = "b"} : !cir.ptr<!rec_DefaultOperatorsNoFloats> -> !cir.ptr<!cir.bool> // CHECK-NEXT: %[[ALL_ONES:.*]] = cir.const #true // CHECK-NEXT: cir.store {{.*}} %[[ALL_ONES]], %[[GET_B]] : !cir.bool, !cir.ptr<!cir.bool> // // CHECK-NEXT: acc.yield // // CHECK-NEXT: } combiner { -// CHECK-NEXT: ^bb0(%[[LHSARG:.*]]: !cir.ptr<!cir.array<!rec_DefaultOperators x 5>> {{.*}}, %[[RHSARG:.*]]: !cir.ptr<!cir.array<!rec_DefaultOperators x 5>> {{.*}}) +// CHECK-NEXT: ^bb0(%[[LHSARG:.*]]: !cir.ptr<!cir.array<!rec_DefaultOperatorsNoFloats x 5>> {{.*}}, %[[RHSARG:.*]]: !cir.ptr<!cir.array<!rec_DefaultOperatorsNoFloats x 5>> {{.*}}) // TODO OpenACC: Expecting combination operation here -// CHECK-NEXT: acc.yield %[[LHSARG]] : !cir.ptr<!cir.array<!rec_DefaultOperators x 5>> +// CHECK-NEXT: acc.yield %[[LHSARG]] : !cir.ptr<!cir.array<!rec_DefaultOperatorsNoFloats x 5>> // CHECK-NEXT: } for(int i=0;i < 5; ++i); -#pragma acc loop reduction(|:someVarArr) -// CHECK-NEXT: acc.reduction.recipe @reduction_ior__ZTSA5_16DefaultOperators : !cir.ptr<!cir.array<!rec_DefaultOperators x 5>> reduction_operator <ior> init { -// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!rec_DefaultOperators x 5>>{{.*}}) -// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !cir.array<!rec_DefaultOperators x 5>, !cir.ptr<!cir.array<!rec_DefaultOperators x 5>>, ["openacc.reduction.init", init] -// CHECK-NEXT: %[[TEMP_ITR:.*]] = cir.alloca !cir.ptr<!rec_DefaultOperators>, !cir.ptr<!cir.ptr<!rec_DefaultOperators>>, ["arrayinit.temp"] -// CHECK-NEXT: %[[DECAY:.*]] = cir.cast array_to_ptrdecay %[[ALLOCA]] : !cir.ptr<!cir.array<!rec_DefaultOperators x 5>> -> !cir.ptr<!rec_DefaultOperators> -// CHECK-NEXT: cir.store {{.*}} %[[DECAY]], %[[TEMP_ITR]] : !cir.ptr<!rec_DefaultOperators>, !cir.ptr<!cir.ptr<!rec_DefaultOperators>> +#pragma acc loop reduction(|:someVarArrNoFloats) +// CHECK-NEXT: acc.reduction.recipe @reduction_ior__ZTSA5_24DefaultOperatorsNoFloats : !cir.ptr<!cir.array<!rec_DefaultOperatorsNoFloats x 5>> reduction_operator <ior> init { +// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!rec_DefaultOperatorsNoFloats x 5>>{{.*}}) +// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !cir.array<!rec_DefaultOperatorsNoFloats x 5>, !cir.ptr<!cir.array<!rec_DefaultOperatorsNoFloats x 5>>, ["openacc.reduction.init", init] +// CHECK-NEXT: %[[TEMP_ITR:.*]] = cir.alloca !cir.ptr<!rec_DefaultOperatorsNoFloats>, !cir.ptr<!cir.ptr<!rec_DefaultOperatorsNoFloats>>, ["arrayinit.temp"] +// CHECK-NEXT: %[[DECAY:.*]] = cir.cast array_to_ptrdecay %[[ALLOCA]] : !cir.ptr<!cir.array<!rec_DefaultOperatorsNoFloats x 5>> -> !cir.ptr<!rec_DefaultOperatorsNoFloats> +// CHECK-NEXT: cir.store {{.*}} %[[DECAY]], %[[TEMP_ITR]] : !cir.ptr<!rec_DefaultOperatorsNoFloats>, !cir.ptr<!cir.ptr<!rec_DefaultOperatorsNoFloats>> // CHECK-NEXT: %[[LAST_IDX:.*]] = cir.const #cir.int<5> : !s64i -// CHECK-NEXT: %[[END_ITR:.*]] = cir.ptr_stride %[[DECAY]], %[[LAST_IDX]] : (!cir.ptr<!rec_DefaultOperators>, !s64i) -> !cir.ptr<!rec_DefaultOperators> +// CHECK-NEXT: %[[END_ITR:.*]] = cir.ptr_stride %[[DECAY]], %[[LAST_IDX]] : (!cir.ptr<!rec_DefaultOperatorsNoFloats>, !s64i) -> !cir.ptr<!rec_DefaultOperatorsNoFloats> // CHECK-NEXT: cir.do { -// CHECK-NEXT: %[[TEMP_LOAD:.*]] = cir.load {{.*}} %[[TEMP_ITR]] : !cir.ptr<!cir.ptr<!rec_DefaultOperators>>, !cir.ptr<!rec_DefaultOperators> -// CHECK-NEXT: %[[GET_I:.*]] = cir.get_member %[[TEMP_LOAD]][0] {name = "i"} : !cir.ptr<!rec_DefaultOperators> -> !cir.ptr<!s32i> +// CHECK-NEXT: %[[TEMP_LOAD:.*]] = cir.load {{.*}} %[[TEMP_ITR]] : !cir.ptr<!cir.ptr<!rec_DefaultOperatorsNoFloats>>, !cir.ptr<!rec_DefaultOperatorsNoFloats> +// CHECK-NEXT: %[[GET_I:.*]] = cir.get_member %[[TEMP_LOAD]][0] {name = "i"} : !cir.ptr<!rec_DefaultOperatorsNoFloats> -> !cir.ptr<!s32i> // CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !s32i // CHECK-NEXT: cir.store {{.*}} %[[ZERO]], %[[GET_I]] : !s32i, !cir.ptr<!s32i> -// CHECK-NEXT: %[[GET_U:.*]] = cir.get_member %[[TEMP_LOAD]][1] {name = "u"} : !cir.ptr<!rec_DefaultOperators> -> !cir.ptr<!u32i> +// CHECK-NEXT: %[[GET_U:.*]] = cir.get_member %[[TEMP_LOAD]][1] {name = "u"} : !cir.ptr<!rec_DefaultOperatorsNoFloats> -> !cir.ptr<!u32i> // CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !u32i // CHECK-NEXT: cir.store {{.*}} %[[ZERO]], %[[GET_U]] : !u32i, !cir.ptr<!u32i> -// CHECK-NEXT: %[[GET_F:.*]] = cir.get_member %[[TEMP_LOAD]][2] {name = "f"} : !cir.ptr<!rec_DefaultOperators> -> !cir.ptr<!cir.float> -// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.fp<0{{.*}}> : !cir.float -// CHECK-NEXT: cir.store {{.*}} %[[ZERO]], %[[GET_F]] : !cir.float, !cir.ptr<!cir.float> -// CHECK-NEXT: %[[GET_D:.*]] = cir.get_member %[[TEMP_LOAD]][3] {name = "d"} : !cir.ptr<!rec_DefaultOperators> -> !cir.ptr<!cir.double> -// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.fp<0{{.*}}> : !cir.double -// CHECK-NEXT: cir.store {{.*}} %[[ZERO]], %[[GET_D]] : !cir.double, !cir.ptr<!cir.double> -// CHECK-NEXT: %[[GET_B:.*]] = cir.get_member %[[TEMP_LOAD]][4] {name = "b"} : !cir.ptr<!rec_DefaultOperators> -> !cir.ptr<!cir.bool> +// CHECK-NEXT: %[[GET_B:.*]] = cir.get_member %[[TEMP_LOAD]][2] {name = "b"} : !cir.ptr<!rec_DefaultOperatorsNoFloats> -> !cir.ptr<!cir.bool> // CHECK-NEXT: %[[ZERO:.*]] = cir.const #false // CHECK-NEXT: cir.store {{.*}} %[[ZERO]], %[[GET_B]] : !cir.bool, !cir.ptr<!cir.bool> // // CHECK-NEXT: %[[ONE:.*]] = cir.const #cir.int<1> : !s64i -// CHECK-NEXT: %[[NEXT_ITEM:.*]] = cir.ptr_stride %[[TEMP_LOAD]], %[[ONE]] : (!cir.ptr<!rec_DefaultOperators>, !s64i) -> !cir.ptr<!rec_DefaultOperators> -// CHECK-NEXT: cir.store {{.*}} %[[NEXT_ITEM]], %[[TEMP_ITR]] : !cir.ptr<!rec_DefaultOperators>, !cir.ptr<!cir.ptr<!rec_DefaultOperators>> +// CHECK-NEXT: %[[NEXT_ITEM:.*]] = cir.ptr_stride %[[TEMP_LOAD]], %[[ONE]] : (!cir.ptr<!rec_DefaultOperatorsNoFloats>, !s64i) -> !cir.ptr<!rec_DefaultOperatorsNoFloats> +// CHECK-NEXT: cir.store {{.*}} %[[NEXT_ITEM]], %[[TEMP_ITR]] : !cir.ptr<!rec_DefaultOperatorsNoFloats>, !cir.ptr<!cir.ptr<!rec_DefaultOperatorsNoFloats>> // CHECK-NEXT: cir.yield // CHECK-NEXT: } while { -// CHECK-NEXT: %[[TEMP_LOAD:.*]] = cir.load {{.*}} %[[TEMP_ITR]] : !cir.ptr<!cir.ptr<!rec_DefaultOperators>>, !cir.ptr<!rec_DefaultOperators> -// CHECK-NEXT: %[[CMP:.*]] = cir.cmp(ne, %[[TEMP_LOAD]], %[[END_ITR]]) : !cir.ptr<!rec_DefaultOperators>, !cir.bool +// CHECK-NEXT: %[[TEMP_LOAD:.*]] = cir.load {{.*}} %[[TEMP_ITR]] : !cir.ptr<!cir.ptr<!rec_DefaultOperatorsNoFloats>>, !cir.ptr<!rec_DefaultOperatorsNoFloats> +// CHECK-NEXT: %[[CMP:.*]] = cir.cmp(ne, %[[TEMP_LOAD]], %[[END_ITR]]) : !cir.ptr<!rec_DefaultOperatorsNoFloats>, !cir.bool // CHECK-NEXT: cir.condition(%[[CMP]]) // CHECK-NEXT: } // CHECK-NEXT: acc.yield // // CHECK-NEXT: } combiner { -// CHECK-NEXT: ^bb0(%[[LHSARG:.*]]: !cir.ptr<!cir.array<!rec_DefaultOperators x 5>> {{.*}}, %[[RHSARG:.*]]: !cir.ptr<!cir.array<!rec_DefaultOperators x 5>> {{.*}}) +// CHECK-NEXT: ^bb0(%[[LHSARG:.*]]: !cir.ptr<!cir.array<!rec_DefaultOperatorsNoFloats x 5>> {{.*}}, %[[RHSARG:.*]]: !cir.ptr<!cir.array<!rec_DefaultOperatorsNoFloats x 5>> {{.*}}) // TODO OpenACC: Expecting combination operation here -// CHECK-NEXT: acc.yield %[[LHSARG]] : !cir.ptr<!cir.array<!rec_DefaultOperators x 5>> +// CHECK-NEXT: acc.yield %[[LHSARG]] : !cir.ptr<!cir.array<!rec_DefaultOperatorsNoFloats x 5>> // CHECK-NEXT: } - for(int i=0;i < 5; ++i); -#pragma acc loop reduction(^:someVarArr) -// CHECK-NEXT: acc.reduction.recipe @reduction_xor__ZTSA5_16DefaultOperators : !cir.ptr<!cir.array<!rec_DefaultOperators x 5>> reduction_operator <xor> init { -// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!rec_DefaultOperators x 5>>{{.*}}) -// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !cir.array<!rec_DefaultOperators x 5>, !cir.ptr<!cir.array<!rec_DefaultOperators x 5>>, ["openacc.reduction.init", init] -// CHECK-NEXT: %[[TEMP_ITR:.*]] = cir.alloca !cir.ptr<!rec_DefaultOperators>, !cir.ptr<!cir.ptr<!rec_DefaultOperators>>, ["arrayinit.temp"] -// CHECK-NEXT: %[[DECAY:.*]] = cir.cast array_to_ptrdecay %[[ALLOCA]] : !cir.ptr<!cir.array<!rec_DefaultOperators x 5>> -> !cir.ptr<!rec_DefaultOperators> -// CHECK-NEXT: cir.store {{.*}} %[[DECAY]], %[[TEMP_ITR]] : !cir.ptr<!rec_DefaultOperators>, !cir.ptr<!cir.ptr<!rec_DefaultOperators>> + for(int i = 0; i < 5; ++i); +#pragma acc loop reduction(^:someVarArrNoFloats) +// CHECK-NEXT: acc.reduction.recipe @reduction_xor__ZTSA5_24DefaultOperatorsNoFloats : !cir.ptr<!cir.array<!rec_DefaultOperatorsNoFloats x 5>> reduction_operator <xor> init { +// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!rec_DefaultOperatorsNoFloats x 5>>{{.*}}) +// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !cir.array<!rec_DefaultOperatorsNoFloats x 5>, !cir.ptr<!cir.array<!rec_DefaultOperatorsNoFloats x 5>>, ["openacc.reduction.init", init] +// CHECK-NEXT: %[[TEMP_ITR:.*]] = cir.alloca !cir.ptr<!rec_DefaultOperatorsNoFloats>, !cir.ptr<!cir.ptr<!rec_DefaultOperatorsNoFloats>>, ["arrayinit.temp"] +// CHECK-NEXT: %[[DECAY:.*]] = cir.cast array_to_ptrdecay %[[ALLOCA]] : !cir.ptr<!cir.array<!rec_DefaultOperatorsNoFloats x 5>> -> !cir.ptr<!rec_DefaultOperatorsNoFloats> +// CHECK-NEXT: cir.store {{.*}} %[[DECAY]], %[[TEMP_ITR]] : !cir.ptr<!rec_DefaultOperatorsNoFloats>, !cir.ptr<!cir.ptr<!rec_DefaultOperatorsNoFloats>> // CHECK-NEXT: %[[LAST_IDX:.*]] = cir.const #cir.int<5> : !s64i -// CHECK-NEXT: %[[END_ITR:.*]] = cir.ptr_stride %[[DECAY]], %[[LAST_IDX]] : (!cir.ptr<!rec_DefaultOperators>, !s64i) -> !cir.ptr<!rec_DefaultOperators> +// CHECK-NEXT: %[[END_ITR:.*]] = cir.ptr_stride %[[DECAY]], %[[LAST_IDX]] : (!cir.ptr<!rec_DefaultOperatorsNoFloats>, !s64i) -> !cir.ptr<!rec_DefaultOperatorsNoFloats> // CHECK-NEXT: cir.do { -// CHECK-NEXT: %[[TEMP_LOAD:.*]] = cir.load {{.*}} %[[TEMP_ITR]] : !cir.ptr<!cir.ptr<!rec_DefaultOperators>>, !cir.ptr<!rec_DefaultOperators> -// CHECK-NEXT: %[[GET_I:.*]] = cir.get_member %[[TEMP_LOAD]][0] {name = "i"} : !cir.ptr<!rec_DefaultOperators> -> !cir.ptr<!s32i> +// CHECK-NEXT: %[[TEMP_LOAD:.*]] = cir.load {{.*}} %[[TEMP_ITR]] : !cir.ptr<!cir.ptr<!rec_DefaultOperatorsNoFloats>>, !cir.ptr<!rec_DefaultOperatorsNoFloats> +// CHECK-NEXT: %[[GET_I:.*]] = cir.get_member %[[TEMP_LOAD]][0] {name = "i"} : !cir.ptr<!rec_DefaultOperatorsNoFloats> -> !cir.ptr<!s32i> // CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !s32i // CHECK-NEXT: cir.store {{.*}} %[[ZERO]], %[[GET_I]] : !s32i, !cir.ptr<!s32i> -// CHECK-NEXT: %[[GET_U:.*]] = cir.get_member %[[TEMP_LOAD]][1] {name = "u"} : !cir.ptr<!rec_DefaultOperators> -> !cir.ptr<!u32i> +// CHECK-NEXT: %[[GET_U:.*]] = cir.get_member %[[TEMP_LOAD]][1] {name = "u"} : !cir.ptr<!rec_DefaultOperatorsNoFloats> -> !cir.ptr<!u32i> // CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !u32i // CHECK-NEXT: cir.store {{.*}} %[[ZERO]], %[[GET_U]] : !u32i, !cir.ptr<!u32i> -// CHECK-NEXT: %[[GET_F:.*]] = cir.get_member %[[TEMP_LOAD]][2] {name = "f"} : !cir.ptr<!rec_DefaultOperators> -> !cir.ptr<!cir.float> -// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.fp<0{{.*}}> : !cir.float -// CHECK-NEXT: cir.store {{.*}} %[[ZERO]], %[[GET_F]] : !cir.float, !cir.ptr<!cir.float> -// CHECK-NEXT: %[[GET_D:.*]] = cir.get_member %[[TEMP_LOAD]][3] {name = "d"} : !cir.ptr<!rec_DefaultOperators> -> !cir.ptr<!cir.double> -// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.fp<0{{.*}}> : !cir.double -// CHECK-NEXT: cir.store {{.*}} %[[ZERO]], %[[GET_D]] : !cir.double, !cir.ptr<!cir.double> -// CHECK-NEXT: %[[GET_B:.*]] = cir.get_member %[[TEMP_LOAD]][4] {name = "b"} : !cir.ptr<!rec_DefaultOperators> -> !cir.ptr<!cir.bool> +// CHECK-NEXT: %[[GET_B:.*]] = cir.get_member %[[TEMP_LOAD]][2] {name = "b"} : !cir.ptr<!rec_DefaultOperatorsNoFloats> -> !cir.ptr<!cir.bool> // CHECK-NEXT: %[[ZERO:.*]] = cir.const #false // CHECK-NEXT: cir.store {{.*}} %[[ZERO]], %[[GET_B]] : !cir.bool, !cir.ptr<!cir.bool> // CHECK-NEXT: %[[ONE:.*]] = cir.const #cir.int<1> : !s64i -// CHECK-NEXT: %[[NEXT_ITEM:.*]] = cir.ptr_stride %[[TEMP_LOAD]], %[[ONE]] : (!cir.ptr<!rec_DefaultOperators>, !s64i) -> !cir.ptr<!rec_DefaultOperators> -// CHECK-NEXT: cir.store {{.*}} %[[NEXT_ITEM]], %[[TEMP_ITR]] : !cir.ptr<!rec_DefaultOperators>, !cir.ptr<!cir.ptr<!rec_DefaultOperators>> +// CHECK-NEXT: %[[NEXT_ITEM:.*]] = cir.ptr_stride %[[TEMP_LOAD]], %[[ONE]] : (!cir.ptr<!rec_DefaultOperatorsNoFloats>, !s64i) -> !cir.ptr<!rec_DefaultOperatorsNoFloats> +// CHECK-NEXT: cir.store {{.*}} %[[NEXT_ITEM]], %[[TEMP_ITR]] : !cir.ptr<!rec_DefaultOperatorsNoFloats>, !cir.ptr<!cir.ptr<!rec_DefaultOperatorsNoFloats>> // CHECK-NEXT: cir.yield // CHECK-NEXT: } while { -// CHECK-NEXT: %[[TEMP_LOAD:.*]] = cir.load {{.*}} %[[TEMP_ITR]] : !cir.ptr<!cir.ptr<!rec_DefaultOperators>>, !cir.ptr<!rec_DefaultOperators> -// CHECK-NEXT: %[[CMP:.*]] = cir.cmp(ne, %[[TEMP_LOAD]], %[[END_ITR]]) : !cir.ptr<!rec_DefaultOperators>, !cir.bool +// CHECK-NEXT: %[[TEMP_LOAD:.*]] = cir.load {{.*}} %[[TEMP_ITR]] : !cir.ptr<!cir.ptr<!rec_DefaultOperatorsNoFloats>>, !cir.ptr<!rec_DefaultOperatorsNoFloats> +// CHECK-NEXT: %[[CMP:.*]] = cir.cmp(ne, %[[TEMP_LOAD]], %[[END_ITR]]) : !cir.ptr<!rec_DefaultOperatorsNoFloats>, !cir.bool // CHECK-NEXT: cir.condition(%[[CMP]]) // CHECK-NEXT: } // CHECK-NEXT: acc.yield // // CHECK-NEXT: } combiner { -// CHECK-NEXT: ^bb0(%[[LHSARG:.*]]: !cir.ptr<!cir.array<!rec_DefaultOperators x 5>> {{.*}}, %[[RHSARG:.*]]: !cir.ptr<!cir.array<!rec_DefaultOperators x 5>> {{.*}}) +// CHECK-NEXT: ^bb0(%[[LHSARG:.*]]: !cir.ptr<!cir.array<!rec_DefaultOperatorsNoFloats x 5>> {{.*}}, %[[RHSARG:.*]]: !cir.ptr<!cir.array<!rec_DefaultOperatorsNoFloats x 5>> {{.*}}) // TODO OpenACC: Expecting combination operation here -// CHECK-NEXT: acc.yield %[[LHSARG]] : !cir.ptr<!cir.array<!rec_DefaultOperators x 5>> +// CHECK-NEXT: acc.yield %[[LHSARG]] : !cir.ptr<!cir.array<!rec_DefaultOperatorsNoFloats x 5>> // CHECK-NEXT: } for(int i=0;i < 5; ++i); #pragma acc loop reduction(&&:someVarArr) @@ -1135,10 +1082,10 @@ void acc_loop() { // CHECK-NEXT: acc.yield %[[LHSARG]] : !cir.ptr<!cir.array<!rec_DefaultOperators x 5>> // CHECK-NEXT: } for(int i=0;i < 5; ++i); -#pragma acc loop reduction(&:someVarArr[2]) -// CHECK-NEXT: acc.reduction.recipe @reduction_iand__Bcnt1__ZTSA5_16DefaultOperators : !cir.ptr<!cir.array<!rec_DefaultOperators x 5>> reduction_operator <iand> init { -// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!rec_DefaultOperators x 5>>{{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty{{.*}})) -// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !cir.array<!rec_DefaultOperators x 5>, !cir.ptr<!cir.array<!rec_DefaultOperators x 5>>, ["openacc.reduction.init"] +#pragma acc loop reduction(&:someVarArrNoFloats[2]) +// CHECK-NEXT: acc.reduction.recipe @reduction_iand__Bcnt1__ZTSA5_24DefaultOperatorsNoFloats : !cir.ptr<!cir.array<!rec_DefaultOperatorsNoFloats x 5>> reduction_operator <iand> init { +// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!rec_DefaultOperatorsNoFloats x 5>>{{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty{{.*}})) +// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !cir.array<!rec_DefaultOperatorsNoFloats x 5>, !cir.ptr<!cir.array<!rec_DefaultOperatorsNoFloats x 5>>, ["openacc.reduction.init"] // CHECK-NEXT: cir.scope { // CHECK-NEXT: %[[LB:.*]] = acc.get_lowerbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index // CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i @@ -1152,21 +1099,15 @@ void acc_loop() { // CHECK-NEXT: cir.condition(%[[COND]]) // CHECK-NEXT: } body { // CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i -// CHECK-NEXT: %[[DECAY:.*]] = cir.cast array_to_ptrdecay %[[ALLOCA]] : !cir.ptr<!cir.array<!rec_DefaultOperators x 5>> -> !cir.ptr<!rec_DefaultOperators> -// CHECK-NEXT: %[[STRIDE:.*]] = cir.ptr_stride %[[DECAY]], %[[ITR_LOAD]] : (!cir.ptr<!rec_DefaultOperators>, !u64i) -> !cir.ptr<!rec_DefaultOperators> -// CHECK-NEXT: %[[GET_I:.*]] = cir.get_member %[[STRIDE]][0] {name = "i"} : !cir.ptr<!rec_DefaultOperators> -> !cir.ptr<!s32i> +// CHECK-NEXT: %[[DECAY:.*]] = cir.cast array_to_ptrdecay %[[ALLOCA]] : !cir.ptr<!cir.array<!rec_DefaultOperatorsNoFloats x 5>> -> !cir.ptr<!rec_DefaultOperatorsNoFloats> +// CHECK-NEXT: %[[STRIDE:.*]] = cir.ptr_stride %[[DECAY]], %[[ITR_LOAD]] : (!cir.ptr<!rec_DefaultOperatorsNoFloats>, !u64i) -> !cir.ptr<!rec_DefaultOperatorsNoFloats> +// CHECK-NEXT: %[[GET_I:.*]] = cir.get_member %[[STRIDE]][0] {name = "i"} : !cir.ptr<!rec_DefaultOperatorsNoFloats> -> !cir.ptr<!s32i> // CHECK-NEXT: %[[ALL_ONES:.*]] = cir.const #cir.int<-1> : !s32i // CHECK-NEXT: cir.store {{.*}} %[[ALL_ONES]], %[[GET_I]] : !s32i, !cir.ptr<!s32i> -// CHECK-NEXT: %[[GET_U:.*]] = cir.get_member %[[STRIDE]][1] {name = "u"} : !cir.ptr<!rec_DefaultOperators> -> !cir.ptr<!u32i> +// CHECK-NEXT: %[[GET_U:.*]] = cir.get_member %[[STRIDE]][1] {name = "u"} : !cir.ptr<!rec_DefaultOperatorsNoFloats> -> !cir.ptr<!u32i> // CHECK-NEXT: %[[ALL_ONES:.*]] = cir.const #cir.int<4294967295> : !u32i // CHECK-NEXT: cir.store {{.*}} %[[ALL_ONES]], %[[GET_U]] : !u32i, !cir.ptr<!u32i> -// CHECK-NEXT: %[[GET_F:.*]] = cir.get_member %[[STRIDE]][2] {name = "f"} : !cir.ptr<!rec_DefaultOperators> -> !cir.ptr<!cir.float> -// CHECK-NEXT: %[[ALL_ONES:.*]] = cir.const #cir.fp<0xFF{{.*}}> : !cir.float -// CHECK-NEXT: cir.store {{.*}} %[[ALL_ONES]], %[[GET_F]] : !cir.float, !cir.ptr<!cir.float> -// CHECK-NEXT: %[[GET_D:.*]] = cir.get_member %[[STRIDE]][3] {name = "d"} : !cir.ptr<!rec_DefaultOperators> -> !cir.ptr<!cir.double> -// CHECK-NEXT: %[[ALL_ONES:.*]] = cir.const #cir.fp<0xFF{{.*}}> : !cir.double -// CHECK-NEXT: cir.store {{.*}} %[[ALL_ONES]], %[[GET_D]] : !cir.double, !cir.ptr<!cir.double> -// CHECK-NEXT: %[[GET_B:.*]] = cir.get_member %[[STRIDE]][4] {name = "b"} : !cir.ptr<!rec_DefaultOperators> -> !cir.ptr<!cir.bool> +// CHECK-NEXT: %[[GET_B:.*]] = cir.get_member %[[STRIDE]][2] {name = "b"} : !cir.ptr<!rec_DefaultOperatorsNoFloats> -> !cir.ptr<!cir.bool> // CHECK-NEXT: %[[ALL_ONES:.*]] = cir.const #true // CHECK-NEXT: cir.store {{.*}} %[[ALL_ONES]], %[[GET_B]] : !cir.bool, !cir.ptr<!cir.bool> // CHECK-NEXT: cir.yield @@ -1179,14 +1120,14 @@ void acc_loop() { // CHECK-NEXT: } // CHECK-NEXT: acc.yield // CHECK-NEXT: } combiner { -// CHECK-NEXT: ^bb0(%[[LHSARG:.*]]: !cir.ptr<!cir.array<!rec_DefaultOperators x 5>> {{.*}}, %[[RHSARG:.*]]: !cir.ptr<!cir.array<!rec_DefaultOperators x 5>> {{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty{{.*}})) -// CHECK-NEXT: acc.yield %[[LHSARG]] : !cir.ptr<!cir.array<!rec_DefaultOperators x 5>> +// CHECK-NEXT: ^bb0(%[[LHSARG:.*]]: !cir.ptr<!cir.array<!rec_DefaultOperatorsNoFloats x 5>> {{.*}}, %[[RHSARG:.*]]: !cir.ptr<!cir.array<!rec_DefaultOperatorsNoFloats x 5>> {{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty{{.*}})) +// CHECK-NEXT: acc.yield %[[LHSARG]] : !cir.ptr<!cir.array<!rec_DefaultOperatorsNoFloats x 5>> // CHECK-NEXT: } for(int i=0;i < 5; ++i); -#pragma acc loop reduction(|:someVarArr[2]) -// CHECK-NEXT: acc.reduction.recipe @reduction_ior__Bcnt1__ZTSA5_16DefaultOperators : !cir.ptr<!cir.array<!rec_DefaultOperators x 5>> reduction_operator <ior> init { -// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!rec_DefaultOperators x 5>>{{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty{{.*}})) -// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !cir.array<!rec_DefaultOperators x 5>, !cir.ptr<!cir.array<!rec_DefaultOperators x 5>>, ["openacc.reduction.init"] +#pragma acc loop reduction(|:someVarArrNoFloats[2]) +// CHECK-NEXT: acc.reduction.recipe @reduction_ior__Bcnt1__ZTSA5_24DefaultOperatorsNoFloats : !cir.ptr<!cir.array<!rec_DefaultOperatorsNoFloats x 5>> reduction_operator <ior> init { +// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!rec_DefaultOperatorsNoFloats x 5>>{{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty{{.*}})) +// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !cir.array<!rec_DefaultOperatorsNoFloats x 5>, !cir.ptr<!cir.array<!rec_DefaultOperatorsNoFloats x 5>>, ["openacc.reduction.init"] // CHECK-NEXT: cir.scope { // CHECK-NEXT: %[[LB:.*]] = acc.get_lowerbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index // CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i @@ -1200,21 +1141,15 @@ void acc_loop() { // CHECK-NEXT: cir.condition(%[[COND]]) // CHECK-NEXT: } body { // CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i -// CHECK-NEXT: %[[DECAY:.*]] = cir.cast array_to_ptrdecay %[[ALLOCA]] : !cir.ptr<!cir.array<!rec_DefaultOperators x 5>> -> !cir.ptr<!rec_DefaultOperators> -// CHECK-NEXT: %[[STRIDE:.*]] = cir.ptr_stride %[[DECAY]], %[[ITR_LOAD]] : (!cir.ptr<!rec_DefaultOperators>, !u64i) -> !cir.ptr<!rec_DefaultOperators> -// CHECK-NEXT: %[[GET_I:.*]] = cir.get_member %[[STRIDE]][0] {name = "i"} : !cir.ptr<!rec_DefaultOperators> -> !cir.ptr<!s32i> +// CHECK-NEXT: %[[DECAY:.*]] = cir.cast array_to_ptrdecay %[[ALLOCA]] : !cir.ptr<!cir.array<!rec_DefaultOperatorsNoFloats x 5>> -> !cir.ptr<!rec_DefaultOperatorsNoFloats> +// CHECK-NEXT: %[[STRIDE:.*]] = cir.ptr_stride %[[DECAY]], %[[ITR_LOAD]] : (!cir.ptr<!rec_DefaultOperatorsNoFloats>, !u64i) -> !cir.ptr<!rec_DefaultOperatorsNoFloats> +// CHECK-NEXT: %[[GET_I:.*]] = cir.get_member %[[STRIDE]][0] {name = "i"} : !cir.ptr<!rec_DefaultOperatorsNoFloats> -> !cir.ptr<!s32i> // CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !s32i // CHECK-NEXT: cir.store {{.*}} %[[ZERO]], %[[GET_I]] : !s32i, !cir.ptr<!s32i> -// CHECK-NEXT: %[[GET_U:.*]] = cir.get_member %[[STRIDE]][1] {name = "u"} : !cir.ptr<!rec_DefaultOperators> -> !cir.ptr<!u32i> +// CHECK-NEXT: %[[GET_U:.*]] = cir.get_member %[[STRIDE]][1] {name = "u"} : !cir.ptr<!rec_DefaultOperatorsNoFloats> -> !cir.ptr<!u32i> // CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !u32i // CHECK-NEXT: cir.store {{.*}} %[[ZERO]], %[[GET_U]] : !u32i, !cir.ptr<!u32i> -// CHECK-NEXT: %[[GET_F:.*]] = cir.get_member %[[STRIDE]][2] {name = "f"} : !cir.ptr<!rec_DefaultOperators> -> !cir.ptr<!cir.float> -// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.fp<0{{.*}}> : !cir.float -// CHECK-NEXT: cir.store {{.*}} %[[ZERO]], %[[GET_F]] : !cir.float, !cir.ptr<!cir.float> -// CHECK-NEXT: %[[GET_D:.*]] = cir.get_member %[[STRIDE]][3] {name = "d"} : !cir.ptr<!rec_DefaultOperators> -> !cir.ptr<!cir.double> -// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.fp<0{{.*}}> : !cir.double -// CHECK-NEXT: cir.store {{.*}} %[[ZERO]], %[[GET_D]] : !cir.double, !cir.ptr<!cir.double> -// CHECK-NEXT: %[[GET_B:.*]] = cir.get_member %[[STRIDE]][4] {name = "b"} : !cir.ptr<!rec_DefaultOperators> -> !cir.ptr<!cir.bool> +// CHECK-NEXT: %[[GET_B:.*]] = cir.get_member %[[STRIDE]][2] {name = "b"} : !cir.ptr<!rec_DefaultOperatorsNoFloats> -> !cir.ptr<!cir.bool> // CHECK-NEXT: %[[ZERO:.*]] = cir.const #false // CHECK-NEXT: cir.store {{.*}} %[[ZERO]], %[[GET_B]] : !cir.bool, !cir.ptr<!cir.bool> // CHECK-NEXT: cir.yield @@ -1227,14 +1162,14 @@ void acc_loop() { // CHECK-NEXT: } // CHECK-NEXT: acc.yield // CHECK-NEXT: } combiner { -// CHECK-NEXT: ^bb0(%[[LHSARG:.*]]: !cir.ptr<!cir.array<!rec_DefaultOperators x 5>> {{.*}}, %[[RHSARG:.*]]: !cir.ptr<!cir.array<!rec_DefaultOperators x 5>> {{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty{{.*}})) -// CHECK-NEXT: acc.yield %[[LHSARG]] : !cir.ptr<!cir.array<!rec_DefaultOperators x 5>> +// CHECK-NEXT: ^bb0(%[[LHSARG:.*]]: !cir.ptr<!cir.array<!rec_DefaultOperatorsNoFloats x 5>> {{.*}}, %[[RHSARG:.*]]: !cir.ptr<!cir.array<!rec_DefaultOperatorsNoFloats x 5>> {{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty{{.*}})) +// CHECK-NEXT: acc.yield %[[LHSARG]] : !cir.ptr<!cir.array<!rec_DefaultOperatorsNoFloats x 5>> // CHECK-NEXT: } for(int i=0;i < 5; ++i); -#pragma acc loop reduction(^:someVarArr[2]) -// CHECK-NEXT: acc.reduction.recipe @reduction_xor__Bcnt1__ZTSA5_16DefaultOperators : !cir.ptr<!cir.array<!rec_DefaultOperators x 5>> reduction_operator <xor> init { -// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!rec_DefaultOperators x 5>>{{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty{{.*}})) -// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !cir.array<!rec_DefaultOperators x 5>, !cir.ptr<!cir.array<!rec_DefaultOperators x 5>>, ["openacc.reduction.init"] +#pragma acc loop reduction(^:someVarArrNoFloats[2]) +// CHECK-NEXT: acc.reduction.recipe @reduction_xor__Bcnt1__ZTSA5_24DefaultOperatorsNoFloats : !cir.ptr<!cir.array<!rec_DefaultOperatorsNoFloats x 5>> reduction_operator <xor> init { +// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!rec_DefaultOperatorsNoFloats x 5>>{{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty{{.*}})) +// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !cir.array<!rec_DefaultOperatorsNoFloats x 5>, !cir.ptr<!cir.array<!rec_DefaultOperatorsNoFloats x 5>>, ["openacc.reduction.init"] // CHECK-NEXT: cir.scope { // CHECK-NEXT: %[[LB:.*]] = acc.get_lowerbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index // CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i @@ -1248,21 +1183,15 @@ void acc_loop() { // CHECK-NEXT: cir.condition(%[[COND]]) // CHECK-NEXT: } body { // CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i -// CHECK-NEXT: %[[DECAY:.*]] = cir.cast array_to_ptrdecay %[[ALLOCA]] : !cir.ptr<!cir.array<!rec_DefaultOperators x 5>> -> !cir.ptr<!rec_DefaultOperators> -// CHECK-NEXT: %[[STRIDE:.*]] = cir.ptr_stride %[[DECAY]], %[[ITR_LOAD]] : (!cir.ptr<!rec_DefaultOperators>, !u64i) -> !cir.ptr<!rec_DefaultOperators> -// CHECK-NEXT: %[[GET_I:.*]] = cir.get_member %[[STRIDE]][0] {name = "i"} : !cir.ptr<!rec_DefaultOperators> -> !cir.ptr<!s32i> +// CHECK-NEXT: %[[DECAY:.*]] = cir.cast array_to_ptrdecay %[[ALLOCA]] : !cir.ptr<!cir.array<!rec_DefaultOperatorsNoFloats x 5>> -> !cir.ptr<!rec_DefaultOperatorsNoFloats> +// CHECK-NEXT: %[[STRIDE:.*]] = cir.ptr_stride %[[DECAY]], %[[ITR_LOAD]] : (!cir.ptr<!rec_DefaultOperatorsNoFloats>, !u64i) -> !cir.ptr<!rec_DefaultOperatorsNoFloats> +// CHECK-NEXT: %[[GET_I:.*]] = cir.get_member %[[STRIDE]][0] {name = "i"} : !cir.ptr<!rec_DefaultOperatorsNoFloats> -> !cir.ptr<!s32i> // CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !s32i // CHECK-NEXT: cir.store {{.*}} %[[ZERO]], %[[GET_I]] : !s32i, !cir.ptr<!s32i> -// CHECK-NEXT: %[[GET_U:.*]] = cir.get_member %[[STRIDE]][1] {name = "u"} : !cir.ptr<!rec_DefaultOperators> -> !cir.ptr<!u32i> +// CHECK-NEXT: %[[GET_U:.*]] = cir.get_member %[[STRIDE]][1] {name = "u"} : !cir.ptr<!rec_DefaultOperatorsNoFloats> -> !cir.ptr<!u32i> // CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.int<0> : !u32i // CHECK-NEXT: cir.store {{.*}} %[[ZERO]], %[[GET_U]] : !u32i, !cir.ptr<!u32i> -// CHECK-NEXT: %[[GET_F:.*]] = cir.get_member %[[STRIDE]][2] {name = "f"} : !cir.ptr<!rec_DefaultOperators> -> !cir.ptr<!cir.float> -// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.fp<0{{.*}}> : !cir.float -// CHECK-NEXT: cir.store {{.*}} %[[ZERO]], %[[GET_F]] : !cir.float, !cir.ptr<!cir.float> -// CHECK-NEXT: %[[GET_D:.*]] = cir.get_member %[[STRIDE]][3] {name = "d"} : !cir.ptr<!rec_DefaultOperators> -> !cir.ptr<!cir.double> -// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.fp<0{{.*}}> : !cir.double -// CHECK-NEXT: cir.store {{.*}} %[[ZERO]], %[[GET_D]] : !cir.double, !cir.ptr<!cir.double> -// CHECK-NEXT: %[[GET_B:.*]] = cir.get_member %[[STRIDE]][4] {name = "b"} : !cir.ptr<!rec_DefaultOperators> -> !cir.ptr<!cir.bool> +// CHECK-NEXT: %[[GET_B:.*]] = cir.get_member %[[STRIDE]][2] {name = "b"} : !cir.ptr<!rec_DefaultOperatorsNoFloats> -> !cir.ptr<!cir.bool> // CHECK-NEXT: %[[ZERO:.*]] = cir.const #false // CHECK-NEXT: cir.store {{.*}} %[[ZERO]], %[[GET_B]] : !cir.bool, !cir.ptr<!cir.bool> // CHECK-NEXT: cir.yield @@ -1275,8 +1204,8 @@ void acc_loop() { // CHECK-NEXT: } // CHECK-NEXT: acc.yield // CHECK-NEXT: } combiner { -// CHECK-NEXT: ^bb0(%[[LHSARG:.*]]: !cir.ptr<!cir.array<!rec_DefaultOperators x 5>> {{.*}}, %[[RHSARG:.*]]: !cir.ptr<!cir.array<!rec_DefaultOperators x 5>> {{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty{{.*}})) -// CHECK-NEXT: acc.yield %[[LHSARG]] : !cir.ptr<!cir.array<!rec_DefaultOperators x 5>> +// CHECK-NEXT: ^bb0(%[[LHSARG:.*]]: !cir.ptr<!cir.array<!rec_DefaultOperatorsNoFloats x 5>> {{.*}}, %[[RHSARG:.*]]: !cir.ptr<!cir.array<!rec_DefaultOperatorsNoFloats x 5>> {{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty{{.*}})) +// CHECK-NEXT: acc.yield %[[LHSARG]] : !cir.ptr<!cir.array<!rec_DefaultOperatorsNoFloats x 5>> // CHECK-NEXT: } for(int i=0;i < 5; ++i); #pragma acc loop reduction(&&:someVarArr[2]) @@ -1384,19 +1313,19 @@ void acc_loop() { for(int i=0;i < 5; ++i); #pragma acc loop reduction(min:someVarArr[1:1]) for(int i=0;i < 5; ++i); -#pragma acc loop reduction(&:someVarArr[1:1]) - for(int i=0;i < 5; ++i); -#pragma acc loop reduction(|:someVarArr[1:1]) - for(int i=0;i < 5; ++i); -#pragma acc loop reduction(^:someVarArr[1:1]) +#pragma acc loop reduction(&:someVarArrNoFloats[1:1]) + for(int i = 0; i < 5; ++i); +#pragma acc loop reduction(|:someVarArrNoFloats[1:1]) + for(int i = 0; i < 5; ++i); +#pragma acc loop reduction(^:someVarArrNoFloats[1:1]) for(int i=0;i < 5; ++i); #pragma acc loop reduction(&&:someVarArr[1:1]) for(int i=0;i < 5; ++i); #pragma acc loop reduction(||:someVarArr[1:1]) for(int i=0;i < 5; ++i); - // CHECK-NEXT: cir.func {{.*}}@_Z8acc_loop + // CHECK-NEXT: cir.func {{.*}}@_Z12acc_combined } void uses() { - acc_loop<DefaultOperators>(); + acc_combined<DefaultOperators>(); } diff --git a/clang/test/CIR/CodeGenOpenACC/loop-reduction-clause-float.cpp b/clang/test/CIR/CodeGenOpenACC/loop-reduction-clause-float.cpp index 52406fd..11b7c35 100644 --- a/clang/test/CIR/CodeGenOpenACC/loop-reduction-clause-float.cpp +++ b/clang/test/CIR/CodeGenOpenACC/loop-reduction-clause-float.cpp @@ -58,47 +58,6 @@ void acc_loop() { // CHECK-NEXT: acc.yield %[[LHSARG]] : !cir.ptr<!cir.float> // CHECK-NEXT: } for(int i=0;i < 5; ++i); -#pragma acc loop reduction(&:someVar) -// CHECK-NEXT: acc.reduction.recipe @reduction_iand__ZTSf : !cir.ptr<!cir.float> reduction_operator <iand> init { -// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.float>{{.*}}) -// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !cir.float, !cir.ptr<!cir.float>, ["openacc.reduction.init", init] -// CHECK-NEXT: %[[ALL_ONES:.*]] = cir.const #cir.fp<0xF{{.*}}> : !cir.float -// CHECK-NEXT: cir.store {{.*}} %[[ALL_ONES]], %[[ALLOCA]] : !cir.float, !cir.ptr<!cir.float> -// CHECK-NEXT: acc.yield -// CHECK-NEXT: } combiner { -// CHECK-NEXT: ^bb0(%[[LHSARG:.*]]: !cir.ptr<!cir.float> {{.*}}, %[[RHSARG:.*]]: !cir.ptr<!cir.float> {{.*}}) -// TODO OpenACC: Expecting combination operation here -// CHECK-NEXT: acc.yield %[[LHSARG]] : !cir.ptr<!cir.float> -// CHECK-NEXT: } - for(int i=0;i < 5; ++i); -#pragma acc loop reduction(|:someVar) -// CHECK-NEXT: acc.reduction.recipe @reduction_ior__ZTSf : !cir.ptr<!cir.float> reduction_operator <ior> init { -// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.float>{{.*}}) -// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !cir.float, !cir.ptr<!cir.float>, ["openacc.reduction.init", init] -// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.fp<0{{.*}}> : !cir.float -// CHECK-NEXT: cir.store {{.*}} %[[ZERO]], %[[ALLOCA]] : !cir.float, !cir.ptr<!cir.float> -// CHECK-NEXT: acc.yield -// -// CHECK-NEXT: } combiner { -// CHECK-NEXT: ^bb0(%[[LHSARG:.*]]: !cir.ptr<!cir.float> {{.*}}, %[[RHSARG:.*]]: !cir.ptr<!cir.float> {{.*}}) -// TODO OpenACC: Expecting combination operation here -// CHECK-NEXT: acc.yield %[[LHSARG]] : !cir.ptr<!cir.float> -// CHECK-NEXT: } - for(int i=0;i < 5; ++i); -#pragma acc loop reduction(^:someVar) -// CHECK-NEXT: acc.reduction.recipe @reduction_xor__ZTSf : !cir.ptr<!cir.float> reduction_operator <xor> init { -// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.float>{{.*}}) -// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !cir.float, !cir.ptr<!cir.float>, ["openacc.reduction.init", init] -// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.fp<0{{.*}}> : !cir.float -// CHECK-NEXT: cir.store {{.*}} %[[ZERO]], %[[ALLOCA]] : !cir.float, !cir.ptr<!cir.float> -// CHECK-NEXT: acc.yield -// -// CHECK-NEXT: } combiner { -// CHECK-NEXT: ^bb0(%[[LHSARG:.*]]: !cir.ptr<!cir.float> {{.*}}, %[[RHSARG:.*]]: !cir.ptr<!cir.float> {{.*}}) -// TODO OpenACC: Expecting combination operation here -// CHECK-NEXT: acc.yield %[[LHSARG]] : !cir.ptr<!cir.float> -// CHECK-NEXT: } - for(int i=0;i < 5; ++i); #pragma acc loop reduction(&&:someVar) // CHECK-NEXT: acc.reduction.recipe @reduction_land__ZTSf : !cir.ptr<!cir.float> reduction_operator <land> init { // CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.float>{{.*}}) @@ -250,97 +209,6 @@ void acc_loop() { // CHECK-NEXT: acc.yield %[[LHSARG]] : !cir.ptr<!cir.array<!cir.float x 5>> // CHECK-NEXT: } for(int i=0;i < 5; ++i); -#pragma acc loop reduction(&:someVarArr) -// CHECK-NEXT: acc.reduction.recipe @reduction_iand__ZTSA5_f : !cir.ptr<!cir.array<!cir.float x 5>> reduction_operator <iand> init { -// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!cir.float x 5>>{{.*}}) -// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !cir.array<!cir.float x 5>, !cir.ptr<!cir.array<!cir.float x 5>>, ["openacc.reduction.init", init] -// CHECK-NEXT: %[[DECAY:.*]] = cir.cast array_to_ptrdecay %[[ALLOCA]] : !cir.ptr<!cir.array<!cir.float x 5>> -> !cir.ptr<!cir.float> -// CHECK-NEXT: %[[ALL_ONES:.*]] = cir.const #cir.fp<0xF{{.*}}> : !cir.float -// CHECK-NEXT: cir.store{{.*}} %[[ALL_ONES]], %[[DECAY]] : !cir.float, !cir.ptr<!cir.float> -// CHECK-NEXT: %[[ONE_IDX:.*]] = cir.const #cir.int<1> : !s64i -// CHECK-NEXT: %[[NEXT_ELT:.*]] = cir.ptr_stride %[[DECAY]], %[[ONE_IDX]] : (!cir.ptr<!cir.float>, !s64i) -> !cir.ptr<!cir.float> -// CHECK-NEXT: %[[ALL_ONES:.*]] = cir.const #cir.fp<0xF{{.*}}> : !cir.float -// CHECK-NEXT: cir.store{{.*}} %[[ALL_ONES]], %[[NEXT_ELT]] : !cir.float, !cir.ptr<!cir.float> -// CHECK-NEXT: %[[TWO_IDX:.*]] = cir.const #cir.int<2> : !s64i -// CHECK-NEXT: %[[NEXT_ELT:.*]] = cir.ptr_stride %[[DECAY]], %[[TWO_IDX]] : (!cir.ptr<!cir.float>, !s64i) -> !cir.ptr<!cir.float> -// CHECK-NEXT: %[[ALL_ONES:.*]] = cir.const #cir.fp<0xF{{.*}}> : !cir.float -// CHECK-NEXT: cir.store{{.*}} %[[ALL_ONES]], %[[NEXT_ELT]] : !cir.float, !cir.ptr<!cir.float> -// CHECK-NEXT: %[[THREE_IDX:.*]] = cir.const #cir.int<3> : !s64i -// CHECK-NEXT: %[[NEXT_ELT:.*]] = cir.ptr_stride %[[DECAY]], %[[THREE_IDX]] : (!cir.ptr<!cir.float>, !s64i) -> !cir.ptr<!cir.float> -// CHECK-NEXT: %[[ALL_ONES:.*]] = cir.const #cir.fp<0xF{{.*}}> : !cir.float -// CHECK-NEXT: cir.store{{.*}} %[[ALL_ONES]], %[[NEXT_ELT]] : !cir.float, !cir.ptr<!cir.float> -// CHECK-NEXT: %[[FOUR_IDX:.*]] = cir.const #cir.int<4> : !s64i -// CHECK-NEXT: %[[NEXT_ELT:.*]] = cir.ptr_stride %[[DECAY]], %[[FOUR_IDX]] : (!cir.ptr<!cir.float>, !s64i) -> !cir.ptr<!cir.float> -// CHECK-NEXT: %[[ALL_ONES:.*]] = cir.const #cir.fp<0xF{{.*}}> : !cir.float -// CHECK-NEXT: cir.store{{.*}} %[[ALL_ONES]], %[[NEXT_ELT]] : !cir.float, !cir.ptr<!cir.float> -// CHECK-NEXT: acc.yield -// -// CHECK-NEXT: } combiner { -// CHECK-NEXT: ^bb0(%[[LHSARG:.*]]: !cir.ptr<!cir.array<!cir.float x 5>> {{.*}}, %[[RHSARG:.*]]: !cir.ptr<!cir.array<!cir.float x 5>> {{.*}}) -// TODO OpenACC: Expecting combination operation here -// CHECK-NEXT: acc.yield %[[LHSARG]] : !cir.ptr<!cir.array<!cir.float x 5>> -// CHECK-NEXT: } - for(int i=0;i < 5; ++i); -#pragma acc loop reduction(|:someVarArr) -// CHECK-NEXT: acc.reduction.recipe @reduction_ior__ZTSA5_f : !cir.ptr<!cir.array<!cir.float x 5>> reduction_operator <ior> init { -// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!cir.float x 5>>{{.*}}) -// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !cir.array<!cir.float x 5>, !cir.ptr<!cir.array<!cir.float x 5>>, ["openacc.reduction.init", init] -// CHECK-NEXT: %[[TEMP_ITR:.*]] = cir.alloca !cir.ptr<!cir.float>, !cir.ptr<!cir.ptr<!cir.float>>, ["arrayinit.temp"] -// CHECK-NEXT: %[[DECAY:.*]] = cir.cast array_to_ptrdecay %[[ALLOCA]] : !cir.ptr<!cir.array<!cir.float x 5>> -> !cir.ptr<!cir.float> -// CHECK-NEXT: cir.store {{.*}} %[[DECAY]], %[[TEMP_ITR]] : !cir.ptr<!cir.float>, !cir.ptr<!cir.ptr<!cir.float>> -// CHECK-NEXT: %[[LAST_IDX:.*]] = cir.const #cir.int<5> : !s64i -// CHECK-NEXT: %[[END_ITR:.*]] = cir.ptr_stride %[[DECAY]], %[[LAST_IDX]] : (!cir.ptr<!cir.float>, !s64i) -> !cir.ptr<!cir.float> -// CHECK-NEXT: cir.do { -// CHECK-NEXT: %[[TEMP_LOAD:.*]] = cir.load {{.*}} %[[TEMP_ITR]] : !cir.ptr<!cir.ptr<!cir.float>>, !cir.ptr<!cir.float> -// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.fp<0{{.*}}> : !cir.float -// CHECK-NEXT: cir.store {{.*}} %[[ZERO]], %[[TEMP_LOAD]] : !cir.float, !cir.ptr<!cir.float> -// CHECK-NEXT: %[[ONE:.*]] = cir.const #cir.int<1> : !s64i -// CHECK-NEXT: %[[NEXT_ITEM:.*]] = cir.ptr_stride %[[TEMP_LOAD]], %[[ONE]] : (!cir.ptr<!cir.float>, !s64i) -> !cir.ptr<!cir.float> -// CHECK-NEXT: cir.store {{.*}} %[[NEXT_ITEM]], %[[TEMP_ITR]] : !cir.ptr<!cir.float>, !cir.ptr<!cir.ptr<!cir.float>> -// CHECK-NEXT: cir.yield -// CHECK-NEXT: } while { -// CHECK-NEXT: %[[TEMP_LOAD:.*]] = cir.load {{.*}} %[[TEMP_ITR]] : !cir.ptr<!cir.ptr<!cir.float>>, !cir.ptr<!cir.float> -// CHECK-NEXT: %[[CMP:.*]] = cir.cmp(ne, %[[TEMP_LOAD]], %[[END_ITR]]) : !cir.ptr<!cir.float>, !cir.bool -// CHECK-NEXT: cir.condition(%[[CMP]]) -// CHECK-NEXT: } -// CHECK-NEXT: acc.yield -// -// CHECK-NEXT: } combiner { -// CHECK-NEXT: ^bb0(%[[LHSARG:.*]]: !cir.ptr<!cir.array<!cir.float x 5>> {{.*}}, %[[RHSARG:.*]]: !cir.ptr<!cir.array<!cir.float x 5>> {{.*}}) -// TODO OpenACC: Expecting combination operation here -// CHECK-NEXT: acc.yield %[[LHSARG]] : !cir.ptr<!cir.array<!cir.float x 5>> -// CHECK-NEXT: } - for(int i=0;i < 5; ++i); -#pragma acc loop reduction(^:someVarArr) -// CHECK-NEXT: acc.reduction.recipe @reduction_xor__ZTSA5_f : !cir.ptr<!cir.array<!cir.float x 5>> reduction_operator <xor> init { -// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!cir.float x 5>>{{.*}}) -// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !cir.array<!cir.float x 5>, !cir.ptr<!cir.array<!cir.float x 5>>, ["openacc.reduction.init", init] -// CHECK-NEXT: %[[TEMP_ITR:.*]] = cir.alloca !cir.ptr<!cir.float>, !cir.ptr<!cir.ptr<!cir.float>>, ["arrayinit.temp"] -// CHECK-NEXT: %[[DECAY:.*]] = cir.cast array_to_ptrdecay %[[ALLOCA]] : !cir.ptr<!cir.array<!cir.float x 5>> -> !cir.ptr<!cir.float> -// CHECK-NEXT: cir.store {{.*}} %[[DECAY]], %[[TEMP_ITR]] : !cir.ptr<!cir.float>, !cir.ptr<!cir.ptr<!cir.float>> -// CHECK-NEXT: %[[LAST_IDX:.*]] = cir.const #cir.int<5> : !s64i -// CHECK-NEXT: %[[END_ITR:.*]] = cir.ptr_stride %[[DECAY]], %[[LAST_IDX]] : (!cir.ptr<!cir.float>, !s64i) -> !cir.ptr<!cir.float> -// CHECK-NEXT: cir.do { -// CHECK-NEXT: %[[TEMP_LOAD:.*]] = cir.load {{.*}} %[[TEMP_ITR]] : !cir.ptr<!cir.ptr<!cir.float>>, !cir.ptr<!cir.float> -// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.fp<0{{.*}}> : !cir.float -// CHECK-NEXT: cir.store {{.*}} %[[ZERO]], %[[TEMP_LOAD]] : !cir.float, !cir.ptr<!cir.float> -// CHECK-NEXT: %[[ONE:.*]] = cir.const #cir.int<1> : !s64i -// CHECK-NEXT: %[[NEXT_ITEM:.*]] = cir.ptr_stride %[[TEMP_LOAD]], %[[ONE]] : (!cir.ptr<!cir.float>, !s64i) -> !cir.ptr<!cir.float> -// CHECK-NEXT: cir.store {{.*}} %[[NEXT_ITEM]], %[[TEMP_ITR]] : !cir.ptr<!cir.float>, !cir.ptr<!cir.ptr<!cir.float>> -// CHECK-NEXT: cir.yield -// CHECK-NEXT: } while { -// CHECK-NEXT: %[[TEMP_LOAD:.*]] = cir.load {{.*}} %[[TEMP_ITR]] : !cir.ptr<!cir.ptr<!cir.float>>, !cir.ptr<!cir.float> -// CHECK-NEXT: %[[CMP:.*]] = cir.cmp(ne, %[[TEMP_LOAD]], %[[END_ITR]]) : !cir.ptr<!cir.float>, !cir.bool -// CHECK-NEXT: cir.condition(%[[CMP]]) -// CHECK-NEXT: } -// CHECK-NEXT: acc.yield -// -// CHECK-NEXT: } combiner { -// CHECK-NEXT: ^bb0(%[[LHSARG:.*]]: !cir.ptr<!cir.array<!cir.float x 5>> {{.*}}, %[[RHSARG:.*]]: !cir.ptr<!cir.array<!cir.float x 5>> {{.*}}) -// TODO OpenACC: Expecting combination operation here -// CHECK-NEXT: acc.yield %[[LHSARG]] : !cir.ptr<!cir.array<!cir.float x 5>> -// CHECK-NEXT: } - for(int i=0;i < 5; ++i); #pragma acc loop reduction(&&:someVarArr) // CHECK-NEXT: acc.reduction.recipe @reduction_land__ZTSA5_f : !cir.ptr<!cir.array<!cir.float x 5>> reduction_operator <land> init { // CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!cir.float x 5>>{{.*}}) @@ -543,111 +411,6 @@ void acc_loop() { // CHECK-NEXT: acc.yield %[[LHSARG]] : !cir.ptr<!cir.array<!cir.float x 5>> // CHECK-NEXT: } for(int i=0;i < 5; ++i); -#pragma acc loop reduction(&:someVarArr[2]) -// CHECK-NEXT: acc.reduction.recipe @reduction_iand__Bcnt1__ZTSA5_f : !cir.ptr<!cir.array<!cir.float x 5>> reduction_operator <iand> init { -// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!cir.float x 5>>{{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty{{.*}})) -// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !cir.array<!cir.float x 5>, !cir.ptr<!cir.array<!cir.float x 5>>, ["openacc.reduction.init"] -// CHECK-NEXT: cir.scope { -// CHECK-NEXT: %[[LB:.*]] = acc.get_lowerbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index -// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i -// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index -// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i -// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"] {alignment = 8 : i64} -// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i> -// CHECK-NEXT: cir.for : cond { -// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i -// CHECK-NEXT: %[[COND:.*]] = cir.cmp(lt, %[[ITR_LOAD]], %[[UB_CAST]]) : !u64i, !cir.bool -// CHECK-NEXT: cir.condition(%[[COND]]) -// CHECK-NEXT: } body { -// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i -// CHECK-NEXT: %[[DECAY:.*]] = cir.cast array_to_ptrdecay %[[ALLOCA]] : !cir.ptr<!cir.array<!cir.float x 5>> -> !cir.ptr<!cir.float> -// CHECK-NEXT: %[[STRIDE:.*]] = cir.ptr_stride %[[DECAY]], %[[ITR_LOAD]] : (!cir.ptr<!cir.float>, !u64i) -> !cir.ptr<!cir.float> -// CHECK-NEXT: %[[ALL_ONES:.*]] = cir.const #cir.fp<0xF{{.*}}> : !cir.float -// CHECK-NEXT: cir.store{{.*}} %[[ALL_ONES]], %[[STRIDE]] : !cir.float, !cir.ptr<!cir.float> -// CHECK-NEXT: cir.yield -// CHECK-NEXT: } step { -// CHECK-NEXT: %[[ITR_LOAD]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i -// CHECK-NEXT: %[[INC:.*]] = cir.unary(inc, %[[ITR_LOAD]]) : !u64i, !u64i -// CHECK-NEXT: cir.store %[[INC]], %[[ITR]] : !u64i, !cir.ptr<!u64i> -// CHECK-NEXT: cir.yield -// CHECK-NEXT: } -// CHECK-NEXT: } -// CHECK-NEXT: acc.yield -// CHECK-NEXT: } combiner { -// CHECK-NEXT: ^bb0(%[[LHSARG:.*]]: !cir.ptr<!cir.array<!cir.float x 5>> {{.*}}, %[[RHSARG:.*]]: !cir.ptr<!cir.array<!cir.float x 5>> {{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty{{.*}})) -// CHECK-NEXT: acc.yield %[[LHSARG]] : !cir.ptr<!cir.array<!cir.float x 5>> -// CHECK-NEXT: } - for(int i=0;i < 5; ++i); -#pragma acc loop reduction(|:someVarArr[2]) -// CHECK-NEXT: acc.reduction.recipe @reduction_ior__Bcnt1__ZTSA5_f : !cir.ptr<!cir.array<!cir.float x 5>> reduction_operator <ior> init { -// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!cir.float x 5>>{{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty{{.*}})) -// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !cir.array<!cir.float x 5>, !cir.ptr<!cir.array<!cir.float x 5>>, ["openacc.reduction.init"] -// CHECK-NEXT: cir.scope { -// CHECK-NEXT: %[[LB:.*]] = acc.get_lowerbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index -// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i -// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index -// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i -// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"] {alignment = 8 : i64} -// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i> -// CHECK-NEXT: cir.for : cond { -// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i -// CHECK-NEXT: %[[COND:.*]] = cir.cmp(lt, %[[ITR_LOAD]], %[[UB_CAST]]) : !u64i, !cir.bool -// CHECK-NEXT: cir.condition(%[[COND]]) -// CHECK-NEXT: } body { -// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i -// CHECK-NEXT: %[[DECAY:.*]] = cir.cast array_to_ptrdecay %[[ALLOCA]] : !cir.ptr<!cir.array<!cir.float x 5>> -> !cir.ptr<!cir.float> -// CHECK-NEXT: %[[STRIDE:.*]] = cir.ptr_stride %[[DECAY]], %[[ITR_LOAD]] : (!cir.ptr<!cir.float>, !u64i) -> !cir.ptr<!cir.float> -// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.fp<0{{.*}}> : !cir.float -// CHECK-NEXT: cir.store{{.*}} %[[ZERO]], %[[STRIDE]] : !cir.float, !cir.ptr<!cir.float> -// CHECK-NEXT: cir.yield -// CHECK-NEXT: } step { -// CHECK-NEXT: %[[ITR_LOAD]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i -// CHECK-NEXT: %[[INC:.*]] = cir.unary(inc, %[[ITR_LOAD]]) : !u64i, !u64i -// CHECK-NEXT: cir.store %[[INC]], %[[ITR]] : !u64i, !cir.ptr<!u64i> -// CHECK-NEXT: cir.yield -// CHECK-NEXT: } -// CHECK-NEXT: } -// CHECK-NEXT: acc.yield -// CHECK-NEXT: } combiner { -// CHECK-NEXT: ^bb0(%[[LHSARG:.*]]: !cir.ptr<!cir.array<!cir.float x 5>> {{.*}}, %[[RHSARG:.*]]: !cir.ptr<!cir.array<!cir.float x 5>> {{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty{{.*}})) -// CHECK-NEXT: acc.yield %[[LHSARG]] : !cir.ptr<!cir.array<!cir.float x 5>> -// CHECK-NEXT: } - for(int i=0;i < 5; ++i); -#pragma acc loop reduction(^:someVarArr[2]) -// CHECK-NEXT: acc.reduction.recipe @reduction_xor__Bcnt1__ZTSA5_f : !cir.ptr<!cir.array<!cir.float x 5>> reduction_operator <xor> init { -// CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!cir.float x 5>>{{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty{{.*}})) -// CHECK-NEXT: %[[ALLOCA:.*]] = cir.alloca !cir.array<!cir.float x 5>, !cir.ptr<!cir.array<!cir.float x 5>>, ["openacc.reduction.init"] -// CHECK-NEXT: cir.scope { -// CHECK-NEXT: %[[LB:.*]] = acc.get_lowerbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index -// CHECK-NEXT: %[[LB_CAST:.*]] = builtin.unrealized_conversion_cast %[[LB]] : index to !u64i -// CHECK-NEXT: %[[UB:.*]] = acc.get_upperbound %[[BOUND1]] : (!acc.data_bounds_ty) -> index -// CHECK-NEXT: %[[UB_CAST:.*]] = builtin.unrealized_conversion_cast %[[UB]] : index to !u64i -// CHECK-NEXT: %[[ITR:.*]] = cir.alloca !u64i, !cir.ptr<!u64i>, ["iter"] {alignment = 8 : i64} -// CHECK-NEXT: cir.store %[[LB_CAST]], %[[ITR]] : !u64i, !cir.ptr<!u64i> -// CHECK-NEXT: cir.for : cond { -// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i -// CHECK-NEXT: %[[COND:.*]] = cir.cmp(lt, %[[ITR_LOAD]], %[[UB_CAST]]) : !u64i, !cir.bool -// CHECK-NEXT: cir.condition(%[[COND]]) -// CHECK-NEXT: } body { -// CHECK-NEXT: %[[ITR_LOAD:.*]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i -// CHECK-NEXT: %[[DECAY:.*]] = cir.cast array_to_ptrdecay %[[ALLOCA]] : !cir.ptr<!cir.array<!cir.float x 5>> -> !cir.ptr<!cir.float> -// CHECK-NEXT: %[[STRIDE:.*]] = cir.ptr_stride %[[DECAY]], %[[ITR_LOAD]] : (!cir.ptr<!cir.float>, !u64i) -> !cir.ptr<!cir.float> -// CHECK-NEXT: %[[ZERO:.*]] = cir.const #cir.fp<0{{.*}}> : !cir.float -// CHECK-NEXT: cir.store{{.*}} %[[ZERO]], %[[STRIDE]] : !cir.float, !cir.ptr<!cir.float> -// CHECK-NEXT: cir.yield -// CHECK-NEXT: } step { -// CHECK-NEXT: %[[ITR_LOAD]] = cir.load %[[ITR]] : !cir.ptr<!u64i>, !u64i -// CHECK-NEXT: %[[INC:.*]] = cir.unary(inc, %[[ITR_LOAD]]) : !u64i, !u64i -// CHECK-NEXT: cir.store %[[INC]], %[[ITR]] : !u64i, !cir.ptr<!u64i> -// CHECK-NEXT: cir.yield -// CHECK-NEXT: } -// CHECK-NEXT: } -// CHECK-NEXT: acc.yield -// CHECK-NEXT: } combiner { -// CHECK-NEXT: ^bb0(%[[LHSARG:.*]]: !cir.ptr<!cir.array<!cir.float x 5>> {{.*}}, %[[RHSARG:.*]]: !cir.ptr<!cir.array<!cir.float x 5>> {{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty{{.*}})) -// CHECK-NEXT: acc.yield %[[LHSARG]] : !cir.ptr<!cir.array<!cir.float x 5>> -// CHECK-NEXT: } - for(int i=0;i < 5; ++i); #pragma acc loop reduction(&&:someVarArr[2]) // CHECK-NEXT: acc.reduction.recipe @reduction_land__Bcnt1__ZTSA5_f : !cir.ptr<!cir.array<!cir.float x 5>> reduction_operator <land> init { // CHECK-NEXT: ^bb0(%[[ARG:.*]]: !cir.ptr<!cir.array<!cir.float x 5>>{{.*}}, %[[BOUND1:.*]]: !acc.data_bounds_ty{{.*}})) @@ -727,12 +490,6 @@ void acc_loop() { for(int i=0;i < 5; ++i); #pragma acc loop reduction(min:someVarArr[1:1]) for(int i=0;i < 5; ++i); -#pragma acc loop reduction(&:someVarArr[1:1]) - for(int i=0;i < 5; ++i); -#pragma acc loop reduction(|:someVarArr[1:1]) - for(int i=0;i < 5; ++i); -#pragma acc loop reduction(^:someVarArr[1:1]) - for(int i=0;i < 5; ++i); #pragma acc loop reduction(&&:someVarArr[1:1]) for(int i=0;i < 5; ++i); #pragma acc loop reduction(||:someVarArr[1:1]) diff --git a/clang/test/CodeGen/backend-unsupported-error.ll b/clang/test/CodeGen/backend-unsupported-error.ll index 2de2c87..47b397b6b 100644 --- a/clang/test/CodeGen/backend-unsupported-error.ll +++ b/clang/test/CodeGen/backend-unsupported-error.ll @@ -21,7 +21,7 @@ entry: ret i32 %call, !dbg !15 } -attributes #0 = { nounwind noinline "disable-tail-calls"="false" "less-precise-fpmad"="false" "frame-pointer"="all" "no-infs-fp-math"="false" "no-nans-fp-math"="false" "stack-protector-buffer-size"="8" "unsafe-fp-math"="false" "use-soft-float"="false" } +attributes #0 = { nounwind noinline "disable-tail-calls"="false" "less-precise-fpmad"="false" "frame-pointer"="all" "no-infs-fp-math"="false" "no-nans-fp-math"="false" "stack-protector-buffer-size"="8" "use-soft-float"="false" } !llvm.dbg.cu = !{!0} !llvm.module.flags = !{!9, !10} diff --git a/clang/test/CodeGen/builtins-image-load.c b/clang/test/CodeGen/builtins-image-load.c new file mode 100644 index 0000000..8442124 --- /dev/null +++ b/clang/test/CodeGen/builtins-image-load.c @@ -0,0 +1,1203 @@ +// NOTE: Assertions have been autogenerated by utils/update_cc_test_checks.py UTC_ARGS: --version 5 +// RUN: %clang_cc1 -triple amdgcn-- -target-cpu gfx1100 %s -emit-llvm -o - | FileCheck %s + +typedef int int4 __attribute__((ext_vector_type(4))); +typedef float float4 __attribute__((ext_vector_type(4))); +typedef _Float16 half; +typedef half half4 __attribute__((ext_vector_type(4))); + +// CHECK-LABEL: define dso_local float @test_builtin_image_load_2d( +// CHECK-SAME: float noundef [[F32:%.*]], i32 noundef [[I32:%.*]], ptr [[TEX:%.*]]) #[[ATTR0:[0-9]+]] { +// CHECK-NEXT: [[ENTRY:.*:]] +// CHECK-NEXT: [[RETVAL:%.*]] = alloca float, align 4, addrspace(5) +// CHECK-NEXT: [[F32_ADDR:%.*]] = alloca float, align 4, addrspace(5) +// CHECK-NEXT: [[I32_ADDR:%.*]] = alloca i32, align 4, addrspace(5) +// CHECK-NEXT: [[TEX_ADDR:%.*]] = alloca ptr, align 32, addrspace(5) +// CHECK-NEXT: [[RETVAL_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[RETVAL]] to ptr +// CHECK-NEXT: [[F32_ADDR_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[F32_ADDR]] to ptr +// CHECK-NEXT: [[I32_ADDR_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[I32_ADDR]] to ptr +// CHECK-NEXT: [[TEX_ADDR_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[TEX_ADDR]] to ptr +// CHECK-NEXT: store float [[F32]], ptr [[F32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: store i32 [[I32]], ptr [[I32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: store ptr [[TEX]], ptr [[TEX_ADDR_ASCAST]], align 32 +// CHECK-NEXT: [[TMP0:%.*]] = load i32, ptr [[I32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: [[TMP1:%.*]] = load i32, ptr [[I32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: [[TMP2:%.*]] = load ptr, ptr [[TEX_ADDR_ASCAST]], align 32 +// CHECK-NEXT: [[TEX_RSRC_VAL:%.*]] = load <8 x i32>, ptr [[TMP2]], align 32 +// CHECK-NEXT: [[TMP3:%.*]] = call float @llvm.amdgcn.image.load.2d.f32.i32.v8i32(i32 12, i32 [[TMP0]], i32 [[TMP1]], <8 x i32> [[TEX_RSRC_VAL]], i32 106, i32 103) +// CHECK-NEXT: ret float [[TMP3]] +// +float test_builtin_image_load_2d(float f32, int i32, __amdgpu_texture_t tex) { + + return __builtin_amdgcn_image_load_2d_f32_i32(12, i32, i32, tex, 106, 103); +} + +// CHECK-LABEL: define dso_local <4 x float> @test_builtin_image_load_2d_1( +// CHECK-SAME: <4 x float> noundef [[V4F32:%.*]], i32 noundef [[I32:%.*]], ptr [[TEX:%.*]]) #[[ATTR0]] { +// CHECK-NEXT: [[ENTRY:.*:]] +// CHECK-NEXT: [[RETVAL:%.*]] = alloca <4 x float>, align 16, addrspace(5) +// CHECK-NEXT: [[V4F32_ADDR:%.*]] = alloca <4 x float>, align 16, addrspace(5) +// CHECK-NEXT: [[I32_ADDR:%.*]] = alloca i32, align 4, addrspace(5) +// CHECK-NEXT: [[TEX_ADDR:%.*]] = alloca ptr, align 32, addrspace(5) +// CHECK-NEXT: [[RETVAL_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[RETVAL]] to ptr +// CHECK-NEXT: [[V4F32_ADDR_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[V4F32_ADDR]] to ptr +// CHECK-NEXT: [[I32_ADDR_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[I32_ADDR]] to ptr +// CHECK-NEXT: [[TEX_ADDR_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[TEX_ADDR]] to ptr +// CHECK-NEXT: store <4 x float> [[V4F32]], ptr [[V4F32_ADDR_ASCAST]], align 16 +// CHECK-NEXT: store i32 [[I32]], ptr [[I32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: store ptr [[TEX]], ptr [[TEX_ADDR_ASCAST]], align 32 +// CHECK-NEXT: [[TMP0:%.*]] = load i32, ptr [[I32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: [[TMP1:%.*]] = load i32, ptr [[I32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: [[TMP2:%.*]] = load ptr, ptr [[TEX_ADDR_ASCAST]], align 32 +// CHECK-NEXT: [[TEX_RSRC_VAL:%.*]] = load <8 x i32>, ptr [[TMP2]], align 32 +// CHECK-NEXT: [[TMP3:%.*]] = call <4 x float> @llvm.amdgcn.image.load.2d.v4f32.i32.v8i32(i32 100, i32 [[TMP0]], i32 [[TMP1]], <8 x i32> [[TEX_RSRC_VAL]], i32 120, i32 110) +// CHECK-NEXT: ret <4 x float> [[TMP3]] +// +float4 test_builtin_image_load_2d_1(float4 v4f32, int i32, __amdgpu_texture_t tex) { + + return __builtin_amdgcn_image_load_2d_v4f32_i32(100, i32, i32, tex, 120, 110); +} + +// CHECK-LABEL: define dso_local <4 x half> @test_builtin_image_load_2d_2( +// CHECK-SAME: <4 x half> noundef [[V4F16:%.*]], i32 noundef [[I32:%.*]], ptr [[TEX:%.*]]) #[[ATTR0]] { +// CHECK-NEXT: [[ENTRY:.*:]] +// CHECK-NEXT: [[RETVAL:%.*]] = alloca <4 x half>, align 8, addrspace(5) +// CHECK-NEXT: [[V4F16_ADDR:%.*]] = alloca <4 x half>, align 8, addrspace(5) +// CHECK-NEXT: [[I32_ADDR:%.*]] = alloca i32, align 4, addrspace(5) +// CHECK-NEXT: [[TEX_ADDR:%.*]] = alloca ptr, align 32, addrspace(5) +// CHECK-NEXT: [[RETVAL_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[RETVAL]] to ptr +// CHECK-NEXT: [[V4F16_ADDR_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[V4F16_ADDR]] to ptr +// CHECK-NEXT: [[I32_ADDR_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[I32_ADDR]] to ptr +// CHECK-NEXT: [[TEX_ADDR_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[TEX_ADDR]] to ptr +// CHECK-NEXT: store <4 x half> [[V4F16]], ptr [[V4F16_ADDR_ASCAST]], align 8 +// CHECK-NEXT: store i32 [[I32]], ptr [[I32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: store ptr [[TEX]], ptr [[TEX_ADDR_ASCAST]], align 32 +// CHECK-NEXT: [[TMP0:%.*]] = load i32, ptr [[I32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: [[TMP1:%.*]] = load i32, ptr [[I32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: [[TMP2:%.*]] = load ptr, ptr [[TEX_ADDR_ASCAST]], align 32 +// CHECK-NEXT: [[TEX_RSRC_VAL:%.*]] = load <8 x i32>, ptr [[TMP2]], align 32 +// CHECK-NEXT: [[TMP3:%.*]] = call <4 x half> @llvm.amdgcn.image.load.2d.v4f16.i32.v8i32(i32 100, i32 [[TMP0]], i32 [[TMP1]], <8 x i32> [[TEX_RSRC_VAL]], i32 120, i32 110) +// CHECK-NEXT: ret <4 x half> [[TMP3]] +// +half4 test_builtin_image_load_2d_2(half4 v4f16, int i32, __amdgpu_texture_t tex) { + + return __builtin_amdgcn_image_load_2d_v4f16_i32(100, i32, i32, tex, 120, 110); +} + +// CHECK-LABEL: define dso_local float @test_builtin_image_load_2darray( +// CHECK-SAME: float noundef [[F32:%.*]], i32 noundef [[I32:%.*]], ptr [[TEX:%.*]]) #[[ATTR0]] { +// CHECK-NEXT: [[ENTRY:.*:]] +// CHECK-NEXT: [[RETVAL:%.*]] = alloca float, align 4, addrspace(5) +// CHECK-NEXT: [[F32_ADDR:%.*]] = alloca float, align 4, addrspace(5) +// CHECK-NEXT: [[I32_ADDR:%.*]] = alloca i32, align 4, addrspace(5) +// CHECK-NEXT: [[TEX_ADDR:%.*]] = alloca ptr, align 32, addrspace(5) +// CHECK-NEXT: [[RETVAL_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[RETVAL]] to ptr +// CHECK-NEXT: [[F32_ADDR_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[F32_ADDR]] to ptr +// CHECK-NEXT: [[I32_ADDR_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[I32_ADDR]] to ptr +// CHECK-NEXT: [[TEX_ADDR_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[TEX_ADDR]] to ptr +// CHECK-NEXT: store float [[F32]], ptr [[F32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: store i32 [[I32]], ptr [[I32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: store ptr [[TEX]], ptr [[TEX_ADDR_ASCAST]], align 32 +// CHECK-NEXT: [[TMP0:%.*]] = load i32, ptr [[I32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: [[TMP1:%.*]] = load i32, ptr [[I32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: [[TMP2:%.*]] = load i32, ptr [[I32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: [[TMP3:%.*]] = load ptr, ptr [[TEX_ADDR_ASCAST]], align 32 +// CHECK-NEXT: [[TEX_RSRC_VAL:%.*]] = load <8 x i32>, ptr [[TMP3]], align 32 +// CHECK-NEXT: [[TMP4:%.*]] = call float @llvm.amdgcn.image.load.2darray.f32.i32.v8i32(i32 100, i32 [[TMP0]], i32 [[TMP1]], i32 [[TMP2]], <8 x i32> [[TEX_RSRC_VAL]], i32 120, i32 110) +// CHECK-NEXT: ret float [[TMP4]] +// +float test_builtin_image_load_2darray(float f32, int i32, __amdgpu_texture_t tex) { + + return __builtin_amdgcn_image_load_2darray_f32_i32(100, i32, i32, i32, tex, 120, 110); +} + +// CHECK-LABEL: define dso_local <4 x float> @test_builtin_image_load_2darray_1( +// CHECK-SAME: <4 x float> noundef [[V4F32:%.*]], i32 noundef [[I32:%.*]], ptr [[TEX:%.*]]) #[[ATTR0]] { +// CHECK-NEXT: [[ENTRY:.*:]] +// CHECK-NEXT: [[RETVAL:%.*]] = alloca <4 x float>, align 16, addrspace(5) +// CHECK-NEXT: [[V4F32_ADDR:%.*]] = alloca <4 x float>, align 16, addrspace(5) +// CHECK-NEXT: [[I32_ADDR:%.*]] = alloca i32, align 4, addrspace(5) +// CHECK-NEXT: [[TEX_ADDR:%.*]] = alloca ptr, align 32, addrspace(5) +// CHECK-NEXT: [[RETVAL_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[RETVAL]] to ptr +// CHECK-NEXT: [[V4F32_ADDR_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[V4F32_ADDR]] to ptr +// CHECK-NEXT: [[I32_ADDR_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[I32_ADDR]] to ptr +// CHECK-NEXT: [[TEX_ADDR_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[TEX_ADDR]] to ptr +// CHECK-NEXT: store <4 x float> [[V4F32]], ptr [[V4F32_ADDR_ASCAST]], align 16 +// CHECK-NEXT: store i32 [[I32]], ptr [[I32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: store ptr [[TEX]], ptr [[TEX_ADDR_ASCAST]], align 32 +// CHECK-NEXT: [[TMP0:%.*]] = load i32, ptr [[I32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: [[TMP1:%.*]] = load i32, ptr [[I32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: [[TMP2:%.*]] = load i32, ptr [[I32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: [[TMP3:%.*]] = load ptr, ptr [[TEX_ADDR_ASCAST]], align 32 +// CHECK-NEXT: [[TEX_RSRC_VAL:%.*]] = load <8 x i32>, ptr [[TMP3]], align 32 +// CHECK-NEXT: [[TMP4:%.*]] = call <4 x float> @llvm.amdgcn.image.load.2darray.v4f32.i32.v8i32(i32 100, i32 [[TMP0]], i32 [[TMP1]], i32 [[TMP2]], <8 x i32> [[TEX_RSRC_VAL]], i32 120, i32 110) +// CHECK-NEXT: ret <4 x float> [[TMP4]] +// +float4 test_builtin_image_load_2darray_1(float4 v4f32, int i32, __amdgpu_texture_t tex) { + + return __builtin_amdgcn_image_load_2darray_v4f32_i32(100, i32, i32, i32, tex, 120, 110); +} + +// CHECK-LABEL: define dso_local <4 x half> @test_builtin_image_load_2darray_2( +// CHECK-SAME: <4 x half> noundef [[V4F16:%.*]], i32 noundef [[I32:%.*]], ptr [[TEX:%.*]]) #[[ATTR0]] { +// CHECK-NEXT: [[ENTRY:.*:]] +// CHECK-NEXT: [[RETVAL:%.*]] = alloca <4 x half>, align 8, addrspace(5) +// CHECK-NEXT: [[V4F16_ADDR:%.*]] = alloca <4 x half>, align 8, addrspace(5) +// CHECK-NEXT: [[I32_ADDR:%.*]] = alloca i32, align 4, addrspace(5) +// CHECK-NEXT: [[TEX_ADDR:%.*]] = alloca ptr, align 32, addrspace(5) +// CHECK-NEXT: [[RETVAL_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[RETVAL]] to ptr +// CHECK-NEXT: [[V4F16_ADDR_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[V4F16_ADDR]] to ptr +// CHECK-NEXT: [[I32_ADDR_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[I32_ADDR]] to ptr +// CHECK-NEXT: [[TEX_ADDR_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[TEX_ADDR]] to ptr +// CHECK-NEXT: store <4 x half> [[V4F16]], ptr [[V4F16_ADDR_ASCAST]], align 8 +// CHECK-NEXT: store i32 [[I32]], ptr [[I32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: store ptr [[TEX]], ptr [[TEX_ADDR_ASCAST]], align 32 +// CHECK-NEXT: [[TMP0:%.*]] = load i32, ptr [[I32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: [[TMP1:%.*]] = load i32, ptr [[I32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: [[TMP2:%.*]] = load i32, ptr [[I32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: [[TMP3:%.*]] = load ptr, ptr [[TEX_ADDR_ASCAST]], align 32 +// CHECK-NEXT: [[TEX_RSRC_VAL:%.*]] = load <8 x i32>, ptr [[TMP3]], align 32 +// CHECK-NEXT: [[TMP4:%.*]] = call <4 x half> @llvm.amdgcn.image.load.2darray.v4f16.i32.v8i32(i32 100, i32 [[TMP0]], i32 [[TMP1]], i32 [[TMP2]], <8 x i32> [[TEX_RSRC_VAL]], i32 120, i32 110) +// CHECK-NEXT: ret <4 x half> [[TMP4]] +// +half4 test_builtin_image_load_2darray_2(half4 v4f16, int i32, __amdgpu_texture_t tex) { + + return __builtin_amdgcn_image_load_2darray_v4f16_i32(100, i32, i32, i32, tex, 120, 110); +} + +// CHECK-LABEL: define dso_local <4 x float> @test_builtin_image_load_1d_1( +// CHECK-SAME: <4 x float> noundef [[V4F32:%.*]], i32 noundef [[I32:%.*]], ptr [[TEX:%.*]]) #[[ATTR0]] { +// CHECK-NEXT: [[ENTRY:.*:]] +// CHECK-NEXT: [[RETVAL:%.*]] = alloca <4 x float>, align 16, addrspace(5) +// CHECK-NEXT: [[V4F32_ADDR:%.*]] = alloca <4 x float>, align 16, addrspace(5) +// CHECK-NEXT: [[I32_ADDR:%.*]] = alloca i32, align 4, addrspace(5) +// CHECK-NEXT: [[TEX_ADDR:%.*]] = alloca ptr, align 32, addrspace(5) +// CHECK-NEXT: [[RETVAL_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[RETVAL]] to ptr +// CHECK-NEXT: [[V4F32_ADDR_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[V4F32_ADDR]] to ptr +// CHECK-NEXT: [[I32_ADDR_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[I32_ADDR]] to ptr +// CHECK-NEXT: [[TEX_ADDR_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[TEX_ADDR]] to ptr +// CHECK-NEXT: store <4 x float> [[V4F32]], ptr [[V4F32_ADDR_ASCAST]], align 16 +// CHECK-NEXT: store i32 [[I32]], ptr [[I32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: store ptr [[TEX]], ptr [[TEX_ADDR_ASCAST]], align 32 +// CHECK-NEXT: [[TMP0:%.*]] = load i32, ptr [[I32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: [[TMP1:%.*]] = load ptr, ptr [[TEX_ADDR_ASCAST]], align 32 +// CHECK-NEXT: [[TEX_RSRC_VAL:%.*]] = load <8 x i32>, ptr [[TMP1]], align 32 +// CHECK-NEXT: [[TMP2:%.*]] = call <4 x float> @llvm.amdgcn.image.load.1d.v4f32.i32.v8i32(i32 100, i32 [[TMP0]], <8 x i32> [[TEX_RSRC_VAL]], i32 120, i32 110) +// CHECK-NEXT: ret <4 x float> [[TMP2]] +// +float4 test_builtin_image_load_1d_1(float4 v4f32, int i32, __amdgpu_texture_t tex) { + + return __builtin_amdgcn_image_load_1d_v4f32_i32(100, i32, tex, 120, 110); +} + +// CHECK-LABEL: define dso_local <4 x half> @test_builtin_image_load_1d_2( +// CHECK-SAME: <4 x half> noundef [[V4F16:%.*]], i32 noundef [[I32:%.*]], ptr [[TEX:%.*]]) #[[ATTR0]] { +// CHECK-NEXT: [[ENTRY:.*:]] +// CHECK-NEXT: [[RETVAL:%.*]] = alloca <4 x half>, align 8, addrspace(5) +// CHECK-NEXT: [[V4F16_ADDR:%.*]] = alloca <4 x half>, align 8, addrspace(5) +// CHECK-NEXT: [[I32_ADDR:%.*]] = alloca i32, align 4, addrspace(5) +// CHECK-NEXT: [[TEX_ADDR:%.*]] = alloca ptr, align 32, addrspace(5) +// CHECK-NEXT: [[RETVAL_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[RETVAL]] to ptr +// CHECK-NEXT: [[V4F16_ADDR_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[V4F16_ADDR]] to ptr +// CHECK-NEXT: [[I32_ADDR_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[I32_ADDR]] to ptr +// CHECK-NEXT: [[TEX_ADDR_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[TEX_ADDR]] to ptr +// CHECK-NEXT: store <4 x half> [[V4F16]], ptr [[V4F16_ADDR_ASCAST]], align 8 +// CHECK-NEXT: store i32 [[I32]], ptr [[I32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: store ptr [[TEX]], ptr [[TEX_ADDR_ASCAST]], align 32 +// CHECK-NEXT: [[TMP0:%.*]] = load i32, ptr [[I32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: [[TMP1:%.*]] = load ptr, ptr [[TEX_ADDR_ASCAST]], align 32 +// CHECK-NEXT: [[TEX_RSRC_VAL:%.*]] = load <8 x i32>, ptr [[TMP1]], align 32 +// CHECK-NEXT: [[TMP2:%.*]] = call <4 x half> @llvm.amdgcn.image.load.1d.v4f16.i32.v8i32(i32 100, i32 [[TMP0]], <8 x i32> [[TEX_RSRC_VAL]], i32 120, i32 110) +// CHECK-NEXT: ret <4 x half> [[TMP2]] +// +half4 test_builtin_image_load_1d_2(half4 v4f16, int i32, __amdgpu_texture_t tex) { + + return __builtin_amdgcn_image_load_1d_v4f16_i32(100, i32, tex, 120, 110); +} + +// CHECK-LABEL: define dso_local <4 x float> @test_builtin_image_load_1darray_1( +// CHECK-SAME: <4 x float> noundef [[V4F32:%.*]], i32 noundef [[I32:%.*]], ptr [[TEX:%.*]]) #[[ATTR0]] { +// CHECK-NEXT: [[ENTRY:.*:]] +// CHECK-NEXT: [[RETVAL:%.*]] = alloca <4 x float>, align 16, addrspace(5) +// CHECK-NEXT: [[V4F32_ADDR:%.*]] = alloca <4 x float>, align 16, addrspace(5) +// CHECK-NEXT: [[I32_ADDR:%.*]] = alloca i32, align 4, addrspace(5) +// CHECK-NEXT: [[TEX_ADDR:%.*]] = alloca ptr, align 32, addrspace(5) +// CHECK-NEXT: [[RETVAL_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[RETVAL]] to ptr +// CHECK-NEXT: [[V4F32_ADDR_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[V4F32_ADDR]] to ptr +// CHECK-NEXT: [[I32_ADDR_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[I32_ADDR]] to ptr +// CHECK-NEXT: [[TEX_ADDR_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[TEX_ADDR]] to ptr +// CHECK-NEXT: store <4 x float> [[V4F32]], ptr [[V4F32_ADDR_ASCAST]], align 16 +// CHECK-NEXT: store i32 [[I32]], ptr [[I32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: store ptr [[TEX]], ptr [[TEX_ADDR_ASCAST]], align 32 +// CHECK-NEXT: [[TMP0:%.*]] = load i32, ptr [[I32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: [[TMP1:%.*]] = load i32, ptr [[I32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: [[TMP2:%.*]] = load ptr, ptr [[TEX_ADDR_ASCAST]], align 32 +// CHECK-NEXT: [[TEX_RSRC_VAL:%.*]] = load <8 x i32>, ptr [[TMP2]], align 32 +// CHECK-NEXT: [[TMP3:%.*]] = call <4 x float> @llvm.amdgcn.image.load.1darray.v4f32.i32.v8i32(i32 100, i32 [[TMP0]], i32 [[TMP1]], <8 x i32> [[TEX_RSRC_VAL]], i32 120, i32 110) +// CHECK-NEXT: ret <4 x float> [[TMP3]] +// +float4 test_builtin_image_load_1darray_1(float4 v4f32, int i32, __amdgpu_texture_t tex) { + + return __builtin_amdgcn_image_load_1darray_v4f32_i32(100, i32, i32, tex, 120, 110); +} + +// CHECK-LABEL: define dso_local <4 x half> @test_builtin_image_load_1darray_2( +// CHECK-SAME: <4 x half> noundef [[V4F16:%.*]], i32 noundef [[I32:%.*]], ptr [[TEX:%.*]]) #[[ATTR0]] { +// CHECK-NEXT: [[ENTRY:.*:]] +// CHECK-NEXT: [[RETVAL:%.*]] = alloca <4 x half>, align 8, addrspace(5) +// CHECK-NEXT: [[V4F16_ADDR:%.*]] = alloca <4 x half>, align 8, addrspace(5) +// CHECK-NEXT: [[I32_ADDR:%.*]] = alloca i32, align 4, addrspace(5) +// CHECK-NEXT: [[TEX_ADDR:%.*]] = alloca ptr, align 32, addrspace(5) +// CHECK-NEXT: [[RETVAL_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[RETVAL]] to ptr +// CHECK-NEXT: [[V4F16_ADDR_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[V4F16_ADDR]] to ptr +// CHECK-NEXT: [[I32_ADDR_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[I32_ADDR]] to ptr +// CHECK-NEXT: [[TEX_ADDR_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[TEX_ADDR]] to ptr +// CHECK-NEXT: store <4 x half> [[V4F16]], ptr [[V4F16_ADDR_ASCAST]], align 8 +// CHECK-NEXT: store i32 [[I32]], ptr [[I32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: store ptr [[TEX]], ptr [[TEX_ADDR_ASCAST]], align 32 +// CHECK-NEXT: [[TMP0:%.*]] = load i32, ptr [[I32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: [[TMP1:%.*]] = load i32, ptr [[I32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: [[TMP2:%.*]] = load ptr, ptr [[TEX_ADDR_ASCAST]], align 32 +// CHECK-NEXT: [[TEX_RSRC_VAL:%.*]] = load <8 x i32>, ptr [[TMP2]], align 32 +// CHECK-NEXT: [[TMP3:%.*]] = call <4 x half> @llvm.amdgcn.image.load.1darray.v4f16.i32.v8i32(i32 100, i32 [[TMP0]], i32 [[TMP1]], <8 x i32> [[TEX_RSRC_VAL]], i32 120, i32 110) +// CHECK-NEXT: ret <4 x half> [[TMP3]] +// +half4 test_builtin_image_load_1darray_2(half4 v4f16, int i32, __amdgpu_texture_t tex) { + + return __builtin_amdgcn_image_load_1darray_v4f16_i32(100, i32, i32, tex, 120, 110); +} + +// CHECK-LABEL: define dso_local <4 x float> @test_builtin_image_load_3d_1( +// CHECK-SAME: <4 x float> noundef [[V4F32:%.*]], i32 noundef [[I32:%.*]], ptr [[TEX:%.*]]) #[[ATTR0]] { +// CHECK-NEXT: [[ENTRY:.*:]] +// CHECK-NEXT: [[RETVAL:%.*]] = alloca <4 x float>, align 16, addrspace(5) +// CHECK-NEXT: [[V4F32_ADDR:%.*]] = alloca <4 x float>, align 16, addrspace(5) +// CHECK-NEXT: [[I32_ADDR:%.*]] = alloca i32, align 4, addrspace(5) +// CHECK-NEXT: [[TEX_ADDR:%.*]] = alloca ptr, align 32, addrspace(5) +// CHECK-NEXT: [[RETVAL_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[RETVAL]] to ptr +// CHECK-NEXT: [[V4F32_ADDR_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[V4F32_ADDR]] to ptr +// CHECK-NEXT: [[I32_ADDR_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[I32_ADDR]] to ptr +// CHECK-NEXT: [[TEX_ADDR_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[TEX_ADDR]] to ptr +// CHECK-NEXT: store <4 x float> [[V4F32]], ptr [[V4F32_ADDR_ASCAST]], align 16 +// CHECK-NEXT: store i32 [[I32]], ptr [[I32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: store ptr [[TEX]], ptr [[TEX_ADDR_ASCAST]], align 32 +// CHECK-NEXT: [[TMP0:%.*]] = load i32, ptr [[I32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: [[TMP1:%.*]] = load i32, ptr [[I32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: [[TMP2:%.*]] = load i32, ptr [[I32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: [[TMP3:%.*]] = load ptr, ptr [[TEX_ADDR_ASCAST]], align 32 +// CHECK-NEXT: [[TEX_RSRC_VAL:%.*]] = load <8 x i32>, ptr [[TMP3]], align 32 +// CHECK-NEXT: [[TMP4:%.*]] = call <4 x float> @llvm.amdgcn.image.load.3d.v4f32.i32.v8i32(i32 100, i32 [[TMP0]], i32 [[TMP1]], i32 [[TMP2]], <8 x i32> [[TEX_RSRC_VAL]], i32 120, i32 110) +// CHECK-NEXT: ret <4 x float> [[TMP4]] +// +float4 test_builtin_image_load_3d_1(float4 v4f32, int i32, __amdgpu_texture_t tex) { + + return __builtin_amdgcn_image_load_3d_v4f32_i32(100, i32, i32, i32, tex, 120, 110); +} + +// CHECK-LABEL: define dso_local <4 x half> @test_builtin_image_load_3d_2( +// CHECK-SAME: <4 x half> noundef [[V4F16:%.*]], i32 noundef [[I32:%.*]], ptr [[TEX:%.*]]) #[[ATTR0]] { +// CHECK-NEXT: [[ENTRY:.*:]] +// CHECK-NEXT: [[RETVAL:%.*]] = alloca <4 x half>, align 8, addrspace(5) +// CHECK-NEXT: [[V4F16_ADDR:%.*]] = alloca <4 x half>, align 8, addrspace(5) +// CHECK-NEXT: [[I32_ADDR:%.*]] = alloca i32, align 4, addrspace(5) +// CHECK-NEXT: [[TEX_ADDR:%.*]] = alloca ptr, align 32, addrspace(5) +// CHECK-NEXT: [[RETVAL_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[RETVAL]] to ptr +// CHECK-NEXT: [[V4F16_ADDR_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[V4F16_ADDR]] to ptr +// CHECK-NEXT: [[I32_ADDR_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[I32_ADDR]] to ptr +// CHECK-NEXT: [[TEX_ADDR_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[TEX_ADDR]] to ptr +// CHECK-NEXT: store <4 x half> [[V4F16]], ptr [[V4F16_ADDR_ASCAST]], align 8 +// CHECK-NEXT: store i32 [[I32]], ptr [[I32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: store ptr [[TEX]], ptr [[TEX_ADDR_ASCAST]], align 32 +// CHECK-NEXT: [[TMP0:%.*]] = load i32, ptr [[I32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: [[TMP1:%.*]] = load i32, ptr [[I32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: [[TMP2:%.*]] = load i32, ptr [[I32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: [[TMP3:%.*]] = load ptr, ptr [[TEX_ADDR_ASCAST]], align 32 +// CHECK-NEXT: [[TEX_RSRC_VAL:%.*]] = load <8 x i32>, ptr [[TMP3]], align 32 +// CHECK-NEXT: [[TMP4:%.*]] = call <4 x half> @llvm.amdgcn.image.load.3d.v4f16.i32.v8i32(i32 100, i32 [[TMP0]], i32 [[TMP1]], i32 [[TMP2]], <8 x i32> [[TEX_RSRC_VAL]], i32 120, i32 110) +// CHECK-NEXT: ret <4 x half> [[TMP4]] +// +half4 test_builtin_image_load_3d_2(half4 v4f16, int i32, __amdgpu_texture_t tex) { + + return __builtin_amdgcn_image_load_3d_v4f16_i32(100, i32, i32, i32, tex, 120, 110); +} + +// CHECK-LABEL: define dso_local <4 x float> @test_builtin_image_load_cube_1( +// CHECK-SAME: <4 x float> noundef [[V4F32:%.*]], i32 noundef [[I32:%.*]], ptr [[TEX:%.*]]) #[[ATTR0]] { +// CHECK-NEXT: [[ENTRY:.*:]] +// CHECK-NEXT: [[RETVAL:%.*]] = alloca <4 x float>, align 16, addrspace(5) +// CHECK-NEXT: [[V4F32_ADDR:%.*]] = alloca <4 x float>, align 16, addrspace(5) +// CHECK-NEXT: [[I32_ADDR:%.*]] = alloca i32, align 4, addrspace(5) +// CHECK-NEXT: [[TEX_ADDR:%.*]] = alloca ptr, align 32, addrspace(5) +// CHECK-NEXT: [[RETVAL_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[RETVAL]] to ptr +// CHECK-NEXT: [[V4F32_ADDR_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[V4F32_ADDR]] to ptr +// CHECK-NEXT: [[I32_ADDR_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[I32_ADDR]] to ptr +// CHECK-NEXT: [[TEX_ADDR_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[TEX_ADDR]] to ptr +// CHECK-NEXT: store <4 x float> [[V4F32]], ptr [[V4F32_ADDR_ASCAST]], align 16 +// CHECK-NEXT: store i32 [[I32]], ptr [[I32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: store ptr [[TEX]], ptr [[TEX_ADDR_ASCAST]], align 32 +// CHECK-NEXT: [[TMP0:%.*]] = load i32, ptr [[I32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: [[TMP1:%.*]] = load i32, ptr [[I32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: [[TMP2:%.*]] = load i32, ptr [[I32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: [[TMP3:%.*]] = load ptr, ptr [[TEX_ADDR_ASCAST]], align 32 +// CHECK-NEXT: [[TEX_RSRC_VAL:%.*]] = load <8 x i32>, ptr [[TMP3]], align 32 +// CHECK-NEXT: [[TMP4:%.*]] = call <4 x float> @llvm.amdgcn.image.load.cube.v4f32.i32.v8i32(i32 100, i32 [[TMP0]], i32 [[TMP1]], i32 [[TMP2]], <8 x i32> [[TEX_RSRC_VAL]], i32 120, i32 110) +// CHECK-NEXT: ret <4 x float> [[TMP4]] +// +float4 test_builtin_image_load_cube_1(float4 v4f32, int i32, __amdgpu_texture_t tex) { + + return __builtin_amdgcn_image_load_cube_v4f32_i32(100, i32, i32, i32, tex, 120, 110); +} + +// CHECK-LABEL: define dso_local <4 x half> @test_builtin_image_load_cube_2( +// CHECK-SAME: <4 x half> noundef [[V4F16:%.*]], i32 noundef [[I32:%.*]], ptr [[TEX:%.*]]) #[[ATTR0]] { +// CHECK-NEXT: [[ENTRY:.*:]] +// CHECK-NEXT: [[RETVAL:%.*]] = alloca <4 x half>, align 8, addrspace(5) +// CHECK-NEXT: [[V4F16_ADDR:%.*]] = alloca <4 x half>, align 8, addrspace(5) +// CHECK-NEXT: [[I32_ADDR:%.*]] = alloca i32, align 4, addrspace(5) +// CHECK-NEXT: [[TEX_ADDR:%.*]] = alloca ptr, align 32, addrspace(5) +// CHECK-NEXT: [[RETVAL_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[RETVAL]] to ptr +// CHECK-NEXT: [[V4F16_ADDR_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[V4F16_ADDR]] to ptr +// CHECK-NEXT: [[I32_ADDR_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[I32_ADDR]] to ptr +// CHECK-NEXT: [[TEX_ADDR_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[TEX_ADDR]] to ptr +// CHECK-NEXT: store <4 x half> [[V4F16]], ptr [[V4F16_ADDR_ASCAST]], align 8 +// CHECK-NEXT: store i32 [[I32]], ptr [[I32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: store ptr [[TEX]], ptr [[TEX_ADDR_ASCAST]], align 32 +// CHECK-NEXT: [[TMP0:%.*]] = load i32, ptr [[I32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: [[TMP1:%.*]] = load i32, ptr [[I32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: [[TMP2:%.*]] = load i32, ptr [[I32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: [[TMP3:%.*]] = load ptr, ptr [[TEX_ADDR_ASCAST]], align 32 +// CHECK-NEXT: [[TEX_RSRC_VAL:%.*]] = load <8 x i32>, ptr [[TMP3]], align 32 +// CHECK-NEXT: [[TMP4:%.*]] = call <4 x half> @llvm.amdgcn.image.load.cube.v4f16.i32.v8i32(i32 100, i32 [[TMP0]], i32 [[TMP1]], i32 [[TMP2]], <8 x i32> [[TEX_RSRC_VAL]], i32 120, i32 110) +// CHECK-NEXT: ret <4 x half> [[TMP4]] +// +half4 test_builtin_image_load_cube_2(half4 v4f16, int i32, __amdgpu_texture_t tex) { + + return __builtin_amdgcn_image_load_cube_v4f16_i32(100, i32, i32, i32, tex, 120, 110); +} + +// CHECK-LABEL: define dso_local <4 x float> @test_builtin_image_load_mip_1d_1( +// CHECK-SAME: <4 x float> noundef [[V4F32:%.*]], i32 noundef [[I32:%.*]], ptr [[TEX:%.*]]) #[[ATTR0]] { +// CHECK-NEXT: [[ENTRY:.*:]] +// CHECK-NEXT: [[RETVAL:%.*]] = alloca <4 x float>, align 16, addrspace(5) +// CHECK-NEXT: [[V4F32_ADDR:%.*]] = alloca <4 x float>, align 16, addrspace(5) +// CHECK-NEXT: [[I32_ADDR:%.*]] = alloca i32, align 4, addrspace(5) +// CHECK-NEXT: [[TEX_ADDR:%.*]] = alloca ptr, align 32, addrspace(5) +// CHECK-NEXT: [[RETVAL_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[RETVAL]] to ptr +// CHECK-NEXT: [[V4F32_ADDR_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[V4F32_ADDR]] to ptr +// CHECK-NEXT: [[I32_ADDR_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[I32_ADDR]] to ptr +// CHECK-NEXT: [[TEX_ADDR_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[TEX_ADDR]] to ptr +// CHECK-NEXT: store <4 x float> [[V4F32]], ptr [[V4F32_ADDR_ASCAST]], align 16 +// CHECK-NEXT: store i32 [[I32]], ptr [[I32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: store ptr [[TEX]], ptr [[TEX_ADDR_ASCAST]], align 32 +// CHECK-NEXT: [[TMP0:%.*]] = load i32, ptr [[I32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: [[TMP1:%.*]] = load i32, ptr [[I32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: [[TMP2:%.*]] = load ptr, ptr [[TEX_ADDR_ASCAST]], align 32 +// CHECK-NEXT: [[TEX_RSRC_VAL:%.*]] = load <8 x i32>, ptr [[TMP2]], align 32 +// CHECK-NEXT: [[TMP3:%.*]] = call <4 x float> @llvm.amdgcn.image.load.mip.1d.v4f32.i32.v8i32(i32 100, i32 [[TMP0]], i32 [[TMP1]], <8 x i32> [[TEX_RSRC_VAL]], i32 120, i32 110) +// CHECK-NEXT: ret <4 x float> [[TMP3]] +// +float4 test_builtin_image_load_mip_1d_1(float4 v4f32, int i32, __amdgpu_texture_t tex) { + + return __builtin_amdgcn_image_load_mip_1d_v4f32_i32(100, i32, i32, tex, 120, 110); +} + +// CHECK-LABEL: define dso_local <4 x half> @test_builtin_image_load_mip_1d_2( +// CHECK-SAME: <4 x half> noundef [[V4F16:%.*]], i32 noundef [[I32:%.*]], ptr [[TEX:%.*]]) #[[ATTR0]] { +// CHECK-NEXT: [[ENTRY:.*:]] +// CHECK-NEXT: [[RETVAL:%.*]] = alloca <4 x half>, align 8, addrspace(5) +// CHECK-NEXT: [[V4F16_ADDR:%.*]] = alloca <4 x half>, align 8, addrspace(5) +// CHECK-NEXT: [[I32_ADDR:%.*]] = alloca i32, align 4, addrspace(5) +// CHECK-NEXT: [[TEX_ADDR:%.*]] = alloca ptr, align 32, addrspace(5) +// CHECK-NEXT: [[RETVAL_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[RETVAL]] to ptr +// CHECK-NEXT: [[V4F16_ADDR_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[V4F16_ADDR]] to ptr +// CHECK-NEXT: [[I32_ADDR_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[I32_ADDR]] to ptr +// CHECK-NEXT: [[TEX_ADDR_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[TEX_ADDR]] to ptr +// CHECK-NEXT: store <4 x half> [[V4F16]], ptr [[V4F16_ADDR_ASCAST]], align 8 +// CHECK-NEXT: store i32 [[I32]], ptr [[I32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: store ptr [[TEX]], ptr [[TEX_ADDR_ASCAST]], align 32 +// CHECK-NEXT: [[TMP0:%.*]] = load i32, ptr [[I32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: [[TMP1:%.*]] = load i32, ptr [[I32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: [[TMP2:%.*]] = load ptr, ptr [[TEX_ADDR_ASCAST]], align 32 +// CHECK-NEXT: [[TEX_RSRC_VAL:%.*]] = load <8 x i32>, ptr [[TMP2]], align 32 +// CHECK-NEXT: [[TMP3:%.*]] = call <4 x half> @llvm.amdgcn.image.load.mip.1d.v4f16.i32.v8i32(i32 100, i32 [[TMP0]], i32 [[TMP1]], <8 x i32> [[TEX_RSRC_VAL]], i32 120, i32 110) +// CHECK-NEXT: ret <4 x half> [[TMP3]] +// +half4 test_builtin_image_load_mip_1d_2(half4 v4f16, int i32, __amdgpu_texture_t tex) { + + return __builtin_amdgcn_image_load_mip_1d_v4f16_i32(100, i32, i32, tex, 120, 110); +} + +// CHECK-LABEL: define dso_local <4 x float> @test_builtin_image_load_mip_1darray_1( +// CHECK-SAME: <4 x float> noundef [[V4F32:%.*]], i32 noundef [[I32:%.*]], ptr [[TEX:%.*]]) #[[ATTR0]] { +// CHECK-NEXT: [[ENTRY:.*:]] +// CHECK-NEXT: [[RETVAL:%.*]] = alloca <4 x float>, align 16, addrspace(5) +// CHECK-NEXT: [[V4F32_ADDR:%.*]] = alloca <4 x float>, align 16, addrspace(5) +// CHECK-NEXT: [[I32_ADDR:%.*]] = alloca i32, align 4, addrspace(5) +// CHECK-NEXT: [[TEX_ADDR:%.*]] = alloca ptr, align 32, addrspace(5) +// CHECK-NEXT: [[RETVAL_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[RETVAL]] to ptr +// CHECK-NEXT: [[V4F32_ADDR_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[V4F32_ADDR]] to ptr +// CHECK-NEXT: [[I32_ADDR_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[I32_ADDR]] to ptr +// CHECK-NEXT: [[TEX_ADDR_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[TEX_ADDR]] to ptr +// CHECK-NEXT: store <4 x float> [[V4F32]], ptr [[V4F32_ADDR_ASCAST]], align 16 +// CHECK-NEXT: store i32 [[I32]], ptr [[I32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: store ptr [[TEX]], ptr [[TEX_ADDR_ASCAST]], align 32 +// CHECK-NEXT: [[TMP0:%.*]] = load i32, ptr [[I32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: [[TMP1:%.*]] = load i32, ptr [[I32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: [[TMP2:%.*]] = load i32, ptr [[I32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: [[TMP3:%.*]] = load ptr, ptr [[TEX_ADDR_ASCAST]], align 32 +// CHECK-NEXT: [[TEX_RSRC_VAL:%.*]] = load <8 x i32>, ptr [[TMP3]], align 32 +// CHECK-NEXT: [[TMP4:%.*]] = call <4 x float> @llvm.amdgcn.image.load.mip.1darray.v4f32.i32.v8i32(i32 100, i32 [[TMP0]], i32 [[TMP1]], i32 [[TMP2]], <8 x i32> [[TEX_RSRC_VAL]], i32 120, i32 110) +// CHECK-NEXT: ret <4 x float> [[TMP4]] +// +float4 test_builtin_image_load_mip_1darray_1(float4 v4f32, int i32, __amdgpu_texture_t tex) { + + return __builtin_amdgcn_image_load_mip_1darray_v4f32_i32(100, i32, i32, i32, tex, 120, 110); +} + +// CHECK-LABEL: define dso_local <4 x half> @test_builtin_image_load_mip_1darray_2( +// CHECK-SAME: <4 x half> noundef [[V4F16:%.*]], i32 noundef [[I32:%.*]], ptr [[TEX:%.*]]) #[[ATTR0]] { +// CHECK-NEXT: [[ENTRY:.*:]] +// CHECK-NEXT: [[RETVAL:%.*]] = alloca <4 x half>, align 8, addrspace(5) +// CHECK-NEXT: [[V4F16_ADDR:%.*]] = alloca <4 x half>, align 8, addrspace(5) +// CHECK-NEXT: [[I32_ADDR:%.*]] = alloca i32, align 4, addrspace(5) +// CHECK-NEXT: [[TEX_ADDR:%.*]] = alloca ptr, align 32, addrspace(5) +// CHECK-NEXT: [[RETVAL_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[RETVAL]] to ptr +// CHECK-NEXT: [[V4F16_ADDR_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[V4F16_ADDR]] to ptr +// CHECK-NEXT: [[I32_ADDR_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[I32_ADDR]] to ptr +// CHECK-NEXT: [[TEX_ADDR_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[TEX_ADDR]] to ptr +// CHECK-NEXT: store <4 x half> [[V4F16]], ptr [[V4F16_ADDR_ASCAST]], align 8 +// CHECK-NEXT: store i32 [[I32]], ptr [[I32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: store ptr [[TEX]], ptr [[TEX_ADDR_ASCAST]], align 32 +// CHECK-NEXT: [[TMP0:%.*]] = load i32, ptr [[I32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: [[TMP1:%.*]] = load i32, ptr [[I32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: [[TMP2:%.*]] = load i32, ptr [[I32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: [[TMP3:%.*]] = load ptr, ptr [[TEX_ADDR_ASCAST]], align 32 +// CHECK-NEXT: [[TEX_RSRC_VAL:%.*]] = load <8 x i32>, ptr [[TMP3]], align 32 +// CHECK-NEXT: [[TMP4:%.*]] = call <4 x half> @llvm.amdgcn.image.load.mip.1darray.v4f16.i32.v8i32(i32 100, i32 [[TMP0]], i32 [[TMP1]], i32 [[TMP2]], <8 x i32> [[TEX_RSRC_VAL]], i32 120, i32 110) +// CHECK-NEXT: ret <4 x half> [[TMP4]] +// +half4 test_builtin_image_load_mip_1darray_2(half4 v4f16, int i32, __amdgpu_texture_t tex) { + + return __builtin_amdgcn_image_load_mip_1darray_v4f16_i32(100, i32, i32, i32, tex, 120, 110); +} + +// CHECK-LABEL: define dso_local float @test_builtin_image_load_mip_2d( +// CHECK-SAME: float noundef [[F32:%.*]], i32 noundef [[I32:%.*]], ptr [[TEX:%.*]]) #[[ATTR0]] { +// CHECK-NEXT: [[ENTRY:.*:]] +// CHECK-NEXT: [[RETVAL:%.*]] = alloca float, align 4, addrspace(5) +// CHECK-NEXT: [[F32_ADDR:%.*]] = alloca float, align 4, addrspace(5) +// CHECK-NEXT: [[I32_ADDR:%.*]] = alloca i32, align 4, addrspace(5) +// CHECK-NEXT: [[TEX_ADDR:%.*]] = alloca ptr, align 32, addrspace(5) +// CHECK-NEXT: [[RETVAL_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[RETVAL]] to ptr +// CHECK-NEXT: [[F32_ADDR_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[F32_ADDR]] to ptr +// CHECK-NEXT: [[I32_ADDR_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[I32_ADDR]] to ptr +// CHECK-NEXT: [[TEX_ADDR_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[TEX_ADDR]] to ptr +// CHECK-NEXT: store float [[F32]], ptr [[F32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: store i32 [[I32]], ptr [[I32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: store ptr [[TEX]], ptr [[TEX_ADDR_ASCAST]], align 32 +// CHECK-NEXT: [[TMP0:%.*]] = load i32, ptr [[I32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: [[TMP1:%.*]] = load i32, ptr [[I32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: [[TMP2:%.*]] = load i32, ptr [[I32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: [[TMP3:%.*]] = load ptr, ptr [[TEX_ADDR_ASCAST]], align 32 +// CHECK-NEXT: [[TEX_RSRC_VAL:%.*]] = load <8 x i32>, ptr [[TMP3]], align 32 +// CHECK-NEXT: [[TMP4:%.*]] = call float @llvm.amdgcn.image.load.mip.2d.f32.i32.v8i32(i32 100, i32 [[TMP0]], i32 [[TMP1]], i32 [[TMP2]], <8 x i32> [[TEX_RSRC_VAL]], i32 120, i32 110) +// CHECK-NEXT: ret float [[TMP4]] +// +float test_builtin_image_load_mip_2d(float f32, int i32, __amdgpu_texture_t tex) { + + return __builtin_amdgcn_image_load_mip_2d_f32_i32(100, i32, i32, i32, tex, 120, 110); +} + +// CHECK-LABEL: define dso_local <4 x float> @test_builtin_image_load_mip_2d_1( +// CHECK-SAME: <4 x float> noundef [[V4F32:%.*]], i32 noundef [[I32:%.*]], ptr [[TEX:%.*]]) #[[ATTR0]] { +// CHECK-NEXT: [[ENTRY:.*:]] +// CHECK-NEXT: [[RETVAL:%.*]] = alloca <4 x float>, align 16, addrspace(5) +// CHECK-NEXT: [[V4F32_ADDR:%.*]] = alloca <4 x float>, align 16, addrspace(5) +// CHECK-NEXT: [[I32_ADDR:%.*]] = alloca i32, align 4, addrspace(5) +// CHECK-NEXT: [[TEX_ADDR:%.*]] = alloca ptr, align 32, addrspace(5) +// CHECK-NEXT: [[RETVAL_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[RETVAL]] to ptr +// CHECK-NEXT: [[V4F32_ADDR_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[V4F32_ADDR]] to ptr +// CHECK-NEXT: [[I32_ADDR_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[I32_ADDR]] to ptr +// CHECK-NEXT: [[TEX_ADDR_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[TEX_ADDR]] to ptr +// CHECK-NEXT: store <4 x float> [[V4F32]], ptr [[V4F32_ADDR_ASCAST]], align 16 +// CHECK-NEXT: store i32 [[I32]], ptr [[I32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: store ptr [[TEX]], ptr [[TEX_ADDR_ASCAST]], align 32 +// CHECK-NEXT: [[TMP0:%.*]] = load i32, ptr [[I32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: [[TMP1:%.*]] = load i32, ptr [[I32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: [[TMP2:%.*]] = load i32, ptr [[I32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: [[TMP3:%.*]] = load ptr, ptr [[TEX_ADDR_ASCAST]], align 32 +// CHECK-NEXT: [[TEX_RSRC_VAL:%.*]] = load <8 x i32>, ptr [[TMP3]], align 32 +// CHECK-NEXT: [[TMP4:%.*]] = call <4 x float> @llvm.amdgcn.image.load.mip.2d.v4f32.i32.v8i32(i32 100, i32 [[TMP0]], i32 [[TMP1]], i32 [[TMP2]], <8 x i32> [[TEX_RSRC_VAL]], i32 120, i32 110) +// CHECK-NEXT: ret <4 x float> [[TMP4]] +// +float4 test_builtin_image_load_mip_2d_1(float4 v4f32, int i32, __amdgpu_texture_t tex) { + + return __builtin_amdgcn_image_load_mip_2d_v4f32_i32(100, i32, i32, i32, tex, 120, 110); +} + +// CHECK-LABEL: define dso_local <4 x half> @test_builtin_image_load_mip_2d_2( +// CHECK-SAME: <4 x half> noundef [[V4F16:%.*]], i32 noundef [[I32:%.*]], ptr [[TEX:%.*]]) #[[ATTR0]] { +// CHECK-NEXT: [[ENTRY:.*:]] +// CHECK-NEXT: [[RETVAL:%.*]] = alloca <4 x half>, align 8, addrspace(5) +// CHECK-NEXT: [[V4F16_ADDR:%.*]] = alloca <4 x half>, align 8, addrspace(5) +// CHECK-NEXT: [[I32_ADDR:%.*]] = alloca i32, align 4, addrspace(5) +// CHECK-NEXT: [[TEX_ADDR:%.*]] = alloca ptr, align 32, addrspace(5) +// CHECK-NEXT: [[RETVAL_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[RETVAL]] to ptr +// CHECK-NEXT: [[V4F16_ADDR_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[V4F16_ADDR]] to ptr +// CHECK-NEXT: [[I32_ADDR_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[I32_ADDR]] to ptr +// CHECK-NEXT: [[TEX_ADDR_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[TEX_ADDR]] to ptr +// CHECK-NEXT: store <4 x half> [[V4F16]], ptr [[V4F16_ADDR_ASCAST]], align 8 +// CHECK-NEXT: store i32 [[I32]], ptr [[I32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: store ptr [[TEX]], ptr [[TEX_ADDR_ASCAST]], align 32 +// CHECK-NEXT: [[TMP0:%.*]] = load i32, ptr [[I32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: [[TMP1:%.*]] = load i32, ptr [[I32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: [[TMP2:%.*]] = load i32, ptr [[I32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: [[TMP3:%.*]] = load ptr, ptr [[TEX_ADDR_ASCAST]], align 32 +// CHECK-NEXT: [[TEX_RSRC_VAL:%.*]] = load <8 x i32>, ptr [[TMP3]], align 32 +// CHECK-NEXT: [[TMP4:%.*]] = call <4 x half> @llvm.amdgcn.image.load.mip.2d.v4f16.i32.v8i32(i32 100, i32 [[TMP0]], i32 [[TMP1]], i32 [[TMP2]], <8 x i32> [[TEX_RSRC_VAL]], i32 120, i32 110) +// CHECK-NEXT: ret <4 x half> [[TMP4]] +// +half4 test_builtin_image_load_mip_2d_2(half4 v4f16, int i32, __amdgpu_texture_t tex) { + + return __builtin_amdgcn_image_load_mip_2d_v4f16_i32(100, i32, i32, i32, tex, 120, 110); +} + +// CHECK-LABEL: define dso_local float @test_builtin_image_load_mip_2darray( +// CHECK-SAME: float noundef [[F32:%.*]], i32 noundef [[I32:%.*]], ptr [[TEX:%.*]]) #[[ATTR0]] { +// CHECK-NEXT: [[ENTRY:.*:]] +// CHECK-NEXT: [[RETVAL:%.*]] = alloca float, align 4, addrspace(5) +// CHECK-NEXT: [[F32_ADDR:%.*]] = alloca float, align 4, addrspace(5) +// CHECK-NEXT: [[I32_ADDR:%.*]] = alloca i32, align 4, addrspace(5) +// CHECK-NEXT: [[TEX_ADDR:%.*]] = alloca ptr, align 32, addrspace(5) +// CHECK-NEXT: [[RETVAL_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[RETVAL]] to ptr +// CHECK-NEXT: [[F32_ADDR_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[F32_ADDR]] to ptr +// CHECK-NEXT: [[I32_ADDR_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[I32_ADDR]] to ptr +// CHECK-NEXT: [[TEX_ADDR_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[TEX_ADDR]] to ptr +// CHECK-NEXT: store float [[F32]], ptr [[F32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: store i32 [[I32]], ptr [[I32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: store ptr [[TEX]], ptr [[TEX_ADDR_ASCAST]], align 32 +// CHECK-NEXT: [[TMP0:%.*]] = load i32, ptr [[I32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: [[TMP1:%.*]] = load i32, ptr [[I32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: [[TMP2:%.*]] = load i32, ptr [[I32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: [[TMP3:%.*]] = load i32, ptr [[I32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: [[TMP4:%.*]] = load ptr, ptr [[TEX_ADDR_ASCAST]], align 32 +// CHECK-NEXT: [[TEX_RSRC_VAL:%.*]] = load <8 x i32>, ptr [[TMP4]], align 32 +// CHECK-NEXT: [[TMP5:%.*]] = call float @llvm.amdgcn.image.load.mip.2darray.f32.i32.v8i32(i32 100, i32 [[TMP0]], i32 [[TMP1]], i32 [[TMP2]], i32 [[TMP3]], <8 x i32> [[TEX_RSRC_VAL]], i32 120, i32 110) +// CHECK-NEXT: ret float [[TMP5]] +// +float test_builtin_image_load_mip_2darray(float f32, int i32, __amdgpu_texture_t tex) { + + return __builtin_amdgcn_image_load_mip_2darray_f32_i32(100, i32, i32, i32, i32, tex, 120, 110); +} + +// CHECK-LABEL: define dso_local <4 x float> @test_builtin_image_load_mip_2darray_1( +// CHECK-SAME: <4 x float> noundef [[V4F32:%.*]], i32 noundef [[I32:%.*]], ptr [[TEX:%.*]]) #[[ATTR0]] { +// CHECK-NEXT: [[ENTRY:.*:]] +// CHECK-NEXT: [[RETVAL:%.*]] = alloca <4 x float>, align 16, addrspace(5) +// CHECK-NEXT: [[V4F32_ADDR:%.*]] = alloca <4 x float>, align 16, addrspace(5) +// CHECK-NEXT: [[I32_ADDR:%.*]] = alloca i32, align 4, addrspace(5) +// CHECK-NEXT: [[TEX_ADDR:%.*]] = alloca ptr, align 32, addrspace(5) +// CHECK-NEXT: [[RETVAL_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[RETVAL]] to ptr +// CHECK-NEXT: [[V4F32_ADDR_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[V4F32_ADDR]] to ptr +// CHECK-NEXT: [[I32_ADDR_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[I32_ADDR]] to ptr +// CHECK-NEXT: [[TEX_ADDR_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[TEX_ADDR]] to ptr +// CHECK-NEXT: store <4 x float> [[V4F32]], ptr [[V4F32_ADDR_ASCAST]], align 16 +// CHECK-NEXT: store i32 [[I32]], ptr [[I32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: store ptr [[TEX]], ptr [[TEX_ADDR_ASCAST]], align 32 +// CHECK-NEXT: [[TMP0:%.*]] = load i32, ptr [[I32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: [[TMP1:%.*]] = load i32, ptr [[I32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: [[TMP2:%.*]] = load i32, ptr [[I32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: [[TMP3:%.*]] = load i32, ptr [[I32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: [[TMP4:%.*]] = load ptr, ptr [[TEX_ADDR_ASCAST]], align 32 +// CHECK-NEXT: [[TEX_RSRC_VAL:%.*]] = load <8 x i32>, ptr [[TMP4]], align 32 +// CHECK-NEXT: [[TMP5:%.*]] = call <4 x float> @llvm.amdgcn.image.load.mip.2darray.v4f32.i32.v8i32(i32 100, i32 [[TMP0]], i32 [[TMP1]], i32 [[TMP2]], i32 [[TMP3]], <8 x i32> [[TEX_RSRC_VAL]], i32 120, i32 110) +// CHECK-NEXT: ret <4 x float> [[TMP5]] +// +float4 test_builtin_image_load_mip_2darray_1(float4 v4f32, int i32, __amdgpu_texture_t tex) { + + return __builtin_amdgcn_image_load_mip_2darray_v4f32_i32(100, i32, i32, i32, i32, tex, 120, 110); +} + +// CHECK-LABEL: define dso_local <4 x half> @test_builtin_image_load_mip_2darray_2( +// CHECK-SAME: <4 x half> noundef [[V4F16:%.*]], i32 noundef [[I32:%.*]], ptr [[TEX:%.*]]) #[[ATTR0]] { +// CHECK-NEXT: [[ENTRY:.*:]] +// CHECK-NEXT: [[RETVAL:%.*]] = alloca <4 x half>, align 8, addrspace(5) +// CHECK-NEXT: [[V4F16_ADDR:%.*]] = alloca <4 x half>, align 8, addrspace(5) +// CHECK-NEXT: [[I32_ADDR:%.*]] = alloca i32, align 4, addrspace(5) +// CHECK-NEXT: [[TEX_ADDR:%.*]] = alloca ptr, align 32, addrspace(5) +// CHECK-NEXT: [[RETVAL_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[RETVAL]] to ptr +// CHECK-NEXT: [[V4F16_ADDR_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[V4F16_ADDR]] to ptr +// CHECK-NEXT: [[I32_ADDR_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[I32_ADDR]] to ptr +// CHECK-NEXT: [[TEX_ADDR_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[TEX_ADDR]] to ptr +// CHECK-NEXT: store <4 x half> [[V4F16]], ptr [[V4F16_ADDR_ASCAST]], align 8 +// CHECK-NEXT: store i32 [[I32]], ptr [[I32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: store ptr [[TEX]], ptr [[TEX_ADDR_ASCAST]], align 32 +// CHECK-NEXT: [[TMP0:%.*]] = load i32, ptr [[I32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: [[TMP1:%.*]] = load i32, ptr [[I32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: [[TMP2:%.*]] = load i32, ptr [[I32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: [[TMP3:%.*]] = load i32, ptr [[I32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: [[TMP4:%.*]] = load ptr, ptr [[TEX_ADDR_ASCAST]], align 32 +// CHECK-NEXT: [[TEX_RSRC_VAL:%.*]] = load <8 x i32>, ptr [[TMP4]], align 32 +// CHECK-NEXT: [[TMP5:%.*]] = call <4 x half> @llvm.amdgcn.image.load.mip.2darray.v4f16.i32.v8i32(i32 100, i32 [[TMP0]], i32 [[TMP1]], i32 [[TMP2]], i32 [[TMP3]], <8 x i32> [[TEX_RSRC_VAL]], i32 120, i32 110) +// CHECK-NEXT: ret <4 x half> [[TMP5]] +// +half4 test_builtin_image_load_mip_2darray_2(half4 v4f16, int i32, __amdgpu_texture_t tex) { + + return __builtin_amdgcn_image_load_mip_2darray_v4f16_i32(100, i32, i32, i32, i32, tex, 120, 110); +} + +// CHECK-LABEL: define dso_local <4 x float> @test_builtin_image_load_mip_3d_1( +// CHECK-SAME: <4 x float> noundef [[V4F32:%.*]], i32 noundef [[I32:%.*]], ptr [[TEX:%.*]]) #[[ATTR0]] { +// CHECK-NEXT: [[ENTRY:.*:]] +// CHECK-NEXT: [[RETVAL:%.*]] = alloca <4 x float>, align 16, addrspace(5) +// CHECK-NEXT: [[V4F32_ADDR:%.*]] = alloca <4 x float>, align 16, addrspace(5) +// CHECK-NEXT: [[I32_ADDR:%.*]] = alloca i32, align 4, addrspace(5) +// CHECK-NEXT: [[TEX_ADDR:%.*]] = alloca ptr, align 32, addrspace(5) +// CHECK-NEXT: [[RETVAL_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[RETVAL]] to ptr +// CHECK-NEXT: [[V4F32_ADDR_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[V4F32_ADDR]] to ptr +// CHECK-NEXT: [[I32_ADDR_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[I32_ADDR]] to ptr +// CHECK-NEXT: [[TEX_ADDR_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[TEX_ADDR]] to ptr +// CHECK-NEXT: store <4 x float> [[V4F32]], ptr [[V4F32_ADDR_ASCAST]], align 16 +// CHECK-NEXT: store i32 [[I32]], ptr [[I32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: store ptr [[TEX]], ptr [[TEX_ADDR_ASCAST]], align 32 +// CHECK-NEXT: [[TMP0:%.*]] = load i32, ptr [[I32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: [[TMP1:%.*]] = load i32, ptr [[I32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: [[TMP2:%.*]] = load i32, ptr [[I32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: [[TMP3:%.*]] = load i32, ptr [[I32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: [[TMP4:%.*]] = load ptr, ptr [[TEX_ADDR_ASCAST]], align 32 +// CHECK-NEXT: [[TEX_RSRC_VAL:%.*]] = load <8 x i32>, ptr [[TMP4]], align 32 +// CHECK-NEXT: [[TMP5:%.*]] = call <4 x float> @llvm.amdgcn.image.load.mip.3d.v4f32.i32.v8i32(i32 100, i32 [[TMP0]], i32 [[TMP1]], i32 [[TMP2]], i32 [[TMP3]], <8 x i32> [[TEX_RSRC_VAL]], i32 120, i32 110) +// CHECK-NEXT: ret <4 x float> [[TMP5]] +// +float4 test_builtin_image_load_mip_3d_1(float4 v4f32, int i32, __amdgpu_texture_t tex) { + + return __builtin_amdgcn_image_load_mip_3d_v4f32_i32(100, i32, i32, i32, i32, tex, 120, 110); +} + +// CHECK-LABEL: define dso_local <4 x half> @test_builtin_image_load_mip_3d_2( +// CHECK-SAME: <4 x half> noundef [[V4F16:%.*]], i32 noundef [[I32:%.*]], ptr [[TEX:%.*]]) #[[ATTR0]] { +// CHECK-NEXT: [[ENTRY:.*:]] +// CHECK-NEXT: [[RETVAL:%.*]] = alloca <4 x half>, align 8, addrspace(5) +// CHECK-NEXT: [[V4F16_ADDR:%.*]] = alloca <4 x half>, align 8, addrspace(5) +// CHECK-NEXT: [[I32_ADDR:%.*]] = alloca i32, align 4, addrspace(5) +// CHECK-NEXT: [[TEX_ADDR:%.*]] = alloca ptr, align 32, addrspace(5) +// CHECK-NEXT: [[RETVAL_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[RETVAL]] to ptr +// CHECK-NEXT: [[V4F16_ADDR_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[V4F16_ADDR]] to ptr +// CHECK-NEXT: [[I32_ADDR_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[I32_ADDR]] to ptr +// CHECK-NEXT: [[TEX_ADDR_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[TEX_ADDR]] to ptr +// CHECK-NEXT: store <4 x half> [[V4F16]], ptr [[V4F16_ADDR_ASCAST]], align 8 +// CHECK-NEXT: store i32 [[I32]], ptr [[I32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: store ptr [[TEX]], ptr [[TEX_ADDR_ASCAST]], align 32 +// CHECK-NEXT: [[TMP0:%.*]] = load i32, ptr [[I32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: [[TMP1:%.*]] = load i32, ptr [[I32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: [[TMP2:%.*]] = load i32, ptr [[I32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: [[TMP3:%.*]] = load i32, ptr [[I32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: [[TMP4:%.*]] = load ptr, ptr [[TEX_ADDR_ASCAST]], align 32 +// CHECK-NEXT: [[TEX_RSRC_VAL:%.*]] = load <8 x i32>, ptr [[TMP4]], align 32 +// CHECK-NEXT: [[TMP5:%.*]] = call <4 x half> @llvm.amdgcn.image.load.mip.3d.v4f16.i32.v8i32(i32 100, i32 [[TMP0]], i32 [[TMP1]], i32 [[TMP2]], i32 [[TMP3]], <8 x i32> [[TEX_RSRC_VAL]], i32 120, i32 110) +// CHECK-NEXT: ret <4 x half> [[TMP5]] +// +half4 test_builtin_image_load_mip_3d_2(half4 v4f16, int i32, __amdgpu_texture_t tex) { + + return __builtin_amdgcn_image_load_mip_3d_v4f16_i32(100, i32, i32, i32, i32, tex, 120, 110); +} + +// CHECK-LABEL: define dso_local <4 x float> @test_builtin_image_load_mip_cube_1( +// CHECK-SAME: <4 x float> noundef [[V4F32:%.*]], i32 noundef [[I32:%.*]], ptr [[TEX:%.*]]) #[[ATTR0]] { +// CHECK-NEXT: [[ENTRY:.*:]] +// CHECK-NEXT: [[RETVAL:%.*]] = alloca <4 x float>, align 16, addrspace(5) +// CHECK-NEXT: [[V4F32_ADDR:%.*]] = alloca <4 x float>, align 16, addrspace(5) +// CHECK-NEXT: [[I32_ADDR:%.*]] = alloca i32, align 4, addrspace(5) +// CHECK-NEXT: [[TEX_ADDR:%.*]] = alloca ptr, align 32, addrspace(5) +// CHECK-NEXT: [[RETVAL_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[RETVAL]] to ptr +// CHECK-NEXT: [[V4F32_ADDR_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[V4F32_ADDR]] to ptr +// CHECK-NEXT: [[I32_ADDR_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[I32_ADDR]] to ptr +// CHECK-NEXT: [[TEX_ADDR_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[TEX_ADDR]] to ptr +// CHECK-NEXT: store <4 x float> [[V4F32]], ptr [[V4F32_ADDR_ASCAST]], align 16 +// CHECK-NEXT: store i32 [[I32]], ptr [[I32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: store ptr [[TEX]], ptr [[TEX_ADDR_ASCAST]], align 32 +// CHECK-NEXT: [[TMP0:%.*]] = load i32, ptr [[I32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: [[TMP1:%.*]] = load i32, ptr [[I32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: [[TMP2:%.*]] = load i32, ptr [[I32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: [[TMP3:%.*]] = load i32, ptr [[I32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: [[TMP4:%.*]] = load ptr, ptr [[TEX_ADDR_ASCAST]], align 32 +// CHECK-NEXT: [[TEX_RSRC_VAL:%.*]] = load <8 x i32>, ptr [[TMP4]], align 32 +// CHECK-NEXT: [[TMP5:%.*]] = call <4 x float> @llvm.amdgcn.image.load.mip.cube.v4f32.i32.v8i32(i32 100, i32 [[TMP0]], i32 [[TMP1]], i32 [[TMP2]], i32 [[TMP3]], <8 x i32> [[TEX_RSRC_VAL]], i32 120, i32 110) +// CHECK-NEXT: ret <4 x float> [[TMP5]] +// +float4 test_builtin_image_load_mip_cube_1(float4 v4f32, int i32, __amdgpu_texture_t tex) { + + return __builtin_amdgcn_image_load_mip_cube_v4f32_i32(100, i32, i32, i32, i32, tex, 120, 110); +} + +// CHECK-LABEL: define dso_local <4 x half> @test_builtin_image_load_mip_cube_2( +// CHECK-SAME: <4 x half> noundef [[V4F16:%.*]], i32 noundef [[I32:%.*]], ptr [[TEX:%.*]]) #[[ATTR0]] { +// CHECK-NEXT: [[ENTRY:.*:]] +// CHECK-NEXT: [[RETVAL:%.*]] = alloca <4 x half>, align 8, addrspace(5) +// CHECK-NEXT: [[V4F16_ADDR:%.*]] = alloca <4 x half>, align 8, addrspace(5) +// CHECK-NEXT: [[I32_ADDR:%.*]] = alloca i32, align 4, addrspace(5) +// CHECK-NEXT: [[TEX_ADDR:%.*]] = alloca ptr, align 32, addrspace(5) +// CHECK-NEXT: [[RETVAL_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[RETVAL]] to ptr +// CHECK-NEXT: [[V4F16_ADDR_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[V4F16_ADDR]] to ptr +// CHECK-NEXT: [[I32_ADDR_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[I32_ADDR]] to ptr +// CHECK-NEXT: [[TEX_ADDR_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[TEX_ADDR]] to ptr +// CHECK-NEXT: store <4 x half> [[V4F16]], ptr [[V4F16_ADDR_ASCAST]], align 8 +// CHECK-NEXT: store i32 [[I32]], ptr [[I32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: store ptr [[TEX]], ptr [[TEX_ADDR_ASCAST]], align 32 +// CHECK-NEXT: [[TMP0:%.*]] = load i32, ptr [[I32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: [[TMP1:%.*]] = load i32, ptr [[I32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: [[TMP2:%.*]] = load i32, ptr [[I32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: [[TMP3:%.*]] = load i32, ptr [[I32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: [[TMP4:%.*]] = load ptr, ptr [[TEX_ADDR_ASCAST]], align 32 +// CHECK-NEXT: [[TEX_RSRC_VAL:%.*]] = load <8 x i32>, ptr [[TMP4]], align 32 +// CHECK-NEXT: [[TMP5:%.*]] = call <4 x half> @llvm.amdgcn.image.load.mip.cube.v4f16.i32.v8i32(i32 100, i32 [[TMP0]], i32 [[TMP1]], i32 [[TMP2]], i32 [[TMP3]], <8 x i32> [[TEX_RSRC_VAL]], i32 120, i32 110) +// CHECK-NEXT: ret <4 x half> [[TMP5]] +// +half4 test_builtin_image_load_mip_cube_2(half4 v4f16, int i32, __amdgpu_texture_t tex) { + + return __builtin_amdgcn_image_load_mip_cube_v4f16_i32(100, i32, i32, i32, i32, tex, 120, 110); +} + +// CHECK-LABEL: define dso_local <4 x float> @test_builtin_amdgcn_image_sample_1d_v4f32_f32( +// CHECK-SAME: <4 x float> noundef [[V4F32:%.*]], i32 noundef [[I32:%.*]], float noundef [[F32:%.*]], ptr [[TEX:%.*]], <4 x i32> noundef [[VEC4I32:%.*]]) #[[ATTR0]] { +// CHECK-NEXT: [[ENTRY:.*:]] +// CHECK-NEXT: [[RETVAL:%.*]] = alloca <4 x float>, align 16, addrspace(5) +// CHECK-NEXT: [[V4F32_ADDR:%.*]] = alloca <4 x float>, align 16, addrspace(5) +// CHECK-NEXT: [[I32_ADDR:%.*]] = alloca i32, align 4, addrspace(5) +// CHECK-NEXT: [[F32_ADDR:%.*]] = alloca float, align 4, addrspace(5) +// CHECK-NEXT: [[TEX_ADDR:%.*]] = alloca ptr, align 32, addrspace(5) +// CHECK-NEXT: [[VEC4I32_ADDR:%.*]] = alloca <4 x i32>, align 16, addrspace(5) +// CHECK-NEXT: [[RETVAL_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[RETVAL]] to ptr +// CHECK-NEXT: [[V4F32_ADDR_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[V4F32_ADDR]] to ptr +// CHECK-NEXT: [[I32_ADDR_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[I32_ADDR]] to ptr +// CHECK-NEXT: [[F32_ADDR_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[F32_ADDR]] to ptr +// CHECK-NEXT: [[TEX_ADDR_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[TEX_ADDR]] to ptr +// CHECK-NEXT: [[VEC4I32_ADDR_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[VEC4I32_ADDR]] to ptr +// CHECK-NEXT: store <4 x float> [[V4F32]], ptr [[V4F32_ADDR_ASCAST]], align 16 +// CHECK-NEXT: store i32 [[I32]], ptr [[I32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: store float [[F32]], ptr [[F32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: store ptr [[TEX]], ptr [[TEX_ADDR_ASCAST]], align 32 +// CHECK-NEXT: store <4 x i32> [[VEC4I32]], ptr [[VEC4I32_ADDR_ASCAST]], align 16 +// CHECK-NEXT: [[TMP0:%.*]] = load float, ptr [[F32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: [[TMP1:%.*]] = load ptr, ptr [[TEX_ADDR_ASCAST]], align 32 +// CHECK-NEXT: [[TEX_RSRC_VAL:%.*]] = load <8 x i32>, ptr [[TMP1]], align 32 +// CHECK-NEXT: [[TMP2:%.*]] = load <4 x i32>, ptr [[VEC4I32_ADDR_ASCAST]], align 16 +// CHECK-NEXT: [[TMP3:%.*]] = call <4 x float> @llvm.amdgcn.image.sample.1d.v4f32.f32.v8i32.v4i32(i32 100, float [[TMP0]], <8 x i32> [[TEX_RSRC_VAL]], <4 x i32> [[TMP2]], i1 false, i32 120, i32 110) +// CHECK-NEXT: ret <4 x float> [[TMP3]] +// +float4 test_builtin_amdgcn_image_sample_1d_v4f32_f32(float4 v4f32, int i32, float f32, __amdgpu_texture_t tex, int4 vec4i32) { + return __builtin_amdgcn_image_sample_1d_v4f32_f32(100, f32, tex, vec4i32, 0, 120, 110); +} + +// CHECK-LABEL: define dso_local <4 x half> @test_builtin_amdgcn_image_sample_1d_v4f16_f32( +// CHECK-SAME: <4 x half> noundef [[V4F16:%.*]], i32 noundef [[I32:%.*]], float noundef [[F32:%.*]], ptr [[TEX:%.*]], <4 x i32> noundef [[VEC4I32:%.*]]) #[[ATTR0]] { +// CHECK-NEXT: [[ENTRY:.*:]] +// CHECK-NEXT: [[RETVAL:%.*]] = alloca <4 x half>, align 8, addrspace(5) +// CHECK-NEXT: [[V4F16_ADDR:%.*]] = alloca <4 x half>, align 8, addrspace(5) +// CHECK-NEXT: [[I32_ADDR:%.*]] = alloca i32, align 4, addrspace(5) +// CHECK-NEXT: [[F32_ADDR:%.*]] = alloca float, align 4, addrspace(5) +// CHECK-NEXT: [[TEX_ADDR:%.*]] = alloca ptr, align 32, addrspace(5) +// CHECK-NEXT: [[VEC4I32_ADDR:%.*]] = alloca <4 x i32>, align 16, addrspace(5) +// CHECK-NEXT: [[RETVAL_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[RETVAL]] to ptr +// CHECK-NEXT: [[V4F16_ADDR_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[V4F16_ADDR]] to ptr +// CHECK-NEXT: [[I32_ADDR_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[I32_ADDR]] to ptr +// CHECK-NEXT: [[F32_ADDR_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[F32_ADDR]] to ptr +// CHECK-NEXT: [[TEX_ADDR_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[TEX_ADDR]] to ptr +// CHECK-NEXT: [[VEC4I32_ADDR_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[VEC4I32_ADDR]] to ptr +// CHECK-NEXT: store <4 x half> [[V4F16]], ptr [[V4F16_ADDR_ASCAST]], align 8 +// CHECK-NEXT: store i32 [[I32]], ptr [[I32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: store float [[F32]], ptr [[F32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: store ptr [[TEX]], ptr [[TEX_ADDR_ASCAST]], align 32 +// CHECK-NEXT: store <4 x i32> [[VEC4I32]], ptr [[VEC4I32_ADDR_ASCAST]], align 16 +// CHECK-NEXT: [[TMP0:%.*]] = load float, ptr [[F32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: [[TMP1:%.*]] = load ptr, ptr [[TEX_ADDR_ASCAST]], align 32 +// CHECK-NEXT: [[TEX_RSRC_VAL:%.*]] = load <8 x i32>, ptr [[TMP1]], align 32 +// CHECK-NEXT: [[TMP2:%.*]] = load <4 x i32>, ptr [[VEC4I32_ADDR_ASCAST]], align 16 +// CHECK-NEXT: [[TMP3:%.*]] = call <4 x half> @llvm.amdgcn.image.sample.1d.v4f16.f32.v8i32.v4i32(i32 100, float [[TMP0]], <8 x i32> [[TEX_RSRC_VAL]], <4 x i32> [[TMP2]], i1 false, i32 120, i32 110) +// CHECK-NEXT: ret <4 x half> [[TMP3]] +// +half4 test_builtin_amdgcn_image_sample_1d_v4f16_f32(half4 v4f16, int i32, float f32, __amdgpu_texture_t tex, int4 vec4i32) { + return __builtin_amdgcn_image_sample_1d_v4f16_f32(100, f32, tex, vec4i32, 0, 120, 110); +} + +// CHECK-LABEL: define dso_local <4 x float> @test_builtin_amdgcn_image_sample_1darray_v4f32_f32( +// CHECK-SAME: i32 noundef [[I32:%.*]], float noundef [[F32:%.*]], ptr [[TEX:%.*]], <4 x i32> noundef [[VEC4I32:%.*]]) #[[ATTR0]] { +// CHECK-NEXT: [[ENTRY:.*:]] +// CHECK-NEXT: [[RETVAL:%.*]] = alloca <4 x float>, align 16, addrspace(5) +// CHECK-NEXT: [[I32_ADDR:%.*]] = alloca i32, align 4, addrspace(5) +// CHECK-NEXT: [[F32_ADDR:%.*]] = alloca float, align 4, addrspace(5) +// CHECK-NEXT: [[TEX_ADDR:%.*]] = alloca ptr, align 32, addrspace(5) +// CHECK-NEXT: [[VEC4I32_ADDR:%.*]] = alloca <4 x i32>, align 16, addrspace(5) +// CHECK-NEXT: [[RETVAL_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[RETVAL]] to ptr +// CHECK-NEXT: [[I32_ADDR_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[I32_ADDR]] to ptr +// CHECK-NEXT: [[F32_ADDR_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[F32_ADDR]] to ptr +// CHECK-NEXT: [[TEX_ADDR_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[TEX_ADDR]] to ptr +// CHECK-NEXT: [[VEC4I32_ADDR_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[VEC4I32_ADDR]] to ptr +// CHECK-NEXT: store i32 [[I32]], ptr [[I32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: store float [[F32]], ptr [[F32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: store ptr [[TEX]], ptr [[TEX_ADDR_ASCAST]], align 32 +// CHECK-NEXT: store <4 x i32> [[VEC4I32]], ptr [[VEC4I32_ADDR_ASCAST]], align 16 +// CHECK-NEXT: [[TMP0:%.*]] = load float, ptr [[F32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: [[TMP1:%.*]] = load float, ptr [[F32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: [[TMP2:%.*]] = load ptr, ptr [[TEX_ADDR_ASCAST]], align 32 +// CHECK-NEXT: [[TEX_RSRC_VAL:%.*]] = load <8 x i32>, ptr [[TMP2]], align 32 +// CHECK-NEXT: [[TMP3:%.*]] = load <4 x i32>, ptr [[VEC4I32_ADDR_ASCAST]], align 16 +// CHECK-NEXT: [[TMP4:%.*]] = call <4 x float> @llvm.amdgcn.image.sample.1darray.v4f32.f32.v8i32.v4i32(i32 100, float [[TMP0]], float [[TMP1]], <8 x i32> [[TEX_RSRC_VAL]], <4 x i32> [[TMP3]], i1 false, i32 120, i32 110) +// CHECK-NEXT: ret <4 x float> [[TMP4]] +// +float4 test_builtin_amdgcn_image_sample_1darray_v4f32_f32(int i32, float f32, __amdgpu_texture_t tex, int4 vec4i32) { + return __builtin_amdgcn_image_sample_1darray_v4f32_f32(100, f32, f32, tex, vec4i32, 0, 120, 110); +} + +// CHECK-LABEL: define dso_local <4 x half> @test_builtin_amdgcn_image_sample_1darray_v4f16_f32( +// CHECK-SAME: <4 x half> noundef [[V4F16:%.*]], i32 noundef [[I32:%.*]], float noundef [[F32:%.*]], ptr [[TEX:%.*]], <4 x i32> noundef [[VEC4I32:%.*]]) #[[ATTR0]] { +// CHECK-NEXT: [[ENTRY:.*:]] +// CHECK-NEXT: [[RETVAL:%.*]] = alloca <4 x half>, align 8, addrspace(5) +// CHECK-NEXT: [[V4F16_ADDR:%.*]] = alloca <4 x half>, align 8, addrspace(5) +// CHECK-NEXT: [[I32_ADDR:%.*]] = alloca i32, align 4, addrspace(5) +// CHECK-NEXT: [[F32_ADDR:%.*]] = alloca float, align 4, addrspace(5) +// CHECK-NEXT: [[TEX_ADDR:%.*]] = alloca ptr, align 32, addrspace(5) +// CHECK-NEXT: [[VEC4I32_ADDR:%.*]] = alloca <4 x i32>, align 16, addrspace(5) +// CHECK-NEXT: [[RETVAL_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[RETVAL]] to ptr +// CHECK-NEXT: [[V4F16_ADDR_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[V4F16_ADDR]] to ptr +// CHECK-NEXT: [[I32_ADDR_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[I32_ADDR]] to ptr +// CHECK-NEXT: [[F32_ADDR_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[F32_ADDR]] to ptr +// CHECK-NEXT: [[TEX_ADDR_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[TEX_ADDR]] to ptr +// CHECK-NEXT: [[VEC4I32_ADDR_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[VEC4I32_ADDR]] to ptr +// CHECK-NEXT: store <4 x half> [[V4F16]], ptr [[V4F16_ADDR_ASCAST]], align 8 +// CHECK-NEXT: store i32 [[I32]], ptr [[I32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: store float [[F32]], ptr [[F32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: store ptr [[TEX]], ptr [[TEX_ADDR_ASCAST]], align 32 +// CHECK-NEXT: store <4 x i32> [[VEC4I32]], ptr [[VEC4I32_ADDR_ASCAST]], align 16 +// CHECK-NEXT: [[TMP0:%.*]] = load float, ptr [[F32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: [[TMP1:%.*]] = load float, ptr [[F32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: [[TMP2:%.*]] = load ptr, ptr [[TEX_ADDR_ASCAST]], align 32 +// CHECK-NEXT: [[TEX_RSRC_VAL:%.*]] = load <8 x i32>, ptr [[TMP2]], align 32 +// CHECK-NEXT: [[TMP3:%.*]] = load <4 x i32>, ptr [[VEC4I32_ADDR_ASCAST]], align 16 +// CHECK-NEXT: [[TMP4:%.*]] = call <4 x half> @llvm.amdgcn.image.sample.1darray.v4f16.f32.v8i32.v4i32(i32 100, float [[TMP0]], float [[TMP1]], <8 x i32> [[TEX_RSRC_VAL]], <4 x i32> [[TMP3]], i1 false, i32 120, i32 110) +// CHECK-NEXT: ret <4 x half> [[TMP4]] +// +half4 test_builtin_amdgcn_image_sample_1darray_v4f16_f32(half4 v4f16, int i32, float f32, __amdgpu_texture_t tex, int4 vec4i32) { + return __builtin_amdgcn_image_sample_1darray_v4f16_f32(100, f32, f32, tex, vec4i32, 0, 120, 110); +} + +// CHECK-LABEL: define dso_local float @test_builtin_amdgcn_image_sample_2d_f32_f32( +// CHECK-SAME: i32 noundef [[I32:%.*]], float noundef [[F32:%.*]], ptr [[TEX:%.*]], <4 x i32> noundef [[VEC4I32:%.*]]) #[[ATTR0]] { +// CHECK-NEXT: [[ENTRY:.*:]] +// CHECK-NEXT: [[RETVAL:%.*]] = alloca float, align 4, addrspace(5) +// CHECK-NEXT: [[I32_ADDR:%.*]] = alloca i32, align 4, addrspace(5) +// CHECK-NEXT: [[F32_ADDR:%.*]] = alloca float, align 4, addrspace(5) +// CHECK-NEXT: [[TEX_ADDR:%.*]] = alloca ptr, align 32, addrspace(5) +// CHECK-NEXT: [[VEC4I32_ADDR:%.*]] = alloca <4 x i32>, align 16, addrspace(5) +// CHECK-NEXT: [[RETVAL_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[RETVAL]] to ptr +// CHECK-NEXT: [[I32_ADDR_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[I32_ADDR]] to ptr +// CHECK-NEXT: [[F32_ADDR_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[F32_ADDR]] to ptr +// CHECK-NEXT: [[TEX_ADDR_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[TEX_ADDR]] to ptr +// CHECK-NEXT: [[VEC4I32_ADDR_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[VEC4I32_ADDR]] to ptr +// CHECK-NEXT: store i32 [[I32]], ptr [[I32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: store float [[F32]], ptr [[F32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: store ptr [[TEX]], ptr [[TEX_ADDR_ASCAST]], align 32 +// CHECK-NEXT: store <4 x i32> [[VEC4I32]], ptr [[VEC4I32_ADDR_ASCAST]], align 16 +// CHECK-NEXT: [[TMP0:%.*]] = load float, ptr [[F32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: [[TMP1:%.*]] = load float, ptr [[F32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: [[TMP2:%.*]] = load ptr, ptr [[TEX_ADDR_ASCAST]], align 32 +// CHECK-NEXT: [[TEX_RSRC_VAL:%.*]] = load <8 x i32>, ptr [[TMP2]], align 32 +// CHECK-NEXT: [[TMP3:%.*]] = load <4 x i32>, ptr [[VEC4I32_ADDR_ASCAST]], align 16 +// CHECK-NEXT: [[TMP4:%.*]] = call float @llvm.amdgcn.image.sample.2d.f32.f32.v8i32.v4i32(i32 100, float [[TMP0]], float [[TMP1]], <8 x i32> [[TEX_RSRC_VAL]], <4 x i32> [[TMP3]], i1 false, i32 120, i32 110) +// CHECK-NEXT: ret float [[TMP4]] +// +float test_builtin_amdgcn_image_sample_2d_f32_f32(int i32, float f32, __amdgpu_texture_t tex, int4 vec4i32) { + return __builtin_amdgcn_image_sample_2d_f32_f32(100, f32, f32, tex, vec4i32, 0, 120, 110); +} + +// CHECK-LABEL: define dso_local <4 x float> @test_builtin_amdgcn_image_sample_2d_v4f32_f32( +// CHECK-SAME: <4 x float> noundef [[V4F32:%.*]], i32 noundef [[I32:%.*]], float noundef [[F32:%.*]], ptr [[TEX:%.*]], <4 x i32> noundef [[VEC4I32:%.*]]) #[[ATTR0]] { +// CHECK-NEXT: [[ENTRY:.*:]] +// CHECK-NEXT: [[RETVAL:%.*]] = alloca <4 x float>, align 16, addrspace(5) +// CHECK-NEXT: [[V4F32_ADDR:%.*]] = alloca <4 x float>, align 16, addrspace(5) +// CHECK-NEXT: [[I32_ADDR:%.*]] = alloca i32, align 4, addrspace(5) +// CHECK-NEXT: [[F32_ADDR:%.*]] = alloca float, align 4, addrspace(5) +// CHECK-NEXT: [[TEX_ADDR:%.*]] = alloca ptr, align 32, addrspace(5) +// CHECK-NEXT: [[VEC4I32_ADDR:%.*]] = alloca <4 x i32>, align 16, addrspace(5) +// CHECK-NEXT: [[RETVAL_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[RETVAL]] to ptr +// CHECK-NEXT: [[V4F32_ADDR_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[V4F32_ADDR]] to ptr +// CHECK-NEXT: [[I32_ADDR_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[I32_ADDR]] to ptr +// CHECK-NEXT: [[F32_ADDR_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[F32_ADDR]] to ptr +// CHECK-NEXT: [[TEX_ADDR_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[TEX_ADDR]] to ptr +// CHECK-NEXT: [[VEC4I32_ADDR_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[VEC4I32_ADDR]] to ptr +// CHECK-NEXT: store <4 x float> [[V4F32]], ptr [[V4F32_ADDR_ASCAST]], align 16 +// CHECK-NEXT: store i32 [[I32]], ptr [[I32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: store float [[F32]], ptr [[F32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: store ptr [[TEX]], ptr [[TEX_ADDR_ASCAST]], align 32 +// CHECK-NEXT: store <4 x i32> [[VEC4I32]], ptr [[VEC4I32_ADDR_ASCAST]], align 16 +// CHECK-NEXT: [[TMP0:%.*]] = load float, ptr [[F32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: [[TMP1:%.*]] = load float, ptr [[F32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: [[TMP2:%.*]] = load ptr, ptr [[TEX_ADDR_ASCAST]], align 32 +// CHECK-NEXT: [[TEX_RSRC_VAL:%.*]] = load <8 x i32>, ptr [[TMP2]], align 32 +// CHECK-NEXT: [[TMP3:%.*]] = load <4 x i32>, ptr [[VEC4I32_ADDR_ASCAST]], align 16 +// CHECK-NEXT: [[TMP4:%.*]] = call <4 x float> @llvm.amdgcn.image.sample.2d.v4f32.f32.v8i32.v4i32(i32 100, float [[TMP0]], float [[TMP1]], <8 x i32> [[TEX_RSRC_VAL]], <4 x i32> [[TMP3]], i1 false, i32 120, i32 110) +// CHECK-NEXT: ret <4 x float> [[TMP4]] +// +float4 test_builtin_amdgcn_image_sample_2d_v4f32_f32(float4 v4f32, int i32, float f32, __amdgpu_texture_t tex, int4 vec4i32) { + return __builtin_amdgcn_image_sample_2d_v4f32_f32(100, f32, f32, tex, vec4i32, 0, 120, 110); +} + +// CHECK-LABEL: define dso_local <4 x half> @test_builtin_amdgcn_image_sample_2d_v4f16_f32( +// CHECK-SAME: <4 x half> noundef [[V4F16:%.*]], i32 noundef [[I32:%.*]], float noundef [[F32:%.*]], ptr [[TEX:%.*]], <4 x i32> noundef [[VEC4I32:%.*]]) #[[ATTR0]] { +// CHECK-NEXT: [[ENTRY:.*:]] +// CHECK-NEXT: [[RETVAL:%.*]] = alloca <4 x half>, align 8, addrspace(5) +// CHECK-NEXT: [[V4F16_ADDR:%.*]] = alloca <4 x half>, align 8, addrspace(5) +// CHECK-NEXT: [[I32_ADDR:%.*]] = alloca i32, align 4, addrspace(5) +// CHECK-NEXT: [[F32_ADDR:%.*]] = alloca float, align 4, addrspace(5) +// CHECK-NEXT: [[TEX_ADDR:%.*]] = alloca ptr, align 32, addrspace(5) +// CHECK-NEXT: [[VEC4I32_ADDR:%.*]] = alloca <4 x i32>, align 16, addrspace(5) +// CHECK-NEXT: [[RETVAL_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[RETVAL]] to ptr +// CHECK-NEXT: [[V4F16_ADDR_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[V4F16_ADDR]] to ptr +// CHECK-NEXT: [[I32_ADDR_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[I32_ADDR]] to ptr +// CHECK-NEXT: [[F32_ADDR_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[F32_ADDR]] to ptr +// CHECK-NEXT: [[TEX_ADDR_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[TEX_ADDR]] to ptr +// CHECK-NEXT: [[VEC4I32_ADDR_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[VEC4I32_ADDR]] to ptr +// CHECK-NEXT: store <4 x half> [[V4F16]], ptr [[V4F16_ADDR_ASCAST]], align 8 +// CHECK-NEXT: store i32 [[I32]], ptr [[I32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: store float [[F32]], ptr [[F32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: store ptr [[TEX]], ptr [[TEX_ADDR_ASCAST]], align 32 +// CHECK-NEXT: store <4 x i32> [[VEC4I32]], ptr [[VEC4I32_ADDR_ASCAST]], align 16 +// CHECK-NEXT: [[TMP0:%.*]] = load float, ptr [[F32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: [[TMP1:%.*]] = load float, ptr [[F32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: [[TMP2:%.*]] = load ptr, ptr [[TEX_ADDR_ASCAST]], align 32 +// CHECK-NEXT: [[TEX_RSRC_VAL:%.*]] = load <8 x i32>, ptr [[TMP2]], align 32 +// CHECK-NEXT: [[TMP3:%.*]] = load <4 x i32>, ptr [[VEC4I32_ADDR_ASCAST]], align 16 +// CHECK-NEXT: [[TMP4:%.*]] = call <4 x half> @llvm.amdgcn.image.sample.2d.v4f16.f32.v8i32.v4i32(i32 100, float [[TMP0]], float [[TMP1]], <8 x i32> [[TEX_RSRC_VAL]], <4 x i32> [[TMP3]], i1 false, i32 120, i32 110) +// CHECK-NEXT: ret <4 x half> [[TMP4]] +// +half4 test_builtin_amdgcn_image_sample_2d_v4f16_f32(half4 v4f16, int i32, float f32, __amdgpu_texture_t tex, int4 vec4i32) { + return __builtin_amdgcn_image_sample_2d_v4f16_f32(100, f32, f32, tex, vec4i32, 0, 120, 110); +} + +// CHECK-LABEL: define dso_local float @test_builtin_amdgcn_image_sample_2darray_f32_f32( +// CHECK-SAME: i32 noundef [[I32:%.*]], float noundef [[F32:%.*]], ptr [[TEX:%.*]], <4 x i32> noundef [[VEC4I32:%.*]]) #[[ATTR0]] { +// CHECK-NEXT: [[ENTRY:.*:]] +// CHECK-NEXT: [[RETVAL:%.*]] = alloca float, align 4, addrspace(5) +// CHECK-NEXT: [[I32_ADDR:%.*]] = alloca i32, align 4, addrspace(5) +// CHECK-NEXT: [[F32_ADDR:%.*]] = alloca float, align 4, addrspace(5) +// CHECK-NEXT: [[TEX_ADDR:%.*]] = alloca ptr, align 32, addrspace(5) +// CHECK-NEXT: [[VEC4I32_ADDR:%.*]] = alloca <4 x i32>, align 16, addrspace(5) +// CHECK-NEXT: [[RETVAL_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[RETVAL]] to ptr +// CHECK-NEXT: [[I32_ADDR_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[I32_ADDR]] to ptr +// CHECK-NEXT: [[F32_ADDR_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[F32_ADDR]] to ptr +// CHECK-NEXT: [[TEX_ADDR_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[TEX_ADDR]] to ptr +// CHECK-NEXT: [[VEC4I32_ADDR_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[VEC4I32_ADDR]] to ptr +// CHECK-NEXT: store i32 [[I32]], ptr [[I32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: store float [[F32]], ptr [[F32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: store ptr [[TEX]], ptr [[TEX_ADDR_ASCAST]], align 32 +// CHECK-NEXT: store <4 x i32> [[VEC4I32]], ptr [[VEC4I32_ADDR_ASCAST]], align 16 +// CHECK-NEXT: [[TMP0:%.*]] = load float, ptr [[F32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: [[TMP1:%.*]] = load float, ptr [[F32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: [[TMP2:%.*]] = load float, ptr [[F32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: [[TMP3:%.*]] = load ptr, ptr [[TEX_ADDR_ASCAST]], align 32 +// CHECK-NEXT: [[TEX_RSRC_VAL:%.*]] = load <8 x i32>, ptr [[TMP3]], align 32 +// CHECK-NEXT: [[TMP4:%.*]] = load <4 x i32>, ptr [[VEC4I32_ADDR_ASCAST]], align 16 +// CHECK-NEXT: [[TMP5:%.*]] = call float @llvm.amdgcn.image.sample.2darray.f32.f32.v8i32.v4i32(i32 100, float [[TMP0]], float [[TMP1]], float [[TMP2]], <8 x i32> [[TEX_RSRC_VAL]], <4 x i32> [[TMP4]], i1 false, i32 120, i32 110) +// CHECK-NEXT: ret float [[TMP5]] +// +float test_builtin_amdgcn_image_sample_2darray_f32_f32(int i32, float f32, __amdgpu_texture_t tex, int4 vec4i32) { + return __builtin_amdgcn_image_sample_2darray_f32_f32(100, f32, f32, f32, tex, vec4i32, 0, 120, 110); +} + +// CHECK-LABEL: define dso_local <4 x float> @test_builtin_amdgcn_image_sample_2darray_v4f32_f32( +// CHECK-SAME: <4 x float> noundef [[V4F32:%.*]], i32 noundef [[I32:%.*]], float noundef [[F32:%.*]], ptr [[TEX:%.*]], <4 x i32> noundef [[VEC4I32:%.*]]) #[[ATTR0]] { +// CHECK-NEXT: [[ENTRY:.*:]] +// CHECK-NEXT: [[RETVAL:%.*]] = alloca <4 x float>, align 16, addrspace(5) +// CHECK-NEXT: [[V4F32_ADDR:%.*]] = alloca <4 x float>, align 16, addrspace(5) +// CHECK-NEXT: [[I32_ADDR:%.*]] = alloca i32, align 4, addrspace(5) +// CHECK-NEXT: [[F32_ADDR:%.*]] = alloca float, align 4, addrspace(5) +// CHECK-NEXT: [[TEX_ADDR:%.*]] = alloca ptr, align 32, addrspace(5) +// CHECK-NEXT: [[VEC4I32_ADDR:%.*]] = alloca <4 x i32>, align 16, addrspace(5) +// CHECK-NEXT: [[RETVAL_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[RETVAL]] to ptr +// CHECK-NEXT: [[V4F32_ADDR_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[V4F32_ADDR]] to ptr +// CHECK-NEXT: [[I32_ADDR_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[I32_ADDR]] to ptr +// CHECK-NEXT: [[F32_ADDR_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[F32_ADDR]] to ptr +// CHECK-NEXT: [[TEX_ADDR_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[TEX_ADDR]] to ptr +// CHECK-NEXT: [[VEC4I32_ADDR_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[VEC4I32_ADDR]] to ptr +// CHECK-NEXT: store <4 x float> [[V4F32]], ptr [[V4F32_ADDR_ASCAST]], align 16 +// CHECK-NEXT: store i32 [[I32]], ptr [[I32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: store float [[F32]], ptr [[F32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: store ptr [[TEX]], ptr [[TEX_ADDR_ASCAST]], align 32 +// CHECK-NEXT: store <4 x i32> [[VEC4I32]], ptr [[VEC4I32_ADDR_ASCAST]], align 16 +// CHECK-NEXT: [[TMP0:%.*]] = load float, ptr [[F32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: [[TMP1:%.*]] = load float, ptr [[F32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: [[TMP2:%.*]] = load float, ptr [[F32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: [[TMP3:%.*]] = load ptr, ptr [[TEX_ADDR_ASCAST]], align 32 +// CHECK-NEXT: [[TEX_RSRC_VAL:%.*]] = load <8 x i32>, ptr [[TMP3]], align 32 +// CHECK-NEXT: [[TMP4:%.*]] = load <4 x i32>, ptr [[VEC4I32_ADDR_ASCAST]], align 16 +// CHECK-NEXT: [[TMP5:%.*]] = call <4 x float> @llvm.amdgcn.image.sample.2darray.v4f32.f32.v8i32.v4i32(i32 100, float [[TMP0]], float [[TMP1]], float [[TMP2]], <8 x i32> [[TEX_RSRC_VAL]], <4 x i32> [[TMP4]], i1 false, i32 120, i32 110) +// CHECK-NEXT: ret <4 x float> [[TMP5]] +// +float4 test_builtin_amdgcn_image_sample_2darray_v4f32_f32(float4 v4f32, int i32, float f32, __amdgpu_texture_t tex, int4 vec4i32) { + return __builtin_amdgcn_image_sample_2darray_v4f32_f32(100, f32, f32, f32, tex, vec4i32, 0, 120, 110); +} + +// CHECK-LABEL: define dso_local <4 x half> @test_builtin_amdgcn_image_sample_2darray_v4f16_f32( +// CHECK-SAME: <4 x half> noundef [[V4F16:%.*]], i32 noundef [[I32:%.*]], float noundef [[F32:%.*]], ptr [[TEX:%.*]], <4 x i32> noundef [[VEC4I32:%.*]]) #[[ATTR0]] { +// CHECK-NEXT: [[ENTRY:.*:]] +// CHECK-NEXT: [[RETVAL:%.*]] = alloca <4 x half>, align 8, addrspace(5) +// CHECK-NEXT: [[V4F16_ADDR:%.*]] = alloca <4 x half>, align 8, addrspace(5) +// CHECK-NEXT: [[I32_ADDR:%.*]] = alloca i32, align 4, addrspace(5) +// CHECK-NEXT: [[F32_ADDR:%.*]] = alloca float, align 4, addrspace(5) +// CHECK-NEXT: [[TEX_ADDR:%.*]] = alloca ptr, align 32, addrspace(5) +// CHECK-NEXT: [[VEC4I32_ADDR:%.*]] = alloca <4 x i32>, align 16, addrspace(5) +// CHECK-NEXT: [[RETVAL_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[RETVAL]] to ptr +// CHECK-NEXT: [[V4F16_ADDR_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[V4F16_ADDR]] to ptr +// CHECK-NEXT: [[I32_ADDR_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[I32_ADDR]] to ptr +// CHECK-NEXT: [[F32_ADDR_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[F32_ADDR]] to ptr +// CHECK-NEXT: [[TEX_ADDR_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[TEX_ADDR]] to ptr +// CHECK-NEXT: [[VEC4I32_ADDR_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[VEC4I32_ADDR]] to ptr +// CHECK-NEXT: store <4 x half> [[V4F16]], ptr [[V4F16_ADDR_ASCAST]], align 8 +// CHECK-NEXT: store i32 [[I32]], ptr [[I32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: store float [[F32]], ptr [[F32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: store ptr [[TEX]], ptr [[TEX_ADDR_ASCAST]], align 32 +// CHECK-NEXT: store <4 x i32> [[VEC4I32]], ptr [[VEC4I32_ADDR_ASCAST]], align 16 +// CHECK-NEXT: [[TMP0:%.*]] = load float, ptr [[F32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: [[TMP1:%.*]] = load float, ptr [[F32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: [[TMP2:%.*]] = load float, ptr [[F32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: [[TMP3:%.*]] = load ptr, ptr [[TEX_ADDR_ASCAST]], align 32 +// CHECK-NEXT: [[TEX_RSRC_VAL:%.*]] = load <8 x i32>, ptr [[TMP3]], align 32 +// CHECK-NEXT: [[TMP4:%.*]] = load <4 x i32>, ptr [[VEC4I32_ADDR_ASCAST]], align 16 +// CHECK-NEXT: [[TMP5:%.*]] = call <4 x half> @llvm.amdgcn.image.sample.2darray.v4f16.f32.v8i32.v4i32(i32 100, float [[TMP0]], float [[TMP1]], float [[TMP2]], <8 x i32> [[TEX_RSRC_VAL]], <4 x i32> [[TMP4]], i1 false, i32 120, i32 110) +// CHECK-NEXT: ret <4 x half> [[TMP5]] +// +half4 test_builtin_amdgcn_image_sample_2darray_v4f16_f32(half4 v4f16, int i32, float f32, __amdgpu_texture_t tex, int4 vec4i32) { + return __builtin_amdgcn_image_sample_2darray_v4f16_f32(100, f32, f32, f32, tex, vec4i32, 0, 120, 110); +} + +// CHECK-LABEL: define dso_local <4 x float> @test_builtin_amdgcn_image_sample_3d_v4f32_f32( +// CHECK-SAME: <4 x float> noundef [[V4F32:%.*]], i32 noundef [[I32:%.*]], float noundef [[F32:%.*]], ptr [[TEX:%.*]], <4 x i32> noundef [[VEC4I32:%.*]]) #[[ATTR0]] { +// CHECK-NEXT: [[ENTRY:.*:]] +// CHECK-NEXT: [[RETVAL:%.*]] = alloca <4 x float>, align 16, addrspace(5) +// CHECK-NEXT: [[V4F32_ADDR:%.*]] = alloca <4 x float>, align 16, addrspace(5) +// CHECK-NEXT: [[I32_ADDR:%.*]] = alloca i32, align 4, addrspace(5) +// CHECK-NEXT: [[F32_ADDR:%.*]] = alloca float, align 4, addrspace(5) +// CHECK-NEXT: [[TEX_ADDR:%.*]] = alloca ptr, align 32, addrspace(5) +// CHECK-NEXT: [[VEC4I32_ADDR:%.*]] = alloca <4 x i32>, align 16, addrspace(5) +// CHECK-NEXT: [[RETVAL_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[RETVAL]] to ptr +// CHECK-NEXT: [[V4F32_ADDR_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[V4F32_ADDR]] to ptr +// CHECK-NEXT: [[I32_ADDR_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[I32_ADDR]] to ptr +// CHECK-NEXT: [[F32_ADDR_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[F32_ADDR]] to ptr +// CHECK-NEXT: [[TEX_ADDR_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[TEX_ADDR]] to ptr +// CHECK-NEXT: [[VEC4I32_ADDR_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[VEC4I32_ADDR]] to ptr +// CHECK-NEXT: store <4 x float> [[V4F32]], ptr [[V4F32_ADDR_ASCAST]], align 16 +// CHECK-NEXT: store i32 [[I32]], ptr [[I32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: store float [[F32]], ptr [[F32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: store ptr [[TEX]], ptr [[TEX_ADDR_ASCAST]], align 32 +// CHECK-NEXT: store <4 x i32> [[VEC4I32]], ptr [[VEC4I32_ADDR_ASCAST]], align 16 +// CHECK-NEXT: [[TMP0:%.*]] = load float, ptr [[F32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: [[TMP1:%.*]] = load float, ptr [[F32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: [[TMP2:%.*]] = load float, ptr [[F32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: [[TMP3:%.*]] = load ptr, ptr [[TEX_ADDR_ASCAST]], align 32 +// CHECK-NEXT: [[TEX_RSRC_VAL:%.*]] = load <8 x i32>, ptr [[TMP3]], align 32 +// CHECK-NEXT: [[TMP4:%.*]] = load <4 x i32>, ptr [[VEC4I32_ADDR_ASCAST]], align 16 +// CHECK-NEXT: [[TMP5:%.*]] = call <4 x float> @llvm.amdgcn.image.sample.3d.v4f32.f32.v8i32.v4i32(i32 100, float [[TMP0]], float [[TMP1]], float [[TMP2]], <8 x i32> [[TEX_RSRC_VAL]], <4 x i32> [[TMP4]], i1 false, i32 120, i32 110) +// CHECK-NEXT: ret <4 x float> [[TMP5]] +// +float4 test_builtin_amdgcn_image_sample_3d_v4f32_f32(float4 v4f32, int i32, float f32, __amdgpu_texture_t tex, int4 vec4i32) { + return __builtin_amdgcn_image_sample_3d_v4f32_f32(100, f32, f32, f32, tex, vec4i32, 0, 120, 110); +} + +// CHECK-LABEL: define dso_local <4 x half> @test_builtin_amdgcn_image_sample_3d_v4f16_f32( +// CHECK-SAME: <4 x half> noundef [[V4F16:%.*]], i32 noundef [[I32:%.*]], float noundef [[F32:%.*]], ptr [[TEX:%.*]], <4 x i32> noundef [[VEC4I32:%.*]]) #[[ATTR0]] { +// CHECK-NEXT: [[ENTRY:.*:]] +// CHECK-NEXT: [[RETVAL:%.*]] = alloca <4 x half>, align 8, addrspace(5) +// CHECK-NEXT: [[V4F16_ADDR:%.*]] = alloca <4 x half>, align 8, addrspace(5) +// CHECK-NEXT: [[I32_ADDR:%.*]] = alloca i32, align 4, addrspace(5) +// CHECK-NEXT: [[F32_ADDR:%.*]] = alloca float, align 4, addrspace(5) +// CHECK-NEXT: [[TEX_ADDR:%.*]] = alloca ptr, align 32, addrspace(5) +// CHECK-NEXT: [[VEC4I32_ADDR:%.*]] = alloca <4 x i32>, align 16, addrspace(5) +// CHECK-NEXT: [[RETVAL_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[RETVAL]] to ptr +// CHECK-NEXT: [[V4F16_ADDR_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[V4F16_ADDR]] to ptr +// CHECK-NEXT: [[I32_ADDR_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[I32_ADDR]] to ptr +// CHECK-NEXT: [[F32_ADDR_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[F32_ADDR]] to ptr +// CHECK-NEXT: [[TEX_ADDR_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[TEX_ADDR]] to ptr +// CHECK-NEXT: [[VEC4I32_ADDR_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[VEC4I32_ADDR]] to ptr +// CHECK-NEXT: store <4 x half> [[V4F16]], ptr [[V4F16_ADDR_ASCAST]], align 8 +// CHECK-NEXT: store i32 [[I32]], ptr [[I32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: store float [[F32]], ptr [[F32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: store ptr [[TEX]], ptr [[TEX_ADDR_ASCAST]], align 32 +// CHECK-NEXT: store <4 x i32> [[VEC4I32]], ptr [[VEC4I32_ADDR_ASCAST]], align 16 +// CHECK-NEXT: [[TMP0:%.*]] = load float, ptr [[F32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: [[TMP1:%.*]] = load float, ptr [[F32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: [[TMP2:%.*]] = load float, ptr [[F32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: [[TMP3:%.*]] = load ptr, ptr [[TEX_ADDR_ASCAST]], align 32 +// CHECK-NEXT: [[TEX_RSRC_VAL:%.*]] = load <8 x i32>, ptr [[TMP3]], align 32 +// CHECK-NEXT: [[TMP4:%.*]] = load <4 x i32>, ptr [[VEC4I32_ADDR_ASCAST]], align 16 +// CHECK-NEXT: [[TMP5:%.*]] = call <4 x half> @llvm.amdgcn.image.sample.3d.v4f16.f32.v8i32.v4i32(i32 100, float [[TMP0]], float [[TMP1]], float [[TMP2]], <8 x i32> [[TEX_RSRC_VAL]], <4 x i32> [[TMP4]], i1 false, i32 120, i32 110) +// CHECK-NEXT: ret <4 x half> [[TMP5]] +// +half4 test_builtin_amdgcn_image_sample_3d_v4f16_f32(half4 v4f16, int i32, float f32, __amdgpu_texture_t tex, int4 vec4i32) { + return __builtin_amdgcn_image_sample_3d_v4f16_f32(100, f32, f32, f32, tex, vec4i32, 0, 120, 110); +} + +// CHECK-LABEL: define dso_local <4 x float> @test_builtin_amdgcn_image_sample_cube_v4f32_f32( +// CHECK-SAME: <4 x float> noundef [[V4F32:%.*]], i32 noundef [[I32:%.*]], float noundef [[F32:%.*]], ptr [[TEX:%.*]], <4 x i32> noundef [[VEC4I32:%.*]]) #[[ATTR0]] { +// CHECK-NEXT: [[ENTRY:.*:]] +// CHECK-NEXT: [[RETVAL:%.*]] = alloca <4 x float>, align 16, addrspace(5) +// CHECK-NEXT: [[V4F32_ADDR:%.*]] = alloca <4 x float>, align 16, addrspace(5) +// CHECK-NEXT: [[I32_ADDR:%.*]] = alloca i32, align 4, addrspace(5) +// CHECK-NEXT: [[F32_ADDR:%.*]] = alloca float, align 4, addrspace(5) +// CHECK-NEXT: [[TEX_ADDR:%.*]] = alloca ptr, align 32, addrspace(5) +// CHECK-NEXT: [[VEC4I32_ADDR:%.*]] = alloca <4 x i32>, align 16, addrspace(5) +// CHECK-NEXT: [[RETVAL_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[RETVAL]] to ptr +// CHECK-NEXT: [[V4F32_ADDR_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[V4F32_ADDR]] to ptr +// CHECK-NEXT: [[I32_ADDR_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[I32_ADDR]] to ptr +// CHECK-NEXT: [[F32_ADDR_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[F32_ADDR]] to ptr +// CHECK-NEXT: [[TEX_ADDR_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[TEX_ADDR]] to ptr +// CHECK-NEXT: [[VEC4I32_ADDR_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[VEC4I32_ADDR]] to ptr +// CHECK-NEXT: store <4 x float> [[V4F32]], ptr [[V4F32_ADDR_ASCAST]], align 16 +// CHECK-NEXT: store i32 [[I32]], ptr [[I32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: store float [[F32]], ptr [[F32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: store ptr [[TEX]], ptr [[TEX_ADDR_ASCAST]], align 32 +// CHECK-NEXT: store <4 x i32> [[VEC4I32]], ptr [[VEC4I32_ADDR_ASCAST]], align 16 +// CHECK-NEXT: [[TMP0:%.*]] = load float, ptr [[F32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: [[TMP1:%.*]] = load float, ptr [[F32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: [[TMP2:%.*]] = load float, ptr [[F32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: [[TMP3:%.*]] = load ptr, ptr [[TEX_ADDR_ASCAST]], align 32 +// CHECK-NEXT: [[TEX_RSRC_VAL:%.*]] = load <8 x i32>, ptr [[TMP3]], align 32 +// CHECK-NEXT: [[TMP4:%.*]] = load <4 x i32>, ptr [[VEC4I32_ADDR_ASCAST]], align 16 +// CHECK-NEXT: [[TMP5:%.*]] = call <4 x float> @llvm.amdgcn.image.sample.cube.v4f32.f32.v8i32.v4i32(i32 100, float [[TMP0]], float [[TMP1]], float [[TMP2]], <8 x i32> [[TEX_RSRC_VAL]], <4 x i32> [[TMP4]], i1 false, i32 120, i32 110) +// CHECK-NEXT: ret <4 x float> [[TMP5]] +// +float4 test_builtin_amdgcn_image_sample_cube_v4f32_f32(float4 v4f32, int i32, float f32, __amdgpu_texture_t tex, int4 vec4i32) { + return __builtin_amdgcn_image_sample_cube_v4f32_f32(100, f32, f32, f32, tex, vec4i32, 0, 120, 110); +} + +// CHECK-LABEL: define dso_local <4 x half> @test_builtin_amdgcn_image_sample_cube_v4f16_f32( +// CHECK-SAME: <4 x half> noundef [[V4F16:%.*]], i32 noundef [[I32:%.*]], float noundef [[F32:%.*]], ptr [[TEX:%.*]], <4 x i32> noundef [[VEC4I32:%.*]]) #[[ATTR0]] { +// CHECK-NEXT: [[ENTRY:.*:]] +// CHECK-NEXT: [[RETVAL:%.*]] = alloca <4 x half>, align 8, addrspace(5) +// CHECK-NEXT: [[V4F16_ADDR:%.*]] = alloca <4 x half>, align 8, addrspace(5) +// CHECK-NEXT: [[I32_ADDR:%.*]] = alloca i32, align 4, addrspace(5) +// CHECK-NEXT: [[F32_ADDR:%.*]] = alloca float, align 4, addrspace(5) +// CHECK-NEXT: [[TEX_ADDR:%.*]] = alloca ptr, align 32, addrspace(5) +// CHECK-NEXT: [[VEC4I32_ADDR:%.*]] = alloca <4 x i32>, align 16, addrspace(5) +// CHECK-NEXT: [[RETVAL_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[RETVAL]] to ptr +// CHECK-NEXT: [[V4F16_ADDR_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[V4F16_ADDR]] to ptr +// CHECK-NEXT: [[I32_ADDR_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[I32_ADDR]] to ptr +// CHECK-NEXT: [[F32_ADDR_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[F32_ADDR]] to ptr +// CHECK-NEXT: [[TEX_ADDR_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[TEX_ADDR]] to ptr +// CHECK-NEXT: [[VEC4I32_ADDR_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[VEC4I32_ADDR]] to ptr +// CHECK-NEXT: store <4 x half> [[V4F16]], ptr [[V4F16_ADDR_ASCAST]], align 8 +// CHECK-NEXT: store i32 [[I32]], ptr [[I32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: store float [[F32]], ptr [[F32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: store ptr [[TEX]], ptr [[TEX_ADDR_ASCAST]], align 32 +// CHECK-NEXT: store <4 x i32> [[VEC4I32]], ptr [[VEC4I32_ADDR_ASCAST]], align 16 +// CHECK-NEXT: [[TMP0:%.*]] = load float, ptr [[F32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: [[TMP1:%.*]] = load float, ptr [[F32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: [[TMP2:%.*]] = load float, ptr [[F32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: [[TMP3:%.*]] = load ptr, ptr [[TEX_ADDR_ASCAST]], align 32 +// CHECK-NEXT: [[TEX_RSRC_VAL:%.*]] = load <8 x i32>, ptr [[TMP3]], align 32 +// CHECK-NEXT: [[TMP4:%.*]] = load <4 x i32>, ptr [[VEC4I32_ADDR_ASCAST]], align 16 +// CHECK-NEXT: [[TMP5:%.*]] = call <4 x half> @llvm.amdgcn.image.sample.cube.v4f16.f32.v8i32.v4i32(i32 100, float [[TMP0]], float [[TMP1]], float [[TMP2]], <8 x i32> [[TEX_RSRC_VAL]], <4 x i32> [[TMP4]], i1 false, i32 120, i32 110) +// CHECK-NEXT: ret <4 x half> [[TMP5]] +// +half4 test_builtin_amdgcn_image_sample_cube_v4f16_f32(half4 v4f16, int i32, float f32, __amdgpu_texture_t tex, int4 vec4i32) { + return __builtin_amdgcn_image_sample_cube_v4f16_f32(100, f32, f32, f32, tex, vec4i32, 0, 120, 110); +} diff --git a/clang/test/CodeGen/builtins-image-store.c b/clang/test/CodeGen/builtins-image-store.c new file mode 100644 index 0000000..5309a16d --- /dev/null +++ b/clang/test/CodeGen/builtins-image-store.c @@ -0,0 +1,730 @@ +// NOTE: Assertions have been autogenerated by utils/update_cc_test_checks.py UTC_ARGS: --version 5 +// RUN: %clang_cc1 -triple amdgcn-- -target-cpu gfx1010 %s -emit-llvm -o - | FileCheck %s + +typedef float float4 __attribute__((ext_vector_type(4))); +typedef _Float16 half; +typedef half half4 __attribute__((ext_vector_type(4))); + +// CHECK-LABEL: define dso_local void @test_builtin_image_store_2d( +// CHECK-SAME: float noundef [[F32:%.*]], i32 noundef [[I32:%.*]], ptr [[TEX:%.*]]) #[[ATTR0:[0-9]+]] { +// CHECK-NEXT: [[ENTRY:.*:]] +// CHECK-NEXT: [[F32_ADDR:%.*]] = alloca float, align 4, addrspace(5) +// CHECK-NEXT: [[I32_ADDR:%.*]] = alloca i32, align 4, addrspace(5) +// CHECK-NEXT: [[TEX_ADDR:%.*]] = alloca ptr, align 32, addrspace(5) +// CHECK-NEXT: [[F32_ADDR_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[F32_ADDR]] to ptr +// CHECK-NEXT: [[I32_ADDR_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[I32_ADDR]] to ptr +// CHECK-NEXT: [[TEX_ADDR_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[TEX_ADDR]] to ptr +// CHECK-NEXT: store float [[F32]], ptr [[F32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: store i32 [[I32]], ptr [[I32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: store ptr [[TEX]], ptr [[TEX_ADDR_ASCAST]], align 32 +// CHECK-NEXT: [[TMP0:%.*]] = load float, ptr [[F32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: [[TMP1:%.*]] = load i32, ptr [[I32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: [[TMP2:%.*]] = load i32, ptr [[I32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: [[TMP3:%.*]] = load ptr, ptr [[TEX_ADDR_ASCAST]], align 32 +// CHECK-NEXT: [[TEX_RSRC_VAL:%.*]] = load <8 x i32>, ptr [[TMP3]], align 32 +// CHECK-NEXT: call void @llvm.amdgcn.image.store.2d.f32.i32.v8i32(float [[TMP0]], i32 12, i32 [[TMP1]], i32 [[TMP2]], <8 x i32> [[TEX_RSRC_VAL]], i32 106, i32 103) +// CHECK-NEXT: ret void +// +void test_builtin_image_store_2d(float f32, int i32, __amdgpu_texture_t tex) { + + __builtin_amdgcn_image_store_2d_f32_i32(f32, 12, i32, i32, tex, 106, 103); + } + +// CHECK-LABEL: define dso_local void @test_builtin_image_store_2d_1( +// CHECK-SAME: <4 x float> noundef [[V4F32:%.*]], i32 noundef [[I32:%.*]], ptr [[TEX:%.*]]) #[[ATTR0]] { +// CHECK-NEXT: [[ENTRY:.*:]] +// CHECK-NEXT: [[V4F32_ADDR:%.*]] = alloca <4 x float>, align 16, addrspace(5) +// CHECK-NEXT: [[I32_ADDR:%.*]] = alloca i32, align 4, addrspace(5) +// CHECK-NEXT: [[TEX_ADDR:%.*]] = alloca ptr, align 32, addrspace(5) +// CHECK-NEXT: [[V4F32_ADDR_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[V4F32_ADDR]] to ptr +// CHECK-NEXT: [[I32_ADDR_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[I32_ADDR]] to ptr +// CHECK-NEXT: [[TEX_ADDR_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[TEX_ADDR]] to ptr +// CHECK-NEXT: store <4 x float> [[V4F32]], ptr [[V4F32_ADDR_ASCAST]], align 16 +// CHECK-NEXT: store i32 [[I32]], ptr [[I32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: store ptr [[TEX]], ptr [[TEX_ADDR_ASCAST]], align 32 +// CHECK-NEXT: [[TMP0:%.*]] = load <4 x float>, ptr [[V4F32_ADDR_ASCAST]], align 16 +// CHECK-NEXT: [[TMP1:%.*]] = load i32, ptr [[I32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: [[TMP2:%.*]] = load i32, ptr [[I32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: [[TMP3:%.*]] = load ptr, ptr [[TEX_ADDR_ASCAST]], align 32 +// CHECK-NEXT: [[TEX_RSRC_VAL:%.*]] = load <8 x i32>, ptr [[TMP3]], align 32 +// CHECK-NEXT: call void @llvm.amdgcn.image.store.2d.v4f32.i32.v8i32(<4 x float> [[TMP0]], i32 100, i32 [[TMP1]], i32 [[TMP2]], <8 x i32> [[TEX_RSRC_VAL]], i32 120, i32 110) +// CHECK-NEXT: ret void +// +void test_builtin_image_store_2d_1(float4 v4f32, int i32, __amdgpu_texture_t tex) { + + __builtin_amdgcn_image_store_2d_v4f32_i32(v4f32, 100, i32, i32, tex, 120, 110); + } + +// CHECK-LABEL: define dso_local void @test_builtin_image_store_2d_2( +// CHECK-SAME: <4 x half> noundef [[V4F16:%.*]], i32 noundef [[I32:%.*]], ptr [[TEX:%.*]]) #[[ATTR0]] { +// CHECK-NEXT: [[ENTRY:.*:]] +// CHECK-NEXT: [[V4F16_ADDR:%.*]] = alloca <4 x half>, align 8, addrspace(5) +// CHECK-NEXT: [[I32_ADDR:%.*]] = alloca i32, align 4, addrspace(5) +// CHECK-NEXT: [[TEX_ADDR:%.*]] = alloca ptr, align 32, addrspace(5) +// CHECK-NEXT: [[V4F16_ADDR_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[V4F16_ADDR]] to ptr +// CHECK-NEXT: [[I32_ADDR_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[I32_ADDR]] to ptr +// CHECK-NEXT: [[TEX_ADDR_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[TEX_ADDR]] to ptr +// CHECK-NEXT: store <4 x half> [[V4F16]], ptr [[V4F16_ADDR_ASCAST]], align 8 +// CHECK-NEXT: store i32 [[I32]], ptr [[I32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: store ptr [[TEX]], ptr [[TEX_ADDR_ASCAST]], align 32 +// CHECK-NEXT: [[TMP0:%.*]] = load <4 x half>, ptr [[V4F16_ADDR_ASCAST]], align 8 +// CHECK-NEXT: [[TMP1:%.*]] = load i32, ptr [[I32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: [[TMP2:%.*]] = load i32, ptr [[I32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: [[TMP3:%.*]] = load ptr, ptr [[TEX_ADDR_ASCAST]], align 32 +// CHECK-NEXT: [[TEX_RSRC_VAL:%.*]] = load <8 x i32>, ptr [[TMP3]], align 32 +// CHECK-NEXT: call void @llvm.amdgcn.image.store.2d.v4f16.i32.v8i32(<4 x half> [[TMP0]], i32 100, i32 [[TMP1]], i32 [[TMP2]], <8 x i32> [[TEX_RSRC_VAL]], i32 120, i32 110) +// CHECK-NEXT: ret void +// +void test_builtin_image_store_2d_2(half4 v4f16, int i32, __amdgpu_texture_t tex) { + + __builtin_amdgcn_image_store_2d_v4f16_i32(v4f16, 100, i32, i32, tex, 120, 110); + } + +// CHECK-LABEL: define dso_local void @test_builtin_image_store_2darray( +// CHECK-SAME: float noundef [[F32:%.*]], i32 noundef [[I32:%.*]], ptr [[TEX:%.*]]) #[[ATTR0]] { +// CHECK-NEXT: [[ENTRY:.*:]] +// CHECK-NEXT: [[F32_ADDR:%.*]] = alloca float, align 4, addrspace(5) +// CHECK-NEXT: [[I32_ADDR:%.*]] = alloca i32, align 4, addrspace(5) +// CHECK-NEXT: [[TEX_ADDR:%.*]] = alloca ptr, align 32, addrspace(5) +// CHECK-NEXT: [[F32_ADDR_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[F32_ADDR]] to ptr +// CHECK-NEXT: [[I32_ADDR_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[I32_ADDR]] to ptr +// CHECK-NEXT: [[TEX_ADDR_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[TEX_ADDR]] to ptr +// CHECK-NEXT: store float [[F32]], ptr [[F32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: store i32 [[I32]], ptr [[I32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: store ptr [[TEX]], ptr [[TEX_ADDR_ASCAST]], align 32 +// CHECK-NEXT: [[TMP0:%.*]] = load float, ptr [[F32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: [[TMP1:%.*]] = load i32, ptr [[I32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: [[TMP2:%.*]] = load i32, ptr [[I32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: [[TMP3:%.*]] = load i32, ptr [[I32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: [[TMP4:%.*]] = load ptr, ptr [[TEX_ADDR_ASCAST]], align 32 +// CHECK-NEXT: [[TEX_RSRC_VAL:%.*]] = load <8 x i32>, ptr [[TMP4]], align 32 +// CHECK-NEXT: call void @llvm.amdgcn.image.store.2darray.f32.i32.v8i32(float [[TMP0]], i32 100, i32 [[TMP1]], i32 [[TMP2]], i32 [[TMP3]], <8 x i32> [[TEX_RSRC_VAL]], i32 120, i32 110) +// CHECK-NEXT: ret void +// +void test_builtin_image_store_2darray(float f32, int i32, __amdgpu_texture_t tex) { + + __builtin_amdgcn_image_store_2darray_f32_i32(f32, 100, i32, i32, i32, tex, 120, 110); + } + +// CHECK-LABEL: define dso_local void @test_builtin_image_store_2darray_1( +// CHECK-SAME: <4 x float> noundef [[V4F32:%.*]], i32 noundef [[I32:%.*]], ptr [[TEX:%.*]]) #[[ATTR0]] { +// CHECK-NEXT: [[ENTRY:.*:]] +// CHECK-NEXT: [[V4F32_ADDR:%.*]] = alloca <4 x float>, align 16, addrspace(5) +// CHECK-NEXT: [[I32_ADDR:%.*]] = alloca i32, align 4, addrspace(5) +// CHECK-NEXT: [[TEX_ADDR:%.*]] = alloca ptr, align 32, addrspace(5) +// CHECK-NEXT: [[V4F32_ADDR_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[V4F32_ADDR]] to ptr +// CHECK-NEXT: [[I32_ADDR_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[I32_ADDR]] to ptr +// CHECK-NEXT: [[TEX_ADDR_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[TEX_ADDR]] to ptr +// CHECK-NEXT: store <4 x float> [[V4F32]], ptr [[V4F32_ADDR_ASCAST]], align 16 +// CHECK-NEXT: store i32 [[I32]], ptr [[I32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: store ptr [[TEX]], ptr [[TEX_ADDR_ASCAST]], align 32 +// CHECK-NEXT: [[TMP0:%.*]] = load <4 x float>, ptr [[V4F32_ADDR_ASCAST]], align 16 +// CHECK-NEXT: [[TMP1:%.*]] = load i32, ptr [[I32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: [[TMP2:%.*]] = load i32, ptr [[I32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: [[TMP3:%.*]] = load i32, ptr [[I32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: [[TMP4:%.*]] = load ptr, ptr [[TEX_ADDR_ASCAST]], align 32 +// CHECK-NEXT: [[TEX_RSRC_VAL:%.*]] = load <8 x i32>, ptr [[TMP4]], align 32 +// CHECK-NEXT: call void @llvm.amdgcn.image.store.2darray.v4f32.i32.v8i32(<4 x float> [[TMP0]], i32 100, i32 [[TMP1]], i32 [[TMP2]], i32 [[TMP3]], <8 x i32> [[TEX_RSRC_VAL]], i32 120, i32 110) +// CHECK-NEXT: ret void +// +void test_builtin_image_store_2darray_1(float4 v4f32, int i32, __amdgpu_texture_t tex) { + + __builtin_amdgcn_image_store_2darray_v4f32_i32(v4f32, 100, i32, i32, i32, tex, 120, 110); + } + +// CHECK-LABEL: define dso_local void @test_builtin_image_store_2darray_2( +// CHECK-SAME: <4 x half> noundef [[V4F16:%.*]], i32 noundef [[I32:%.*]], ptr [[TEX:%.*]]) #[[ATTR0]] { +// CHECK-NEXT: [[ENTRY:.*:]] +// CHECK-NEXT: [[V4F16_ADDR:%.*]] = alloca <4 x half>, align 8, addrspace(5) +// CHECK-NEXT: [[I32_ADDR:%.*]] = alloca i32, align 4, addrspace(5) +// CHECK-NEXT: [[TEX_ADDR:%.*]] = alloca ptr, align 32, addrspace(5) +// CHECK-NEXT: [[V4F16_ADDR_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[V4F16_ADDR]] to ptr +// CHECK-NEXT: [[I32_ADDR_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[I32_ADDR]] to ptr +// CHECK-NEXT: [[TEX_ADDR_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[TEX_ADDR]] to ptr +// CHECK-NEXT: store <4 x half> [[V4F16]], ptr [[V4F16_ADDR_ASCAST]], align 8 +// CHECK-NEXT: store i32 [[I32]], ptr [[I32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: store ptr [[TEX]], ptr [[TEX_ADDR_ASCAST]], align 32 +// CHECK-NEXT: [[TMP0:%.*]] = load <4 x half>, ptr [[V4F16_ADDR_ASCAST]], align 8 +// CHECK-NEXT: [[TMP1:%.*]] = load i32, ptr [[I32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: [[TMP2:%.*]] = load i32, ptr [[I32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: [[TMP3:%.*]] = load i32, ptr [[I32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: [[TMP4:%.*]] = load ptr, ptr [[TEX_ADDR_ASCAST]], align 32 +// CHECK-NEXT: [[TEX_RSRC_VAL:%.*]] = load <8 x i32>, ptr [[TMP4]], align 32 +// CHECK-NEXT: call void @llvm.amdgcn.image.store.2darray.v4f16.i32.v8i32(<4 x half> [[TMP0]], i32 100, i32 [[TMP1]], i32 [[TMP2]], i32 [[TMP3]], <8 x i32> [[TEX_RSRC_VAL]], i32 120, i32 110) +// CHECK-NEXT: ret void +// +void test_builtin_image_store_2darray_2(half4 v4f16, int i32, __amdgpu_texture_t tex) { + + __builtin_amdgcn_image_store_2darray_v4f16_i32(v4f16, 100, i32, i32, i32, tex, 120, 110); + } + +// CHECK-LABEL: define dso_local void @test_builtin_image_store_1d_1( +// CHECK-SAME: <4 x float> noundef [[V4F32:%.*]], i32 noundef [[I32:%.*]], ptr [[TEX:%.*]]) #[[ATTR0]] { +// CHECK-NEXT: [[ENTRY:.*:]] +// CHECK-NEXT: [[V4F32_ADDR:%.*]] = alloca <4 x float>, align 16, addrspace(5) +// CHECK-NEXT: [[I32_ADDR:%.*]] = alloca i32, align 4, addrspace(5) +// CHECK-NEXT: [[TEX_ADDR:%.*]] = alloca ptr, align 32, addrspace(5) +// CHECK-NEXT: [[V4F32_ADDR_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[V4F32_ADDR]] to ptr +// CHECK-NEXT: [[I32_ADDR_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[I32_ADDR]] to ptr +// CHECK-NEXT: [[TEX_ADDR_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[TEX_ADDR]] to ptr +// CHECK-NEXT: store <4 x float> [[V4F32]], ptr [[V4F32_ADDR_ASCAST]], align 16 +// CHECK-NEXT: store i32 [[I32]], ptr [[I32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: store ptr [[TEX]], ptr [[TEX_ADDR_ASCAST]], align 32 +// CHECK-NEXT: [[TMP0:%.*]] = load <4 x float>, ptr [[V4F32_ADDR_ASCAST]], align 16 +// CHECK-NEXT: [[TMP1:%.*]] = load i32, ptr [[I32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: [[TMP2:%.*]] = load ptr, ptr [[TEX_ADDR_ASCAST]], align 32 +// CHECK-NEXT: [[TEX_RSRC_VAL:%.*]] = load <8 x i32>, ptr [[TMP2]], align 32 +// CHECK-NEXT: call void @llvm.amdgcn.image.store.1d.v4f32.i32.v8i32(<4 x float> [[TMP0]], i32 100, i32 [[TMP1]], <8 x i32> [[TEX_RSRC_VAL]], i32 120, i32 110) +// CHECK-NEXT: ret void +// +void test_builtin_image_store_1d_1(float4 v4f32, int i32, __amdgpu_texture_t tex) { + + __builtin_amdgcn_image_store_1d_v4f32_i32(v4f32, 100, i32, tex, 120, 110); + } + +// CHECK-LABEL: define dso_local void @test_builtin_image_store_1d_2( +// CHECK-SAME: <4 x half> noundef [[V4F16:%.*]], i32 noundef [[I32:%.*]], ptr [[TEX:%.*]]) #[[ATTR0]] { +// CHECK-NEXT: [[ENTRY:.*:]] +// CHECK-NEXT: [[V4F16_ADDR:%.*]] = alloca <4 x half>, align 8, addrspace(5) +// CHECK-NEXT: [[I32_ADDR:%.*]] = alloca i32, align 4, addrspace(5) +// CHECK-NEXT: [[TEX_ADDR:%.*]] = alloca ptr, align 32, addrspace(5) +// CHECK-NEXT: [[V4F16_ADDR_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[V4F16_ADDR]] to ptr +// CHECK-NEXT: [[I32_ADDR_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[I32_ADDR]] to ptr +// CHECK-NEXT: [[TEX_ADDR_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[TEX_ADDR]] to ptr +// CHECK-NEXT: store <4 x half> [[V4F16]], ptr [[V4F16_ADDR_ASCAST]], align 8 +// CHECK-NEXT: store i32 [[I32]], ptr [[I32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: store ptr [[TEX]], ptr [[TEX_ADDR_ASCAST]], align 32 +// CHECK-NEXT: [[TMP0:%.*]] = load <4 x half>, ptr [[V4F16_ADDR_ASCAST]], align 8 +// CHECK-NEXT: [[TMP1:%.*]] = load i32, ptr [[I32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: [[TMP2:%.*]] = load ptr, ptr [[TEX_ADDR_ASCAST]], align 32 +// CHECK-NEXT: [[TEX_RSRC_VAL:%.*]] = load <8 x i32>, ptr [[TMP2]], align 32 +// CHECK-NEXT: call void @llvm.amdgcn.image.store.1d.v4f16.i32.v8i32(<4 x half> [[TMP0]], i32 100, i32 [[TMP1]], <8 x i32> [[TEX_RSRC_VAL]], i32 120, i32 110) +// CHECK-NEXT: ret void +// +void test_builtin_image_store_1d_2(half4 v4f16, int i32, __amdgpu_texture_t tex) { + + __builtin_amdgcn_image_store_1d_v4f16_i32(v4f16, 100, i32, tex, 120, 110); + } + +// CHECK-LABEL: define dso_local void @test_builtin_image_store_1darray_1( +// CHECK-SAME: <4 x float> noundef [[V4F32:%.*]], i32 noundef [[I32:%.*]], ptr [[TEX:%.*]]) #[[ATTR0]] { +// CHECK-NEXT: [[ENTRY:.*:]] +// CHECK-NEXT: [[V4F32_ADDR:%.*]] = alloca <4 x float>, align 16, addrspace(5) +// CHECK-NEXT: [[I32_ADDR:%.*]] = alloca i32, align 4, addrspace(5) +// CHECK-NEXT: [[TEX_ADDR:%.*]] = alloca ptr, align 32, addrspace(5) +// CHECK-NEXT: [[V4F32_ADDR_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[V4F32_ADDR]] to ptr +// CHECK-NEXT: [[I32_ADDR_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[I32_ADDR]] to ptr +// CHECK-NEXT: [[TEX_ADDR_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[TEX_ADDR]] to ptr +// CHECK-NEXT: store <4 x float> [[V4F32]], ptr [[V4F32_ADDR_ASCAST]], align 16 +// CHECK-NEXT: store i32 [[I32]], ptr [[I32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: store ptr [[TEX]], ptr [[TEX_ADDR_ASCAST]], align 32 +// CHECK-NEXT: [[TMP0:%.*]] = load <4 x float>, ptr [[V4F32_ADDR_ASCAST]], align 16 +// CHECK-NEXT: [[TMP1:%.*]] = load i32, ptr [[I32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: [[TMP2:%.*]] = load i32, ptr [[I32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: [[TMP3:%.*]] = load ptr, ptr [[TEX_ADDR_ASCAST]], align 32 +// CHECK-NEXT: [[TEX_RSRC_VAL:%.*]] = load <8 x i32>, ptr [[TMP3]], align 32 +// CHECK-NEXT: call void @llvm.amdgcn.image.store.1darray.v4f32.i32.v8i32(<4 x float> [[TMP0]], i32 100, i32 [[TMP1]], i32 [[TMP2]], <8 x i32> [[TEX_RSRC_VAL]], i32 120, i32 110) +// CHECK-NEXT: ret void +// +void test_builtin_image_store_1darray_1(float4 v4f32, int i32, __amdgpu_texture_t tex) { + + __builtin_amdgcn_image_store_1darray_v4f32_i32(v4f32, 100, i32, i32, tex, 120, 110); + } + +// CHECK-LABEL: define dso_local void @test_builtin_image_store_1darray_2( +// CHECK-SAME: <4 x half> noundef [[V4F16:%.*]], i32 noundef [[I32:%.*]], ptr [[TEX:%.*]]) #[[ATTR0]] { +// CHECK-NEXT: [[ENTRY:.*:]] +// CHECK-NEXT: [[V4F16_ADDR:%.*]] = alloca <4 x half>, align 8, addrspace(5) +// CHECK-NEXT: [[I32_ADDR:%.*]] = alloca i32, align 4, addrspace(5) +// CHECK-NEXT: [[TEX_ADDR:%.*]] = alloca ptr, align 32, addrspace(5) +// CHECK-NEXT: [[V4F16_ADDR_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[V4F16_ADDR]] to ptr +// CHECK-NEXT: [[I32_ADDR_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[I32_ADDR]] to ptr +// CHECK-NEXT: [[TEX_ADDR_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[TEX_ADDR]] to ptr +// CHECK-NEXT: store <4 x half> [[V4F16]], ptr [[V4F16_ADDR_ASCAST]], align 8 +// CHECK-NEXT: store i32 [[I32]], ptr [[I32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: store ptr [[TEX]], ptr [[TEX_ADDR_ASCAST]], align 32 +// CHECK-NEXT: [[TMP0:%.*]] = load <4 x half>, ptr [[V4F16_ADDR_ASCAST]], align 8 +// CHECK-NEXT: [[TMP1:%.*]] = load i32, ptr [[I32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: [[TMP2:%.*]] = load i32, ptr [[I32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: [[TMP3:%.*]] = load ptr, ptr [[TEX_ADDR_ASCAST]], align 32 +// CHECK-NEXT: [[TEX_RSRC_VAL:%.*]] = load <8 x i32>, ptr [[TMP3]], align 32 +// CHECK-NEXT: call void @llvm.amdgcn.image.store.1darray.v4f16.i32.v8i32(<4 x half> [[TMP0]], i32 100, i32 [[TMP1]], i32 [[TMP2]], <8 x i32> [[TEX_RSRC_VAL]], i32 120, i32 110) +// CHECK-NEXT: ret void +// +void test_builtin_image_store_1darray_2(half4 v4f16, int i32, __amdgpu_texture_t tex) { + + __builtin_amdgcn_image_store_1darray_v4f16_i32(v4f16, 100, i32, i32, tex, 120, 110); + } + +// CHECK-LABEL: define dso_local void @test_builtin_image_store_3d_1( +// CHECK-SAME: <4 x float> noundef [[V4F32:%.*]], i32 noundef [[I32:%.*]], ptr [[TEX:%.*]]) #[[ATTR0]] { +// CHECK-NEXT: [[ENTRY:.*:]] +// CHECK-NEXT: [[V4F32_ADDR:%.*]] = alloca <4 x float>, align 16, addrspace(5) +// CHECK-NEXT: [[I32_ADDR:%.*]] = alloca i32, align 4, addrspace(5) +// CHECK-NEXT: [[TEX_ADDR:%.*]] = alloca ptr, align 32, addrspace(5) +// CHECK-NEXT: [[V4F32_ADDR_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[V4F32_ADDR]] to ptr +// CHECK-NEXT: [[I32_ADDR_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[I32_ADDR]] to ptr +// CHECK-NEXT: [[TEX_ADDR_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[TEX_ADDR]] to ptr +// CHECK-NEXT: store <4 x float> [[V4F32]], ptr [[V4F32_ADDR_ASCAST]], align 16 +// CHECK-NEXT: store i32 [[I32]], ptr [[I32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: store ptr [[TEX]], ptr [[TEX_ADDR_ASCAST]], align 32 +// CHECK-NEXT: [[TMP0:%.*]] = load <4 x float>, ptr [[V4F32_ADDR_ASCAST]], align 16 +// CHECK-NEXT: [[TMP1:%.*]] = load i32, ptr [[I32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: [[TMP2:%.*]] = load i32, ptr [[I32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: [[TMP3:%.*]] = load i32, ptr [[I32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: [[TMP4:%.*]] = load ptr, ptr [[TEX_ADDR_ASCAST]], align 32 +// CHECK-NEXT: [[TEX_RSRC_VAL:%.*]] = load <8 x i32>, ptr [[TMP4]], align 32 +// CHECK-NEXT: call void @llvm.amdgcn.image.store.3d.v4f32.i32.v8i32(<4 x float> [[TMP0]], i32 100, i32 [[TMP1]], i32 [[TMP2]], i32 [[TMP3]], <8 x i32> [[TEX_RSRC_VAL]], i32 120, i32 110) +// CHECK-NEXT: ret void +// +void test_builtin_image_store_3d_1(float4 v4f32, int i32, __amdgpu_texture_t tex) { + + __builtin_amdgcn_image_store_3d_v4f32_i32(v4f32, 100, i32, i32, i32, tex, 120, 110); + } + +// CHECK-LABEL: define dso_local void @test_builtin_image_store_3d_2( +// CHECK-SAME: <4 x half> noundef [[V4F16:%.*]], i32 noundef [[I32:%.*]], ptr [[TEX:%.*]]) #[[ATTR0]] { +// CHECK-NEXT: [[ENTRY:.*:]] +// CHECK-NEXT: [[V4F16_ADDR:%.*]] = alloca <4 x half>, align 8, addrspace(5) +// CHECK-NEXT: [[I32_ADDR:%.*]] = alloca i32, align 4, addrspace(5) +// CHECK-NEXT: [[TEX_ADDR:%.*]] = alloca ptr, align 32, addrspace(5) +// CHECK-NEXT: [[V4F16_ADDR_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[V4F16_ADDR]] to ptr +// CHECK-NEXT: [[I32_ADDR_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[I32_ADDR]] to ptr +// CHECK-NEXT: [[TEX_ADDR_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[TEX_ADDR]] to ptr +// CHECK-NEXT: store <4 x half> [[V4F16]], ptr [[V4F16_ADDR_ASCAST]], align 8 +// CHECK-NEXT: store i32 [[I32]], ptr [[I32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: store ptr [[TEX]], ptr [[TEX_ADDR_ASCAST]], align 32 +// CHECK-NEXT: [[TMP0:%.*]] = load <4 x half>, ptr [[V4F16_ADDR_ASCAST]], align 8 +// CHECK-NEXT: [[TMP1:%.*]] = load i32, ptr [[I32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: [[TMP2:%.*]] = load i32, ptr [[I32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: [[TMP3:%.*]] = load i32, ptr [[I32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: [[TMP4:%.*]] = load ptr, ptr [[TEX_ADDR_ASCAST]], align 32 +// CHECK-NEXT: [[TEX_RSRC_VAL:%.*]] = load <8 x i32>, ptr [[TMP4]], align 32 +// CHECK-NEXT: call void @llvm.amdgcn.image.store.3d.v4f16.i32.v8i32(<4 x half> [[TMP0]], i32 100, i32 [[TMP1]], i32 [[TMP2]], i32 [[TMP3]], <8 x i32> [[TEX_RSRC_VAL]], i32 120, i32 110) +// CHECK-NEXT: ret void +// +void test_builtin_image_store_3d_2(half4 v4f16, int i32, __amdgpu_texture_t tex) { + + __builtin_amdgcn_image_store_3d_v4f16_i32(v4f16, 100, i32, i32, i32, tex, 120, 110); + } + +// CHECK-LABEL: define dso_local void @test_builtin_image_store_cube_1( +// CHECK-SAME: <4 x float> noundef [[V4F32:%.*]], i32 noundef [[I32:%.*]], ptr [[TEX:%.*]]) #[[ATTR0]] { +// CHECK-NEXT: [[ENTRY:.*:]] +// CHECK-NEXT: [[V4F32_ADDR:%.*]] = alloca <4 x float>, align 16, addrspace(5) +// CHECK-NEXT: [[I32_ADDR:%.*]] = alloca i32, align 4, addrspace(5) +// CHECK-NEXT: [[TEX_ADDR:%.*]] = alloca ptr, align 32, addrspace(5) +// CHECK-NEXT: [[V4F32_ADDR_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[V4F32_ADDR]] to ptr +// CHECK-NEXT: [[I32_ADDR_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[I32_ADDR]] to ptr +// CHECK-NEXT: [[TEX_ADDR_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[TEX_ADDR]] to ptr +// CHECK-NEXT: store <4 x float> [[V4F32]], ptr [[V4F32_ADDR_ASCAST]], align 16 +// CHECK-NEXT: store i32 [[I32]], ptr [[I32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: store ptr [[TEX]], ptr [[TEX_ADDR_ASCAST]], align 32 +// CHECK-NEXT: [[TMP0:%.*]] = load <4 x float>, ptr [[V4F32_ADDR_ASCAST]], align 16 +// CHECK-NEXT: [[TMP1:%.*]] = load i32, ptr [[I32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: [[TMP2:%.*]] = load i32, ptr [[I32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: [[TMP3:%.*]] = load i32, ptr [[I32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: [[TMP4:%.*]] = load ptr, ptr [[TEX_ADDR_ASCAST]], align 32 +// CHECK-NEXT: [[TEX_RSRC_VAL:%.*]] = load <8 x i32>, ptr [[TMP4]], align 32 +// CHECK-NEXT: call void @llvm.amdgcn.image.store.cube.v4f32.i32.v8i32(<4 x float> [[TMP0]], i32 100, i32 [[TMP1]], i32 [[TMP2]], i32 [[TMP3]], <8 x i32> [[TEX_RSRC_VAL]], i32 120, i32 110) +// CHECK-NEXT: ret void +// +void test_builtin_image_store_cube_1(float4 v4f32, int i32, __amdgpu_texture_t tex) { + + __builtin_amdgcn_image_store_cube_v4f32_i32(v4f32, 100, i32, i32, i32, tex, 120, 110); + } + +// CHECK-LABEL: define dso_local void @test_builtin_image_store_cube_2( +// CHECK-SAME: <4 x half> noundef [[V4F16:%.*]], i32 noundef [[I32:%.*]], ptr [[TEX:%.*]]) #[[ATTR0]] { +// CHECK-NEXT: [[ENTRY:.*:]] +// CHECK-NEXT: [[V4F16_ADDR:%.*]] = alloca <4 x half>, align 8, addrspace(5) +// CHECK-NEXT: [[I32_ADDR:%.*]] = alloca i32, align 4, addrspace(5) +// CHECK-NEXT: [[TEX_ADDR:%.*]] = alloca ptr, align 32, addrspace(5) +// CHECK-NEXT: [[V4F16_ADDR_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[V4F16_ADDR]] to ptr +// CHECK-NEXT: [[I32_ADDR_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[I32_ADDR]] to ptr +// CHECK-NEXT: [[TEX_ADDR_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[TEX_ADDR]] to ptr +// CHECK-NEXT: store <4 x half> [[V4F16]], ptr [[V4F16_ADDR_ASCAST]], align 8 +// CHECK-NEXT: store i32 [[I32]], ptr [[I32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: store ptr [[TEX]], ptr [[TEX_ADDR_ASCAST]], align 32 +// CHECK-NEXT: [[TMP0:%.*]] = load <4 x half>, ptr [[V4F16_ADDR_ASCAST]], align 8 +// CHECK-NEXT: [[TMP1:%.*]] = load i32, ptr [[I32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: [[TMP2:%.*]] = load i32, ptr [[I32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: [[TMP3:%.*]] = load i32, ptr [[I32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: [[TMP4:%.*]] = load ptr, ptr [[TEX_ADDR_ASCAST]], align 32 +// CHECK-NEXT: [[TEX_RSRC_VAL:%.*]] = load <8 x i32>, ptr [[TMP4]], align 32 +// CHECK-NEXT: call void @llvm.amdgcn.image.store.cube.v4f16.i32.v8i32(<4 x half> [[TMP0]], i32 100, i32 [[TMP1]], i32 [[TMP2]], i32 [[TMP3]], <8 x i32> [[TEX_RSRC_VAL]], i32 120, i32 110) +// CHECK-NEXT: ret void +// +void test_builtin_image_store_cube_2(half4 v4f16, int i32, __amdgpu_texture_t tex) { + + __builtin_amdgcn_image_store_cube_v4f16_i32(v4f16, 100, i32, i32, i32, tex, 120, 110); + } + +// CHECK-LABEL: define dso_local void @test_builtin_image_store_mip_1d_1( +// CHECK-SAME: <4 x float> noundef [[V4F32:%.*]], i32 noundef [[I32:%.*]], ptr [[TEX:%.*]]) #[[ATTR0]] { +// CHECK-NEXT: [[ENTRY:.*:]] +// CHECK-NEXT: [[V4F32_ADDR:%.*]] = alloca <4 x float>, align 16, addrspace(5) +// CHECK-NEXT: [[I32_ADDR:%.*]] = alloca i32, align 4, addrspace(5) +// CHECK-NEXT: [[TEX_ADDR:%.*]] = alloca ptr, align 32, addrspace(5) +// CHECK-NEXT: [[V4F32_ADDR_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[V4F32_ADDR]] to ptr +// CHECK-NEXT: [[I32_ADDR_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[I32_ADDR]] to ptr +// CHECK-NEXT: [[TEX_ADDR_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[TEX_ADDR]] to ptr +// CHECK-NEXT: store <4 x float> [[V4F32]], ptr [[V4F32_ADDR_ASCAST]], align 16 +// CHECK-NEXT: store i32 [[I32]], ptr [[I32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: store ptr [[TEX]], ptr [[TEX_ADDR_ASCAST]], align 32 +// CHECK-NEXT: [[TMP0:%.*]] = load <4 x float>, ptr [[V4F32_ADDR_ASCAST]], align 16 +// CHECK-NEXT: [[TMP1:%.*]] = load i32, ptr [[I32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: [[TMP2:%.*]] = load i32, ptr [[I32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: [[TMP3:%.*]] = load ptr, ptr [[TEX_ADDR_ASCAST]], align 32 +// CHECK-NEXT: [[TEX_RSRC_VAL:%.*]] = load <8 x i32>, ptr [[TMP3]], align 32 +// CHECK-NEXT: call void @llvm.amdgcn.image.store.mip.1d.v4f32.i32.v8i32(<4 x float> [[TMP0]], i32 100, i32 [[TMP1]], i32 [[TMP2]], <8 x i32> [[TEX_RSRC_VAL]], i32 120, i32 110) +// CHECK-NEXT: ret void +// +void test_builtin_image_store_mip_1d_1(float4 v4f32, int i32, __amdgpu_texture_t tex) { + + __builtin_amdgcn_image_store_mip_1d_v4f32_i32(v4f32, 100, i32, i32, tex, 120, 110); + } + +// CHECK-LABEL: define dso_local void @test_builtin_image_store_mip_1d_2( +// CHECK-SAME: <4 x half> noundef [[V4F16:%.*]], i32 noundef [[I32:%.*]], ptr [[TEX:%.*]]) #[[ATTR0]] { +// CHECK-NEXT: [[ENTRY:.*:]] +// CHECK-NEXT: [[V4F16_ADDR:%.*]] = alloca <4 x half>, align 8, addrspace(5) +// CHECK-NEXT: [[I32_ADDR:%.*]] = alloca i32, align 4, addrspace(5) +// CHECK-NEXT: [[TEX_ADDR:%.*]] = alloca ptr, align 32, addrspace(5) +// CHECK-NEXT: [[V4F16_ADDR_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[V4F16_ADDR]] to ptr +// CHECK-NEXT: [[I32_ADDR_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[I32_ADDR]] to ptr +// CHECK-NEXT: [[TEX_ADDR_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[TEX_ADDR]] to ptr +// CHECK-NEXT: store <4 x half> [[V4F16]], ptr [[V4F16_ADDR_ASCAST]], align 8 +// CHECK-NEXT: store i32 [[I32]], ptr [[I32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: store ptr [[TEX]], ptr [[TEX_ADDR_ASCAST]], align 32 +// CHECK-NEXT: [[TMP0:%.*]] = load <4 x half>, ptr [[V4F16_ADDR_ASCAST]], align 8 +// CHECK-NEXT: [[TMP1:%.*]] = load i32, ptr [[I32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: [[TMP2:%.*]] = load i32, ptr [[I32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: [[TMP3:%.*]] = load ptr, ptr [[TEX_ADDR_ASCAST]], align 32 +// CHECK-NEXT: [[TEX_RSRC_VAL:%.*]] = load <8 x i32>, ptr [[TMP3]], align 32 +// CHECK-NEXT: call void @llvm.amdgcn.image.store.mip.1d.v4f16.i32.v8i32(<4 x half> [[TMP0]], i32 100, i32 [[TMP1]], i32 [[TMP2]], <8 x i32> [[TEX_RSRC_VAL]], i32 120, i32 110) +// CHECK-NEXT: ret void +// +void test_builtin_image_store_mip_1d_2(half4 v4f16, int i32, __amdgpu_texture_t tex) { + + __builtin_amdgcn_image_store_mip_1d_v4f16_i32(v4f16, 100, i32, i32, tex, 120, 110); + } + +// CHECK-LABEL: define dso_local void @test_builtin_image_store_mip_1darray_1( +// CHECK-SAME: <4 x float> noundef [[V4F32:%.*]], i32 noundef [[I32:%.*]], ptr [[TEX:%.*]]) #[[ATTR0]] { +// CHECK-NEXT: [[ENTRY:.*:]] +// CHECK-NEXT: [[V4F32_ADDR:%.*]] = alloca <4 x float>, align 16, addrspace(5) +// CHECK-NEXT: [[I32_ADDR:%.*]] = alloca i32, align 4, addrspace(5) +// CHECK-NEXT: [[TEX_ADDR:%.*]] = alloca ptr, align 32, addrspace(5) +// CHECK-NEXT: [[V4F32_ADDR_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[V4F32_ADDR]] to ptr +// CHECK-NEXT: [[I32_ADDR_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[I32_ADDR]] to ptr +// CHECK-NEXT: [[TEX_ADDR_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[TEX_ADDR]] to ptr +// CHECK-NEXT: store <4 x float> [[V4F32]], ptr [[V4F32_ADDR_ASCAST]], align 16 +// CHECK-NEXT: store i32 [[I32]], ptr [[I32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: store ptr [[TEX]], ptr [[TEX_ADDR_ASCAST]], align 32 +// CHECK-NEXT: [[TMP0:%.*]] = load <4 x float>, ptr [[V4F32_ADDR_ASCAST]], align 16 +// CHECK-NEXT: [[TMP1:%.*]] = load i32, ptr [[I32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: [[TMP2:%.*]] = load i32, ptr [[I32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: [[TMP3:%.*]] = load i32, ptr [[I32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: [[TMP4:%.*]] = load ptr, ptr [[TEX_ADDR_ASCAST]], align 32 +// CHECK-NEXT: [[TEX_RSRC_VAL:%.*]] = load <8 x i32>, ptr [[TMP4]], align 32 +// CHECK-NEXT: call void @llvm.amdgcn.image.store.mip.1darray.v4f32.i32.v8i32(<4 x float> [[TMP0]], i32 100, i32 [[TMP1]], i32 [[TMP2]], i32 [[TMP3]], <8 x i32> [[TEX_RSRC_VAL]], i32 120, i32 110) +// CHECK-NEXT: ret void +// +void test_builtin_image_store_mip_1darray_1(float4 v4f32, int i32, __amdgpu_texture_t tex) { + + __builtin_amdgcn_image_store_mip_1darray_v4f32_i32(v4f32, 100, i32, i32, i32, tex, 120, 110); + } + +// CHECK-LABEL: define dso_local void @test_builtin_image_store_mip_1darray_2( +// CHECK-SAME: <4 x half> noundef [[V4F16:%.*]], i32 noundef [[I32:%.*]], ptr [[TEX:%.*]]) #[[ATTR0]] { +// CHECK-NEXT: [[ENTRY:.*:]] +// CHECK-NEXT: [[V4F16_ADDR:%.*]] = alloca <4 x half>, align 8, addrspace(5) +// CHECK-NEXT: [[I32_ADDR:%.*]] = alloca i32, align 4, addrspace(5) +// CHECK-NEXT: [[TEX_ADDR:%.*]] = alloca ptr, align 32, addrspace(5) +// CHECK-NEXT: [[V4F16_ADDR_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[V4F16_ADDR]] to ptr +// CHECK-NEXT: [[I32_ADDR_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[I32_ADDR]] to ptr +// CHECK-NEXT: [[TEX_ADDR_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[TEX_ADDR]] to ptr +// CHECK-NEXT: store <4 x half> [[V4F16]], ptr [[V4F16_ADDR_ASCAST]], align 8 +// CHECK-NEXT: store i32 [[I32]], ptr [[I32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: store ptr [[TEX]], ptr [[TEX_ADDR_ASCAST]], align 32 +// CHECK-NEXT: [[TMP0:%.*]] = load <4 x half>, ptr [[V4F16_ADDR_ASCAST]], align 8 +// CHECK-NEXT: [[TMP1:%.*]] = load i32, ptr [[I32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: [[TMP2:%.*]] = load i32, ptr [[I32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: [[TMP3:%.*]] = load i32, ptr [[I32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: [[TMP4:%.*]] = load ptr, ptr [[TEX_ADDR_ASCAST]], align 32 +// CHECK-NEXT: [[TEX_RSRC_VAL:%.*]] = load <8 x i32>, ptr [[TMP4]], align 32 +// CHECK-NEXT: call void @llvm.amdgcn.image.store.mip.1darray.v4f16.i32.v8i32(<4 x half> [[TMP0]], i32 100, i32 [[TMP1]], i32 [[TMP2]], i32 [[TMP3]], <8 x i32> [[TEX_RSRC_VAL]], i32 120, i32 110) +// CHECK-NEXT: ret void +// +void test_builtin_image_store_mip_1darray_2(half4 v4f16, int i32, __amdgpu_texture_t tex) { + + __builtin_amdgcn_image_store_mip_1darray_v4f16_i32(v4f16, 100, i32, i32, i32, tex, 120, 110); + } + +// CHECK-LABEL: define dso_local void @test_builtin_image_store_mip_2d( +// CHECK-SAME: float noundef [[F32:%.*]], i32 noundef [[I32:%.*]], ptr [[TEX:%.*]]) #[[ATTR0]] { +// CHECK-NEXT: [[ENTRY:.*:]] +// CHECK-NEXT: [[F32_ADDR:%.*]] = alloca float, align 4, addrspace(5) +// CHECK-NEXT: [[I32_ADDR:%.*]] = alloca i32, align 4, addrspace(5) +// CHECK-NEXT: [[TEX_ADDR:%.*]] = alloca ptr, align 32, addrspace(5) +// CHECK-NEXT: [[F32_ADDR_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[F32_ADDR]] to ptr +// CHECK-NEXT: [[I32_ADDR_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[I32_ADDR]] to ptr +// CHECK-NEXT: [[TEX_ADDR_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[TEX_ADDR]] to ptr +// CHECK-NEXT: store float [[F32]], ptr [[F32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: store i32 [[I32]], ptr [[I32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: store ptr [[TEX]], ptr [[TEX_ADDR_ASCAST]], align 32 +// CHECK-NEXT: [[TMP0:%.*]] = load float, ptr [[F32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: [[TMP1:%.*]] = load i32, ptr [[I32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: [[TMP2:%.*]] = load i32, ptr [[I32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: [[TMP3:%.*]] = load i32, ptr [[I32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: [[TMP4:%.*]] = load ptr, ptr [[TEX_ADDR_ASCAST]], align 32 +// CHECK-NEXT: [[TEX_RSRC_VAL:%.*]] = load <8 x i32>, ptr [[TMP4]], align 32 +// CHECK-NEXT: call void @llvm.amdgcn.image.store.mip.2d.f32.i32.v8i32(float [[TMP0]], i32 100, i32 [[TMP1]], i32 [[TMP2]], i32 [[TMP3]], <8 x i32> [[TEX_RSRC_VAL]], i32 120, i32 110) +// CHECK-NEXT: ret void +// +void test_builtin_image_store_mip_2d(float f32, int i32, __amdgpu_texture_t tex) { + + __builtin_amdgcn_image_store_mip_2d_f32_i32(f32, 100, i32, i32, i32, tex, 120, 110); + } + +// CHECK-LABEL: define dso_local void @test_builtin_image_store_mip_2d_1( +// CHECK-SAME: <4 x float> noundef [[V4F32:%.*]], i32 noundef [[I32:%.*]], ptr [[TEX:%.*]]) #[[ATTR0]] { +// CHECK-NEXT: [[ENTRY:.*:]] +// CHECK-NEXT: [[V4F32_ADDR:%.*]] = alloca <4 x float>, align 16, addrspace(5) +// CHECK-NEXT: [[I32_ADDR:%.*]] = alloca i32, align 4, addrspace(5) +// CHECK-NEXT: [[TEX_ADDR:%.*]] = alloca ptr, align 32, addrspace(5) +// CHECK-NEXT: [[V4F32_ADDR_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[V4F32_ADDR]] to ptr +// CHECK-NEXT: [[I32_ADDR_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[I32_ADDR]] to ptr +// CHECK-NEXT: [[TEX_ADDR_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[TEX_ADDR]] to ptr +// CHECK-NEXT: store <4 x float> [[V4F32]], ptr [[V4F32_ADDR_ASCAST]], align 16 +// CHECK-NEXT: store i32 [[I32]], ptr [[I32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: store ptr [[TEX]], ptr [[TEX_ADDR_ASCAST]], align 32 +// CHECK-NEXT: [[TMP0:%.*]] = load <4 x float>, ptr [[V4F32_ADDR_ASCAST]], align 16 +// CHECK-NEXT: [[TMP1:%.*]] = load i32, ptr [[I32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: [[TMP2:%.*]] = load i32, ptr [[I32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: [[TMP3:%.*]] = load i32, ptr [[I32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: [[TMP4:%.*]] = load ptr, ptr [[TEX_ADDR_ASCAST]], align 32 +// CHECK-NEXT: [[TEX_RSRC_VAL:%.*]] = load <8 x i32>, ptr [[TMP4]], align 32 +// CHECK-NEXT: call void @llvm.amdgcn.image.store.mip.2d.v4f32.i32.v8i32(<4 x float> [[TMP0]], i32 100, i32 [[TMP1]], i32 [[TMP2]], i32 [[TMP3]], <8 x i32> [[TEX_RSRC_VAL]], i32 120, i32 110) +// CHECK-NEXT: ret void +// +void test_builtin_image_store_mip_2d_1(float4 v4f32, int i32, __amdgpu_texture_t tex) { + + __builtin_amdgcn_image_store_mip_2d_v4f32_i32(v4f32, 100, i32, i32, i32, tex, 120, 110); + } + +// CHECK-LABEL: define dso_local void @test_builtin_image_store_mip_2d_2( +// CHECK-SAME: <4 x half> noundef [[V4F16:%.*]], i32 noundef [[I32:%.*]], ptr [[TEX:%.*]]) #[[ATTR0]] { +// CHECK-NEXT: [[ENTRY:.*:]] +// CHECK-NEXT: [[V4F16_ADDR:%.*]] = alloca <4 x half>, align 8, addrspace(5) +// CHECK-NEXT: [[I32_ADDR:%.*]] = alloca i32, align 4, addrspace(5) +// CHECK-NEXT: [[TEX_ADDR:%.*]] = alloca ptr, align 32, addrspace(5) +// CHECK-NEXT: [[V4F16_ADDR_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[V4F16_ADDR]] to ptr +// CHECK-NEXT: [[I32_ADDR_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[I32_ADDR]] to ptr +// CHECK-NEXT: [[TEX_ADDR_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[TEX_ADDR]] to ptr +// CHECK-NEXT: store <4 x half> [[V4F16]], ptr [[V4F16_ADDR_ASCAST]], align 8 +// CHECK-NEXT: store i32 [[I32]], ptr [[I32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: store ptr [[TEX]], ptr [[TEX_ADDR_ASCAST]], align 32 +// CHECK-NEXT: [[TMP0:%.*]] = load <4 x half>, ptr [[V4F16_ADDR_ASCAST]], align 8 +// CHECK-NEXT: [[TMP1:%.*]] = load i32, ptr [[I32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: [[TMP2:%.*]] = load i32, ptr [[I32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: [[TMP3:%.*]] = load i32, ptr [[I32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: [[TMP4:%.*]] = load ptr, ptr [[TEX_ADDR_ASCAST]], align 32 +// CHECK-NEXT: [[TEX_RSRC_VAL:%.*]] = load <8 x i32>, ptr [[TMP4]], align 32 +// CHECK-NEXT: call void @llvm.amdgcn.image.store.mip.2d.v4f16.i32.v8i32(<4 x half> [[TMP0]], i32 100, i32 [[TMP1]], i32 [[TMP2]], i32 [[TMP3]], <8 x i32> [[TEX_RSRC_VAL]], i32 120, i32 110) +// CHECK-NEXT: ret void +// +void test_builtin_image_store_mip_2d_2(half4 v4f16, int i32, __amdgpu_texture_t tex) { + + __builtin_amdgcn_image_store_mip_2d_v4f16_i32(v4f16, 100, i32, i32, i32, tex, 120, 110); + } + +// CHECK-LABEL: define dso_local void @test_builtin_image_store_mip_2darray( +// CHECK-SAME: float noundef [[F32:%.*]], i32 noundef [[I32:%.*]], ptr [[TEX:%.*]]) #[[ATTR0]] { +// CHECK-NEXT: [[ENTRY:.*:]] +// CHECK-NEXT: [[F32_ADDR:%.*]] = alloca float, align 4, addrspace(5) +// CHECK-NEXT: [[I32_ADDR:%.*]] = alloca i32, align 4, addrspace(5) +// CHECK-NEXT: [[TEX_ADDR:%.*]] = alloca ptr, align 32, addrspace(5) +// CHECK-NEXT: [[F32_ADDR_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[F32_ADDR]] to ptr +// CHECK-NEXT: [[I32_ADDR_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[I32_ADDR]] to ptr +// CHECK-NEXT: [[TEX_ADDR_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[TEX_ADDR]] to ptr +// CHECK-NEXT: store float [[F32]], ptr [[F32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: store i32 [[I32]], ptr [[I32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: store ptr [[TEX]], ptr [[TEX_ADDR_ASCAST]], align 32 +// CHECK-NEXT: [[TMP0:%.*]] = load float, ptr [[F32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: [[TMP1:%.*]] = load i32, ptr [[I32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: [[TMP2:%.*]] = load i32, ptr [[I32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: [[TMP3:%.*]] = load i32, ptr [[I32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: [[TMP4:%.*]] = load i32, ptr [[I32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: [[TMP5:%.*]] = load ptr, ptr [[TEX_ADDR_ASCAST]], align 32 +// CHECK-NEXT: [[TEX_RSRC_VAL:%.*]] = load <8 x i32>, ptr [[TMP5]], align 32 +// CHECK-NEXT: call void @llvm.amdgcn.image.store.mip.2darray.f32.i32.v8i32(float [[TMP0]], i32 100, i32 [[TMP1]], i32 [[TMP2]], i32 [[TMP3]], i32 [[TMP4]], <8 x i32> [[TEX_RSRC_VAL]], i32 120, i32 110) +// CHECK-NEXT: ret void +// +void test_builtin_image_store_mip_2darray(float f32, int i32, __amdgpu_texture_t tex) { + + __builtin_amdgcn_image_store_mip_2darray_f32_i32(f32, 100, i32, i32, i32, i32, tex, 120, 110); + } + +// CHECK-LABEL: define dso_local void @test_builtin_image_store_mip_2darray_1( +// CHECK-SAME: <4 x float> noundef [[V4F32:%.*]], i32 noundef [[I32:%.*]], ptr [[TEX:%.*]]) #[[ATTR0]] { +// CHECK-NEXT: [[ENTRY:.*:]] +// CHECK-NEXT: [[V4F32_ADDR:%.*]] = alloca <4 x float>, align 16, addrspace(5) +// CHECK-NEXT: [[I32_ADDR:%.*]] = alloca i32, align 4, addrspace(5) +// CHECK-NEXT: [[TEX_ADDR:%.*]] = alloca ptr, align 32, addrspace(5) +// CHECK-NEXT: [[V4F32_ADDR_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[V4F32_ADDR]] to ptr +// CHECK-NEXT: [[I32_ADDR_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[I32_ADDR]] to ptr +// CHECK-NEXT: [[TEX_ADDR_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[TEX_ADDR]] to ptr +// CHECK-NEXT: store <4 x float> [[V4F32]], ptr [[V4F32_ADDR_ASCAST]], align 16 +// CHECK-NEXT: store i32 [[I32]], ptr [[I32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: store ptr [[TEX]], ptr [[TEX_ADDR_ASCAST]], align 32 +// CHECK-NEXT: [[TMP0:%.*]] = load <4 x float>, ptr [[V4F32_ADDR_ASCAST]], align 16 +// CHECK-NEXT: [[TMP1:%.*]] = load i32, ptr [[I32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: [[TMP2:%.*]] = load i32, ptr [[I32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: [[TMP3:%.*]] = load i32, ptr [[I32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: [[TMP4:%.*]] = load i32, ptr [[I32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: [[TMP5:%.*]] = load ptr, ptr [[TEX_ADDR_ASCAST]], align 32 +// CHECK-NEXT: [[TEX_RSRC_VAL:%.*]] = load <8 x i32>, ptr [[TMP5]], align 32 +// CHECK-NEXT: call void @llvm.amdgcn.image.store.mip.2darray.v4f32.i32.v8i32(<4 x float> [[TMP0]], i32 100, i32 [[TMP1]], i32 [[TMP2]], i32 [[TMP3]], i32 [[TMP4]], <8 x i32> [[TEX_RSRC_VAL]], i32 120, i32 110) +// CHECK-NEXT: ret void +// +void test_builtin_image_store_mip_2darray_1(float4 v4f32, int i32, __amdgpu_texture_t tex) { + + __builtin_amdgcn_image_store_mip_2darray_v4f32_i32(v4f32, 100, i32, i32, i32, i32, tex, 120, 110); + } + +// CHECK-LABEL: define dso_local void @test_builtin_image_store_mip_2darray_2( +// CHECK-SAME: <4 x half> noundef [[V4F16:%.*]], i32 noundef [[I32:%.*]], ptr [[TEX:%.*]]) #[[ATTR0]] { +// CHECK-NEXT: [[ENTRY:.*:]] +// CHECK-NEXT: [[V4F16_ADDR:%.*]] = alloca <4 x half>, align 8, addrspace(5) +// CHECK-NEXT: [[I32_ADDR:%.*]] = alloca i32, align 4, addrspace(5) +// CHECK-NEXT: [[TEX_ADDR:%.*]] = alloca ptr, align 32, addrspace(5) +// CHECK-NEXT: [[V4F16_ADDR_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[V4F16_ADDR]] to ptr +// CHECK-NEXT: [[I32_ADDR_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[I32_ADDR]] to ptr +// CHECK-NEXT: [[TEX_ADDR_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[TEX_ADDR]] to ptr +// CHECK-NEXT: store <4 x half> [[V4F16]], ptr [[V4F16_ADDR_ASCAST]], align 8 +// CHECK-NEXT: store i32 [[I32]], ptr [[I32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: store ptr [[TEX]], ptr [[TEX_ADDR_ASCAST]], align 32 +// CHECK-NEXT: [[TMP0:%.*]] = load <4 x half>, ptr [[V4F16_ADDR_ASCAST]], align 8 +// CHECK-NEXT: [[TMP1:%.*]] = load i32, ptr [[I32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: [[TMP2:%.*]] = load i32, ptr [[I32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: [[TMP3:%.*]] = load i32, ptr [[I32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: [[TMP4:%.*]] = load i32, ptr [[I32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: [[TMP5:%.*]] = load ptr, ptr [[TEX_ADDR_ASCAST]], align 32 +// CHECK-NEXT: [[TEX_RSRC_VAL:%.*]] = load <8 x i32>, ptr [[TMP5]], align 32 +// CHECK-NEXT: call void @llvm.amdgcn.image.store.mip.2darray.v4f16.i32.v8i32(<4 x half> [[TMP0]], i32 100, i32 [[TMP1]], i32 [[TMP2]], i32 [[TMP3]], i32 [[TMP4]], <8 x i32> [[TEX_RSRC_VAL]], i32 120, i32 110) +// CHECK-NEXT: ret void +// +void test_builtin_image_store_mip_2darray_2(half4 v4f16, int i32, __amdgpu_texture_t tex) { + + __builtin_amdgcn_image_store_mip_2darray_v4f16_i32(v4f16, 100, i32, i32, i32, i32, tex, 120, 110); + } + +// CHECK-LABEL: define dso_local void @test_builtin_image_store_mip_3d_1( +// CHECK-SAME: <4 x float> noundef [[V4F32:%.*]], i32 noundef [[I32:%.*]], ptr [[TEX:%.*]]) #[[ATTR0]] { +// CHECK-NEXT: [[ENTRY:.*:]] +// CHECK-NEXT: [[V4F32_ADDR:%.*]] = alloca <4 x float>, align 16, addrspace(5) +// CHECK-NEXT: [[I32_ADDR:%.*]] = alloca i32, align 4, addrspace(5) +// CHECK-NEXT: [[TEX_ADDR:%.*]] = alloca ptr, align 32, addrspace(5) +// CHECK-NEXT: [[V4F32_ADDR_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[V4F32_ADDR]] to ptr +// CHECK-NEXT: [[I32_ADDR_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[I32_ADDR]] to ptr +// CHECK-NEXT: [[TEX_ADDR_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[TEX_ADDR]] to ptr +// CHECK-NEXT: store <4 x float> [[V4F32]], ptr [[V4F32_ADDR_ASCAST]], align 16 +// CHECK-NEXT: store i32 [[I32]], ptr [[I32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: store ptr [[TEX]], ptr [[TEX_ADDR_ASCAST]], align 32 +// CHECK-NEXT: [[TMP0:%.*]] = load <4 x float>, ptr [[V4F32_ADDR_ASCAST]], align 16 +// CHECK-NEXT: [[TMP1:%.*]] = load i32, ptr [[I32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: [[TMP2:%.*]] = load i32, ptr [[I32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: [[TMP3:%.*]] = load i32, ptr [[I32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: [[TMP4:%.*]] = load i32, ptr [[I32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: [[TMP5:%.*]] = load ptr, ptr [[TEX_ADDR_ASCAST]], align 32 +// CHECK-NEXT: [[TEX_RSRC_VAL:%.*]] = load <8 x i32>, ptr [[TMP5]], align 32 +// CHECK-NEXT: call void @llvm.amdgcn.image.store.mip.3d.v4f32.i32.v8i32(<4 x float> [[TMP0]], i32 100, i32 [[TMP1]], i32 [[TMP2]], i32 [[TMP3]], i32 [[TMP4]], <8 x i32> [[TEX_RSRC_VAL]], i32 120, i32 110) +// CHECK-NEXT: ret void +// +void test_builtin_image_store_mip_3d_1(float4 v4f32, int i32, __amdgpu_texture_t tex) { + + __builtin_amdgcn_image_store_mip_3d_v4f32_i32(v4f32, 100, i32, i32, i32, i32, tex, 120, 110); + } + +// CHECK-LABEL: define dso_local void @test_builtin_image_store_mip_3d_2( +// CHECK-SAME: <4 x half> noundef [[V4F16:%.*]], i32 noundef [[I32:%.*]], ptr [[TEX:%.*]]) #[[ATTR0]] { +// CHECK-NEXT: [[ENTRY:.*:]] +// CHECK-NEXT: [[V4F16_ADDR:%.*]] = alloca <4 x half>, align 8, addrspace(5) +// CHECK-NEXT: [[I32_ADDR:%.*]] = alloca i32, align 4, addrspace(5) +// CHECK-NEXT: [[TEX_ADDR:%.*]] = alloca ptr, align 32, addrspace(5) +// CHECK-NEXT: [[V4F16_ADDR_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[V4F16_ADDR]] to ptr +// CHECK-NEXT: [[I32_ADDR_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[I32_ADDR]] to ptr +// CHECK-NEXT: [[TEX_ADDR_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[TEX_ADDR]] to ptr +// CHECK-NEXT: store <4 x half> [[V4F16]], ptr [[V4F16_ADDR_ASCAST]], align 8 +// CHECK-NEXT: store i32 [[I32]], ptr [[I32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: store ptr [[TEX]], ptr [[TEX_ADDR_ASCAST]], align 32 +// CHECK-NEXT: [[TMP0:%.*]] = load <4 x half>, ptr [[V4F16_ADDR_ASCAST]], align 8 +// CHECK-NEXT: [[TMP1:%.*]] = load i32, ptr [[I32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: [[TMP2:%.*]] = load i32, ptr [[I32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: [[TMP3:%.*]] = load i32, ptr [[I32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: [[TMP4:%.*]] = load i32, ptr [[I32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: [[TMP5:%.*]] = load ptr, ptr [[TEX_ADDR_ASCAST]], align 32 +// CHECK-NEXT: [[TEX_RSRC_VAL:%.*]] = load <8 x i32>, ptr [[TMP5]], align 32 +// CHECK-NEXT: call void @llvm.amdgcn.image.store.mip.3d.v4f16.i32.v8i32(<4 x half> [[TMP0]], i32 100, i32 [[TMP1]], i32 [[TMP2]], i32 [[TMP3]], i32 [[TMP4]], <8 x i32> [[TEX_RSRC_VAL]], i32 120, i32 110) +// CHECK-NEXT: ret void +// +void test_builtin_image_store_mip_3d_2(half4 v4f16, int i32, __amdgpu_texture_t tex) { + + __builtin_amdgcn_image_store_mip_3d_v4f16_i32(v4f16, 100, i32, i32, i32, i32, tex, 120, 110); + } + +// CHECK-LABEL: define dso_local void @test_builtin_image_store_mip_cube_1( +// CHECK-SAME: <4 x float> noundef [[V4F32:%.*]], i32 noundef [[I32:%.*]], ptr [[TEX:%.*]]) #[[ATTR0]] { +// CHECK-NEXT: [[ENTRY:.*:]] +// CHECK-NEXT: [[V4F32_ADDR:%.*]] = alloca <4 x float>, align 16, addrspace(5) +// CHECK-NEXT: [[I32_ADDR:%.*]] = alloca i32, align 4, addrspace(5) +// CHECK-NEXT: [[TEX_ADDR:%.*]] = alloca ptr, align 32, addrspace(5) +// CHECK-NEXT: [[V4F32_ADDR_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[V4F32_ADDR]] to ptr +// CHECK-NEXT: [[I32_ADDR_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[I32_ADDR]] to ptr +// CHECK-NEXT: [[TEX_ADDR_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[TEX_ADDR]] to ptr +// CHECK-NEXT: store <4 x float> [[V4F32]], ptr [[V4F32_ADDR_ASCAST]], align 16 +// CHECK-NEXT: store i32 [[I32]], ptr [[I32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: store ptr [[TEX]], ptr [[TEX_ADDR_ASCAST]], align 32 +// CHECK-NEXT: [[TMP0:%.*]] = load <4 x float>, ptr [[V4F32_ADDR_ASCAST]], align 16 +// CHECK-NEXT: [[TMP1:%.*]] = load i32, ptr [[I32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: [[TMP2:%.*]] = load i32, ptr [[I32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: [[TMP3:%.*]] = load i32, ptr [[I32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: [[TMP4:%.*]] = load i32, ptr [[I32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: [[TMP5:%.*]] = load ptr, ptr [[TEX_ADDR_ASCAST]], align 32 +// CHECK-NEXT: [[TEX_RSRC_VAL:%.*]] = load <8 x i32>, ptr [[TMP5]], align 32 +// CHECK-NEXT: call void @llvm.amdgcn.image.store.mip.cube.v4f32.i32.v8i32(<4 x float> [[TMP0]], i32 100, i32 [[TMP1]], i32 [[TMP2]], i32 [[TMP3]], i32 [[TMP4]], <8 x i32> [[TEX_RSRC_VAL]], i32 120, i32 110) +// CHECK-NEXT: ret void +// +void test_builtin_image_store_mip_cube_1(float4 v4f32, int i32, __amdgpu_texture_t tex) { + + __builtin_amdgcn_image_store_mip_cube_v4f32_i32(v4f32, 100, i32, i32, i32, i32, tex, 120, 110); + } + +// CHECK-LABEL: define dso_local void @test_builtin_image_store_mip_cube_2( +// CHECK-SAME: <4 x half> noundef [[V4F16:%.*]], i32 noundef [[I32:%.*]], ptr [[TEX:%.*]]) #[[ATTR0]] { +// CHECK-NEXT: [[ENTRY:.*:]] +// CHECK-NEXT: [[V4F16_ADDR:%.*]] = alloca <4 x half>, align 8, addrspace(5) +// CHECK-NEXT: [[I32_ADDR:%.*]] = alloca i32, align 4, addrspace(5) +// CHECK-NEXT: [[TEX_ADDR:%.*]] = alloca ptr, align 32, addrspace(5) +// CHECK-NEXT: [[V4F16_ADDR_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[V4F16_ADDR]] to ptr +// CHECK-NEXT: [[I32_ADDR_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[I32_ADDR]] to ptr +// CHECK-NEXT: [[TEX_ADDR_ASCAST:%.*]] = addrspacecast ptr addrspace(5) [[TEX_ADDR]] to ptr +// CHECK-NEXT: store <4 x half> [[V4F16]], ptr [[V4F16_ADDR_ASCAST]], align 8 +// CHECK-NEXT: store i32 [[I32]], ptr [[I32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: store ptr [[TEX]], ptr [[TEX_ADDR_ASCAST]], align 32 +// CHECK-NEXT: [[TMP0:%.*]] = load <4 x half>, ptr [[V4F16_ADDR_ASCAST]], align 8 +// CHECK-NEXT: [[TMP1:%.*]] = load i32, ptr [[I32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: [[TMP2:%.*]] = load i32, ptr [[I32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: [[TMP3:%.*]] = load i32, ptr [[I32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: [[TMP4:%.*]] = load i32, ptr [[I32_ADDR_ASCAST]], align 4 +// CHECK-NEXT: [[TMP5:%.*]] = load ptr, ptr [[TEX_ADDR_ASCAST]], align 32 +// CHECK-NEXT: [[TEX_RSRC_VAL:%.*]] = load <8 x i32>, ptr [[TMP5]], align 32 +// CHECK-NEXT: call void @llvm.amdgcn.image.store.mip.cube.v4f16.i32.v8i32(<4 x half> [[TMP0]], i32 100, i32 [[TMP1]], i32 [[TMP2]], i32 [[TMP3]], i32 [[TMP4]], <8 x i32> [[TEX_RSRC_VAL]], i32 120, i32 110) +// CHECK-NEXT: ret void +// +void test_builtin_image_store_mip_cube_2(half4 v4f16, int i32, __amdgpu_texture_t tex) { + + __builtin_amdgcn_image_store_mip_cube_v4f16_i32(v4f16, 100, i32, i32, i32, i32, tex, 120, 110); + } diff --git a/clang/test/CodeGen/fp-function-attrs.cpp b/clang/test/CodeGen/fp-function-attrs.cpp index e92c26c..3775bd5 100644 --- a/clang/test/CodeGen/fp-function-attrs.cpp +++ b/clang/test/CodeGen/fp-function-attrs.cpp @@ -36,7 +36,7 @@ float test_reassociate_off_pragma(float a, float b, float c) { return tmp; } -// CHECK: define{{.*}} float @_Z27test_reassociate_off_pragmafff(float noundef nofpclass(nan inf) %a, float noundef nofpclass(nan inf) %b, float noundef nofpclass(nan inf) %c) [[NO_UNSAFE_ATTRS:#[0-9]+]] +// CHECK: define{{.*}} float @_Z27test_reassociate_off_pragmafff(float noundef nofpclass(nan inf) %a, float noundef nofpclass(nan inf) %b, float noundef nofpclass(nan inf) %c) // CHECK: fadd nnan ninf nsz arcp contract afn float {{%.+}}, {{%.+}} // CHECK: fadd fast float {{%.+}}, {{%.+}} @@ -49,10 +49,9 @@ float test_contract_on_pragma(float a, float b, float c) { return tmp; } -// CHECK: define{{.*}} float @_Z23test_contract_on_pragmafff(float noundef nofpclass(nan inf) %a, float noundef nofpclass(nan inf) %b, float noundef nofpclass(nan inf) %c) [[NO_UNSAFE_ATTRS:#[0-9]+]] +// CHECK: define{{.*}} float @_Z23test_contract_on_pragmafff(float noundef nofpclass(nan inf) %a, float noundef nofpclass(nan inf) %b, float noundef nofpclass(nan inf) %c) // CHECK: fmul fast float {{%.+}}, {{%.+}} // CHECK: fadd reassoc nnan ninf nsz arcp afn float {{%.+}}, {{%.+}} -// CHECK: attributes [[FAST_ATTRS]] = { {{.*}}"no-infs-fp-math"="true" {{.*}}"no-nans-fp-math"="true" "no-signed-zeros-fp-math"="true" {{.*}}"unsafe-fp-math"="true"{{.*}} } -// CHECK: attributes [[PRECISE_ATTRS]] = { {{.*}}"no-infs-fp-math"="false" {{.*}}"no-nans-fp-math"="false" "no-signed-zeros-fp-math"="false" {{.*}}"unsafe-fp-math"="false"{{.*}} } -// CHECK: attributes [[NO_UNSAFE_ATTRS]] = { {{.*}}"no-infs-fp-math"="true" {{.*}}"no-nans-fp-math"="true" "no-signed-zeros-fp-math"="true" {{.*}}"unsafe-fp-math"="false"{{.*}} } +// CHECK: attributes [[FAST_ATTRS]] = { {{.*}}"no-infs-fp-math"="true" {{.*}}"no-nans-fp-math"="true" "no-signed-zeros-fp-math"="true"{{.*}} } +// CHECK: attributes [[PRECISE_ATTRS]] = { {{.*}}"no-infs-fp-math"="false" {{.*}}"no-nans-fp-math"="false" "no-signed-zeros-fp-math"="false"{{.*}} } diff --git a/clang/test/CodeGen/func-attr.c b/clang/test/CodeGen/func-attr.c index 1b36c51..42b7f1c 100644 --- a/clang/test/CodeGen/func-attr.c +++ b/clang/test/CodeGen/func-attr.c @@ -1,18 +1,18 @@ // RUN: %clang_cc1 -triple x86_64-linux-gnu -ffast-math \ // RUN: -ffp-contract=fast -emit-llvm -o - %s | \ -// RUN: FileCheck %s --check-prefixes=CHECK,CHECK-UNSAFE,FINITEONLY +// RUN: FileCheck %s --check-prefixes=CHECK,FINITEONLY // RUN: %clang_cc1 -triple x86_64-linux-gnu -funsafe-math-optimizations \ // RUN: -ffp-contract=fast -emit-llvm -o - %s | \ -// RUN: FileCheck %s --check-prefixes=CHECK,CHECK-UNSAFE,NOFINITEONLY +// RUN: FileCheck %s --check-prefixes=CHECK,NOFINITEONLY // RUN: %clang_cc1 -triple x86_64-linux-gnu -funsafe-math-optimizations \ // RUN: -ffp-contract=on -emit-llvm -o - %s | \ -// RUN: FileCheck %s --check-prefixes=CHECK,CHECK-NOUNSAFE,NOFINITEONLY +// RUN: FileCheck %s --check-prefixes=CHECK,NOFINITEONLY // RUN: %clang_cc1 -triple x86_64-linux-gnu -funsafe-math-optimizations \ // RUN: -ffp-contract=off -emit-llvm -o - %s | \ -// RUN: FileCheck %s --check-prefixes=CHECK,CHECK-NOUNSAFE,NOFINITEONLY +// RUN: FileCheck %s --check-prefixes=CHECK,NOFINITEONLY float foo(float a, float b) { return a+b; @@ -24,6 +24,4 @@ float foo(float a, float b) { // CHECK: attributes [[ATTRS]] = { // CHECK-SAME: "no-signed-zeros-fp-math"="true" // CHECK-SAME: "no-trapping-math"="true" -// CHECK-UNSAFE-SAME: "unsafe-fp-math"="true" -// CHECK-NOUNSAFE-NOT: "unsafe-fp-math"="true" // CHECK-SAME: } diff --git a/clang/test/CodeGenCUDA/propagate-attributes.cu b/clang/test/CodeGenCUDA/propagate-attributes.cu index 6dfd444..a7e6b09 100644 --- a/clang/test/CodeGenCUDA/propagate-attributes.cu +++ b/clang/test/CodeGenCUDA/propagate-attributes.cu @@ -12,18 +12,17 @@ // RUN: %clang_cc1 -x cuda %s -emit-llvm -mlink-builtin-bitcode %t.bc -o - \ // RUN: -fcuda-is-device -triple nvptx-unknown-unknown \ -// RUN: | FileCheck %s --check-prefix=CHECK --check-prefix=NOFTZ --check-prefix=NOFAST +// RUN: | FileCheck %s --check-prefix=CHECK --check-prefix=NOFTZ // RUN: %clang_cc1 -x cuda %s -emit-llvm -mlink-builtin-bitcode %t.bc \ // RUN: -fdenormal-fp-math-f32=preserve-sign -o - \ // RUN: -fcuda-is-device -triple nvptx-unknown-unknown \ -// RUN: | FileCheck %s --check-prefix=CHECK --check-prefix=FTZ \ -// RUN: --check-prefix=NOFAST +// RUN: | FileCheck %s --check-prefix=CHECK --check-prefix=FTZ // RUN: %clang_cc1 -x cuda %s -emit-llvm -mlink-builtin-bitcode %t.bc \ // RUN: -fdenormal-fp-math-f32=preserve-sign -o - \ // RUN: -fcuda-is-device -funsafe-math-optimizations -triple nvptx-unknown-unknown \ -// RUN: | FileCheck %s --check-prefix=CHECK --check-prefix=FAST +// RUN: | FileCheck %s --check-prefix=CHECK #ifndef LIB #include "Inputs/cuda.h" @@ -65,9 +64,6 @@ __global__ void kernel() { lib_fn(); } // CHECK-SAME: "no-trapping-math"="true" -// FAST-SAME: "unsafe-fp-math"="true" -// NOFAST-NOT: "unsafe-fp-math"="true" - // Check the attribute list for lib_fn. // CHECK: attributes [[fattr]] = { @@ -81,6 +77,3 @@ __global__ void kernel() { lib_fn(); } // NOFTZ-NOT: "denormal-fp-math-f32" // CHECK-SAME: "no-trapping-math"="true" - -// FAST-SAME: "unsafe-fp-math"="true" -// NOFAST-NOT: "unsafe-fp-math"="true" diff --git a/clang/test/CodeGenOpenCL/relaxed-fpmath.cl b/clang/test/CodeGenOpenCL/relaxed-fpmath.cl index a5f0019..c113d23 100644 --- a/clang/test/CodeGenOpenCL/relaxed-fpmath.cl +++ b/clang/test/CodeGenOpenCL/relaxed-fpmath.cl @@ -33,37 +33,31 @@ float spscalardiv(float a, float b) { // NORMAL-NOT: "no-infs-fp-math" // NORMAL-NOT: "no-nans-fp-math" // NORMAL-NOT: "no-signed-zeros-fp-math" -// NORMAL-NOT: "unsafe-fp-math" // FAST: "less-precise-fpmad"="true" // FAST: "no-infs-fp-math"="true" // FAST: "no-nans-fp-math"="true" // FAST: "no-signed-zeros-fp-math"="true" -// FAST: "unsafe-fp-math"="true" // FINITE-NOT: "less-precise-fpmad" // FINITE: "no-infs-fp-math"="true" // FINITE: "no-nans-fp-math"="true" // FINITE-NOT: "no-signed-zeros-fp-math" -// FINITE-NOT: "unsafe-fp-math" // UNSAFE: "less-precise-fpmad"="true" // UNSAFE-NOT: "no-infs-fp-math" // UNSAFE-NOT: "no-nans-fp-math" // UNSAFE: "no-signed-zeros-fp-math"="true" -// UNSAFE: "unsafe-fp-math"="true" // MAD: "less-precise-fpmad"="true" // MAD-NOT: "no-infs-fp-math" // MAD-NOT: "no-nans-fp-math" // MAD-NOT: "no-signed-zeros-fp-math" -// MAD-NOT: "unsafe-fp-math" // NOSIGNED-NOT: "less-precise-fpmad" // NOSIGNED-NOT: "no-infs-fp-math" // NOSIGNED-NOT: "no-nans-fp-math" // NOSIGNED: "no-signed-zeros-fp-math"="true" -// NOSIGNED-NOT: "unsafe-fp-math" #else // Undefine this to avoid putting it in the PCH. 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_LP_sve2_OR_sme2_RP_AND_faminmax___sme_AND_sme2_AND_faminmax.c index 1004058..36cb1ba 100644 --- 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_LP_sve2_OR_sme2_RP_AND_faminmax___sme_AND_sme2_AND_faminmax.c @@ -1,14 +1,13 @@ // 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 +// RUN: %clang_cc1 %s -fsyntax-only -triple aarch64-none-linux-gnu -target-feature +faminmax -target-feature +sme -target-feature +sme2 -target-feature +sve -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" +// Properties: guard="sve,(sve2|sme2),faminmax" streaming_guard="sme,sme2,faminmax" flags="feature-dependent" void test(void) { float16_t float16_t_val; @@ -19,149 +18,77 @@ void test(void) { 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); } @@ -329,220 +256,148 @@ void test_streaming_compatible(void) __arm_streaming_compatible{ 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}} + // 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@+2 {{builtin can only be called from a non-streaming function}} - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + // 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@+2 {{builtin can only be called from a non-streaming function}} - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + // 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@+2 {{builtin can only be called from a non-streaming function}} - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + // 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@+2 {{builtin can only be called from a non-streaming function}} - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + // 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@+2 {{builtin can only be called from a non-streaming function}} - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + // 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@+2 {{builtin can only be called from a non-streaming function}} - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + // 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@+2 {{builtin can only be called from a non-streaming function}} - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + // 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@+2 {{builtin can only be called from a non-streaming function}} - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + // 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@+2 {{builtin can only be called from a non-streaming function}} - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + // 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@+2 {{builtin can only be called from a non-streaming function}} - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + // 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@+2 {{builtin can only be called from a non-streaming function}} - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + // 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@+2 {{builtin can only be called from a non-streaming function}} - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + // 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@+2 {{builtin can only be called from a non-streaming function}} - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + // 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@+2 {{builtin can only be called from a non-streaming function}} - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + // 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@+2 {{builtin can only be called from a non-streaming function}} - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + // 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@+2 {{builtin can only be called from a non-streaming function}} - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + // 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@+2 {{builtin can only be called from a non-streaming function}} - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + // 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@+2 {{builtin can only be called from a non-streaming function}} - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + // 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@+2 {{builtin can only be called from a non-streaming function}} - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + // 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@+2 {{builtin can only be called from a non-streaming function}} - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + // 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@+2 {{builtin can only be called from a non-streaming function}} - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + // 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@+2 {{builtin can only be called from a non-streaming function}} - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + // 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@+2 {{builtin can only be called from a non-streaming function}} - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + // 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@+2 {{builtin can only be called from a non-streaming function}} - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + // 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@+2 {{builtin can only be called from a non-streaming function}} - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + // 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@+2 {{builtin can only be called from a non-streaming function}} - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + // 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@+2 {{builtin can only be called from a non-streaming function}} - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + // 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@+2 {{builtin can only be called from a non-streaming function}} - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + // 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@+2 {{builtin can only be called from a non-streaming function}} - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + // 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@+2 {{builtin can only be called from a non-streaming function}} - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + // 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@+2 {{builtin can only be called from a non-streaming function}} - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + // 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@+2 {{builtin can only be called from a non-streaming function}} - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + // 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@+2 {{builtin can only be called from a non-streaming function}} - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + // 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@+2 {{builtin can only be called from a non-streaming function}} - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + // 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@+2 {{builtin can only be called from a non-streaming function}} - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + // 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@+2 {{builtin can only be called from a non-streaming function}} - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + // 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@+2 {{builtin can only be called from a non-streaming function}} - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + // 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@+2 {{builtin can only be called from a non-streaming function}} - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + // 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@+2 {{builtin can only be called from a non-streaming function}} - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + // 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@+2 {{builtin can only be called from a non-streaming function}} - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + // 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@+2 {{builtin can only be called from a non-streaming function}} - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + // 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@+2 {{builtin can only be called from a non-streaming function}} - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + // 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@+2 {{builtin can only be called from a non-streaming function}} - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + // 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@+2 {{builtin can only be called from a non-streaming function}} - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + // 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@+2 {{builtin can only be called from a non-streaming function}} - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + // 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@+2 {{builtin can only be called from a non-streaming function}} - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + // 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@+2 {{builtin can only be called from a non-streaming function}} - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + // 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@+2 {{builtin can only be called from a non-streaming function}} - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + // 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@+2 {{builtin can only be called from a non-streaming function}} - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + // 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@+2 {{builtin can only be called from a non-streaming function}} - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + // 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@+2 {{builtin can only be called from a non-streaming function}} - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + // 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@+2 {{builtin can only be called from a non-streaming function}} - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + // 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@+2 {{builtin can only be called from a non-streaming function}} - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + // 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@+2 {{builtin can only be called from a non-streaming function}} - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + // 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@+2 {{builtin can only be called from a non-streaming function}} - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + // 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@+2 {{builtin can only be called from a non-streaming function}} - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + // 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@+2 {{builtin can only be called from a non-streaming function}} - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + // 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@+2 {{builtin can only be called from a non-streaming function}} - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + // 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@+2 {{builtin can only be called from a non-streaming function}} - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + // 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@+2 {{builtin can only be called from a non-streaming function}} - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + // 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@+2 {{builtin can only be called from a non-streaming function}} - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + // 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@+2 {{builtin can only be called from a non-streaming function}} - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + // 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@+2 {{builtin can only be called from a non-streaming function}} - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + // 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@+2 {{builtin can only be called from a non-streaming function}} - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + // 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@+2 {{builtin can only be called from a non-streaming function}} - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + // 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@+2 {{builtin can only be called from a non-streaming function}} - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + // 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@+2 {{builtin can only be called from a non-streaming function}} - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + // 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@+2 {{builtin can only be called from a non-streaming function}} - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + // 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@+2 {{builtin can only be called from a non-streaming function}} - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + // 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@+2 {{builtin can only be called from a non-streaming function}} - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + // 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@+2 {{builtin can only be called from a non-streaming function}} - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + // guard-error@+1 {{builtin can only be called from a non-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_LP_sve2_OR_sme2_RP_AND_fp8___sme_AND_sme2_AND_fp8.c index a5735d0..2f82298 100644 --- 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_LP_sve2_OR_sme2_RP_AND_fp8___sme_AND_sme2_AND_fp8.c @@ -1,14 +1,13 @@ // 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 +// RUN: %clang_cc1 %s -fsyntax-only -triple aarch64-none-linux-gnu -target-feature +fp8 -target-feature +sme -target-feature +sme2 -target-feature +sve -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" +// Properties: guard="sve,(sve2|sme2),fp8" streaming_guard="sme,sme2,fp8" flags="feature-dependent" void test(void) { fpm_t fpm_t_val; @@ -17,53 +16,29 @@ void test(void) { 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); } @@ -131,76 +106,52 @@ void test_streaming_compatible(void) __arm_streaming_compatible{ 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}} + // guard-error@+1 {{builtin can only be called from a non-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}} + // 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@+2 {{builtin can only be called from a non-streaming function}} - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + // guard-error@+1 {{builtin can only be called from a non-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}} + // 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@+2 {{builtin can only be called from a non-streaming function}} - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + // guard-error@+1 {{builtin can only be called from a non-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}} + // 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@+2 {{builtin can only be called from a non-streaming function}} - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + // guard-error@+1 {{builtin can only be called from a non-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}} + // 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@+2 {{builtin can only be called from a non-streaming function}} - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + // guard-error@+1 {{builtin can only be called from a non-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}} + // 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@+2 {{builtin can only be called from a non-streaming function}} - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + // guard-error@+1 {{builtin can only be called from a non-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}} + // 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@+2 {{builtin can only be called from a non-streaming function}} - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + // guard-error@+1 {{builtin can only be called from a non-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}} + // 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@+2 {{builtin can only be called from a non-streaming function}} - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + // guard-error@+1 {{builtin can only be called from a non-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}} + // 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@+2 {{builtin can only be called from a non-streaming function}} - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + // 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@+2 {{builtin can only be called from a non-streaming function}} - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + // 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@+2 {{builtin can only be called from a non-streaming function}} - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + // guard-error@+1 {{builtin can only be called from a non-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}} + // guard-error@+1 {{builtin can only be called from a non-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}} + // 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@+2 {{builtin can only be called from a non-streaming function}} - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + // guard-error@+1 {{builtin can only be called from a non-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}} + // 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@+2 {{builtin can only be called from a non-streaming function}} - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + // 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); } 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_LP_sve2_OR_sme2_RP_AND_lut___sme_AND_sme2_AND_lut.c index f54392c..172fd74 100644 --- 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_LP_sve2_OR_sme2_RP_AND_lut___sme_AND_sme2_AND_lut.c @@ -1,14 +1,13 @@ // 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 +// RUN: %clang_cc1 %s -fsyntax-only -triple aarch64-none-linux-gnu -target-feature +lut -target-feature +sme -target-feature +sme2 -target-feature +sve -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" +// Properties: guard="sve,(sve2|sme2),lut" streaming_guard="sme,sme2,lut" flags="feature-dependent" void test(void) { svbfloat16_t svbfloat16_t_val; @@ -22,69 +21,37 @@ void test(void) { 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); } @@ -178,100 +145,68 @@ void test_streaming_compatible(void) __arm_streaming_compatible{ 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}} + // guard-error@+1 {{builtin can only be called from a non-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}} + // guard-error@+1 {{builtin can only be called from a non-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}} + // guard-error@+1 {{builtin can only be called from a non-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}} + // guard-error@+1 {{builtin can only be called from a non-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}} + // guard-error@+1 {{builtin can only be called from a non-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}} + // guard-error@+1 {{builtin can only be called from a non-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}} + // 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@+2 {{builtin can only be called from a non-streaming function}} - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + // 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@+2 {{builtin can only be called from a non-streaming function}} - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + // 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@+2 {{builtin can only be called from a non-streaming function}} - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + // 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@+2 {{builtin can only be called from a non-streaming function}} - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + // 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@+2 {{builtin can only be called from a non-streaming function}} - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + // 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@+2 {{builtin can only be called from a non-streaming function}} - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + // guard-error@+1 {{builtin can only be called from a non-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}} + // guard-error@+1 {{builtin can only be called from a non-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}} + // guard-error@+1 {{builtin can only be called from a non-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}} + // guard-error@+1 {{builtin can only be called from a non-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}} + // guard-error@+1 {{builtin can only be called from a non-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}} + // guard-error@+1 {{builtin can only be called from a non-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}} + // guard-error@+1 {{builtin can only be called from a non-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}} + // guard-error@+1 {{builtin can only be called from a non-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}} + // guard-error@+1 {{builtin can only be called from a non-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}} + // guard-error@+1 {{builtin can only be called from a non-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}} + // 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@+2 {{builtin can only be called from a non-streaming function}} - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + // 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@+2 {{builtin can only be called from a non-streaming function}} - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + // 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@+2 {{builtin can only be called from a non-streaming function}} - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + // 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@+2 {{builtin can only be called from a non-streaming function}} - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + // 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@+2 {{builtin can only be called from a non-streaming function}} - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + // 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@+2 {{builtin can only be called from a non-streaming function}} - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + // 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@+2 {{builtin can only be called from a non-streaming function}} - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + // 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@+2 {{builtin can only be called from a non-streaming function}} - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + // 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@+2 {{builtin can only be called from a non-streaming function}} - // streaming-guard-error@+1 {{builtin can only be called from a streaming function}} + // guard-error@+1 {{builtin can only be called from a non-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_LP_sve2_OR_sme_RP___sme.c b/clang/test/Sema/AArch64/arm_sve_feature_dependent_sve_AND_LP_sve2_OR_sme_RP___sme.c new file mode 100644 index 0000000..7e66581 --- /dev/null +++ b/clang/test/Sema/AArch64/arm_sve_feature_dependent_sve_AND_LP_sve2_OR_sme_RP___sme.c @@ -0,0 +1,9945 @@ +// 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,(sve2|sme)" 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; + + 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(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; + + 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); +} 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_sme2p1_AND_sve-sha3.c index 7e4a06f..8cc9271 100644 --- 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_sme2p1_AND_sve-sha3.c @@ -7,7 +7,7 @@ #include <arm_sve.h> -// Properties: guard="sve,sve-sha3" streaming_guard="sme,sve-sha3,sme2p1" flags="feature-dependent" +// Properties: guard="sve,sve-sha3" streaming_guard="sme,sme2p1,sve-sha3" flags="feature-dependent" void test(void) { svint64_t svint64_t_val; 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 deleted file mode 100644 index b149f44..0000000 --- a/clang/test/Sema/AArch64/arm_sve_feature_dependent_sve_AND_sve2___sme.c +++ /dev/null @@ -1,16470 +0,0 @@ -// 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_LP_sve2p1_OR_sme2_RP.c index 104d0f3..07e275a 100644 --- 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_LP_sve2p1_OR_sme2_RP.c @@ -1,14 +1,13 @@ // 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 +// RUN: %clang_cc1 %s -fsyntax-only -triple aarch64-none-linux-gnu -target-feature +sme -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" +// Properties: guard="sve,sve2p1" streaming_guard="sme,(sve2p1|sme2)" flags="feature-dependent" void test(void) { bfloat16_t * bfloat16_t_ptr_val; @@ -1114,1015 +1113,510 @@ void test_streaming(void) __arm_streaming{ 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); } @@ -2172,1519 +1666,1014 @@ void test_streaming_compatible(void) __arm_streaming_compatible{ 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-sve2-intrinsics/acle_sve2.cpp b/clang/test/Sema/aarch64-sve2-intrinsics/acle_sve2.cpp index 4229f6c..313e043 100644 --- a/clang/test/Sema/aarch64-sve2-intrinsics/acle_sve2.cpp +++ b/clang/test/Sema/aarch64-sve2-intrinsics/acle_sve2.cpp @@ -40,1153 +40,1153 @@ void test(svbool_t pg, const int8_t *const_i8_ptr, const uint8_t *const_u8_ptr, // expected-error@+2 {{'svhistseg_s8' needs target feature sve,sve2}} // overload-error@+1 {{'svhistseg' needs target feature sve,sve2}} SVE_ACLE_FUNC(svhistseg,_s8,,)(svundef_s8(), svundef_s8()); - // expected-error@+2 {{'svqrdmulh_s8' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqrdmulh' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqrdmulh_s8' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqrdmulh' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqrdmulh,_s8,,)(svundef_s8(), svundef_s8()); - // expected-error@+2 {{'svqrdmulh_n_s8' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqrdmulh' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqrdmulh_n_s8' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqrdmulh' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqrdmulh,_n_s8,,)(svundef_s8(), i8); - // expected-error@+2 {{'svqdmulh_s8' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqdmulh' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqdmulh_s8' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqdmulh' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqdmulh,_s8,,)(svundef_s8(), svundef_s8()); - // expected-error@+2 {{'svqdmulh_n_s8' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqdmulh' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqdmulh_n_s8' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqdmulh' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqdmulh,_n_s8,,)(svundef_s8(), i8); - // expected-error@+2 {{'svsra_n_s8' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svsra' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svsra_n_s8' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svsra' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svsra,_n_s8,,)(svundef_s8(), svundef_s8(), 1); - // expected-error@+2 {{'svnbsl_s8' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svnbsl' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svnbsl_s8' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svnbsl' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svnbsl,_s8,,)(svundef_s8(), svundef_s8(), svundef_s8()); - // expected-error@+2 {{'svnbsl_n_s8' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svnbsl' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svnbsl_n_s8' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svnbsl' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svnbsl,_n_s8,,)(svundef_s8(), svundef_s8(), i8); - // expected-error@+2 {{'svqabs_s8_z' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqabs_z' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqabs_s8_z' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqabs_z' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqabs,_s8,_z,)(pg, svundef_s8()); - // expected-error@+2 {{'svqabs_s8_m' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqabs_m' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqabs_s8_m' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqabs_m' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqabs,_s8,_m,)(svundef_s8(), pg, svundef_s8()); - // expected-error@+2 {{'svqabs_s8_x' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqabs_x' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqabs_s8_x' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqabs_x' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqabs,_s8,_x,)(pg, svundef_s8()); - // expected-error@+2 {{'svcadd_s8' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svcadd' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svcadd_s8' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svcadd' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svcadd,_s8,,)(svundef_s8(), svundef_s8(), 90); - // expected-error@+2 {{'svtbl2_s8' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svtbl2' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svtbl2_s8' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svtbl2' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svtbl2,_s8,,)(svundef2_s8(), svundef_u8()); - // expected-error@+2 {{'svhsubr_s8_z' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svhsubr_z' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svhsubr_s8_z' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svhsubr_z' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svhsubr,_s8,_z,)(pg, svundef_s8(), svundef_s8()); - // expected-error@+2 {{'svhsubr_s8_m' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svhsubr_m' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svhsubr_s8_m' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svhsubr_m' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svhsubr,_s8,_m,)(pg, svundef_s8(), svundef_s8()); - // expected-error@+2 {{'svhsubr_s8_x' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svhsubr_x' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svhsubr_s8_x' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svhsubr_x' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svhsubr,_s8,_x,)(pg, svundef_s8(), svundef_s8()); - // expected-error@+2 {{'svhsubr_n_s8_z' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svhsubr_z' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svhsubr_n_s8_z' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svhsubr_z' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svhsubr,_n_s8,_z,)(pg, svundef_s8(), i8); - // expected-error@+2 {{'svhsubr_n_s8_m' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svhsubr_m' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svhsubr_n_s8_m' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svhsubr_m' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svhsubr,_n_s8,_m,)(pg, svundef_s8(), i8); - // expected-error@+2 {{'svhsubr_n_s8_x' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svhsubr_x' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svhsubr_n_s8_x' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svhsubr_x' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svhsubr,_n_s8,_x,)(pg, svundef_s8(), i8); - // expected-error@+2 {{'sveortb_s8' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'sveortb' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'sveortb_s8' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'sveortb' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(sveortb,_s8,,)(svundef_s8(), svundef_s8(), svundef_s8()); - // expected-error@+2 {{'sveortb_n_s8' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'sveortb' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'sveortb_n_s8' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'sveortb' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(sveortb,_n_s8,,)(svundef_s8(), svundef_s8(), i8); - // expected-error@+2 {{'svbcax_s8' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svbcax' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svbcax_s8' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svbcax' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svbcax,_s8,,)(svundef_s8(), svundef_s8(), svundef_s8()); - // expected-error@+2 {{'svbcax_n_s8' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svbcax' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svbcax_n_s8' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svbcax' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svbcax,_n_s8,,)(svundef_s8(), svundef_s8(), i8); - // expected-error@+2 {{'svqshlu_n_s8_z' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqshlu_z' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqshlu_n_s8_z' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqshlu_z' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqshlu,_n_s8,_z,)(pg, svundef_s8(), 1); - // expected-error@+2 {{'svqrshl_s8_z' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqrshl_z' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqrshl_s8_z' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqrshl_z' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqrshl,_s8,_z,)(pg, svundef_s8(), svundef_s8()); - // expected-error@+2 {{'svqrshl_s8_m' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqrshl_m' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqrshl_s8_m' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqrshl_m' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqrshl,_s8,_m,)(pg, svundef_s8(), svundef_s8()); - // expected-error@+2 {{'svqrshl_s8_x' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqrshl_x' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqrshl_s8_x' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqrshl_x' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqrshl,_s8,_x,)(pg, svundef_s8(), svundef_s8()); - // expected-error@+2 {{'svqrshl_n_s8_z' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqrshl_z' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqrshl_n_s8_z' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqrshl_z' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqrshl,_n_s8,_z,)(pg, svundef_s8(), i8); - // expected-error@+2 {{'svqrshl_n_s8_m' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqrshl_m' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqrshl_n_s8_m' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqrshl_m' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqrshl,_n_s8,_m,)(pg, svundef_s8(), i8); - // expected-error@+2 {{'svqrshl_n_s8_x' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqrshl_x' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqrshl_n_s8_x' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqrshl_x' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqrshl,_n_s8,_x,)(pg, svundef_s8(), i8); - // expected-error@+2 {{'svcmla_s8' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svcmla' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svcmla_s8' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svcmla' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svcmla,_s8,,)(svundef_s8(), svundef_s8(), svundef_s8(), 90); - // expected-error@+2 {{'svqsubr_s8_z' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqsubr_z' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqsubr_s8_z' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqsubr_z' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqsubr,_s8,_z,)(pg, svundef_s8(), svundef_s8()); - // expected-error@+2 {{'svqsubr_s8_m' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqsubr_m' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqsubr_s8_m' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqsubr_m' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqsubr,_s8,_m,)(pg, svundef_s8(), svundef_s8()); - // expected-error@+2 {{'svqsubr_s8_x' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqsubr_x' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqsubr_s8_x' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqsubr_x' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqsubr,_s8,_x,)(pg, svundef_s8(), svundef_s8()); - // expected-error@+2 {{'svqsubr_n_s8_z' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqsubr_z' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqsubr_n_s8_z' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqsubr_z' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqsubr,_n_s8,_z,)(pg, svundef_s8(), i8); - // expected-error@+2 {{'svqsubr_n_s8_m' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqsubr_m' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqsubr_n_s8_m' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqsubr_m' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqsubr,_n_s8,_m,)(pg, svundef_s8(), i8); - // expected-error@+2 {{'svqsubr_n_s8_x' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqsubr_x' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqsubr_n_s8_x' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqsubr_x' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqsubr,_n_s8,_x,)(pg, svundef_s8(), i8); - // expected-error@+2 {{'svrshr_n_s8_z' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svrshr_z' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svrshr_n_s8_z' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svrshr_z' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svrshr,_n_s8,_z,)(pg, svundef_s8(), 1); - // expected-error@+2 {{'svaddp_s8_m' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svaddp_m' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svaddp_s8_m' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svaddp_m' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svaddp,_s8,_m,)(pg, svundef_s8(), svundef_s8()); - // expected-error@+2 {{'svaddp_s8_x' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svaddp_x' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svaddp_s8_x' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svaddp_x' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svaddp,_s8,_x,)(pg, svundef_s8(), svundef_s8()); - // expected-error@+2 {{'svqadd_s8_m' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqadd_m' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqadd_s8_m' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqadd_m' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqadd,_s8,_m,)(pg, svundef_s8(), svundef_s8()); - // expected-error@+2 {{'svqadd_n_s8_m' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqadd_m' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqadd_n_s8_m' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqadd_m' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqadd,_n_s8,_m,)(pg, svundef_s8(), i8); - // expected-error@+2 {{'svqadd_s8_z' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqadd_z' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqadd_s8_z' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqadd_z' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqadd,_s8,_z,)(pg, svundef_s8(), svundef_s8()); - // expected-error@+2 {{'svqadd_n_s8_z' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqadd_z' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqadd_n_s8_z' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqadd_z' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqadd,_n_s8,_z,)(pg, svundef_s8(), i8); - // expected-error@+2 {{'svqadd_s8_x' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqadd_x' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqadd_s8_x' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqadd_x' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqadd,_s8,_x,)(pg, svundef_s8(), svundef_s8()); - // expected-error@+2 {{'svqadd_n_s8_x' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqadd_x' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqadd_n_s8_x' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqadd_x' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqadd,_n_s8,_x,)(pg, svundef_s8(), i8); - // expected-error@+2 {{'svtbx_s8' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svtbx' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svtbx_s8' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svtbx' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svtbx,_s8,,)(svundef_s8(), svundef_s8(), svundef_u8()); - // expected-error@+2 {{'svqrdcmlah_s8' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqrdcmlah' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqrdcmlah_s8' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqrdcmlah' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqrdcmlah,_s8,,)(svundef_s8(), svundef_s8(), svundef_s8(), 90); - // expected-error@+2 {{'svminp_s8_m' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svminp_m' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svminp_s8_m' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svminp_m' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svminp,_s8,_m,)(pg, svundef_s8(), svundef_s8()); - // expected-error@+2 {{'svminp_s8_x' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svminp_x' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svminp_s8_x' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svminp_x' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svminp,_s8,_x,)(pg, svundef_s8(), svundef_s8()); - // expected-error@+2 {{'svqsub_s8_z' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqsub_z' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqsub_s8_z' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqsub_z' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqsub,_s8,_z,)(pg, svundef_s8(), svundef_s8()); - // expected-error@+2 {{'svqsub_s8_m' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqsub_m' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqsub_s8_m' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqsub_m' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqsub,_s8,_m,)(pg, svundef_s8(), svundef_s8()); - // expected-error@+2 {{'svqsub_s8_x' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqsub_x' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqsub_s8_x' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqsub_x' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqsub,_s8,_x,)(pg, svundef_s8(), svundef_s8()); - // expected-error@+2 {{'svqsub_n_s8_z' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqsub_z' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqsub_n_s8_z' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqsub_z' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqsub,_n_s8,_z,)(pg, svundef_s8(), i8); - // expected-error@+2 {{'svqsub_n_s8_m' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqsub_m' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqsub_n_s8_m' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqsub_m' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqsub,_n_s8,_m,)(pg, svundef_s8(), i8); - // expected-error@+2 {{'svqsub_n_s8_x' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqsub_x' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqsub_n_s8_x' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqsub_x' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqsub,_n_s8,_x,)(pg, svundef_s8(), i8); - // expected-error@+2 {{'svrsra_n_s8' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svrsra' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svrsra_n_s8' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svrsra' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svrsra,_n_s8,,)(svundef_s8(), svundef_s8(), 1); - // expected-error@+2 {{'sveor3_s8' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'sveor3' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'sveor3_s8' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'sveor3' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(sveor3,_s8,,)(svundef_s8(), svundef_s8(), svundef_s8()); - // expected-error@+2 {{'sveor3_n_s8' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'sveor3' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'sveor3_n_s8' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'sveor3' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(sveor3,_n_s8,,)(svundef_s8(), svundef_s8(), i8); - // expected-error@+2 {{'svhadd_s8_m' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svhadd_m' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svhadd_s8_m' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svhadd_m' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svhadd,_s8,_m,)(pg, svundef_s8(), svundef_s8()); - // expected-error@+2 {{'svhadd_n_s8_m' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svhadd_m' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svhadd_n_s8_m' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svhadd_m' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svhadd,_n_s8,_m,)(pg, svundef_s8(), i8); - // expected-error@+2 {{'svhadd_s8_z' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svhadd_z' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svhadd_s8_z' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svhadd_z' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svhadd,_s8,_z,)(pg, svundef_s8(), svundef_s8()); - // expected-error@+2 {{'svhadd_n_s8_z' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svhadd_z' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svhadd_n_s8_z' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svhadd_z' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svhadd,_n_s8,_z,)(pg, svundef_s8(), i8); - // expected-error@+2 {{'svhadd_s8_x' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svhadd_x' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svhadd_s8_x' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svhadd_x' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svhadd,_s8,_x,)(pg, svundef_s8(), svundef_s8()); - // expected-error@+2 {{'svhadd_n_s8_x' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svhadd_x' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svhadd_n_s8_x' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svhadd_x' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svhadd,_n_s8,_x,)(pg, svundef_s8(), i8); - // expected-error@+2 {{'svqrdmlsh_s8' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqrdmlsh' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqrdmlsh_s8' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqrdmlsh' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqrdmlsh,_s8,,)(svundef_s8(), svundef_s8(), svundef_s8()); - // expected-error@+2 {{'svqrdmlsh_n_s8' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqrdmlsh' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqrdmlsh_n_s8' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqrdmlsh' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqrdmlsh,_n_s8,,)(svundef_s8(), svundef_s8(), i8); - // expected-error@+2 {{'svmaxp_s8_m' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svmaxp_m' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svmaxp_s8_m' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svmaxp_m' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svmaxp,_s8,_m,)(pg, svundef_s8(), svundef_s8()); - // expected-error@+2 {{'svmaxp_s8_x' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svmaxp_x' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svmaxp_s8_x' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svmaxp_x' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svmaxp,_s8,_x,)(pg, svundef_s8(), svundef_s8()); // expected-error@+2 {{'svmatch_s8' needs target feature sve,sve2}} // overload-error@+1 {{'svmatch' needs target feature sve,sve2}} SVE_ACLE_FUNC(svmatch,_s8,,)(pg, svundef_s8(), svundef_s8()); - // expected-error@+2 {{'svwhilerw_s8' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svwhilerw' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svwhilerw_s8' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svwhilerw' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svwhilerw,_s8,,)(const_i8_ptr, const_i8_ptr); - // expected-error@+2 {{'svqcadd_s8' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqcadd' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqcadd_s8' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqcadd' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqcadd,_s8,,)(svundef_s8(), svundef_s8(), 90); - // expected-error@+2 {{'svrhadd_s8_m' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svrhadd_m' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svrhadd_s8_m' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svrhadd_m' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svrhadd,_s8,_m,)(pg, svundef_s8(), svundef_s8()); - // expected-error@+2 {{'svrhadd_n_s8_m' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svrhadd_m' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svrhadd_n_s8_m' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svrhadd_m' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svrhadd,_n_s8,_m,)(pg, svundef_s8(), i8); - // expected-error@+2 {{'svrhadd_s8_z' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svrhadd_z' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svrhadd_s8_z' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svrhadd_z' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svrhadd,_s8,_z,)(pg, svundef_s8(), svundef_s8()); - // expected-error@+2 {{'svrhadd_n_s8_z' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svrhadd_z' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svrhadd_n_s8_z' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svrhadd_z' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svrhadd,_n_s8,_z,)(pg, svundef_s8(), i8); - // expected-error@+2 {{'svrhadd_s8_x' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svrhadd_x' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svrhadd_s8_x' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svrhadd_x' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svrhadd,_s8,_x,)(pg, svundef_s8(), svundef_s8()); - // expected-error@+2 {{'svrhadd_n_s8_x' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svrhadd_x' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svrhadd_n_s8_x' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svrhadd_x' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svrhadd,_n_s8,_x,)(pg, svundef_s8(), i8); - // expected-error@+2 {{'svwhilewr_s8' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svwhilewr' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svwhilewr_s8' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svwhilewr' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svwhilewr,_s8,,)(const_i8_ptr, const_i8_ptr); - // expected-error@+2 {{'svsli_n_s8' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svsli' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svsli_n_s8' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svsli' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svsli,_n_s8,,)(svundef_s8(), svundef_s8(), 1); // expected-error@+2 {{'svnmatch_s8' needs target feature sve,sve2}} // overload-error@+1 {{'svnmatch' needs target feature sve,sve2}} SVE_ACLE_FUNC(svnmatch,_s8,,)(pg, svundef_s8(), svundef_s8()); - // expected-error@+2 {{'svaba_s8' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svaba' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svaba_s8' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svaba' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svaba,_s8,,)(svundef_s8(), svundef_s8(), svundef_s8()); - // expected-error@+2 {{'svaba_n_s8' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svaba' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svaba_n_s8' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svaba' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svaba,_n_s8,,)(svundef_s8(), svundef_s8(), i8); - // expected-error@+2 {{'svuqadd_s8_m' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svuqadd_m' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svuqadd_s8_m' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svuqadd_m' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svuqadd,_s8,_m,)(pg, svundef_s8(), svundef_u8()); - // expected-error@+2 {{'svuqadd_n_s8_m' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svuqadd_m' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svuqadd_n_s8_m' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svuqadd_m' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svuqadd,_n_s8,_m,)(pg, svundef_s8(), u8); - // expected-error@+2 {{'svuqadd_s8_z' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svuqadd_z' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svuqadd_s8_z' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svuqadd_z' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svuqadd,_s8,_z,)(pg, svundef_s8(), svundef_u8()); - // expected-error@+2 {{'svuqadd_n_s8_z' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svuqadd_z' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svuqadd_n_s8_z' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svuqadd_z' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svuqadd,_n_s8,_z,)(pg, svundef_s8(), u8); - // expected-error@+2 {{'svuqadd_s8_x' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svuqadd_x' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svuqadd_s8_x' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svuqadd_x' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svuqadd,_s8,_x,)(pg, svundef_s8(), svundef_u8()); - // expected-error@+2 {{'svuqadd_n_s8_x' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svuqadd_x' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svuqadd_n_s8_x' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svuqadd_x' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svuqadd,_n_s8,_x,)(pg, svundef_s8(), u8); - // expected-error@+2 {{'sveorbt_s8' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'sveorbt' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'sveorbt_s8' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'sveorbt' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(sveorbt,_s8,,)(svundef_s8(), svundef_s8(), svundef_s8()); - // expected-error@+2 {{'sveorbt_n_s8' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'sveorbt' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'sveorbt_n_s8' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'sveorbt' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(sveorbt,_n_s8,,)(svundef_s8(), svundef_s8(), i8); - // expected-error@+2 {{'svbsl_s8' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svbsl' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svbsl_s8' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svbsl' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svbsl,_s8,,)(svundef_s8(), svundef_s8(), svundef_s8()); - // expected-error@+2 {{'svbsl_n_s8' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svbsl' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svbsl_n_s8' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svbsl' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svbsl,_n_s8,,)(svundef_s8(), svundef_s8(), i8); - // expected-error@+2 {{'svhsub_s8_z' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svhsub_z' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svhsub_s8_z' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svhsub_z' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svhsub,_s8,_z,)(pg, svundef_s8(), svundef_s8()); - // expected-error@+2 {{'svhsub_s8_m' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svhsub_m' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svhsub_s8_m' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svhsub_m' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svhsub,_s8,_m,)(pg, svundef_s8(), svundef_s8()); - // expected-error@+2 {{'svhsub_s8_x' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svhsub_x' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svhsub_s8_x' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svhsub_x' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svhsub,_s8,_x,)(pg, svundef_s8(), svundef_s8()); - // expected-error@+2 {{'svhsub_n_s8_z' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svhsub_z' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svhsub_n_s8_z' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svhsub_z' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svhsub,_n_s8,_z,)(pg, svundef_s8(), i8); - // expected-error@+2 {{'svhsub_n_s8_m' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svhsub_m' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svhsub_n_s8_m' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svhsub_m' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svhsub,_n_s8,_m,)(pg, svundef_s8(), i8); - // expected-error@+2 {{'svhsub_n_s8_x' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svhsub_x' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svhsub_n_s8_x' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svhsub_x' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svhsub,_n_s8,_x,)(pg, svundef_s8(), i8); - // expected-error@+2 {{'svqrdmlah_s8' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqrdmlah' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqrdmlah_s8' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqrdmlah' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqrdmlah,_s8,,)(svundef_s8(), svundef_s8(), svundef_s8()); - // expected-error@+2 {{'svqrdmlah_n_s8' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqrdmlah' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqrdmlah_n_s8' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqrdmlah' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqrdmlah,_n_s8,,)(svundef_s8(), svundef_s8(), i8); - // expected-error@+2 {{'svbsl2n_s8' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svbsl2n' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svbsl2n_s8' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svbsl2n' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svbsl2n,_s8,,)(svundef_s8(), svundef_s8(), svundef_s8()); - // expected-error@+2 {{'svbsl2n_n_s8' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svbsl2n' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svbsl2n_n_s8' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svbsl2n' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svbsl2n,_n_s8,,)(svundef_s8(), svundef_s8(), i8); - // expected-error@+2 {{'svsri_n_s8' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svsri' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svsri_n_s8' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svsri' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svsri,_n_s8,,)(svundef_s8(), svundef_s8(), 1); - // expected-error@+2 {{'svbsl1n_s8' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svbsl1n' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svbsl1n_s8' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svbsl1n' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svbsl1n,_s8,,)(svundef_s8(), svundef_s8(), svundef_s8()); - // expected-error@+2 {{'svbsl1n_n_s8' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svbsl1n' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svbsl1n_n_s8' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svbsl1n' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svbsl1n,_n_s8,,)(svundef_s8(), svundef_s8(), i8); - // expected-error@+2 {{'svrshl_s8_z' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svrshl_z' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svrshl_s8_z' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svrshl_z' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svrshl,_s8,_z,)(pg, svundef_s8(), svundef_s8()); - // expected-error@+2 {{'svrshl_s8_m' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svrshl_m' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svrshl_s8_m' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svrshl_m' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svrshl,_s8,_m,)(pg, svundef_s8(), svundef_s8()); - // expected-error@+2 {{'svrshl_s8_x' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svrshl_x' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svrshl_s8_x' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svrshl_x' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svrshl,_s8,_x,)(pg, svundef_s8(), svundef_s8()); - // expected-error@+2 {{'svrshl_n_s8_z' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svrshl_z' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svrshl_n_s8_z' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svrshl_z' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svrshl,_n_s8,_z,)(pg, svundef_s8(), i8); - // expected-error@+2 {{'svrshl_n_s8_m' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svrshl_m' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svrshl_n_s8_m' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svrshl_m' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svrshl,_n_s8,_m,)(pg, svundef_s8(), i8); - // expected-error@+2 {{'svrshl_n_s8_x' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svrshl_x' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svrshl_n_s8_x' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svrshl_x' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svrshl,_n_s8,_x,)(pg, svundef_s8(), i8); - // expected-error@+2 {{'svqneg_s8_z' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqneg_z' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqneg_s8_z' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqneg_z' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqneg,_s8,_z,)(pg, svundef_s8()); - // expected-error@+2 {{'svqneg_s8_m' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqneg_m' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqneg_s8_m' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqneg_m' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqneg,_s8,_m,)(svundef_s8(), pg, svundef_s8()); - // expected-error@+2 {{'svqneg_s8_x' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqneg_x' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqneg_s8_x' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqneg_x' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqneg,_s8,_x,)(pg, svundef_s8()); - // expected-error@+2 {{'svxar_n_s8' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svxar' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svxar_n_s8' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svxar' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svxar,_n_s8,,)(svundef_s8(), svundef_s8(), 1); - // expected-error@+2 {{'svqshl_s8_z' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqshl_z' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqshl_s8_z' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqshl_z' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqshl,_s8,_z,)(pg, svundef_s8(), svundef_s8()); - // expected-error@+2 {{'svqshl_s8_m' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqshl_m' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqshl_s8_m' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqshl_m' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqshl,_s8,_m,)(pg, svundef_s8(), svundef_s8()); - // expected-error@+2 {{'svqshl_s8_x' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqshl_x' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqshl_s8_x' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqshl_x' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqshl,_s8,_x,)(pg, svundef_s8(), svundef_s8()); - // expected-error@+2 {{'svqshl_n_s8_z' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqshl_z' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqshl_n_s8_z' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqshl_z' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqshl,_n_s8,_z,)(pg, svundef_s8(), i8); - // expected-error@+2 {{'svqshl_n_s8_m' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqshl_m' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqshl_n_s8_m' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqshl_m' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqshl,_n_s8,_m,)(pg, svundef_s8(), i8); - // expected-error@+2 {{'svqshl_n_s8_x' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqshl_x' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqshl_n_s8_x' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqshl_x' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqshl,_n_s8,_x,)(pg, svundef_s8(), i8); - // expected-error@+2 {{'svmullb_s16' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svmullb' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svmullb_s16' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svmullb' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svmullb,_s16,,)(svundef_s8(), svundef_s8()); - // expected-error@+2 {{'svmullb_n_s16' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svmullb' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svmullb_n_s16' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svmullb' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svmullb,_n_s16,,)(svundef_s8(), i8); - // expected-error@+2 {{'svqrshrunb_n_s16' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqrshrunb' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqrshrunb_n_s16' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqrshrunb' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqrshrunb,_n_s16,,)(svundef_s16(), 1); - // expected-error@+2 {{'svqdmlalbt_s16' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqdmlalbt' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqdmlalbt_s16' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqdmlalbt' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqdmlalbt,_s16,,)(svundef_s16(), svundef_s8(), svundef_s8()); - // expected-error@+2 {{'svqdmlalbt_n_s16' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqdmlalbt' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqdmlalbt_n_s16' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqdmlalbt' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqdmlalbt,_n_s16,,)(svundef_s16(), svundef_s8(), i8); - // expected-error@+2 {{'svqrdmulh_s16' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqrdmulh' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqrdmulh_s16' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqrdmulh' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqrdmulh,_s16,,)(svundef_s16(), svundef_s16()); - // expected-error@+2 {{'svqrdmulh_n_s16' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqrdmulh' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqrdmulh_n_s16' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqrdmulh' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqrdmulh,_n_s16,,)(svundef_s16(), i16); - // expected-error@+2 {{'svqrdmulh_lane_s16' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqrdmulh_lane' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqrdmulh_lane_s16' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqrdmulh_lane' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqrdmulh_lane,_s16,,)(svundef_s16(), svundef_s16(), 1); - // expected-error@+2 {{'svaddwb_s16' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svaddwb' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svaddwb_s16' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svaddwb' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svaddwb,_s16,,)(svundef_s16(), svundef_s8()); - // expected-error@+2 {{'svaddwb_n_s16' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svaddwb' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svaddwb_n_s16' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svaddwb' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svaddwb,_n_s16,,)(svundef_s16(), i8); - // expected-error@+2 {{'svsubhnb_s16' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svsubhnb' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svsubhnb_s16' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svsubhnb' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svsubhnb,_s16,,)(svundef_s16(), svundef_s16()); - // expected-error@+2 {{'svsubhnb_n_s16' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svsubhnb' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svsubhnb_n_s16' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svsubhnb' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svsubhnb,_n_s16,,)(svundef_s16(), i16); - // expected-error@+2 {{'svqdmulh_s16' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqdmulh' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqdmulh_s16' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqdmulh' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqdmulh,_s16,,)(svundef_s16(), svundef_s16()); - // expected-error@+2 {{'svqdmulh_n_s16' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqdmulh' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqdmulh_n_s16' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqdmulh' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqdmulh,_n_s16,,)(svundef_s16(), i16); - // expected-error@+2 {{'svqdmulh_lane_s16' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqdmulh_lane' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqdmulh_lane_s16' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqdmulh_lane' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqdmulh_lane,_s16,,)(svundef_s16(), svundef_s16(), 1); - // expected-error@+2 {{'svqshrunt_n_s16' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqshrunt' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqshrunt_n_s16' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqshrunt' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqshrunt,_n_s16,,)(svundef_u8(), svundef_s16(), 1); - // expected-error@+2 {{'svrsubhnt_s16' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svrsubhnt' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svrsubhnt_s16' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svrsubhnt' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svrsubhnt,_s16,,)(svundef_s8(), svundef_s16(), svundef_s16()); - // expected-error@+2 {{'svrsubhnt_n_s16' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svrsubhnt' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svrsubhnt_n_s16' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svrsubhnt' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svrsubhnt,_n_s16,,)(svundef_s8(), svundef_s16(), i16); - // expected-error@+2 {{'svnbsl_s16' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svnbsl' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svnbsl_s16' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svnbsl' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svnbsl,_s16,,)(svundef_s16(), svundef_s16(), svundef_s16()); - // expected-error@+2 {{'svnbsl_n_s16' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svnbsl' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svnbsl_n_s16' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svnbsl' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svnbsl,_n_s16,,)(svundef_s16(), svundef_s16(), i16); - // expected-error@+2 {{'svqdmlslb_s16' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqdmlslb' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqdmlslb_s16' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqdmlslb' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqdmlslb,_s16,,)(svundef_s16(), svundef_s8(), svundef_s8()); - // expected-error@+2 {{'svqdmlslb_n_s16' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqdmlslb' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqdmlslb_n_s16' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqdmlslb' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqdmlslb,_n_s16,,)(svundef_s16(), svundef_s8(), i8); - // expected-error@+2 {{'svsubhnt_s16' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svsubhnt' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svsubhnt_s16' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svsubhnt' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svsubhnt,_s16,,)(svundef_s8(), svundef_s16(), svundef_s16()); - // expected-error@+2 {{'svsubhnt_n_s16' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svsubhnt' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svsubhnt_n_s16' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svsubhnt' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svsubhnt,_n_s16,,)(svundef_s8(), svundef_s16(), i16); - // expected-error@+2 {{'svqabs_s16_z' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqabs_z' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqabs_s16_z' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqabs_z' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqabs,_s16,_z,)(pg, svundef_s16()); - // expected-error@+2 {{'svqabs_s16_m' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqabs_m' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqabs_s16_m' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqabs_m' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqabs,_s16,_m,)(svundef_s16(), pg, svundef_s16()); - // expected-error@+2 {{'svqabs_s16_x' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqabs_x' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqabs_s16_x' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqabs_x' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqabs,_s16,_x,)(pg, svundef_s16()); - // expected-error@+2 {{'svaddlbt_s16' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svaddlbt' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svaddlbt_s16' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svaddlbt' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svaddlbt,_s16,,)(svundef_s8(), svundef_s8()); - // expected-error@+2 {{'svaddlbt_n_s16' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svaddlbt' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svaddlbt_n_s16' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svaddlbt' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svaddlbt,_n_s16,,)(svundef_s8(), i8); - // expected-error@+2 {{'svtbl2_s16' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svtbl2' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svtbl2_s16' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svtbl2' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svtbl2,_s16,,)(svundef2_s16(), svundef_u16()); - // expected-error@+2 {{'svshrnt_n_s16' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svshrnt' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svshrnt_n_s16' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svshrnt' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svshrnt,_n_s16,,)(svundef_s8(), svundef_s16(), 1); - // expected-error@+2 {{'svhsubr_s16_z' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svhsubr_z' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svhsubr_s16_z' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svhsubr_z' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svhsubr,_s16,_z,)(pg, svundef_s16(), svundef_s16()); - // expected-error@+2 {{'svhsubr_s16_m' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svhsubr_m' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svhsubr_s16_m' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svhsubr_m' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svhsubr,_s16,_m,)(pg, svundef_s16(), svundef_s16()); - // expected-error@+2 {{'svhsubr_s16_x' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svhsubr_x' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svhsubr_s16_x' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svhsubr_x' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svhsubr,_s16,_x,)(pg, svundef_s16(), svundef_s16()); - // expected-error@+2 {{'svhsubr_n_s16_z' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svhsubr_z' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svhsubr_n_s16_z' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svhsubr_z' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svhsubr,_n_s16,_z,)(pg, svundef_s16(), i16); - // expected-error@+2 {{'svhsubr_n_s16_m' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svhsubr_m' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svhsubr_n_s16_m' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svhsubr_m' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svhsubr,_n_s16,_m,)(pg, svundef_s16(), i16); - // expected-error@+2 {{'svhsubr_n_s16_x' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svhsubr_x' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svhsubr_n_s16_x' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svhsubr_x' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svhsubr,_n_s16,_x,)(pg, svundef_s16(), i16); - // expected-error@+2 {{'sveortb_s16' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'sveortb' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'sveortb_s16' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'sveortb' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(sveortb,_s16,,)(svundef_s16(), svundef_s16(), svundef_s16()); - // expected-error@+2 {{'sveortb_n_s16' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'sveortb' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'sveortb_n_s16' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'sveortb' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(sveortb,_n_s16,,)(svundef_s16(), svundef_s16(), i16); - // expected-error@+2 {{'svqxtnb_s16' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqxtnb' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqxtnb_s16' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqxtnb' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqxtnb,_s16,,)(svundef_s16()); - // expected-error@+2 {{'svmlalt_s16' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svmlalt' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svmlalt_s16' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svmlalt' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svmlalt,_s16,,)(svundef_s16(), svundef_s8(), svundef_s8()); - // expected-error@+2 {{'svmlalt_n_s16' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svmlalt' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svmlalt_n_s16' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svmlalt' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svmlalt,_n_s16,,)(svundef_s16(), svundef_s8(), i8); - // expected-error@+2 {{'svshrnb_n_s16' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svshrnb' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svshrnb_n_s16' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svshrnb' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svshrnb,_n_s16,,)(svundef_s16(), 1); - // expected-error@+2 {{'svaddhnt_s16' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svaddhnt' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svaddhnt_s16' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svaddhnt' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svaddhnt,_s16,,)(svundef_s8(), svundef_s16(), svundef_s16()); - // expected-error@+2 {{'svaddhnt_n_s16' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svaddhnt' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svaddhnt_n_s16' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svaddhnt' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svaddhnt,_n_s16,,)(svundef_s8(), svundef_s16(), i16); - // expected-error@+2 {{'svmls_lane_s16' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svmls_lane' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svmls_lane_s16' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svmls_lane' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svmls_lane,_s16,,)(svundef_s16(), svundef_s16(), svundef_s16(), 1); - // expected-error@+2 {{'svqdmlalt_s16' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqdmlalt' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqdmlalt_s16' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqdmlalt' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqdmlalt,_s16,,)(svundef_s16(), svundef_s8(), svundef_s8()); - // expected-error@+2 {{'svqdmlalt_n_s16' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqdmlalt' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqdmlalt_n_s16' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqdmlalt' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqdmlalt,_n_s16,,)(svundef_s16(), svundef_s8(), i8); - // expected-error@+2 {{'svbcax_s16' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svbcax' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svbcax_s16' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svbcax' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svbcax,_s16,,)(svundef_s16(), svundef_s16(), svundef_s16()); - // expected-error@+2 {{'svbcax_n_s16' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svbcax' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svbcax_n_s16' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svbcax' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svbcax,_n_s16,,)(svundef_s16(), svundef_s16(), i16); - // expected-error@+2 {{'svqxtnt_s16' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqxtnt' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqxtnt_s16' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqxtnt' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqxtnt,_s16,,)(svundef_s8(), svundef_s16()); - // expected-error@+2 {{'svqdmlalb_s16' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqdmlalb' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqdmlalb_s16' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqdmlalb' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqdmlalb,_s16,,)(svundef_s16(), svundef_s8(), svundef_s8()); - // expected-error@+2 {{'svqdmlalb_n_s16' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqdmlalb' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqdmlalb_n_s16' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqdmlalb' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqdmlalb,_n_s16,,)(svundef_s16(), svundef_s8(), i8); - // expected-error@+2 {{'svqrshl_s16_z' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqrshl_z' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqrshl_s16_z' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqrshl_z' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqrshl,_s16,_z,)(pg, svundef_s16(), svundef_s16()); - // expected-error@+2 {{'svqrshl_s16_m' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqrshl_m' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqrshl_s16_m' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqrshl_m' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqrshl,_s16,_m,)(pg, svundef_s16(), svundef_s16()); - // expected-error@+2 {{'svqrshl_s16_x' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqrshl_x' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqrshl_s16_x' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqrshl_x' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqrshl,_s16,_x,)(pg, svundef_s16(), svundef_s16()); - // expected-error@+2 {{'svqrshl_n_s16_z' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqrshl_z' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqrshl_n_s16_z' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqrshl_z' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqrshl,_n_s16,_z,)(pg, svundef_s16(), i16); - // expected-error@+2 {{'svqrshl_n_s16_m' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqrshl_m' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqrshl_n_s16_m' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqrshl_m' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqrshl,_n_s16,_m,)(pg, svundef_s16(), i16); - // expected-error@+2 {{'svqrshl_n_s16_x' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqrshl_x' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqrshl_n_s16_x' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqrshl_x' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqrshl,_n_s16,_x,)(pg, svundef_s16(), i16); - // expected-error@+2 {{'svsublbt_s16' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svsublbt' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svsublbt_s16' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svsublbt' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svsublbt,_s16,,)(svundef_s8(), svundef_s8()); - // expected-error@+2 {{'svsublbt_n_s16' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svsublbt' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svsublbt_n_s16' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svsublbt' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svsublbt,_n_s16,,)(svundef_s8(), i8); - // expected-error@+2 {{'svqshrnt_n_s16' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqshrnt' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqshrnt_n_s16' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqshrnt' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqshrnt,_n_s16,,)(svundef_s8(), svundef_s16(), 1); - // expected-error@+2 {{'svqdmullt_s16' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqdmullt' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqdmullt_s16' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqdmullt' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqdmullt,_s16,,)(svundef_s8(), svundef_s8()); - // expected-error@+2 {{'svqdmullt_n_s16' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqdmullt' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqdmullt_n_s16' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqdmullt' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqdmullt,_n_s16,,)(svundef_s8(), i8); - // expected-error@+2 {{'svsublt_s16' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svsublt' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svsublt_s16' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svsublt' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svsublt,_s16,,)(svundef_s8(), svundef_s8()); - // expected-error@+2 {{'svsublt_n_s16' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svsublt' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svsublt_n_s16' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svsublt' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svsublt,_n_s16,,)(svundef_s8(), i8); - // expected-error@+2 {{'svqdmlslbt_s16' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqdmlslbt' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqdmlslbt_s16' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqdmlslbt' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqdmlslbt,_s16,,)(svundef_s16(), svundef_s8(), svundef_s8()); - // expected-error@+2 {{'svqdmlslbt_n_s16' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqdmlslbt' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqdmlslbt_n_s16' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqdmlslbt' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqdmlslbt,_n_s16,,)(svundef_s16(), svundef_s8(), i8); - // expected-error@+2 {{'svadalp_s16_z' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svadalp_z' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svadalp_s16_z' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svadalp_z' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svadalp,_s16,_z,)(pg, svundef_s16(), svundef_s8()); - // expected-error@+2 {{'svadalp_s16_m' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svadalp_m' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svadalp_s16_m' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svadalp_m' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svadalp,_s16,_m,)(pg, svundef_s16(), svundef_s8()); - // expected-error@+2 {{'svadalp_s16_x' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svadalp_x' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svadalp_s16_x' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svadalp_x' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svadalp,_s16,_x,)(pg, svundef_s16(), svundef_s8()); - // expected-error@+2 {{'svmul_lane_s16' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svmul_lane' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svmul_lane_s16' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svmul_lane' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svmul_lane,_s16,,)(svundef_s16(), svundef_s16(), 1); - // expected-error@+2 {{'svsubwt_s16' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svsubwt' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svsubwt_s16' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svsubwt' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svsubwt,_s16,,)(svundef_s16(), svundef_s8()); - // expected-error@+2 {{'svsubwt_n_s16' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svsubwt' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svsubwt_n_s16' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svsubwt' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svsubwt,_n_s16,,)(svundef_s16(), i8); - // expected-error@+2 {{'svqsubr_s16_z' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqsubr_z' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqsubr_s16_z' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqsubr_z' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqsubr,_s16,_z,)(pg, svundef_s16(), svundef_s16()); - // expected-error@+2 {{'svqsubr_s16_m' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqsubr_m' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqsubr_s16_m' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqsubr_m' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqsubr,_s16,_m,)(pg, svundef_s16(), svundef_s16()); - // expected-error@+2 {{'svqsubr_s16_x' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqsubr_x' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqsubr_s16_x' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqsubr_x' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqsubr,_s16,_x,)(pg, svundef_s16(), svundef_s16()); - // expected-error@+2 {{'svqsubr_n_s16_z' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqsubr_z' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqsubr_n_s16_z' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqsubr_z' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqsubr,_n_s16,_z,)(pg, svundef_s16(), i16); - // expected-error@+2 {{'svqsubr_n_s16_m' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqsubr_m' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqsubr_n_s16_m' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqsubr_m' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqsubr,_n_s16,_m,)(pg, svundef_s16(), i16); - // expected-error@+2 {{'svqsubr_n_s16_x' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqsubr_x' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqsubr_n_s16_x' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqsubr_x' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqsubr,_n_s16,_x,)(pg, svundef_s16(), i16); - // expected-error@+2 {{'svqrshrnt_n_s16' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqrshrnt' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqrshrnt_n_s16' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqrshrnt' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqrshrnt,_n_s16,,)(svundef_s8(), svundef_s16(), 1); - // expected-error@+2 {{'svaddp_s16_m' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svaddp_m' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svaddp_s16_m' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svaddp_m' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svaddp,_s16,_m,)(pg, svundef_s16(), svundef_s16()); - // expected-error@+2 {{'svaddp_s16_x' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svaddp_x' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svaddp_s16_x' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svaddp_x' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svaddp,_s16,_x,)(pg, svundef_s16(), svundef_s16()); - // expected-error@+2 {{'svqadd_s16_m' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqadd_m' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqadd_s16_m' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqadd_m' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqadd,_s16,_m,)(pg, svundef_s16(), svundef_s16()); - // expected-error@+2 {{'svqadd_n_s16_m' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqadd_m' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqadd_n_s16_m' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqadd_m' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqadd,_n_s16,_m,)(pg, svundef_s16(), i16); - // expected-error@+2 {{'svqadd_s16_z' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqadd_z' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqadd_s16_z' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqadd_z' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqadd,_s16,_z,)(pg, svundef_s16(), svundef_s16()); - // expected-error@+2 {{'svqadd_n_s16_z' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqadd_z' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqadd_n_s16_z' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqadd_z' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqadd,_n_s16,_z,)(pg, svundef_s16(), i16); - // expected-error@+2 {{'svqadd_s16_x' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqadd_x' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqadd_s16_x' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqadd_x' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqadd,_s16,_x,)(pg, svundef_s16(), svundef_s16()); - // expected-error@+2 {{'svqadd_n_s16_x' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqadd_x' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqadd_n_s16_x' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqadd_x' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqadd,_n_s16,_x,)(pg, svundef_s16(), i16); - // expected-error@+2 {{'svabdlb_s16' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svabdlb' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svabdlb_s16' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svabdlb' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svabdlb,_s16,,)(svundef_s8(), svundef_s8()); - // expected-error@+2 {{'svabdlb_n_s16' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svabdlb' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svabdlb_n_s16' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svabdlb' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svabdlb,_n_s16,,)(svundef_s8(), i8); - // expected-error@+2 {{'svtbx_s16' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svtbx' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svtbx_s16' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svtbx' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svtbx,_s16,,)(svundef_s16(), svundef_s16(), svundef_u16()); - // expected-error@+2 {{'svabdlt_s16' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svabdlt' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svabdlt_s16' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svabdlt' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svabdlt,_s16,,)(svundef_s8(), svundef_s8()); - // expected-error@+2 {{'svabdlt_n_s16' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svabdlt' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svabdlt_n_s16' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svabdlt' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svabdlt,_n_s16,,)(svundef_s8(), i8); - // expected-error@+2 {{'svqrshrnb_n_s16' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqrshrnb' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqrshrnb_n_s16' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqrshrnb' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqrshrnb,_n_s16,,)(svundef_s16(), 1); - // expected-error@+2 {{'svminp_s16_m' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svminp_m' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svminp_s16_m' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svminp_m' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svminp,_s16,_m,)(pg, svundef_s16(), svundef_s16()); - // expected-error@+2 {{'svminp_s16_x' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svminp_x' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svminp_s16_x' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svminp_x' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svminp,_s16,_x,)(pg, svundef_s16(), svundef_s16()); - // expected-error@+2 {{'svqsub_s16_z' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqsub_z' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqsub_s16_z' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqsub_z' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqsub,_s16,_z,)(pg, svundef_s16(), svundef_s16()); - // expected-error@+2 {{'svqsub_s16_m' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqsub_m' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqsub_s16_m' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqsub_m' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqsub,_s16,_m,)(pg, svundef_s16(), svundef_s16()); - // expected-error@+2 {{'svqsub_s16_x' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqsub_x' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqsub_s16_x' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqsub_x' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqsub,_s16,_x,)(pg, svundef_s16(), svundef_s16()); - // expected-error@+2 {{'svqsub_n_s16_z' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqsub_z' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqsub_n_s16_z' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqsub_z' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqsub,_n_s16,_z,)(pg, svundef_s16(), i16); - // expected-error@+2 {{'svqsub_n_s16_m' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqsub_m' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqsub_n_s16_m' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqsub_m' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqsub,_n_s16,_m,)(pg, svundef_s16(), i16); - // expected-error@+2 {{'svqsub_n_s16_x' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqsub_x' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqsub_n_s16_x' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqsub_x' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqsub,_n_s16,_x,)(pg, svundef_s16(), i16); - // expected-error@+2 {{'svrsubhnb_s16' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svrsubhnb' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svrsubhnb_s16' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svrsubhnb' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svrsubhnb,_s16,,)(svundef_s16(), svundef_s16()); - // expected-error@+2 {{'svrsubhnb_n_s16' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svrsubhnb' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svrsubhnb_n_s16' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svrsubhnb' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svrsubhnb,_n_s16,,)(svundef_s16(), i16); - // expected-error@+2 {{'svaddhnb_s16' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svaddhnb' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svaddhnb_s16' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svaddhnb' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svaddhnb,_s16,,)(svundef_s16(), svundef_s16()); - // expected-error@+2 {{'svaddhnb_n_s16' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svaddhnb' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svaddhnb_n_s16' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svaddhnb' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svaddhnb,_n_s16,,)(svundef_s16(), i16); - // expected-error@+2 {{'svabalt_s16' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svabalt' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svabalt_s16' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svabalt' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svabalt,_s16,,)(svundef_s16(), svundef_s8(), svundef_s8()); - // expected-error@+2 {{'svabalt_n_s16' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svabalt' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svabalt_n_s16' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svabalt' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svabalt,_n_s16,,)(svundef_s16(), svundef_s8(), i8); - // expected-error@+2 {{'svqshrnb_n_s16' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqshrnb' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqshrnb_n_s16' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqshrnb' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqshrnb,_n_s16,,)(svundef_s16(), 1); - // expected-error@+2 {{'sveor3_s16' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'sveor3' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'sveor3_s16' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'sveor3' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(sveor3,_s16,,)(svundef_s16(), svundef_s16(), svundef_s16()); - // expected-error@+2 {{'sveor3_n_s16' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'sveor3' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'sveor3_n_s16' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'sveor3' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(sveor3,_n_s16,,)(svundef_s16(), svundef_s16(), i16); - // expected-error@+2 {{'svhadd_s16_m' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svhadd_m' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svhadd_s16_m' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svhadd_m' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svhadd,_s16,_m,)(pg, svundef_s16(), svundef_s16()); - // expected-error@+2 {{'svhadd_n_s16_m' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svhadd_m' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svhadd_n_s16_m' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svhadd_m' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svhadd,_n_s16,_m,)(pg, svundef_s16(), i16); - // expected-error@+2 {{'svhadd_s16_z' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svhadd_z' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svhadd_s16_z' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svhadd_z' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svhadd,_s16,_z,)(pg, svundef_s16(), svundef_s16()); - // expected-error@+2 {{'svhadd_n_s16_z' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svhadd_z' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svhadd_n_s16_z' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svhadd_z' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svhadd,_n_s16,_z,)(pg, svundef_s16(), i16); - // expected-error@+2 {{'svhadd_s16_x' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svhadd_x' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svhadd_s16_x' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svhadd_x' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svhadd,_s16,_x,)(pg, svundef_s16(), svundef_s16()); - // expected-error@+2 {{'svhadd_n_s16_x' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svhadd_x' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svhadd_n_s16_x' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svhadd_x' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svhadd,_n_s16,_x,)(pg, svundef_s16(), i16); - // expected-error@+2 {{'svqshrunb_n_s16' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqshrunb' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqshrunb_n_s16' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqshrunb' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqshrunb,_n_s16,,)(svundef_s16(), 1); - // expected-error@+2 {{'svmovlb_s16' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svmovlb' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svmovlb_s16' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svmovlb' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svmovlb,_s16,,)(svundef_s8()); - // expected-error@+2 {{'svqrdmlsh_s16' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqrdmlsh' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqrdmlsh_s16' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqrdmlsh' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqrdmlsh,_s16,,)(svundef_s16(), svundef_s16(), svundef_s16()); - // expected-error@+2 {{'svqrdmlsh_n_s16' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqrdmlsh' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqrdmlsh_n_s16' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqrdmlsh' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqrdmlsh,_n_s16,,)(svundef_s16(), svundef_s16(), i16); - // expected-error@+2 {{'svqrdmlsh_lane_s16' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqrdmlsh_lane' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqrdmlsh_lane_s16' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqrdmlsh_lane' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqrdmlsh_lane,_s16,,)(svundef_s16(), svundef_s16(), svundef_s16(), 1); - // expected-error@+2 {{'svqdmlslt_s16' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqdmlslt' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqdmlslt_s16' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqdmlslt' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqdmlslt,_s16,,)(svundef_s16(), svundef_s8(), svundef_s8()); - // expected-error@+2 {{'svqdmlslt_n_s16' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqdmlslt' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqdmlslt_n_s16' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqdmlslt' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqdmlslt,_n_s16,,)(svundef_s16(), svundef_s8(), i8); - // expected-error@+2 {{'svmaxp_s16_m' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svmaxp_m' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svmaxp_s16_m' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svmaxp_m' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svmaxp,_s16,_m,)(pg, svundef_s16(), svundef_s16()); - // expected-error@+2 {{'svmaxp_s16_x' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svmaxp_x' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svmaxp_s16_x' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svmaxp_x' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svmaxp,_s16,_x,)(pg, svundef_s16(), svundef_s16()); - // expected-error@+2 {{'svmullt_s16' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svmullt' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svmullt_s16' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svmullt' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svmullt,_s16,,)(svundef_s8(), svundef_s8()); - // expected-error@+2 {{'svmullt_n_s16' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svmullt' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svmullt_n_s16' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svmullt' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svmullt,_n_s16,,)(svundef_s8(), i8); // expected-error@+2 {{'svmatch_s16' needs target feature sve,sve2}} // overload-error@+1 {{'svmatch' needs target feature sve,sve2}} SVE_ACLE_FUNC(svmatch,_s16,,)(pg, svundef_s16(), svundef_s16()); - // expected-error@+2 {{'svqxtunb_s16' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqxtunb' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqxtunb_s16' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqxtunb' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqxtunb,_s16,,)(svundef_s16()); - // expected-error@+2 {{'svmla_lane_s16' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svmla_lane' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svmla_lane_s16' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svmla_lane' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svmla_lane,_s16,,)(svundef_s16(), svundef_s16(), svundef_s16(), 1); - // expected-error@+2 {{'svrshrnb_n_s16' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svrshrnb' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svrshrnb_n_s16' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svrshrnb' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svrshrnb,_n_s16,,)(svundef_s16(), 1); - // expected-error@+2 {{'svwhilerw_s16' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svwhilerw' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svwhilerw_s16' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svwhilerw' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svwhilerw,_s16,,)(const_i16_ptr, const_i16_ptr); - // expected-error@+2 {{'svshllb_n_s16' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svshllb' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svshllb_n_s16' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svshllb' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svshllb,_n_s16,,)(svundef_s8(), 2); - // expected-error@+2 {{'svrhadd_s16_m' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svrhadd_m' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svrhadd_s16_m' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svrhadd_m' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svrhadd,_s16,_m,)(pg, svundef_s16(), svundef_s16()); - // expected-error@+2 {{'svrhadd_n_s16_m' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svrhadd_m' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svrhadd_n_s16_m' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svrhadd_m' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svrhadd,_n_s16,_m,)(pg, svundef_s16(), i16); - // expected-error@+2 {{'svrhadd_s16_z' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svrhadd_z' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svrhadd_s16_z' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svrhadd_z' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svrhadd,_s16,_z,)(pg, svundef_s16(), svundef_s16()); - // expected-error@+2 {{'svrhadd_n_s16_z' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svrhadd_z' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svrhadd_n_s16_z' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svrhadd_z' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svrhadd,_n_s16,_z,)(pg, svundef_s16(), i16); - // expected-error@+2 {{'svrhadd_s16_x' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svrhadd_x' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svrhadd_s16_x' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svrhadd_x' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svrhadd,_s16,_x,)(pg, svundef_s16(), svundef_s16()); - // expected-error@+2 {{'svrhadd_n_s16_x' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svrhadd_x' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svrhadd_n_s16_x' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svrhadd_x' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svrhadd,_n_s16,_x,)(pg, svundef_s16(), i16); - // expected-error@+2 {{'svraddhnb_s16' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svraddhnb' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svraddhnb_s16' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svraddhnb' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svraddhnb,_s16,,)(svundef_s16(), svundef_s16()); - // expected-error@+2 {{'svraddhnb_n_s16' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svraddhnb' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svraddhnb_n_s16' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svraddhnb' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svraddhnb,_n_s16,,)(svundef_s16(), i16); - // expected-error@+2 {{'svwhilewr_s16' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svwhilewr' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svwhilewr_s16' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svwhilewr' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svwhilewr,_s16,,)(const_i16_ptr, const_i16_ptr); - // expected-error@+2 {{'svmlalb_s16' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svmlalb' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svmlalb_s16' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svmlalb' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svmlalb,_s16,,)(svundef_s16(), svundef_s8(), svundef_s8()); - // expected-error@+2 {{'svmlalb_n_s16' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svmlalb' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svmlalb_n_s16' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svmlalb' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svmlalb,_n_s16,,)(svundef_s16(), svundef_s8(), i8); - // expected-error@+2 {{'svsubwb_s16' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svsubwb' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svsubwb_s16' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svsubwb' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svsubwb,_s16,,)(svundef_s16(), svundef_s8()); - // expected-error@+2 {{'svsubwb_n_s16' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svsubwb' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svsubwb_n_s16' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svsubwb' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svsubwb,_n_s16,,)(svundef_s16(), i8); // expected-error@+2 {{'svnmatch_s16' needs target feature sve,sve2}} // overload-error@+1 {{'svnmatch' needs target feature sve,sve2}} SVE_ACLE_FUNC(svnmatch,_s16,,)(pg, svundef_s16(), svundef_s16()); - // expected-error@+2 {{'svaba_s16' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svaba' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svaba_s16' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svaba' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svaba,_s16,,)(svundef_s16(), svundef_s16(), svundef_s16()); - // expected-error@+2 {{'svaba_n_s16' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svaba' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svaba_n_s16' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svaba' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svaba,_n_s16,,)(svundef_s16(), svundef_s16(), i16); - // expected-error@+2 {{'svraddhnt_s16' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svraddhnt' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svraddhnt_s16' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svraddhnt' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svraddhnt,_s16,,)(svundef_s8(), svundef_s16(), svundef_s16()); - // expected-error@+2 {{'svraddhnt_n_s16' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svraddhnt' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svraddhnt_n_s16' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svraddhnt' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svraddhnt,_n_s16,,)(svundef_s8(), svundef_s16(), i16); - // expected-error@+2 {{'svuqadd_s16_m' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svuqadd_m' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svuqadd_s16_m' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svuqadd_m' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svuqadd,_s16,_m,)(pg, svundef_s16(), svundef_u16()); - // expected-error@+2 {{'svuqadd_n_s16_m' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svuqadd_m' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svuqadd_n_s16_m' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svuqadd_m' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svuqadd,_n_s16,_m,)(pg, svundef_s16(), u16); - // expected-error@+2 {{'svuqadd_s16_z' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svuqadd_z' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svuqadd_s16_z' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svuqadd_z' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svuqadd,_s16,_z,)(pg, svundef_s16(), svundef_u16()); - // expected-error@+2 {{'svuqadd_n_s16_z' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svuqadd_z' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svuqadd_n_s16_z' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svuqadd_z' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svuqadd,_n_s16,_z,)(pg, svundef_s16(), u16); - // expected-error@+2 {{'svuqadd_s16_x' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svuqadd_x' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svuqadd_s16_x' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svuqadd_x' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svuqadd,_s16,_x,)(pg, svundef_s16(), svundef_u16()); - // expected-error@+2 {{'svuqadd_n_s16_x' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svuqadd_x' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svuqadd_n_s16_x' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svuqadd_x' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svuqadd,_n_s16,_x,)(pg, svundef_s16(), u16); - // expected-error@+2 {{'sveorbt_s16' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'sveorbt' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'sveorbt_s16' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'sveorbt' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(sveorbt,_s16,,)(svundef_s16(), svundef_s16(), svundef_s16()); - // expected-error@+2 {{'sveorbt_n_s16' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'sveorbt' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'sveorbt_n_s16' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'sveorbt' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(sveorbt,_n_s16,,)(svundef_s16(), svundef_s16(), i16); - // expected-error@+2 {{'svbsl_s16' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svbsl' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svbsl_s16' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svbsl' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svbsl,_s16,,)(svundef_s16(), svundef_s16(), svundef_s16()); - // expected-error@+2 {{'svbsl_n_s16' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svbsl' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svbsl_n_s16' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svbsl' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svbsl,_n_s16,,)(svundef_s16(), svundef_s16(), i16); - // expected-error@+2 {{'svshllt_n_s16' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svshllt' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svshllt_n_s16' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svshllt' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svshllt,_n_s16,,)(svundef_s8(), 2); - // expected-error@+2 {{'svsubltb_s16' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svsubltb' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svsubltb_s16' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svsubltb' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svsubltb,_s16,,)(svundef_s8(), svundef_s8()); - // expected-error@+2 {{'svsubltb_n_s16' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svsubltb' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svsubltb_n_s16' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svsubltb' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svsubltb,_n_s16,,)(svundef_s8(), i8); - // expected-error@+2 {{'svhsub_s16_z' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svhsub_z' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svhsub_s16_z' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svhsub_z' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svhsub,_s16,_z,)(pg, svundef_s16(), svundef_s16()); - // expected-error@+2 {{'svhsub_s16_m' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svhsub_m' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svhsub_s16_m' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svhsub_m' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svhsub,_s16,_m,)(pg, svundef_s16(), svundef_s16()); - // expected-error@+2 {{'svhsub_s16_x' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svhsub_x' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svhsub_s16_x' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svhsub_x' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svhsub,_s16,_x,)(pg, svundef_s16(), svundef_s16()); - // expected-error@+2 {{'svhsub_n_s16_z' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svhsub_z' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svhsub_n_s16_z' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svhsub_z' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svhsub,_n_s16,_z,)(pg, svundef_s16(), i16); - // expected-error@+2 {{'svhsub_n_s16_m' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svhsub_m' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svhsub_n_s16_m' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svhsub_m' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svhsub,_n_s16,_m,)(pg, svundef_s16(), i16); - // expected-error@+2 {{'svhsub_n_s16_x' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svhsub_x' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svhsub_n_s16_x' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svhsub_x' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svhsub,_n_s16,_x,)(pg, svundef_s16(), i16); - // expected-error@+2 {{'svaddlb_s16' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svaddlb' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svaddlb_s16' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svaddlb' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svaddlb,_s16,,)(svundef_s8(), svundef_s8()); - // expected-error@+2 {{'svaddlb_n_s16' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svaddlb' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svaddlb_n_s16' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svaddlb' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svaddlb,_n_s16,,)(svundef_s8(), i8); - // expected-error@+2 {{'svqrdmlah_s16' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqrdmlah' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqrdmlah_s16' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqrdmlah' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqrdmlah,_s16,,)(svundef_s16(), svundef_s16(), svundef_s16()); - // expected-error@+2 {{'svqrdmlah_n_s16' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqrdmlah' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqrdmlah_n_s16' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqrdmlah' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqrdmlah,_n_s16,,)(svundef_s16(), svundef_s16(), i16); - // expected-error@+2 {{'svqrdmlah_lane_s16' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqrdmlah_lane' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqrdmlah_lane_s16' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqrdmlah_lane' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqrdmlah_lane,_s16,,)(svundef_s16(), svundef_s16(), svundef_s16(), 1); - // expected-error@+2 {{'svqdmullb_s16' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqdmullb' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqdmullb_s16' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqdmullb' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqdmullb,_s16,,)(svundef_s8(), svundef_s8()); - // expected-error@+2 {{'svqdmullb_n_s16' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqdmullb' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqdmullb_n_s16' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqdmullb' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqdmullb,_n_s16,,)(svundef_s8(), i8); - // expected-error@+2 {{'svbsl2n_s16' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svbsl2n' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svbsl2n_s16' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svbsl2n' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svbsl2n,_s16,,)(svundef_s16(), svundef_s16(), svundef_s16()); - // expected-error@+2 {{'svbsl2n_n_s16' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svbsl2n' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svbsl2n_n_s16' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svbsl2n' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svbsl2n,_n_s16,,)(svundef_s16(), svundef_s16(), i16); - // expected-error@+2 {{'svaddlt_s16' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svaddlt' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svaddlt_s16' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svaddlt' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svaddlt,_s16,,)(svundef_s8(), svundef_s8()); - // expected-error@+2 {{'svaddlt_n_s16' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svaddlt' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svaddlt_n_s16' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svaddlt' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svaddlt,_n_s16,,)(svundef_s8(), i8); - // expected-error@+2 {{'svqxtunt_s16' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqxtunt' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqxtunt_s16' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqxtunt' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqxtunt,_s16,,)(svundef_u8(), svundef_s16()); - // expected-error@+2 {{'svqrshrunt_n_s16' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqrshrunt' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqrshrunt_n_s16' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqrshrunt' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqrshrunt,_n_s16,,)(svundef_u8(), svundef_s16(), 1); - // expected-error@+2 {{'svabalb_s16' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svabalb' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svabalb_s16' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svabalb' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svabalb,_s16,,)(svundef_s16(), svundef_s8(), svundef_s8()); - // expected-error@+2 {{'svabalb_n_s16' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svabalb' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svabalb_n_s16' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svabalb' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svabalb,_n_s16,,)(svundef_s16(), svundef_s8(), i8); - // expected-error@+2 {{'svsublb_s16' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svsublb' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svsublb_s16' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svsublb' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svsublb,_s16,,)(svundef_s8(), svundef_s8()); - // expected-error@+2 {{'svsublb_n_s16' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svsublb' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svsublb_n_s16' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svsublb' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svsublb,_n_s16,,)(svundef_s8(), i8); - // expected-error@+2 {{'svbsl1n_s16' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svbsl1n' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svbsl1n_s16' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svbsl1n' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svbsl1n,_s16,,)(svundef_s16(), svundef_s16(), svundef_s16()); - // expected-error@+2 {{'svbsl1n_n_s16' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svbsl1n' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svbsl1n_n_s16' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svbsl1n' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svbsl1n,_n_s16,,)(svundef_s16(), svundef_s16(), i16); - // expected-error@+2 {{'svrshl_s16_z' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svrshl_z' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svrshl_s16_z' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svrshl_z' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svrshl,_s16,_z,)(pg, svundef_s16(), svundef_s16()); - // expected-error@+2 {{'svrshl_s16_m' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svrshl_m' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svrshl_s16_m' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svrshl_m' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svrshl,_s16,_m,)(pg, svundef_s16(), svundef_s16()); - // expected-error@+2 {{'svrshl_s16_x' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svrshl_x' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svrshl_s16_x' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svrshl_x' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svrshl,_s16,_x,)(pg, svundef_s16(), svundef_s16()); - // expected-error@+2 {{'svrshl_n_s16_z' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svrshl_z' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svrshl_n_s16_z' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svrshl_z' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svrshl,_n_s16,_z,)(pg, svundef_s16(), i16); - // expected-error@+2 {{'svrshl_n_s16_m' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svrshl_m' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svrshl_n_s16_m' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svrshl_m' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svrshl,_n_s16,_m,)(pg, svundef_s16(), i16); - // expected-error@+2 {{'svrshl_n_s16_x' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svrshl_x' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svrshl_n_s16_x' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svrshl_x' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svrshl,_n_s16,_x,)(pg, svundef_s16(), i16); - // expected-error@+2 {{'svaddwt_s16' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svaddwt' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svaddwt_s16' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svaddwt' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svaddwt,_s16,,)(svundef_s16(), svundef_s8()); - // expected-error@+2 {{'svaddwt_n_s16' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svaddwt' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svaddwt_n_s16' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svaddwt' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svaddwt,_n_s16,,)(svundef_s16(), i8); - // expected-error@+2 {{'svmlslb_s16' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svmlslb' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svmlslb_s16' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svmlslb' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svmlslb,_s16,,)(svundef_s16(), svundef_s8(), svundef_s8()); - // expected-error@+2 {{'svmlslb_n_s16' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svmlslb' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svmlslb_n_s16' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svmlslb' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svmlslb,_n_s16,,)(svundef_s16(), svundef_s8(), i8); - // expected-error@+2 {{'svmlslt_s16' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svmlslt' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svmlslt_s16' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svmlslt' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svmlslt,_s16,,)(svundef_s16(), svundef_s8(), svundef_s8()); - // expected-error@+2 {{'svmlslt_n_s16' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svmlslt' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svmlslt_n_s16' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svmlslt' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svmlslt,_n_s16,,)(svundef_s16(), svundef_s8(), i8); - // expected-error@+2 {{'svqneg_s16_z' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqneg_z' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqneg_s16_z' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqneg_z' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqneg,_s16,_z,)(pg, svundef_s16()); - // expected-error@+2 {{'svqneg_s16_m' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqneg_m' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqneg_s16_m' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqneg_m' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqneg,_s16,_m,)(svundef_s16(), pg, svundef_s16()); - // expected-error@+2 {{'svqneg_s16_x' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqneg_x' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqneg_s16_x' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqneg_x' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqneg,_s16,_x,)(pg, svundef_s16()); - // expected-error@+2 {{'svmovlt_s16' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svmovlt' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svmovlt_s16' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svmovlt' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svmovlt,_s16,,)(svundef_s8()); - // expected-error@+2 {{'svrshrnt_n_s16' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svrshrnt' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svrshrnt_n_s16' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svrshrnt' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svrshrnt,_n_s16,,)(svundef_s8(), svundef_s16(), 1); - // expected-error@+2 {{'svqshl_s16_z' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqshl_z' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqshl_s16_z' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqshl_z' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqshl,_s16,_z,)(pg, svundef_s16(), svundef_s16()); - // expected-error@+2 {{'svqshl_s16_m' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqshl_m' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqshl_s16_m' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqshl_m' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqshl,_s16,_m,)(pg, svundef_s16(), svundef_s16()); - // expected-error@+2 {{'svqshl_s16_x' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqshl_x' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqshl_s16_x' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqshl_x' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqshl,_s16,_x,)(pg, svundef_s16(), svundef_s16()); - // expected-error@+2 {{'svqshl_n_s16_z' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqshl_z' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqshl_n_s16_z' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqshl_z' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqshl,_n_s16,_z,)(pg, svundef_s16(), i16); - // expected-error@+2 {{'svqshl_n_s16_m' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqshl_m' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqshl_n_s16_m' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqshl_m' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqshl,_n_s16,_m,)(pg, svundef_s16(), i16); - // expected-error@+2 {{'svqshl_n_s16_x' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqshl_x' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqshl_n_s16_x' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqshl_x' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqshl,_n_s16,_x,)(pg, svundef_s16(), i16); - // expected-error@+2 {{'svmullb_s32' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svmullb' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svmullb_s32' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svmullb' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svmullb,_s32,,)(svundef_s16(), svundef_s16()); - // expected-error@+2 {{'svmullb_n_s32' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svmullb' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svmullb_n_s32' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svmullb' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svmullb,_n_s32,,)(svundef_s16(), i16); - // expected-error@+2 {{'svmullb_lane_s32' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svmullb_lane' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svmullb_lane_s32' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svmullb_lane' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svmullb_lane,_s32,,)(svundef_s16(), svundef_s16(), 1); - // expected-error@+2 {{'svqdmlalbt_s32' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqdmlalbt' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqdmlalbt_s32' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqdmlalbt' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqdmlalbt,_s32,,)(svundef_s32(), svundef_s16(), svundef_s16()); - // expected-error@+2 {{'svqdmlalbt_n_s32' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqdmlalbt' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqdmlalbt_n_s32' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqdmlalbt' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqdmlalbt,_n_s32,,)(svundef_s32(), svundef_s16(), i16); - // expected-error@+2 {{'svqrdmulh_s32' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqrdmulh' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqrdmulh_s32' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqrdmulh' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqrdmulh,_s32,,)(svundef_s32(), svundef_s32()); - // expected-error@+2 {{'svqrdmulh_n_s32' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqrdmulh' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqrdmulh_n_s32' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqrdmulh' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqrdmulh,_n_s32,,)(svundef_s32(), i32); - // expected-error@+2 {{'svaddwb_s32' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svaddwb' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svaddwb_s32' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svaddwb' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svaddwb,_s32,,)(svundef_s32(), svundef_s16()); - // expected-error@+2 {{'svaddwb_n_s32' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svaddwb' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svaddwb_n_s32' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svaddwb' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svaddwb,_n_s32,,)(svundef_s32(), i16); - // expected-error@+2 {{'svsubhnb_s32' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svsubhnb' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svsubhnb_s32' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svsubhnb' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svsubhnb,_s32,,)(svundef_s32(), svundef_s32()); - // expected-error@+2 {{'svsubhnb_n_s32' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svsubhnb' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svsubhnb_n_s32' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svsubhnb' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svsubhnb,_n_s32,,)(svundef_s32(), i32); - // expected-error@+2 {{'svqdmulh_s32' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqdmulh' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqdmulh_s32' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqdmulh' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqdmulh,_s32,,)(svundef_s32(), svundef_s32()); - // expected-error@+2 {{'svqdmulh_n_s32' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqdmulh' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqdmulh_n_s32' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqdmulh' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqdmulh,_n_s32,,)(svundef_s32(), i32); - // expected-error@+2 {{'svrsubhnt_s32' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svrsubhnt' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svrsubhnt_s32' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svrsubhnt' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svrsubhnt,_s32,,)(svundef_s16(), svundef_s32(), svundef_s32()); - // expected-error@+2 {{'svrsubhnt_n_s32' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svrsubhnt' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svrsubhnt_n_s32' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svrsubhnt' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svrsubhnt,_n_s32,,)(svundef_s16(), svundef_s32(), i32); - // expected-error@+2 {{'svnbsl_s32' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svnbsl' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svnbsl_s32' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svnbsl' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svnbsl,_s32,,)(svundef_s32(), svundef_s32(), svundef_s32()); - // expected-error@+2 {{'svnbsl_n_s32' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svnbsl' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svnbsl_n_s32' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svnbsl' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svnbsl,_n_s32,,)(svundef_s32(), svundef_s32(), i32); - // expected-error@+2 {{'svqdmlslb_s32' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqdmlslb' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqdmlslb_s32' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqdmlslb' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqdmlslb,_s32,,)(svundef_s32(), svundef_s16(), svundef_s16()); - // expected-error@+2 {{'svqdmlslb_n_s32' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqdmlslb' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqdmlslb_n_s32' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqdmlslb' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqdmlslb,_n_s32,,)(svundef_s32(), svundef_s16(), i16); - // expected-error@+2 {{'svqdmlslb_lane_s32' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqdmlslb_lane' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqdmlslb_lane_s32' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqdmlslb_lane' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqdmlslb_lane,_s32,,)(svundef_s32(), svundef_s16(), svundef_s16(), 1); - // expected-error@+2 {{'svsubhnt_s32' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svsubhnt' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svsubhnt_s32' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svsubhnt' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svsubhnt,_s32,,)(svundef_s16(), svundef_s32(), svundef_s32()); - // expected-error@+2 {{'svsubhnt_n_s32' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svsubhnt' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svsubhnt_n_s32' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svsubhnt' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svsubhnt,_n_s32,,)(svundef_s16(), svundef_s32(), i32); - // expected-error@+2 {{'svqabs_s32_z' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqabs_z' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqabs_s32_z' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqabs_z' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqabs,_s32,_z,)(pg, svundef_s32()); - // expected-error@+2 {{'svqabs_s32_m' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqabs_m' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqabs_s32_m' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqabs_m' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqabs,_s32,_m,)(svundef_s32(), pg, svundef_s32()); - // expected-error@+2 {{'svqabs_s32_x' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqabs_x' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqabs_s32_x' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqabs_x' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqabs,_s32,_x,)(pg, svundef_s32()); - // expected-error@+2 {{'svwhilegt_b8_s32' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svwhilegt_b8' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svwhilegt_b8_s32' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svwhilegt_b8' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svwhilegt_b8,_s32,,)(i32, i32); - // expected-error@+2 {{'svwhilegt_b16_s32' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svwhilegt_b16' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svwhilegt_b16_s32' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svwhilegt_b16' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svwhilegt_b16,_s32,,)(i32, i32); - // expected-error@+2 {{'svwhilegt_b32_s32' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svwhilegt_b32' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svwhilegt_b32_s32' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svwhilegt_b32' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svwhilegt_b32,_s32,,)(i32, i32); - // expected-error@+2 {{'svwhilegt_b64_s32' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svwhilegt_b64' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svwhilegt_b64_s32' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svwhilegt_b64' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svwhilegt_b64,_s32,,)(i32, i32); - // expected-error@+2 {{'svaddlbt_s32' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svaddlbt' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svaddlbt_s32' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svaddlbt' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svaddlbt,_s32,,)(svundef_s16(), svundef_s16()); - // expected-error@+2 {{'svaddlbt_n_s32' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svaddlbt' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svaddlbt_n_s32' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svaddlbt' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svaddlbt,_n_s32,,)(svundef_s16(), i16); - // expected-error@+2 {{'svtbl2_s32' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svtbl2' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svtbl2_s32' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svtbl2' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svtbl2,_s32,,)(svundef2_s32(), svundef_u32()); - // expected-error@+2 {{'svhsubr_s32_z' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svhsubr_z' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svhsubr_s32_z' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svhsubr_z' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svhsubr,_s32,_z,)(pg, svundef_s32(), svundef_s32()); - // expected-error@+2 {{'svhsubr_s32_m' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svhsubr_m' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svhsubr_s32_m' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svhsubr_m' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svhsubr,_s32,_m,)(pg, svundef_s32(), svundef_s32()); - // expected-error@+2 {{'svhsubr_s32_x' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svhsubr_x' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svhsubr_s32_x' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svhsubr_x' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svhsubr,_s32,_x,)(pg, svundef_s32(), svundef_s32()); - // expected-error@+2 {{'svhsubr_n_s32_z' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svhsubr_z' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svhsubr_n_s32_z' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svhsubr_z' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svhsubr,_n_s32,_z,)(pg, svundef_s32(), i32); - // expected-error@+2 {{'svhsubr_n_s32_m' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svhsubr_m' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svhsubr_n_s32_m' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svhsubr_m' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svhsubr,_n_s32,_m,)(pg, svundef_s32(), i32); - // expected-error@+2 {{'svhsubr_n_s32_x' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svhsubr_x' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svhsubr_n_s32_x' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svhsubr_x' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svhsubr,_n_s32,_x,)(pg, svundef_s32(), i32); // expected-error@+2 {{'svhistcnt_s32_z' needs target feature sve,sve2}} // overload-error@+1 {{'svhistcnt_z' needs target feature sve,sve2}} SVE_ACLE_FUNC(svhistcnt,_s32,_z,)(pg, svundef_s32(), svundef_s32()); - // expected-error@+2 {{'sveortb_s32' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'sveortb' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'sveortb_s32' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'sveortb' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(sveortb,_s32,,)(svundef_s32(), svundef_s32(), svundef_s32()); - // expected-error@+2 {{'sveortb_n_s32' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'sveortb' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'sveortb_n_s32' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'sveortb' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(sveortb,_n_s32,,)(svundef_s32(), svundef_s32(), i32); - // expected-error@+2 {{'svqxtnb_s32' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqxtnb' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqxtnb_s32' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqxtnb' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqxtnb,_s32,,)(svundef_s32()); - // expected-error@+2 {{'svmlalt_s32' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svmlalt' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svmlalt_s32' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svmlalt' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svmlalt,_s32,,)(svundef_s32(), svundef_s16(), svundef_s16()); - // expected-error@+2 {{'svmlalt_n_s32' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svmlalt' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svmlalt_n_s32' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svmlalt' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svmlalt,_n_s32,,)(svundef_s32(), svundef_s16(), i16); - // expected-error@+2 {{'svmlalt_lane_s32' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svmlalt_lane' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svmlalt_lane_s32' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svmlalt_lane' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svmlalt_lane,_s32,,)(svundef_s32(), svundef_s16(), svundef_s16(), 1); - // expected-error@+2 {{'svaddhnt_s32' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svaddhnt' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svaddhnt_s32' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svaddhnt' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svaddhnt,_s32,,)(svundef_s16(), svundef_s32(), svundef_s32()); - // expected-error@+2 {{'svaddhnt_n_s32' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svaddhnt' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svaddhnt_n_s32' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svaddhnt' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svaddhnt,_n_s32,,)(svundef_s16(), svundef_s32(), i32); // expected-error@+2 {{'svldnt1uh_gather_u32base_s32' needs target feature sve,sve2}} // overload-error@+1 {{'svldnt1uh_gather_s32' needs target feature sve,sve2}} @@ -1200,233 +1200,233 @@ void test(svbool_t pg, const int8_t *const_i8_ptr, const uint8_t *const_u8_ptr, // expected-error@+2 {{'svldnt1uh_gather_u32base_index_s32' needs target feature sve,sve2}} // overload-error@+1 {{'svldnt1uh_gather_index_s32' needs target feature sve,sve2}} SVE_ACLE_FUNC(svldnt1uh_gather, _u32base, _index_s32, )(pg, svundef_u32(), i64); - // expected-error@+2 {{'svqdmlalt_s32' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqdmlalt' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqdmlalt_s32' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqdmlalt' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqdmlalt,_s32,,)(svundef_s32(), svundef_s16(), svundef_s16()); - // expected-error@+2 {{'svqdmlalt_n_s32' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqdmlalt' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqdmlalt_n_s32' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqdmlalt' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqdmlalt,_n_s32,,)(svundef_s32(), svundef_s16(), i16); - // expected-error@+2 {{'svqdmlalt_lane_s32' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqdmlalt_lane' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqdmlalt_lane_s32' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqdmlalt_lane' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqdmlalt_lane,_s32,,)(svundef_s32(), svundef_s16(), svundef_s16(), 1); - // expected-error@+2 {{'svbcax_s32' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svbcax' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svbcax_s32' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svbcax' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svbcax,_s32,,)(svundef_s32(), svundef_s32(), svundef_s32()); - // expected-error@+2 {{'svbcax_n_s32' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svbcax' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svbcax_n_s32' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svbcax' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svbcax,_n_s32,,)(svundef_s32(), svundef_s32(), i32); - // expected-error@+2 {{'svqxtnt_s32' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqxtnt' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqxtnt_s32' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqxtnt' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqxtnt,_s32,,)(svundef_s16(), svundef_s32()); - // expected-error@+2 {{'svqdmlalb_s32' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqdmlalb' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqdmlalb_s32' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqdmlalb' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqdmlalb,_s32,,)(svundef_s32(), svundef_s16(), svundef_s16()); - // expected-error@+2 {{'svqdmlalb_n_s32' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqdmlalb' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqdmlalb_n_s32' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqdmlalb' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqdmlalb,_n_s32,,)(svundef_s32(), svundef_s16(), i16); - // expected-error@+2 {{'svqdmlalb_lane_s32' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqdmlalb_lane' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqdmlalb_lane_s32' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqdmlalb_lane' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqdmlalb_lane,_s32,,)(svundef_s32(), svundef_s16(), svundef_s16(), 1); - // expected-error@+2 {{'svqrshl_s32_z' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqrshl_z' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqrshl_s32_z' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqrshl_z' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqrshl,_s32,_z,)(pg, svundef_s32(), svundef_s32()); - // expected-error@+2 {{'svqrshl_s32_m' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqrshl_m' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqrshl_s32_m' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqrshl_m' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqrshl,_s32,_m,)(pg, svundef_s32(), svundef_s32()); - // expected-error@+2 {{'svqrshl_s32_x' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqrshl_x' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqrshl_s32_x' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqrshl_x' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqrshl,_s32,_x,)(pg, svundef_s32(), svundef_s32()); - // expected-error@+2 {{'svqrshl_n_s32_z' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqrshl_z' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqrshl_n_s32_z' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqrshl_z' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqrshl,_n_s32,_z,)(pg, svundef_s32(), i32); - // expected-error@+2 {{'svqrshl_n_s32_m' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqrshl_m' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqrshl_n_s32_m' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqrshl_m' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqrshl,_n_s32,_m,)(pg, svundef_s32(), i32); - // expected-error@+2 {{'svqrshl_n_s32_x' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqrshl_x' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqrshl_n_s32_x' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqrshl_x' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqrshl,_n_s32,_x,)(pg, svundef_s32(), i32); - // expected-error@+2 {{'svcdot_s32' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svcdot' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svcdot_s32' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svcdot' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svcdot,_s32,,)(svundef_s32(), svundef_s8(), svundef_s8(), 90); - // expected-error@+2 {{'svsublbt_s32' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svsublbt' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svsublbt_s32' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svsublbt' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svsublbt,_s32,,)(svundef_s16(), svundef_s16()); - // expected-error@+2 {{'svsublbt_n_s32' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svsublbt' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svsublbt_n_s32' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svsublbt' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svsublbt,_n_s32,,)(svundef_s16(), i16); - // expected-error@+2 {{'svqdmullt_s32' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqdmullt' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqdmullt_s32' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqdmullt' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqdmullt,_s32,,)(svundef_s16(), svundef_s16()); - // expected-error@+2 {{'svqdmullt_n_s32' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqdmullt' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqdmullt_n_s32' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqdmullt' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqdmullt,_n_s32,,)(svundef_s16(), i16); - // expected-error@+2 {{'svqdmullt_lane_s32' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqdmullt_lane' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqdmullt_lane_s32' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqdmullt_lane' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqdmullt_lane,_s32,,)(svundef_s16(), svundef_s16(), 1); - // expected-error@+2 {{'svsublt_s32' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svsublt' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svsublt_s32' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svsublt' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svsublt,_s32,,)(svundef_s16(), svundef_s16()); - // expected-error@+2 {{'svsublt_n_s32' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svsublt' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svsublt_n_s32' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svsublt' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svsublt,_n_s32,,)(svundef_s16(), i16); - // expected-error@+2 {{'svqdmlslbt_s32' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqdmlslbt' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqdmlslbt_s32' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqdmlslbt' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqdmlslbt,_s32,,)(svundef_s32(), svundef_s16(), svundef_s16()); - // expected-error@+2 {{'svqdmlslbt_n_s32' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqdmlslbt' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqdmlslbt_n_s32' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqdmlslbt' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqdmlslbt,_n_s32,,)(svundef_s32(), svundef_s16(), i16); - // expected-error@+2 {{'svadalp_s32_z' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svadalp_z' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svadalp_s32_z' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svadalp_z' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svadalp,_s32,_z,)(pg, svundef_s32(), svundef_s16()); - // expected-error@+2 {{'svadalp_s32_m' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svadalp_m' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svadalp_s32_m' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svadalp_m' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svadalp,_s32,_m,)(pg, svundef_s32(), svundef_s16()); - // expected-error@+2 {{'svadalp_s32_x' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svadalp_x' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svadalp_s32_x' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svadalp_x' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svadalp,_s32,_x,)(pg, svundef_s32(), svundef_s16()); - // expected-error@+2 {{'svwhilege_b8_s32' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svwhilege_b8' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svwhilege_b8_s32' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svwhilege_b8' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svwhilege_b8,_s32,,)(i32, i32); - // expected-error@+2 {{'svwhilege_b16_s32' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svwhilege_b16' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svwhilege_b16_s32' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svwhilege_b16' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svwhilege_b16,_s32,,)(i32, i32); - // expected-error@+2 {{'svwhilege_b32_s32' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svwhilege_b32' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svwhilege_b32_s32' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svwhilege_b32' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svwhilege_b32,_s32,,)(i32, i32); - // expected-error@+2 {{'svwhilege_b64_s32' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svwhilege_b64' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svwhilege_b64_s32' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svwhilege_b64' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svwhilege_b64,_s32,,)(i32, i32); - // expected-error@+2 {{'svsubwt_s32' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svsubwt' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svsubwt_s32' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svsubwt' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svsubwt,_s32,,)(svundef_s32(), svundef_s16()); - // expected-error@+2 {{'svsubwt_n_s32' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svsubwt' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svsubwt_n_s32' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svsubwt' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svsubwt,_n_s32,,)(svundef_s32(), i16); - // expected-error@+2 {{'svqsubr_s32_z' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqsubr_z' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqsubr_s32_z' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqsubr_z' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqsubr,_s32,_z,)(pg, svundef_s32(), svundef_s32()); - // expected-error@+2 {{'svqsubr_s32_m' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqsubr_m' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqsubr_s32_m' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqsubr_m' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqsubr,_s32,_m,)(pg, svundef_s32(), svundef_s32()); - // expected-error@+2 {{'svqsubr_s32_x' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqsubr_x' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqsubr_s32_x' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqsubr_x' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqsubr,_s32,_x,)(pg, svundef_s32(), svundef_s32()); - // expected-error@+2 {{'svqsubr_n_s32_z' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqsubr_z' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqsubr_n_s32_z' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqsubr_z' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqsubr,_n_s32,_z,)(pg, svundef_s32(), i32); - // expected-error@+2 {{'svqsubr_n_s32_m' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqsubr_m' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqsubr_n_s32_m' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqsubr_m' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqsubr,_n_s32,_m,)(pg, svundef_s32(), i32); - // expected-error@+2 {{'svqsubr_n_s32_x' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqsubr_x' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqsubr_n_s32_x' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqsubr_x' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqsubr,_n_s32,_x,)(pg, svundef_s32(), i32); - // expected-error@+2 {{'svaddp_s32_m' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svaddp_m' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svaddp_s32_m' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svaddp_m' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svaddp,_s32,_m,)(pg, svundef_s32(), svundef_s32()); - // expected-error@+2 {{'svaddp_s32_x' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svaddp_x' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svaddp_s32_x' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svaddp_x' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svaddp,_s32,_x,)(pg, svundef_s32(), svundef_s32()); - // expected-error@+2 {{'svqadd_s32_m' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqadd_m' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqadd_s32_m' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqadd_m' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqadd,_s32,_m,)(pg, svundef_s32(), svundef_s32()); - // expected-error@+2 {{'svqadd_n_s32_m' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqadd_m' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqadd_n_s32_m' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqadd_m' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqadd,_n_s32,_m,)(pg, svundef_s32(), i32); - // expected-error@+2 {{'svqadd_s32_z' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqadd_z' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqadd_s32_z' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqadd_z' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqadd,_s32,_z,)(pg, svundef_s32(), svundef_s32()); - // expected-error@+2 {{'svqadd_n_s32_z' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqadd_z' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqadd_n_s32_z' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqadd_z' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqadd,_n_s32,_z,)(pg, svundef_s32(), i32); - // expected-error@+2 {{'svqadd_s32_x' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqadd_x' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqadd_s32_x' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqadd_x' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqadd,_s32,_x,)(pg, svundef_s32(), svundef_s32()); - // expected-error@+2 {{'svqadd_n_s32_x' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqadd_x' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqadd_n_s32_x' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqadd_x' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqadd,_n_s32,_x,)(pg, svundef_s32(), i32); - // expected-error@+2 {{'svabdlb_s32' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svabdlb' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svabdlb_s32' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svabdlb' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svabdlb,_s32,,)(svundef_s16(), svundef_s16()); - // expected-error@+2 {{'svabdlb_n_s32' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svabdlb' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svabdlb_n_s32' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svabdlb' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svabdlb,_n_s32,,)(svundef_s16(), i16); - // expected-error@+2 {{'svtbx_s32' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svtbx' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svtbx_s32' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svtbx' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svtbx,_s32,,)(svundef_s32(), svundef_s32(), svundef_u32()); - // expected-error@+2 {{'svabdlt_s32' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svabdlt' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svabdlt_s32' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svabdlt' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svabdlt,_s32,,)(svundef_s16(), svundef_s16()); - // expected-error@+2 {{'svabdlt_n_s32' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svabdlt' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svabdlt_n_s32' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svabdlt' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svabdlt,_n_s32,,)(svundef_s16(), i16); - // expected-error@+2 {{'svminp_s32_m' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svminp_m' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svminp_s32_m' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svminp_m' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svminp,_s32,_m,)(pg, svundef_s32(), svundef_s32()); - // expected-error@+2 {{'svminp_s32_x' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svminp_x' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svminp_s32_x' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svminp_x' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svminp,_s32,_x,)(pg, svundef_s32(), svundef_s32()); - // expected-error@+2 {{'svqsub_s32_z' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqsub_z' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqsub_s32_z' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqsub_z' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqsub,_s32,_z,)(pg, svundef_s32(), svundef_s32()); - // expected-error@+2 {{'svqsub_s32_m' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqsub_m' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqsub_s32_m' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqsub_m' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqsub,_s32,_m,)(pg, svundef_s32(), svundef_s32()); - // expected-error@+2 {{'svqsub_s32_x' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqsub_x' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqsub_s32_x' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqsub_x' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqsub,_s32,_x,)(pg, svundef_s32(), svundef_s32()); - // expected-error@+2 {{'svqsub_n_s32_z' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqsub_z' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqsub_n_s32_z' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqsub_z' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqsub,_n_s32,_z,)(pg, svundef_s32(), i32); - // expected-error@+2 {{'svqsub_n_s32_m' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqsub_m' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqsub_n_s32_m' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqsub_m' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqsub,_n_s32,_m,)(pg, svundef_s32(), i32); - // expected-error@+2 {{'svqsub_n_s32_x' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqsub_x' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqsub_n_s32_x' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqsub_x' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqsub,_n_s32,_x,)(pg, svundef_s32(), i32); - // expected-error@+2 {{'svrsubhnb_s32' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svrsubhnb' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svrsubhnb_s32' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svrsubhnb' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svrsubhnb,_s32,,)(svundef_s32(), svundef_s32()); - // expected-error@+2 {{'svrsubhnb_n_s32' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svrsubhnb' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svrsubhnb_n_s32' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svrsubhnb' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svrsubhnb,_n_s32,,)(svundef_s32(), i32); - // expected-error@+2 {{'svaddhnb_s32' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svaddhnb' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svaddhnb_s32' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svaddhnb' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svaddhnb,_s32,,)(svundef_s32(), svundef_s32()); - // expected-error@+2 {{'svaddhnb_n_s32' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svaddhnb' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svaddhnb_n_s32' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svaddhnb' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svaddhnb,_n_s32,,)(svundef_s32(), i32); - // expected-error@+2 {{'svabalt_s32' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svabalt' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svabalt_s32' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svabalt' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svabalt,_s32,,)(svundef_s32(), svundef_s16(), svundef_s16()); - // expected-error@+2 {{'svabalt_n_s32' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svabalt' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svabalt_n_s32' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svabalt' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svabalt,_n_s32,,)(svundef_s32(), svundef_s16(), i16); - // expected-error@+2 {{'sveor3_s32' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'sveor3' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'sveor3_s32' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'sveor3' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(sveor3,_s32,,)(svundef_s32(), svundef_s32(), svundef_s32()); - // expected-error@+2 {{'sveor3_n_s32' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'sveor3' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'sveor3_n_s32' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'sveor3' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(sveor3,_n_s32,,)(svundef_s32(), svundef_s32(), i32); - // expected-error@+2 {{'svhadd_s32_m' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svhadd_m' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svhadd_s32_m' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svhadd_m' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svhadd,_s32,_m,)(pg, svundef_s32(), svundef_s32()); - // expected-error@+2 {{'svhadd_n_s32_m' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svhadd_m' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svhadd_n_s32_m' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svhadd_m' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svhadd,_n_s32,_m,)(pg, svundef_s32(), i32); - // expected-error@+2 {{'svhadd_s32_z' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svhadd_z' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svhadd_s32_z' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svhadd_z' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svhadd,_s32,_z,)(pg, svundef_s32(), svundef_s32()); - // expected-error@+2 {{'svhadd_n_s32_z' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svhadd_z' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svhadd_n_s32_z' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svhadd_z' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svhadd,_n_s32,_z,)(pg, svundef_s32(), i32); - // expected-error@+2 {{'svhadd_s32_x' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svhadd_x' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svhadd_s32_x' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svhadd_x' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svhadd,_s32,_x,)(pg, svundef_s32(), svundef_s32()); - // expected-error@+2 {{'svhadd_n_s32_x' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svhadd_x' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svhadd_n_s32_x' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svhadd_x' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svhadd,_n_s32,_x,)(pg, svundef_s32(), i32); - // expected-error@+2 {{'svmovlb_s32' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svmovlb' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svmovlb_s32' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svmovlb' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svmovlb,_s32,,)(svundef_s16()); // expected-error@+2 {{'svstnt1_scatter_u32base_s32' needs target feature sve,sve2}} // overload-error@+1 {{'svstnt1_scatter' needs target feature sve,sve2}} @@ -1440,35 +1440,35 @@ void test(svbool_t pg, const int8_t *const_i8_ptr, const uint8_t *const_u8_ptr, // expected-error@+2 {{'svstnt1_scatter_u32base_index_s32' needs target feature sve,sve2}} // overload-error@+1 {{'svstnt1_scatter_index' needs target feature sve,sve2}} SVE_ACLE_FUNC(svstnt1_scatter, _u32base, _index, _s32)(pg, svundef_u32(), i64, svundef_s32()); - // expected-error@+2 {{'svqrdmlsh_s32' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqrdmlsh' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqrdmlsh_s32' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqrdmlsh' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqrdmlsh,_s32,,)(svundef_s32(), svundef_s32(), svundef_s32()); - // expected-error@+2 {{'svqrdmlsh_n_s32' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqrdmlsh' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqrdmlsh_n_s32' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqrdmlsh' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqrdmlsh,_n_s32,,)(svundef_s32(), svundef_s32(), i32); - // expected-error@+2 {{'svqdmlslt_s32' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqdmlslt' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqdmlslt_s32' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqdmlslt' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqdmlslt,_s32,,)(svundef_s32(), svundef_s16(), svundef_s16()); - // expected-error@+2 {{'svqdmlslt_n_s32' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqdmlslt' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqdmlslt_n_s32' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqdmlslt' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqdmlslt,_n_s32,,)(svundef_s32(), svundef_s16(), i16); - // expected-error@+2 {{'svqdmlslt_lane_s32' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqdmlslt_lane' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqdmlslt_lane_s32' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqdmlslt_lane' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqdmlslt_lane,_s32,,)(svundef_s32(), svundef_s16(), svundef_s16(), 1); - // expected-error@+2 {{'svmaxp_s32_m' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svmaxp_m' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svmaxp_s32_m' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svmaxp_m' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svmaxp,_s32,_m,)(pg, svundef_s32(), svundef_s32()); - // expected-error@+2 {{'svmaxp_s32_x' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svmaxp_x' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svmaxp_s32_x' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svmaxp_x' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svmaxp,_s32,_x,)(pg, svundef_s32(), svundef_s32()); - // expected-error@+2 {{'svmullt_s32' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svmullt' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svmullt_s32' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svmullt' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svmullt,_s32,,)(svundef_s16(), svundef_s16()); - // expected-error@+2 {{'svmullt_n_s32' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svmullt' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svmullt_n_s32' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svmullt' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svmullt,_n_s32,,)(svundef_s16(), i16); - // expected-error@+2 {{'svmullt_lane_s32' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svmullt_lane' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svmullt_lane_s32' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svmullt_lane' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svmullt_lane,_s32,,)(svundef_s16(), svundef_s16(), 1); // expected-error@+2 {{'svldnt1sh_gather_u32base_s32' needs target feature sve,sve2}} // overload-error@+1 {{'svldnt1sh_gather_s32' needs target feature sve,sve2}} @@ -1482,47 +1482,47 @@ void test(svbool_t pg, const int8_t *const_i8_ptr, const uint8_t *const_u8_ptr, // expected-error@+2 {{'svldnt1sh_gather_u32base_index_s32' needs target feature sve,sve2}} // overload-error@+1 {{'svldnt1sh_gather_index_s32' needs target feature sve,sve2}} SVE_ACLE_FUNC(svldnt1sh_gather, _u32base, _index_s32, )(pg, svundef_u32(), i64); - // expected-error@+2 {{'svqxtunb_s32' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqxtunb' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqxtunb_s32' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqxtunb' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqxtunb,_s32,,)(svundef_s32()); - // expected-error@+2 {{'svwhilerw_s32' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svwhilerw' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svwhilerw_s32' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svwhilerw' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svwhilerw,_s32,,)(const_i32_ptr, const_i32_ptr); - // expected-error@+2 {{'svrhadd_s32_m' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svrhadd_m' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svrhadd_s32_m' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svrhadd_m' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svrhadd,_s32,_m,)(pg, svundef_s32(), svundef_s32()); - // expected-error@+2 {{'svrhadd_n_s32_m' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svrhadd_m' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svrhadd_n_s32_m' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svrhadd_m' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svrhadd,_n_s32,_m,)(pg, svundef_s32(), i32); - // expected-error@+2 {{'svrhadd_s32_z' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svrhadd_z' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svrhadd_s32_z' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svrhadd_z' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svrhadd,_s32,_z,)(pg, svundef_s32(), svundef_s32()); - // expected-error@+2 {{'svrhadd_n_s32_z' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svrhadd_z' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svrhadd_n_s32_z' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svrhadd_z' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svrhadd,_n_s32,_z,)(pg, svundef_s32(), i32); - // expected-error@+2 {{'svrhadd_s32_x' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svrhadd_x' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svrhadd_s32_x' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svrhadd_x' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svrhadd,_s32,_x,)(pg, svundef_s32(), svundef_s32()); - // expected-error@+2 {{'svrhadd_n_s32_x' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svrhadd_x' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svrhadd_n_s32_x' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svrhadd_x' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svrhadd,_n_s32,_x,)(pg, svundef_s32(), i32); - // expected-error@+2 {{'svraddhnb_s32' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svraddhnb' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svraddhnb_s32' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svraddhnb' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svraddhnb,_s32,,)(svundef_s32(), svundef_s32()); - // expected-error@+2 {{'svraddhnb_n_s32' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svraddhnb' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svraddhnb_n_s32' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svraddhnb' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svraddhnb,_n_s32,,)(svundef_s32(), i32); - // expected-error@+2 {{'svwhilewr_s32' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svwhilewr' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svwhilewr_s32' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svwhilewr' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svwhilewr,_s32,,)(const_i32_ptr, const_i32_ptr); - // expected-error@+2 {{'svmlalb_s32' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svmlalb' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svmlalb_s32' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svmlalb' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svmlalb,_s32,,)(svundef_s32(), svundef_s16(), svundef_s16()); - // expected-error@+2 {{'svmlalb_n_s32' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svmlalb' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svmlalb_n_s32' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svmlalb' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svmlalb,_n_s32,,)(svundef_s32(), svundef_s16(), i16); - // expected-error@+2 {{'svmlalb_lane_s32' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svmlalb_lane' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svmlalb_lane_s32' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svmlalb_lane' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svmlalb_lane,_s32,,)(svundef_s32(), svundef_s16(), svundef_s16(), 1); // expected-error@+2 {{'svldnt1sb_gather_u32base_s32' needs target feature sve,sve2}} // overload-error@+1 {{'svldnt1sb_gather_s32' needs target feature sve,sve2}} @@ -1533,11 +1533,11 @@ void test(svbool_t pg, const int8_t *const_i8_ptr, const uint8_t *const_u8_ptr, // expected-error@+2 {{'svldnt1sb_gather_u32base_offset_s32' needs target feature sve,sve2}} // overload-error@+1 {{'svldnt1sb_gather_offset_s32' needs target feature sve,sve2}} SVE_ACLE_FUNC(svldnt1sb_gather, _u32base, _offset_s32, )(pg, svundef_u32(), i64); - // expected-error@+2 {{'svsubwb_s32' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svsubwb' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svsubwb_s32' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svsubwb' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svsubwb,_s32,,)(svundef_s32(), svundef_s16()); - // expected-error@+2 {{'svsubwb_n_s32' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svsubwb' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svsubwb_n_s32' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svsubwb' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svsubwb,_n_s32,,)(svundef_s32(), i16); // expected-error@+2 {{'svldnt1ub_gather_u32base_s32' needs target feature sve,sve2}} // overload-error@+1 {{'svldnt1ub_gather_s32' needs target feature sve,sve2}} @@ -1548,71 +1548,71 @@ void test(svbool_t pg, const int8_t *const_i8_ptr, const uint8_t *const_u8_ptr, // expected-error@+2 {{'svldnt1ub_gather_u32base_offset_s32' needs target feature sve,sve2}} // overload-error@+1 {{'svldnt1ub_gather_offset_s32' needs target feature sve,sve2}} SVE_ACLE_FUNC(svldnt1ub_gather, _u32base, _offset_s32, )(pg, svundef_u32(), i64); - // expected-error@+2 {{'svaba_s32' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svaba' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svaba_s32' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svaba' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svaba,_s32,,)(svundef_s32(), svundef_s32(), svundef_s32()); - // expected-error@+2 {{'svaba_n_s32' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svaba' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svaba_n_s32' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svaba' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svaba,_n_s32,,)(svundef_s32(), svundef_s32(), i32); - // expected-error@+2 {{'svraddhnt_s32' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svraddhnt' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svraddhnt_s32' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svraddhnt' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svraddhnt,_s32,,)(svundef_s16(), svundef_s32(), svundef_s32()); - // expected-error@+2 {{'svraddhnt_n_s32' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svraddhnt' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svraddhnt_n_s32' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svraddhnt' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svraddhnt,_n_s32,,)(svundef_s16(), svundef_s32(), i32); - // expected-error@+2 {{'svuqadd_s32_m' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svuqadd_m' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svuqadd_s32_m' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svuqadd_m' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svuqadd,_s32,_m,)(pg, svundef_s32(), svundef_u32()); - // expected-error@+2 {{'svuqadd_n_s32_m' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svuqadd_m' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svuqadd_n_s32_m' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svuqadd_m' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svuqadd,_n_s32,_m,)(pg, svundef_s32(), u32); - // expected-error@+2 {{'svuqadd_s32_z' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svuqadd_z' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svuqadd_s32_z' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svuqadd_z' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svuqadd,_s32,_z,)(pg, svundef_s32(), svundef_u32()); - // expected-error@+2 {{'svuqadd_n_s32_z' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svuqadd_z' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svuqadd_n_s32_z' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svuqadd_z' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svuqadd,_n_s32,_z,)(pg, svundef_s32(), u32); - // expected-error@+2 {{'svuqadd_s32_x' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svuqadd_x' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svuqadd_s32_x' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svuqadd_x' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svuqadd,_s32,_x,)(pg, svundef_s32(), svundef_u32()); - // expected-error@+2 {{'svuqadd_n_s32_x' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svuqadd_x' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svuqadd_n_s32_x' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svuqadd_x' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svuqadd,_n_s32,_x,)(pg, svundef_s32(), u32); - // expected-error@+2 {{'sveorbt_s32' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'sveorbt' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'sveorbt_s32' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'sveorbt' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(sveorbt,_s32,,)(svundef_s32(), svundef_s32(), svundef_s32()); - // expected-error@+2 {{'sveorbt_n_s32' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'sveorbt' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'sveorbt_n_s32' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'sveorbt' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(sveorbt,_n_s32,,)(svundef_s32(), svundef_s32(), i32); - // expected-error@+2 {{'svbsl_s32' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svbsl' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svbsl_s32' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svbsl' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svbsl,_s32,,)(svundef_s32(), svundef_s32(), svundef_s32()); - // expected-error@+2 {{'svbsl_n_s32' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svbsl' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svbsl_n_s32' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svbsl' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svbsl,_n_s32,,)(svundef_s32(), svundef_s32(), i32); - // expected-error@+2 {{'svsubltb_s32' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svsubltb' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svsubltb_s32' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svsubltb' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svsubltb,_s32,,)(svundef_s16(), svundef_s16()); - // expected-error@+2 {{'svsubltb_n_s32' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svsubltb' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svsubltb_n_s32' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svsubltb' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svsubltb,_n_s32,,)(svundef_s16(), i16); - // expected-error@+2 {{'svhsub_s32_z' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svhsub_z' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svhsub_s32_z' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svhsub_z' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svhsub,_s32,_z,)(pg, svundef_s32(), svundef_s32()); - // expected-error@+2 {{'svhsub_s32_m' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svhsub_m' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svhsub_s32_m' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svhsub_m' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svhsub,_s32,_m,)(pg, svundef_s32(), svundef_s32()); - // expected-error@+2 {{'svhsub_s32_x' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svhsub_x' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svhsub_s32_x' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svhsub_x' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svhsub,_s32,_x,)(pg, svundef_s32(), svundef_s32()); - // expected-error@+2 {{'svhsub_n_s32_z' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svhsub_z' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svhsub_n_s32_z' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svhsub_z' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svhsub,_n_s32,_z,)(pg, svundef_s32(), i32); - // expected-error@+2 {{'svhsub_n_s32_m' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svhsub_m' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svhsub_n_s32_m' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svhsub_m' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svhsub,_n_s32,_m,)(pg, svundef_s32(), i32); - // expected-error@+2 {{'svhsub_n_s32_x' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svhsub_x' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svhsub_n_s32_x' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svhsub_x' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svhsub,_n_s32,_x,)(pg, svundef_s32(), i32); // expected-error@+2 {{'svldnt1_gather_u32base_s32' needs target feature sve,sve2}} // overload-error@+1 {{'svldnt1_gather_s32' needs target feature sve,sve2}} @@ -1626,26 +1626,26 @@ void test(svbool_t pg, const int8_t *const_i8_ptr, const uint8_t *const_u8_ptr, // expected-error@+2 {{'svldnt1_gather_u32base_index_s32' needs target feature sve,sve2}} // overload-error@+1 {{'svldnt1_gather_index_s32' needs target feature sve,sve2}} SVE_ACLE_FUNC(svldnt1_gather, _u32base, _index_s32, )(pg, svundef_u32(), i64); - // expected-error@+2 {{'svaddlb_s32' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svaddlb' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svaddlb_s32' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svaddlb' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svaddlb,_s32,,)(svundef_s16(), svundef_s16()); - // expected-error@+2 {{'svaddlb_n_s32' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svaddlb' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svaddlb_n_s32' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svaddlb' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svaddlb,_n_s32,,)(svundef_s16(), i16); - // expected-error@+2 {{'svqrdmlah_s32' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqrdmlah' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqrdmlah_s32' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqrdmlah' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqrdmlah,_s32,,)(svundef_s32(), svundef_s32(), svundef_s32()); - // expected-error@+2 {{'svqrdmlah_n_s32' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqrdmlah' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqrdmlah_n_s32' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqrdmlah' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqrdmlah,_n_s32,,)(svundef_s32(), svundef_s32(), i32); - // expected-error@+2 {{'svqdmullb_s32' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqdmullb' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqdmullb_s32' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqdmullb' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqdmullb,_s32,,)(svundef_s16(), svundef_s16()); - // expected-error@+2 {{'svqdmullb_n_s32' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqdmullb' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqdmullb_n_s32' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqdmullb' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqdmullb,_n_s32,,)(svundef_s16(), i16); - // expected-error@+2 {{'svqdmullb_lane_s32' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqdmullb_lane' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqdmullb_lane_s32' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqdmullb_lane' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqdmullb_lane,_s32,,)(svundef_s16(), svundef_s16(), 1); // expected-error@+2 {{'svstnt1h_scatter_u32base_s32' needs target feature sve,sve2}} // overload-error@+1 {{'svstnt1h_scatter' needs target feature sve,sve2}} @@ -1668,243 +1668,243 @@ void test(svbool_t pg, const int8_t *const_i8_ptr, const uint8_t *const_u8_ptr, // expected-error@+2 {{'svstnt1b_scatter_u32base_offset_s32' needs target feature sve,sve2}} // overload-error@+1 {{'svstnt1b_scatter_offset' needs target feature sve,sve2}} SVE_ACLE_FUNC(svstnt1b_scatter, _u32base, _offset, _s32)(pg, svundef_u32(), i64, svundef_s32()); - // expected-error@+2 {{'svbsl2n_s32' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svbsl2n' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svbsl2n_s32' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svbsl2n' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svbsl2n,_s32,,)(svundef_s32(), svundef_s32(), svundef_s32()); - // expected-error@+2 {{'svbsl2n_n_s32' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svbsl2n' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svbsl2n_n_s32' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svbsl2n' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svbsl2n,_n_s32,,)(svundef_s32(), svundef_s32(), i32); - // expected-error@+2 {{'svaddlt_s32' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svaddlt' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svaddlt_s32' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svaddlt' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svaddlt,_s32,,)(svundef_s16(), svundef_s16()); - // expected-error@+2 {{'svaddlt_n_s32' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svaddlt' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svaddlt_n_s32' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svaddlt' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svaddlt,_n_s32,,)(svundef_s16(), i16); - // expected-error@+2 {{'svqxtunt_s32' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqxtunt' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqxtunt_s32' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqxtunt' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqxtunt,_s32,,)(svundef_u16(), svundef_s32()); - // expected-error@+2 {{'svabalb_s32' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svabalb' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svabalb_s32' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svabalb' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svabalb,_s32,,)(svundef_s32(), svundef_s16(), svundef_s16()); - // expected-error@+2 {{'svabalb_n_s32' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svabalb' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svabalb_n_s32' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svabalb' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svabalb,_n_s32,,)(svundef_s32(), svundef_s16(), i16); - // expected-error@+2 {{'svsublb_s32' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svsublb' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svsublb_s32' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svsublb' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svsublb,_s32,,)(svundef_s16(), svundef_s16()); - // expected-error@+2 {{'svsublb_n_s32' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svsublb' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svsublb_n_s32' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svsublb' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svsublb,_n_s32,,)(svundef_s16(), i16); - // expected-error@+2 {{'svbsl1n_s32' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svbsl1n' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svbsl1n_s32' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svbsl1n' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svbsl1n,_s32,,)(svundef_s32(), svundef_s32(), svundef_s32()); - // expected-error@+2 {{'svbsl1n_n_s32' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svbsl1n' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svbsl1n_n_s32' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svbsl1n' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svbsl1n,_n_s32,,)(svundef_s32(), svundef_s32(), i32); - // expected-error@+2 {{'svrshl_s32_z' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svrshl_z' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svrshl_s32_z' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svrshl_z' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svrshl,_s32,_z,)(pg, svundef_s32(), svundef_s32()); - // expected-error@+2 {{'svrshl_s32_m' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svrshl_m' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svrshl_s32_m' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svrshl_m' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svrshl,_s32,_m,)(pg, svundef_s32(), svundef_s32()); - // expected-error@+2 {{'svrshl_s32_x' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svrshl_x' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svrshl_s32_x' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svrshl_x' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svrshl,_s32,_x,)(pg, svundef_s32(), svundef_s32()); - // expected-error@+2 {{'svrshl_n_s32_z' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svrshl_z' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svrshl_n_s32_z' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svrshl_z' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svrshl,_n_s32,_z,)(pg, svundef_s32(), i32); - // expected-error@+2 {{'svrshl_n_s32_m' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svrshl_m' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svrshl_n_s32_m' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svrshl_m' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svrshl,_n_s32,_m,)(pg, svundef_s32(), i32); - // expected-error@+2 {{'svrshl_n_s32_x' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svrshl_x' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svrshl_n_s32_x' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svrshl_x' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svrshl,_n_s32,_x,)(pg, svundef_s32(), i32); - // expected-error@+2 {{'svaddwt_s32' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svaddwt' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svaddwt_s32' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svaddwt' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svaddwt,_s32,,)(svundef_s32(), svundef_s16()); - // expected-error@+2 {{'svaddwt_n_s32' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svaddwt' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svaddwt_n_s32' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svaddwt' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svaddwt,_n_s32,,)(svundef_s32(), i16); - // expected-error@+2 {{'svmlslb_s32' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svmlslb' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svmlslb_s32' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svmlslb' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svmlslb,_s32,,)(svundef_s32(), svundef_s16(), svundef_s16()); - // expected-error@+2 {{'svmlslb_n_s32' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svmlslb' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svmlslb_n_s32' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svmlslb' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svmlslb,_n_s32,,)(svundef_s32(), svundef_s16(), i16); - // expected-error@+2 {{'svmlslb_lane_s32' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svmlslb_lane' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svmlslb_lane_s32' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svmlslb_lane' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svmlslb_lane,_s32,,)(svundef_s32(), svundef_s16(), svundef_s16(), 1); - // expected-error@+2 {{'svmlslt_s32' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svmlslt' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svmlslt_s32' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svmlslt' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svmlslt,_s32,,)(svundef_s32(), svundef_s16(), svundef_s16()); - // expected-error@+2 {{'svmlslt_n_s32' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svmlslt' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svmlslt_n_s32' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svmlslt' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svmlslt,_n_s32,,)(svundef_s32(), svundef_s16(), i16); - // expected-error@+2 {{'svmlslt_lane_s32' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svmlslt_lane' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svmlslt_lane_s32' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svmlslt_lane' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svmlslt_lane,_s32,,)(svundef_s32(), svundef_s16(), svundef_s16(), 1); - // expected-error@+2 {{'svqneg_s32_z' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqneg_z' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqneg_s32_z' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqneg_z' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqneg,_s32,_z,)(pg, svundef_s32()); - // expected-error@+2 {{'svqneg_s32_m' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqneg_m' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqneg_s32_m' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqneg_m' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqneg,_s32,_m,)(svundef_s32(), pg, svundef_s32()); - // expected-error@+2 {{'svqneg_s32_x' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqneg_x' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqneg_s32_x' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqneg_x' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqneg,_s32,_x,)(pg, svundef_s32()); - // expected-error@+2 {{'svmovlt_s32' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svmovlt' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svmovlt_s32' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svmovlt' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svmovlt,_s32,,)(svundef_s16()); - // expected-error@+2 {{'svqshl_s32_z' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqshl_z' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqshl_s32_z' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqshl_z' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqshl,_s32,_z,)(pg, svundef_s32(), svundef_s32()); - // expected-error@+2 {{'svqshl_s32_m' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqshl_m' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqshl_s32_m' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqshl_m' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqshl,_s32,_m,)(pg, svundef_s32(), svundef_s32()); - // expected-error@+2 {{'svqshl_s32_x' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqshl_x' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqshl_s32_x' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqshl_x' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqshl,_s32,_x,)(pg, svundef_s32(), svundef_s32()); - // expected-error@+2 {{'svqshl_n_s32_z' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqshl_z' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqshl_n_s32_z' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqshl_z' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqshl,_n_s32,_z,)(pg, svundef_s32(), i32); - // expected-error@+2 {{'svqshl_n_s32_m' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqshl_m' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqshl_n_s32_m' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqshl_m' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqshl,_n_s32,_m,)(pg, svundef_s32(), i32); - // expected-error@+2 {{'svqshl_n_s32_x' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqshl_x' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqshl_n_s32_x' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqshl_x' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqshl,_n_s32,_x,)(pg, svundef_s32(), i32); - // expected-error@+2 {{'svmullb_s64' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svmullb' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svmullb_s64' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svmullb' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svmullb,_s64,,)(svundef_s32(), svundef_s32()); - // expected-error@+2 {{'svmullb_n_s64' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svmullb' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svmullb_n_s64' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svmullb' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svmullb,_n_s64,,)(svundef_s32(), i32); - // expected-error@+2 {{'svqdmlalbt_s64' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqdmlalbt' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqdmlalbt_s64' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqdmlalbt' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqdmlalbt,_s64,,)(svundef_s64(), svundef_s32(), svundef_s32()); - // expected-error@+2 {{'svqdmlalbt_n_s64' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqdmlalbt' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqdmlalbt_n_s64' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqdmlalbt' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqdmlalbt,_n_s64,,)(svundef_s64(), svundef_s32(), i32); - // expected-error@+2 {{'svqrdmulh_s64' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqrdmulh' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqrdmulh_s64' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqrdmulh' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqrdmulh,_s64,,)(svundef_s64(), svundef_s64()); - // expected-error@+2 {{'svqrdmulh_n_s64' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqrdmulh' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqrdmulh_n_s64' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqrdmulh' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqrdmulh,_n_s64,,)(svundef_s64(), i64); - // expected-error@+2 {{'svaddwb_s64' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svaddwb' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svaddwb_s64' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svaddwb' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svaddwb,_s64,,)(svundef_s64(), svundef_s32()); - // expected-error@+2 {{'svaddwb_n_s64' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svaddwb' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svaddwb_n_s64' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svaddwb' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svaddwb,_n_s64,,)(svundef_s64(), i32); - // expected-error@+2 {{'svsubhnb_s64' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svsubhnb' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svsubhnb_s64' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svsubhnb' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svsubhnb,_s64,,)(svundef_s64(), svundef_s64()); - // expected-error@+2 {{'svsubhnb_n_s64' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svsubhnb' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svsubhnb_n_s64' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svsubhnb' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svsubhnb,_n_s64,,)(svundef_s64(), i64); - // expected-error@+2 {{'svqdmulh_s64' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqdmulh' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqdmulh_s64' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqdmulh' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqdmulh,_s64,,)(svundef_s64(), svundef_s64()); - // expected-error@+2 {{'svqdmulh_n_s64' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqdmulh' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqdmulh_n_s64' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqdmulh' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqdmulh,_n_s64,,)(svundef_s64(), i64); - // expected-error@+2 {{'svrsubhnt_s64' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svrsubhnt' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svrsubhnt_s64' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svrsubhnt' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svrsubhnt,_s64,,)(svundef_s32(), svundef_s64(), svundef_s64()); - // expected-error@+2 {{'svrsubhnt_n_s64' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svrsubhnt' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svrsubhnt_n_s64' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svrsubhnt' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svrsubhnt,_n_s64,,)(svundef_s32(), svundef_s64(), i64); - // expected-error@+2 {{'svnbsl_s64' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svnbsl' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svnbsl_s64' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svnbsl' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svnbsl,_s64,,)(svundef_s64(), svundef_s64(), svundef_s64()); - // expected-error@+2 {{'svnbsl_n_s64' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svnbsl' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svnbsl_n_s64' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svnbsl' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svnbsl,_n_s64,,)(svundef_s64(), svundef_s64(), i64); - // expected-error@+2 {{'svqdmlslb_s64' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqdmlslb' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqdmlslb_s64' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqdmlslb' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqdmlslb,_s64,,)(svundef_s64(), svundef_s32(), svundef_s32()); - // expected-error@+2 {{'svqdmlslb_n_s64' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqdmlslb' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqdmlslb_n_s64' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqdmlslb' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqdmlslb,_n_s64,,)(svundef_s64(), svundef_s32(), i32); - // expected-error@+2 {{'svsubhnt_s64' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svsubhnt' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svsubhnt_s64' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svsubhnt' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svsubhnt,_s64,,)(svundef_s32(), svundef_s64(), svundef_s64()); - // expected-error@+2 {{'svsubhnt_n_s64' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svsubhnt' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svsubhnt_n_s64' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svsubhnt' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svsubhnt,_n_s64,,)(svundef_s32(), svundef_s64(), i64); - // expected-error@+2 {{'svqabs_s64_z' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqabs_z' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqabs_s64_z' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqabs_z' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqabs,_s64,_z,)(pg, svundef_s64()); - // expected-error@+2 {{'svqabs_s64_m' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqabs_m' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqabs_s64_m' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqabs_m' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqabs,_s64,_m,)(svundef_s64(), pg, svundef_s64()); - // expected-error@+2 {{'svqabs_s64_x' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqabs_x' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqabs_s64_x' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqabs_x' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqabs,_s64,_x,)(pg, svundef_s64()); - // expected-error@+2 {{'svwhilegt_b8_s64' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svwhilegt_b8' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svwhilegt_b8_s64' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svwhilegt_b8' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svwhilegt_b8,_s64,,)(i64, i64); - // expected-error@+2 {{'svwhilegt_b16_s64' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svwhilegt_b16' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svwhilegt_b16_s64' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svwhilegt_b16' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svwhilegt_b16,_s64,,)(i64, i64); - // expected-error@+2 {{'svwhilegt_b32_s64' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svwhilegt_b32' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svwhilegt_b32_s64' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svwhilegt_b32' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svwhilegt_b32,_s64,,)(i64, i64); - // expected-error@+2 {{'svwhilegt_b64_s64' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svwhilegt_b64' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svwhilegt_b64_s64' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svwhilegt_b64' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svwhilegt_b64,_s64,,)(i64, i64); - // expected-error@+2 {{'svaddlbt_s64' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svaddlbt' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svaddlbt_s64' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svaddlbt' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svaddlbt,_s64,,)(svundef_s32(), svundef_s32()); - // expected-error@+2 {{'svaddlbt_n_s64' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svaddlbt' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svaddlbt_n_s64' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svaddlbt' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svaddlbt,_n_s64,,)(svundef_s32(), i32); - // expected-error@+2 {{'svtbl2_s64' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svtbl2' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svtbl2_s64' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svtbl2' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svtbl2,_s64,,)(svundef2_s64(), svundef_u64()); - // expected-error@+2 {{'svhsubr_s64_z' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svhsubr_z' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svhsubr_s64_z' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svhsubr_z' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svhsubr,_s64,_z,)(pg, svundef_s64(), svundef_s64()); - // expected-error@+2 {{'svhsubr_s64_m' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svhsubr_m' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svhsubr_s64_m' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svhsubr_m' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svhsubr,_s64,_m,)(pg, svundef_s64(), svundef_s64()); - // expected-error@+2 {{'svhsubr_s64_x' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svhsubr_x' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svhsubr_s64_x' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svhsubr_x' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svhsubr,_s64,_x,)(pg, svundef_s64(), svundef_s64()); - // expected-error@+2 {{'svhsubr_n_s64_z' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svhsubr_z' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svhsubr_n_s64_z' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svhsubr_z' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svhsubr,_n_s64,_z,)(pg, svundef_s64(), i64); - // expected-error@+2 {{'svhsubr_n_s64_m' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svhsubr_m' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svhsubr_n_s64_m' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svhsubr_m' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svhsubr,_n_s64,_m,)(pg, svundef_s64(), i64); - // expected-error@+2 {{'svhsubr_n_s64_x' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svhsubr_x' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svhsubr_n_s64_x' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svhsubr_x' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svhsubr,_n_s64,_x,)(pg, svundef_s64(), i64); // expected-error@+2 {{'svhistcnt_s64_z' needs target feature sve,sve2}} // overload-error@+1 {{'svhistcnt_z' needs target feature sve,sve2}} SVE_ACLE_FUNC(svhistcnt,_s64,_z,)(pg, svundef_s64(), svundef_s64()); - // expected-error@+2 {{'sveortb_s64' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'sveortb' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'sveortb_s64' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'sveortb' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(sveortb,_s64,,)(svundef_s64(), svundef_s64(), svundef_s64()); - // expected-error@+2 {{'sveortb_n_s64' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'sveortb' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'sveortb_n_s64' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'sveortb' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(sveortb,_n_s64,,)(svundef_s64(), svundef_s64(), i64); - // expected-error@+2 {{'svqxtnb_s64' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqxtnb' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqxtnb_s64' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqxtnb' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqxtnb,_s64,,)(svundef_s64()); - // expected-error@+2 {{'svmlalt_s64' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svmlalt' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svmlalt_s64' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svmlalt' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svmlalt,_s64,,)(svundef_s64(), svundef_s32(), svundef_s32()); - // expected-error@+2 {{'svmlalt_n_s64' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svmlalt' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svmlalt_n_s64' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svmlalt' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svmlalt,_n_s64,,)(svundef_s64(), svundef_s32(), i32); - // expected-error@+2 {{'svaddhnt_s64' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svaddhnt' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svaddhnt_s64' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svaddhnt' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svaddhnt,_s64,,)(svundef_s32(), svundef_s64(), svundef_s64()); - // expected-error@+2 {{'svaddhnt_n_s64' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svaddhnt' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svaddhnt_n_s64' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svaddhnt' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svaddhnt,_n_s64,,)(svundef_s32(), svundef_s64(), i64); // expected-error@+2 {{'svldnt1uh_gather_u64base_s64' needs target feature sve,sve2}} // overload-error@+1 {{'svldnt1uh_gather_s64' needs target feature sve,sve2}} @@ -1927,221 +1927,221 @@ void test(svbool_t pg, const int8_t *const_i8_ptr, const uint8_t *const_u8_ptr, // expected-error@+2 {{'svldnt1uh_gather_u64base_index_s64' needs target feature sve,sve2}} // overload-error@+1 {{'svldnt1uh_gather_index_s64' needs target feature sve,sve2}} SVE_ACLE_FUNC(svldnt1uh_gather, _u64base, _index_s64, )(pg, svundef_u64(), i64); - // expected-error@+2 {{'svqdmlalt_s64' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqdmlalt' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqdmlalt_s64' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqdmlalt' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqdmlalt,_s64,,)(svundef_s64(), svundef_s32(), svundef_s32()); - // expected-error@+2 {{'svqdmlalt_n_s64' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqdmlalt' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqdmlalt_n_s64' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqdmlalt' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqdmlalt,_n_s64,,)(svundef_s64(), svundef_s32(), i32); - // expected-error@+2 {{'svbcax_s64' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svbcax' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svbcax_s64' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svbcax' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svbcax,_s64,,)(svundef_s64(), svundef_s64(), svundef_s64()); - // expected-error@+2 {{'svbcax_n_s64' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svbcax' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svbcax_n_s64' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svbcax' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svbcax,_n_s64,,)(svundef_s64(), svundef_s64(), i64); - // expected-error@+2 {{'svqxtnt_s64' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqxtnt' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqxtnt_s64' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqxtnt' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqxtnt,_s64,,)(svundef_s32(), svundef_s64()); - // expected-error@+2 {{'svqdmlalb_s64' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqdmlalb' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqdmlalb_s64' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqdmlalb' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqdmlalb,_s64,,)(svundef_s64(), svundef_s32(), svundef_s32()); - // expected-error@+2 {{'svqdmlalb_n_s64' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqdmlalb' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqdmlalb_n_s64' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqdmlalb' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqdmlalb,_n_s64,,)(svundef_s64(), svundef_s32(), i32); - // expected-error@+2 {{'svqrshl_s64_z' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqrshl_z' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqrshl_s64_z' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqrshl_z' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqrshl,_s64,_z,)(pg, svundef_s64(), svundef_s64()); - // expected-error@+2 {{'svqrshl_s64_m' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqrshl_m' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqrshl_s64_m' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqrshl_m' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqrshl,_s64,_m,)(pg, svundef_s64(), svundef_s64()); - // expected-error@+2 {{'svqrshl_s64_x' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqrshl_x' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqrshl_s64_x' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqrshl_x' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqrshl,_s64,_x,)(pg, svundef_s64(), svundef_s64()); - // expected-error@+2 {{'svqrshl_n_s64_z' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqrshl_z' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqrshl_n_s64_z' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqrshl_z' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqrshl,_n_s64,_z,)(pg, svundef_s64(), i64); - // expected-error@+2 {{'svqrshl_n_s64_m' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqrshl_m' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqrshl_n_s64_m' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqrshl_m' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqrshl,_n_s64,_m,)(pg, svundef_s64(), i64); - // expected-error@+2 {{'svqrshl_n_s64_x' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqrshl_x' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqrshl_n_s64_x' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqrshl_x' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqrshl,_n_s64,_x,)(pg, svundef_s64(), i64); - // expected-error@+2 {{'svsublbt_s64' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svsublbt' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svsublbt_s64' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svsublbt' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svsublbt,_s64,,)(svundef_s32(), svundef_s32()); - // expected-error@+2 {{'svsublbt_n_s64' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svsublbt' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svsublbt_n_s64' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svsublbt' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svsublbt,_n_s64,,)(svundef_s32(), i32); - // expected-error@+2 {{'svqdmullt_s64' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqdmullt' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqdmullt_s64' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqdmullt' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqdmullt,_s64,,)(svundef_s32(), svundef_s32()); - // expected-error@+2 {{'svqdmullt_n_s64' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqdmullt' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqdmullt_n_s64' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqdmullt' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqdmullt,_n_s64,,)(svundef_s32(), i32); - // expected-error@+2 {{'svsublt_s64' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svsublt' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svsublt_s64' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svsublt' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svsublt,_s64,,)(svundef_s32(), svundef_s32()); - // expected-error@+2 {{'svsublt_n_s64' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svsublt' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svsublt_n_s64' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svsublt' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svsublt,_n_s64,,)(svundef_s32(), i32); - // expected-error@+2 {{'svqdmlslbt_s64' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqdmlslbt' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqdmlslbt_s64' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqdmlslbt' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqdmlslbt,_s64,,)(svundef_s64(), svundef_s32(), svundef_s32()); - // expected-error@+2 {{'svqdmlslbt_n_s64' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqdmlslbt' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqdmlslbt_n_s64' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqdmlslbt' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqdmlslbt,_n_s64,,)(svundef_s64(), svundef_s32(), i32); - // expected-error@+2 {{'svadalp_s64_z' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svadalp_z' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svadalp_s64_z' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svadalp_z' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svadalp,_s64,_z,)(pg, svundef_s64(), svundef_s32()); - // expected-error@+2 {{'svadalp_s64_m' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svadalp_m' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svadalp_s64_m' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svadalp_m' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svadalp,_s64,_m,)(pg, svundef_s64(), svundef_s32()); - // expected-error@+2 {{'svadalp_s64_x' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svadalp_x' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svadalp_s64_x' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svadalp_x' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svadalp,_s64,_x,)(pg, svundef_s64(), svundef_s32()); - // expected-error@+2 {{'svwhilege_b8_s64' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svwhilege_b8' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svwhilege_b8_s64' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svwhilege_b8' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svwhilege_b8,_s64,,)(i64, i64); - // expected-error@+2 {{'svwhilege_b16_s64' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svwhilege_b16' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svwhilege_b16_s64' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svwhilege_b16' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svwhilege_b16,_s64,,)(i64, i64); - // expected-error@+2 {{'svwhilege_b32_s64' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svwhilege_b32' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svwhilege_b32_s64' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svwhilege_b32' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svwhilege_b32,_s64,,)(i64, i64); - // expected-error@+2 {{'svwhilege_b64_s64' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svwhilege_b64' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svwhilege_b64_s64' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svwhilege_b64' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svwhilege_b64,_s64,,)(i64, i64); - // expected-error@+2 {{'svsubwt_s64' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svsubwt' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svsubwt_s64' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svsubwt' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svsubwt,_s64,,)(svundef_s64(), svundef_s32()); - // expected-error@+2 {{'svsubwt_n_s64' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svsubwt' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svsubwt_n_s64' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svsubwt' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svsubwt,_n_s64,,)(svundef_s64(), i32); - // expected-error@+2 {{'svqsubr_s64_z' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqsubr_z' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqsubr_s64_z' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqsubr_z' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqsubr,_s64,_z,)(pg, svundef_s64(), svundef_s64()); - // expected-error@+2 {{'svqsubr_s64_m' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqsubr_m' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqsubr_s64_m' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqsubr_m' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqsubr,_s64,_m,)(pg, svundef_s64(), svundef_s64()); - // expected-error@+2 {{'svqsubr_s64_x' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqsubr_x' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqsubr_s64_x' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqsubr_x' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqsubr,_s64,_x,)(pg, svundef_s64(), svundef_s64()); - // expected-error@+2 {{'svqsubr_n_s64_z' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqsubr_z' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqsubr_n_s64_z' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqsubr_z' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqsubr,_n_s64,_z,)(pg, svundef_s64(), i64); - // expected-error@+2 {{'svqsubr_n_s64_m' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqsubr_m' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqsubr_n_s64_m' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqsubr_m' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqsubr,_n_s64,_m,)(pg, svundef_s64(), i64); - // expected-error@+2 {{'svqsubr_n_s64_x' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqsubr_x' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqsubr_n_s64_x' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqsubr_x' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqsubr,_n_s64,_x,)(pg, svundef_s64(), i64); - // expected-error@+2 {{'svaddp_s64_m' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svaddp_m' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svaddp_s64_m' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svaddp_m' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svaddp,_s64,_m,)(pg, svundef_s64(), svundef_s64()); - // expected-error@+2 {{'svaddp_s64_x' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svaddp_x' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svaddp_s64_x' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svaddp_x' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svaddp,_s64,_x,)(pg, svundef_s64(), svundef_s64()); - // expected-error@+2 {{'svqadd_s64_m' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqadd_m' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqadd_s64_m' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqadd_m' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqadd,_s64,_m,)(pg, svundef_s64(), svundef_s64()); - // expected-error@+2 {{'svqadd_n_s64_m' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqadd_m' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqadd_n_s64_m' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqadd_m' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqadd,_n_s64,_m,)(pg, svundef_s64(), i64); - // expected-error@+2 {{'svqadd_s64_z' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqadd_z' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqadd_s64_z' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqadd_z' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqadd,_s64,_z,)(pg, svundef_s64(), svundef_s64()); - // expected-error@+2 {{'svqadd_n_s64_z' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqadd_z' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqadd_n_s64_z' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqadd_z' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqadd,_n_s64,_z,)(pg, svundef_s64(), i64); - // expected-error@+2 {{'svqadd_s64_x' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqadd_x' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqadd_s64_x' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqadd_x' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqadd,_s64,_x,)(pg, svundef_s64(), svundef_s64()); - // expected-error@+2 {{'svqadd_n_s64_x' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqadd_x' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqadd_n_s64_x' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqadd_x' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqadd,_n_s64,_x,)(pg, svundef_s64(), i64); - // expected-error@+2 {{'svabdlb_s64' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svabdlb' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svabdlb_s64' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svabdlb' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svabdlb,_s64,,)(svundef_s32(), svundef_s32()); - // expected-error@+2 {{'svabdlb_n_s64' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svabdlb' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svabdlb_n_s64' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svabdlb' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svabdlb,_n_s64,,)(svundef_s32(), i32); - // expected-error@+2 {{'svtbx_s64' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svtbx' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svtbx_s64' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svtbx' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svtbx,_s64,,)(svundef_s64(), svundef_s64(), svundef_u64()); - // expected-error@+2 {{'svabdlt_s64' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svabdlt' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svabdlt_s64' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svabdlt' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svabdlt,_s64,,)(svundef_s32(), svundef_s32()); - // expected-error@+2 {{'svabdlt_n_s64' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svabdlt' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svabdlt_n_s64' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svabdlt' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svabdlt,_n_s64,,)(svundef_s32(), i32); - // expected-error@+2 {{'svminp_s64_m' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svminp_m' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svminp_s64_m' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svminp_m' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svminp,_s64,_m,)(pg, svundef_s64(), svundef_s64()); - // expected-error@+2 {{'svminp_s64_x' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svminp_x' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svminp_s64_x' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svminp_x' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svminp,_s64,_x,)(pg, svundef_s64(), svundef_s64()); - // expected-error@+2 {{'svqsub_s64_z' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqsub_z' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqsub_s64_z' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqsub_z' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqsub,_s64,_z,)(pg, svundef_s64(), svundef_s64()); - // expected-error@+2 {{'svqsub_s64_m' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqsub_m' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqsub_s64_m' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqsub_m' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqsub,_s64,_m,)(pg, svundef_s64(), svundef_s64()); - // expected-error@+2 {{'svqsub_s64_x' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqsub_x' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqsub_s64_x' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqsub_x' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqsub,_s64,_x,)(pg, svundef_s64(), svundef_s64()); - // expected-error@+2 {{'svqsub_n_s64_z' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqsub_z' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqsub_n_s64_z' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqsub_z' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqsub,_n_s64,_z,)(pg, svundef_s64(), i64); - // expected-error@+2 {{'svqsub_n_s64_m' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqsub_m' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqsub_n_s64_m' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqsub_m' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqsub,_n_s64,_m,)(pg, svundef_s64(), i64); - // expected-error@+2 {{'svqsub_n_s64_x' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqsub_x' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqsub_n_s64_x' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqsub_x' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqsub,_n_s64,_x,)(pg, svundef_s64(), i64); - // expected-error@+2 {{'svrsubhnb_s64' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svrsubhnb' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svrsubhnb_s64' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svrsubhnb' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svrsubhnb,_s64,,)(svundef_s64(), svundef_s64()); - // expected-error@+2 {{'svrsubhnb_n_s64' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svrsubhnb' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svrsubhnb_n_s64' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svrsubhnb' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svrsubhnb,_n_s64,,)(svundef_s64(), i64); - // expected-error@+2 {{'svaddhnb_s64' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svaddhnb' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svaddhnb_s64' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svaddhnb' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svaddhnb,_s64,,)(svundef_s64(), svundef_s64()); - // expected-error@+2 {{'svaddhnb_n_s64' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svaddhnb' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svaddhnb_n_s64' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svaddhnb' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svaddhnb,_n_s64,,)(svundef_s64(), i64); - // expected-error@+2 {{'svabalt_s64' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svabalt' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svabalt_s64' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svabalt' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svabalt,_s64,,)(svundef_s64(), svundef_s32(), svundef_s32()); - // expected-error@+2 {{'svabalt_n_s64' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svabalt' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svabalt_n_s64' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svabalt' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svabalt,_n_s64,,)(svundef_s64(), svundef_s32(), i32); - // expected-error@+2 {{'sveor3_s64' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'sveor3' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'sveor3_s64' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'sveor3' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(sveor3,_s64,,)(svundef_s64(), svundef_s64(), svundef_s64()); - // expected-error@+2 {{'sveor3_n_s64' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'sveor3' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'sveor3_n_s64' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'sveor3' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(sveor3,_n_s64,,)(svundef_s64(), svundef_s64(), i64); - // expected-error@+2 {{'svhadd_s64_m' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svhadd_m' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svhadd_s64_m' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svhadd_m' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svhadd,_s64,_m,)(pg, svundef_s64(), svundef_s64()); - // expected-error@+2 {{'svhadd_n_s64_m' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svhadd_m' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svhadd_n_s64_m' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svhadd_m' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svhadd,_n_s64,_m,)(pg, svundef_s64(), i64); - // expected-error@+2 {{'svhadd_s64_z' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svhadd_z' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svhadd_s64_z' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svhadd_z' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svhadd,_s64,_z,)(pg, svundef_s64(), svundef_s64()); - // expected-error@+2 {{'svhadd_n_s64_z' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svhadd_z' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svhadd_n_s64_z' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svhadd_z' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svhadd,_n_s64,_z,)(pg, svundef_s64(), i64); - // expected-error@+2 {{'svhadd_s64_x' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svhadd_x' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svhadd_s64_x' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svhadd_x' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svhadd,_s64,_x,)(pg, svundef_s64(), svundef_s64()); - // expected-error@+2 {{'svhadd_n_s64_x' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svhadd_x' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svhadd_n_s64_x' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svhadd_x' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svhadd,_n_s64,_x,)(pg, svundef_s64(), i64); - // expected-error@+2 {{'svmovlb_s64' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svmovlb' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svmovlb_s64' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svmovlb' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svmovlb,_s64,,)(svundef_s32()); // expected-error@+2 {{'svstnt1_scatter_u64base_s64' needs target feature sve,sve2}} // overload-error@+1 {{'svstnt1_scatter' needs target feature sve,sve2}} @@ -2164,29 +2164,29 @@ void test(svbool_t pg, const int8_t *const_i8_ptr, const uint8_t *const_u8_ptr, // expected-error@+2 {{'svstnt1_scatter_u64base_index_s64' needs target feature sve,sve2}} // overload-error@+1 {{'svstnt1_scatter_index' needs target feature sve,sve2}} SVE_ACLE_FUNC(svstnt1_scatter, _u64base, _index, _s64)(pg, svundef_u64(), i64, svundef_s64()); - // expected-error@+2 {{'svqrdmlsh_s64' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqrdmlsh' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqrdmlsh_s64' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqrdmlsh' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqrdmlsh,_s64,,)(svundef_s64(), svundef_s64(), svundef_s64()); - // expected-error@+2 {{'svqrdmlsh_n_s64' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqrdmlsh' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqrdmlsh_n_s64' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqrdmlsh' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqrdmlsh,_n_s64,,)(svundef_s64(), svundef_s64(), i64); - // expected-error@+2 {{'svqdmlslt_s64' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqdmlslt' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqdmlslt_s64' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqdmlslt' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqdmlslt,_s64,,)(svundef_s64(), svundef_s32(), svundef_s32()); - // expected-error@+2 {{'svqdmlslt_n_s64' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqdmlslt' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqdmlslt_n_s64' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqdmlslt' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqdmlslt,_n_s64,,)(svundef_s64(), svundef_s32(), i32); - // expected-error@+2 {{'svmaxp_s64_m' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svmaxp_m' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svmaxp_s64_m' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svmaxp_m' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svmaxp,_s64,_m,)(pg, svundef_s64(), svundef_s64()); - // expected-error@+2 {{'svmaxp_s64_x' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svmaxp_x' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svmaxp_s64_x' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svmaxp_x' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svmaxp,_s64,_x,)(pg, svundef_s64(), svundef_s64()); - // expected-error@+2 {{'svmullt_s64' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svmullt' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svmullt_s64' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svmullt' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svmullt,_s64,,)(svundef_s32(), svundef_s32()); - // expected-error@+2 {{'svmullt_n_s64' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svmullt' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svmullt_n_s64' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svmullt' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svmullt,_n_s64,,)(svundef_s32(), i32); // expected-error@+2 {{'svldnt1sh_gather_u64base_s64' needs target feature sve,sve2}} // overload-error@+1 {{'svldnt1sh_gather_s64' needs target feature sve,sve2}} @@ -2209,44 +2209,44 @@ void test(svbool_t pg, const int8_t *const_i8_ptr, const uint8_t *const_u8_ptr, // expected-error@+2 {{'svldnt1sh_gather_u64base_index_s64' needs target feature sve,sve2}} // overload-error@+1 {{'svldnt1sh_gather_index_s64' needs target feature sve,sve2}} SVE_ACLE_FUNC(svldnt1sh_gather, _u64base, _index_s64, )(pg, svundef_u64(), i64); - // expected-error@+2 {{'svqxtunb_s64' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqxtunb' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqxtunb_s64' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqxtunb' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqxtunb,_s64,,)(svundef_s64()); - // expected-error@+2 {{'svwhilerw_s64' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svwhilerw' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svwhilerw_s64' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svwhilerw' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svwhilerw,_s64,,)(const_i64_ptr, const_i64_ptr); - // expected-error@+2 {{'svrhadd_s64_m' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svrhadd_m' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svrhadd_s64_m' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svrhadd_m' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svrhadd,_s64,_m,)(pg, svundef_s64(), svundef_s64()); - // expected-error@+2 {{'svrhadd_n_s64_m' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svrhadd_m' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svrhadd_n_s64_m' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svrhadd_m' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svrhadd,_n_s64,_m,)(pg, svundef_s64(), i64); - // expected-error@+2 {{'svrhadd_s64_z' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svrhadd_z' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svrhadd_s64_z' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svrhadd_z' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svrhadd,_s64,_z,)(pg, svundef_s64(), svundef_s64()); - // expected-error@+2 {{'svrhadd_n_s64_z' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svrhadd_z' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svrhadd_n_s64_z' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svrhadd_z' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svrhadd,_n_s64,_z,)(pg, svundef_s64(), i64); - // expected-error@+2 {{'svrhadd_s64_x' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svrhadd_x' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svrhadd_s64_x' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svrhadd_x' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svrhadd,_s64,_x,)(pg, svundef_s64(), svundef_s64()); - // expected-error@+2 {{'svrhadd_n_s64_x' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svrhadd_x' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svrhadd_n_s64_x' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svrhadd_x' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svrhadd,_n_s64,_x,)(pg, svundef_s64(), i64); - // expected-error@+2 {{'svraddhnb_s64' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svraddhnb' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svraddhnb_s64' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svraddhnb' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svraddhnb,_s64,,)(svundef_s64(), svundef_s64()); - // expected-error@+2 {{'svraddhnb_n_s64' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svraddhnb' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svraddhnb_n_s64' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svraddhnb' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svraddhnb,_n_s64,,)(svundef_s64(), i64); - // expected-error@+2 {{'svwhilewr_s64' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svwhilewr' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svwhilewr_s64' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svwhilewr' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svwhilewr,_s64,,)(const_i64_ptr, const_i64_ptr); - // expected-error@+2 {{'svmlalb_s64' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svmlalb' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svmlalb_s64' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svmlalb' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svmlalb,_s64,,)(svundef_s64(), svundef_s32(), svundef_s32()); - // expected-error@+2 {{'svmlalb_n_s64' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svmlalb' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svmlalb_n_s64' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svmlalb' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svmlalb,_n_s64,,)(svundef_s64(), svundef_s32(), i32); // expected-error@+2 {{'svldnt1sb_gather_u64base_s64' needs target feature sve,sve2}} // overload-error@+1 {{'svldnt1sb_gather_s64' needs target feature sve,sve2}} @@ -2260,11 +2260,11 @@ void test(svbool_t pg, const int8_t *const_i8_ptr, const uint8_t *const_u8_ptr, // expected-error@+2 {{'svldnt1sb_gather_u64base_offset_s64' needs target feature sve,sve2}} // overload-error@+1 {{'svldnt1sb_gather_offset_s64' needs target feature sve,sve2}} SVE_ACLE_FUNC(svldnt1sb_gather, _u64base, _offset_s64, )(pg, svundef_u64(), i64); - // expected-error@+2 {{'svsubwb_s64' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svsubwb' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svsubwb_s64' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svsubwb' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svsubwb,_s64,,)(svundef_s64(), svundef_s32()); - // expected-error@+2 {{'svsubwb_n_s64' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svsubwb' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svsubwb_n_s64' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svsubwb' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svsubwb,_n_s64,,)(svundef_s64(), i32); // expected-error@+2 {{'svldnt1ub_gather_u64base_s64' needs target feature sve,sve2}} // overload-error@+1 {{'svldnt1ub_gather_s64' needs target feature sve,sve2}} @@ -2278,41 +2278,41 @@ void test(svbool_t pg, const int8_t *const_i8_ptr, const uint8_t *const_u8_ptr, // expected-error@+2 {{'svldnt1ub_gather_u64base_offset_s64' needs target feature sve,sve2}} // overload-error@+1 {{'svldnt1ub_gather_offset_s64' needs target feature sve,sve2}} SVE_ACLE_FUNC(svldnt1ub_gather, _u64base, _offset_s64, )(pg, svundef_u64(), i64); - // expected-error@+2 {{'svaba_s64' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svaba' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svaba_s64' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svaba' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svaba,_s64,,)(svundef_s64(), svundef_s64(), svundef_s64()); - // expected-error@+2 {{'svaba_n_s64' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svaba' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svaba_n_s64' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svaba' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svaba,_n_s64,,)(svundef_s64(), svundef_s64(), i64); - // expected-error@+2 {{'svraddhnt_s64' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svraddhnt' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svraddhnt_s64' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svraddhnt' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svraddhnt,_s64,,)(svundef_s32(), svundef_s64(), svundef_s64()); - // expected-error@+2 {{'svraddhnt_n_s64' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svraddhnt' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svraddhnt_n_s64' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svraddhnt' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svraddhnt,_n_s64,,)(svundef_s32(), svundef_s64(), i64); - // expected-error@+2 {{'svuqadd_s64_m' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svuqadd_m' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svuqadd_s64_m' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svuqadd_m' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svuqadd,_s64,_m,)(pg, svundef_s64(), svundef_u64()); - // expected-error@+2 {{'svuqadd_n_s64_m' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svuqadd_m' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svuqadd_n_s64_m' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svuqadd_m' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svuqadd,_n_s64,_m,)(pg, svundef_s64(), u64); - // expected-error@+2 {{'svuqadd_s64_z' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svuqadd_z' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svuqadd_s64_z' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svuqadd_z' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svuqadd,_s64,_z,)(pg, svundef_s64(), svundef_u64()); - // expected-error@+2 {{'svuqadd_n_s64_z' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svuqadd_z' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svuqadd_n_s64_z' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svuqadd_z' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svuqadd,_n_s64,_z,)(pg, svundef_s64(), u64); - // expected-error@+2 {{'svuqadd_s64_x' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svuqadd_x' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svuqadd_s64_x' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svuqadd_x' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svuqadd,_s64,_x,)(pg, svundef_s64(), svundef_u64()); - // expected-error@+2 {{'svuqadd_n_s64_x' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svuqadd_x' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svuqadd_n_s64_x' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svuqadd_x' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svuqadd,_n_s64,_x,)(pg, svundef_s64(), u64); - // expected-error@+2 {{'sveorbt_s64' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'sveorbt' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'sveorbt_s64' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'sveorbt' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(sveorbt,_s64,,)(svundef_s64(), svundef_s64(), svundef_s64()); - // expected-error@+2 {{'sveorbt_n_s64' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'sveorbt' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'sveorbt_n_s64' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'sveorbt' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(sveorbt,_n_s64,,)(svundef_s64(), svundef_s64(), i64); // expected-error@+2 {{'svldnt1sw_gather_u64base_s64' needs target feature sve,sve2}} // overload-error@+1 {{'svldnt1sw_gather_s64' needs target feature sve,sve2}} @@ -2335,35 +2335,35 @@ void test(svbool_t pg, const int8_t *const_i8_ptr, const uint8_t *const_u8_ptr, // expected-error@+2 {{'svldnt1sw_gather_u64base_index_s64' needs target feature sve,sve2}} // overload-error@+1 {{'svldnt1sw_gather_index_s64' needs target feature sve,sve2}} SVE_ACLE_FUNC(svldnt1sw_gather, _u64base, _index_s64, )(pg, svundef_u64(), i64); - // expected-error@+2 {{'svbsl_s64' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svbsl' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svbsl_s64' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svbsl' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svbsl,_s64,,)(svundef_s64(), svundef_s64(), svundef_s64()); - // expected-error@+2 {{'svbsl_n_s64' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svbsl' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svbsl_n_s64' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svbsl' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svbsl,_n_s64,,)(svundef_s64(), svundef_s64(), i64); - // expected-error@+2 {{'svsubltb_s64' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svsubltb' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svsubltb_s64' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svsubltb' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svsubltb,_s64,,)(svundef_s32(), svundef_s32()); - // expected-error@+2 {{'svsubltb_n_s64' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svsubltb' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svsubltb_n_s64' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svsubltb' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svsubltb,_n_s64,,)(svundef_s32(), i32); - // expected-error@+2 {{'svhsub_s64_z' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svhsub_z' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svhsub_s64_z' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svhsub_z' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svhsub,_s64,_z,)(pg, svundef_s64(), svundef_s64()); - // expected-error@+2 {{'svhsub_s64_m' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svhsub_m' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svhsub_s64_m' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svhsub_m' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svhsub,_s64,_m,)(pg, svundef_s64(), svundef_s64()); - // expected-error@+2 {{'svhsub_s64_x' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svhsub_x' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svhsub_s64_x' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svhsub_x' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svhsub,_s64,_x,)(pg, svundef_s64(), svundef_s64()); - // expected-error@+2 {{'svhsub_n_s64_z' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svhsub_z' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svhsub_n_s64_z' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svhsub_z' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svhsub,_n_s64,_z,)(pg, svundef_s64(), i64); - // expected-error@+2 {{'svhsub_n_s64_m' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svhsub_m' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svhsub_n_s64_m' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svhsub_m' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svhsub,_n_s64,_m,)(pg, svundef_s64(), i64); - // expected-error@+2 {{'svhsub_n_s64_x' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svhsub_x' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svhsub_n_s64_x' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svhsub_x' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svhsub,_n_s64,_x,)(pg, svundef_s64(), i64); // expected-error@+2 {{'svldnt1_gather_u64base_s64' needs target feature sve,sve2}} // overload-error@+1 {{'svldnt1_gather_s64' needs target feature sve,sve2}} @@ -2386,23 +2386,23 @@ void test(svbool_t pg, const int8_t *const_i8_ptr, const uint8_t *const_u8_ptr, // expected-error@+2 {{'svldnt1_gather_u64base_index_s64' needs target feature sve,sve2}} // overload-error@+1 {{'svldnt1_gather_index_s64' needs target feature sve,sve2}} SVE_ACLE_FUNC(svldnt1_gather, _u64base, _index_s64, )(pg, svundef_u64(), i64); - // expected-error@+2 {{'svaddlb_s64' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svaddlb' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svaddlb_s64' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svaddlb' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svaddlb,_s64,,)(svundef_s32(), svundef_s32()); - // expected-error@+2 {{'svaddlb_n_s64' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svaddlb' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svaddlb_n_s64' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svaddlb' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svaddlb,_n_s64,,)(svundef_s32(), i32); - // expected-error@+2 {{'svqrdmlah_s64' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqrdmlah' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqrdmlah_s64' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqrdmlah' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqrdmlah,_s64,,)(svundef_s64(), svundef_s64(), svundef_s64()); - // expected-error@+2 {{'svqrdmlah_n_s64' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqrdmlah' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqrdmlah_n_s64' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqrdmlah' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqrdmlah,_n_s64,,)(svundef_s64(), svundef_s64(), i64); - // expected-error@+2 {{'svqdmullb_s64' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqdmullb' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqdmullb_s64' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqdmullb' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqdmullb,_s64,,)(svundef_s32(), svundef_s32()); - // expected-error@+2 {{'svqdmullb_n_s64' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqdmullb' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqdmullb_n_s64' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqdmullb' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqdmullb,_n_s64,,)(svundef_s32(), i32); // expected-error@+2 {{'svldnt1uw_gather_u64base_s64' needs target feature sve,sve2}} // overload-error@+1 {{'svldnt1uw_gather_s64' needs target feature sve,sve2}} @@ -2458,17 +2458,17 @@ void test(svbool_t pg, const int8_t *const_i8_ptr, const uint8_t *const_u8_ptr, // expected-error@+2 {{'svstnt1b_scatter_u64base_offset_s64' needs target feature sve,sve2}} // overload-error@+1 {{'svstnt1b_scatter_offset' needs target feature sve,sve2}} SVE_ACLE_FUNC(svstnt1b_scatter, _u64base, _offset, _s64)(pg, svundef_u64(), i64, svundef_s64()); - // expected-error@+2 {{'svbsl2n_s64' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svbsl2n' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svbsl2n_s64' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svbsl2n' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svbsl2n,_s64,,)(svundef_s64(), svundef_s64(), svundef_s64()); - // expected-error@+2 {{'svbsl2n_n_s64' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svbsl2n' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svbsl2n_n_s64' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svbsl2n' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svbsl2n,_n_s64,,)(svundef_s64(), svundef_s64(), i64); - // expected-error@+2 {{'svaddlt_s64' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svaddlt' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svaddlt_s64' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svaddlt' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svaddlt,_s64,,)(svundef_s32(), svundef_s32()); - // expected-error@+2 {{'svaddlt_n_s64' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svaddlt' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svaddlt_n_s64' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svaddlt' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svaddlt,_n_s64,,)(svundef_s32(), i32); // expected-error@+2 {{'svstnt1w_scatter_u64base_s64' needs target feature sve,sve2}} // overload-error@+1 {{'svstnt1w_scatter' needs target feature sve,sve2}} @@ -2491,980 +2491,980 @@ void test(svbool_t pg, const int8_t *const_i8_ptr, const uint8_t *const_u8_ptr, // expected-error@+2 {{'svstnt1w_scatter_u64base_index_s64' needs target feature sve,sve2}} // overload-error@+1 {{'svstnt1w_scatter_index' needs target feature sve,sve2}} SVE_ACLE_FUNC(svstnt1w_scatter, _u64base, _index, _s64)(pg, svundef_u64(), i64, svundef_s64()); - // expected-error@+2 {{'svqxtunt_s64' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqxtunt' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqxtunt_s64' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqxtunt' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqxtunt,_s64,,)(svundef_u32(), svundef_s64()); - // expected-error@+2 {{'svabalb_s64' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svabalb' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svabalb_s64' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svabalb' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svabalb,_s64,,)(svundef_s64(), svundef_s32(), svundef_s32()); - // expected-error@+2 {{'svabalb_n_s64' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svabalb' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svabalb_n_s64' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svabalb' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svabalb,_n_s64,,)(svundef_s64(), svundef_s32(), i32); - // expected-error@+2 {{'svsublb_s64' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svsublb' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svsublb_s64' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svsublb' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svsublb,_s64,,)(svundef_s32(), svundef_s32()); - // expected-error@+2 {{'svsublb_n_s64' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svsublb' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svsublb_n_s64' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svsublb' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svsublb,_n_s64,,)(svundef_s32(), i32); - // expected-error@+2 {{'svbsl1n_s64' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svbsl1n' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svbsl1n_s64' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svbsl1n' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svbsl1n,_s64,,)(svundef_s64(), svundef_s64(), svundef_s64()); - // expected-error@+2 {{'svbsl1n_n_s64' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svbsl1n' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svbsl1n_n_s64' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svbsl1n' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svbsl1n,_n_s64,,)(svundef_s64(), svundef_s64(), i64); - // expected-error@+2 {{'svrshl_s64_z' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svrshl_z' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svrshl_s64_z' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svrshl_z' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svrshl,_s64,_z,)(pg, svundef_s64(), svundef_s64()); - // expected-error@+2 {{'svrshl_s64_m' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svrshl_m' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svrshl_s64_m' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svrshl_m' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svrshl,_s64,_m,)(pg, svundef_s64(), svundef_s64()); - // expected-error@+2 {{'svrshl_s64_x' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svrshl_x' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svrshl_s64_x' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svrshl_x' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svrshl,_s64,_x,)(pg, svundef_s64(), svundef_s64()); - // expected-error@+2 {{'svrshl_n_s64_z' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svrshl_z' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svrshl_n_s64_z' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svrshl_z' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svrshl,_n_s64,_z,)(pg, svundef_s64(), i64); - // expected-error@+2 {{'svrshl_n_s64_m' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svrshl_m' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svrshl_n_s64_m' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svrshl_m' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svrshl,_n_s64,_m,)(pg, svundef_s64(), i64); - // expected-error@+2 {{'svrshl_n_s64_x' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svrshl_x' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svrshl_n_s64_x' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svrshl_x' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svrshl,_n_s64,_x,)(pg, svundef_s64(), i64); - // expected-error@+2 {{'svaddwt_s64' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svaddwt' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svaddwt_s64' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svaddwt' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svaddwt,_s64,,)(svundef_s64(), svundef_s32()); - // expected-error@+2 {{'svaddwt_n_s64' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svaddwt' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svaddwt_n_s64' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svaddwt' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svaddwt,_n_s64,,)(svundef_s64(), i32); - // expected-error@+2 {{'svmlslb_s64' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svmlslb' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svmlslb_s64' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svmlslb' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svmlslb,_s64,,)(svundef_s64(), svundef_s32(), svundef_s32()); - // expected-error@+2 {{'svmlslb_n_s64' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svmlslb' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svmlslb_n_s64' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svmlslb' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svmlslb,_n_s64,,)(svundef_s64(), svundef_s32(), i32); - // expected-error@+2 {{'svmlslt_s64' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svmlslt' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svmlslt_s64' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svmlslt' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svmlslt,_s64,,)(svundef_s64(), svundef_s32(), svundef_s32()); - // expected-error@+2 {{'svmlslt_n_s64' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svmlslt' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svmlslt_n_s64' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svmlslt' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svmlslt,_n_s64,,)(svundef_s64(), svundef_s32(), i32); - // expected-error@+2 {{'svqneg_s64_z' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqneg_z' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqneg_s64_z' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqneg_z' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqneg,_s64,_z,)(pg, svundef_s64()); - // expected-error@+2 {{'svqneg_s64_m' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqneg_m' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqneg_s64_m' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqneg_m' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqneg,_s64,_m,)(svundef_s64(), pg, svundef_s64()); - // expected-error@+2 {{'svqneg_s64_x' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqneg_x' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqneg_s64_x' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqneg_x' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqneg,_s64,_x,)(pg, svundef_s64()); - // expected-error@+2 {{'svmovlt_s64' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svmovlt' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svmovlt_s64' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svmovlt' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svmovlt,_s64,,)(svundef_s32()); - // expected-error@+2 {{'svqshl_s64_z' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqshl_z' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqshl_s64_z' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqshl_z' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqshl,_s64,_z,)(pg, svundef_s64(), svundef_s64()); - // expected-error@+2 {{'svqshl_s64_m' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqshl_m' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqshl_s64_m' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqshl_m' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqshl,_s64,_m,)(pg, svundef_s64(), svundef_s64()); - // expected-error@+2 {{'svqshl_s64_x' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqshl_x' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqshl_s64_x' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqshl_x' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqshl,_s64,_x,)(pg, svundef_s64(), svundef_s64()); - // expected-error@+2 {{'svqshl_n_s64_z' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqshl_z' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqshl_n_s64_z' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqshl_z' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqshl,_n_s64,_z,)(pg, svundef_s64(), i64); - // expected-error@+2 {{'svqshl_n_s64_m' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqshl_m' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqshl_n_s64_m' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqshl_m' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqshl,_n_s64,_m,)(pg, svundef_s64(), i64); - // expected-error@+2 {{'svqshl_n_s64_x' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqshl_x' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqshl_n_s64_x' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqshl_x' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqshl,_n_s64,_x,)(pg, svundef_s64(), i64); // expected-error@+2 {{'svhistseg_u8' needs target feature sve,sve2}} // overload-error@+1 {{'svhistseg' needs target feature sve,sve2}} SVE_ACLE_FUNC(svhistseg,_u8,,)(svundef_u8(), svundef_u8()); - // expected-error@+2 {{'svpmullb_pair_u8' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svpmullb_pair' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svpmullb_pair_u8' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svpmullb_pair' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svpmullb_pair,_u8,,)(svundef_u8(), svundef_u8()); - // expected-error@+2 {{'svpmullb_pair_n_u8' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svpmullb_pair' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svpmullb_pair_n_u8' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svpmullb_pair' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svpmullb_pair,_n_u8,,)(svundef_u8(), u8); - // expected-error@+2 {{'svnbsl_u8' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svnbsl' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svnbsl_u8' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svnbsl' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svnbsl,_u8,,)(svundef_u8(), svundef_u8(), svundef_u8()); - // expected-error@+2 {{'svnbsl_n_u8' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svnbsl' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svnbsl_n_u8' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svnbsl' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svnbsl,_n_u8,,)(svundef_u8(), svundef_u8(), u8); - // expected-error@+2 {{'svtbl2_u8' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svtbl2' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svtbl2_u8' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svtbl2' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svtbl2,_u8,,)(svundef2_u8(), svundef_u8()); - // expected-error@+2 {{'svhsubr_u8_z' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svhsubr_z' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svhsubr_u8_z' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svhsubr_z' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svhsubr,_u8,_z,)(pg, svundef_u8(), svundef_u8()); - // expected-error@+2 {{'svhsubr_u8_m' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svhsubr_m' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svhsubr_u8_m' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svhsubr_m' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svhsubr,_u8,_m,)(pg, svundef_u8(), svundef_u8()); - // expected-error@+2 {{'svhsubr_u8_x' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svhsubr_x' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svhsubr_u8_x' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svhsubr_x' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svhsubr,_u8,_x,)(pg, svundef_u8(), svundef_u8()); - // expected-error@+2 {{'svhsubr_n_u8_z' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svhsubr_z' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svhsubr_n_u8_z' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svhsubr_z' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svhsubr,_n_u8,_z,)(pg, svundef_u8(), u8); - // expected-error@+2 {{'svhsubr_n_u8_m' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svhsubr_m' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svhsubr_n_u8_m' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svhsubr_m' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svhsubr,_n_u8,_m,)(pg, svundef_u8(), u8); - // expected-error@+2 {{'svhsubr_n_u8_x' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svhsubr_x' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svhsubr_n_u8_x' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svhsubr_x' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svhsubr,_n_u8,_x,)(pg, svundef_u8(), u8); - // expected-error@+2 {{'svpmul_u8' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svpmul' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svpmul_u8' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svpmul' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svpmul,_u8,,)(svundef_u8(), svundef_u8()); - // expected-error@+2 {{'svpmul_n_u8' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svpmul' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svpmul_n_u8' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svpmul' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svpmul,_n_u8,,)(svundef_u8(), u8); - // expected-error@+2 {{'sveortb_u8' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'sveortb' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'sveortb_u8' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'sveortb' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(sveortb,_u8,,)(svundef_u8(), svundef_u8(), svundef_u8()); - // expected-error@+2 {{'sveortb_n_u8' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'sveortb' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'sveortb_n_u8' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'sveortb' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(sveortb,_n_u8,,)(svundef_u8(), svundef_u8(), u8); - // expected-error@+2 {{'svbcax_u8' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svbcax' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svbcax_u8' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svbcax' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svbcax,_u8,,)(svundef_u8(), svundef_u8(), svundef_u8()); - // expected-error@+2 {{'svbcax_n_u8' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svbcax' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svbcax_n_u8' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svbcax' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svbcax,_n_u8,,)(svundef_u8(), svundef_u8(), u8); - // expected-error@+2 {{'svqrshl_u8_z' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqrshl_z' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqrshl_u8_z' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqrshl_z' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqrshl,_u8,_z,)(pg, svundef_u8(), svundef_s8()); - // expected-error@+2 {{'svqrshl_u8_m' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqrshl_m' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqrshl_u8_m' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqrshl_m' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqrshl,_u8,_m,)(pg, svundef_u8(), svundef_s8()); - // expected-error@+2 {{'svqrshl_u8_x' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqrshl_x' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqrshl_u8_x' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqrshl_x' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqrshl,_u8,_x,)(pg, svundef_u8(), svundef_s8()); - // expected-error@+2 {{'svqrshl_n_u8_z' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqrshl_z' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqrshl_n_u8_z' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqrshl_z' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqrshl,_n_u8,_z,)(pg, svundef_u8(), i8); - // expected-error@+2 {{'svqrshl_n_u8_m' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqrshl_m' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqrshl_n_u8_m' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqrshl_m' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqrshl,_n_u8,_m,)(pg, svundef_u8(), i8); - // expected-error@+2 {{'svqrshl_n_u8_x' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqrshl_x' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqrshl_n_u8_x' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqrshl_x' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqrshl,_n_u8,_x,)(pg, svundef_u8(), i8); - // expected-error@+2 {{'svpmullt_pair_u8' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svpmullt_pair' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svpmullt_pair_u8' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svpmullt_pair' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svpmullt_pair,_u8,,)(svundef_u8(), svundef_u8()); - // expected-error@+2 {{'svpmullt_pair_n_u8' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svpmullt_pair' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svpmullt_pair_n_u8' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svpmullt_pair' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svpmullt_pair,_n_u8,,)(svundef_u8(), u8); - // expected-error@+2 {{'svqsubr_u8_z' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqsubr_z' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqsubr_u8_z' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqsubr_z' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqsubr,_u8,_z,)(pg, svundef_u8(), svundef_u8()); - // expected-error@+2 {{'svqsubr_u8_m' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqsubr_m' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqsubr_u8_m' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqsubr_m' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqsubr,_u8,_m,)(pg, svundef_u8(), svundef_u8()); - // expected-error@+2 {{'svqsubr_u8_x' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqsubr_x' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqsubr_u8_x' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqsubr_x' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqsubr,_u8,_x,)(pg, svundef_u8(), svundef_u8()); - // expected-error@+2 {{'svqsubr_n_u8_z' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqsubr_z' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqsubr_n_u8_z' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqsubr_z' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqsubr,_n_u8,_z,)(pg, svundef_u8(), u8); - // expected-error@+2 {{'svqsubr_n_u8_m' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqsubr_m' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqsubr_n_u8_m' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqsubr_m' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqsubr,_n_u8,_m,)(pg, svundef_u8(), u8); - // expected-error@+2 {{'svqsubr_n_u8_x' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqsubr_x' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqsubr_n_u8_x' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqsubr_x' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqsubr,_n_u8,_x,)(pg, svundef_u8(), u8); - // expected-error@+2 {{'svaddp_u8_m' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svaddp_m' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svaddp_u8_m' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svaddp_m' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svaddp,_u8,_m,)(pg, svundef_u8(), svundef_u8()); - // expected-error@+2 {{'svaddp_u8_x' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svaddp_x' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svaddp_u8_x' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svaddp_x' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svaddp,_u8,_x,)(pg, svundef_u8(), svundef_u8()); - // expected-error@+2 {{'svqadd_u8_m' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqadd_m' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqadd_u8_m' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqadd_m' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqadd,_u8,_m,)(pg, svundef_u8(), svundef_u8()); - // expected-error@+2 {{'svqadd_n_u8_m' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqadd_m' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqadd_n_u8_m' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqadd_m' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqadd,_n_u8,_m,)(pg, svundef_u8(), u8); - // expected-error@+2 {{'svqadd_u8_z' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqadd_z' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqadd_u8_z' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqadd_z' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqadd,_u8,_z,)(pg, svundef_u8(), svundef_u8()); - // expected-error@+2 {{'svqadd_n_u8_z' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqadd_z' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqadd_n_u8_z' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqadd_z' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqadd,_n_u8,_z,)(pg, svundef_u8(), u8); - // expected-error@+2 {{'svqadd_u8_x' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqadd_x' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqadd_u8_x' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqadd_x' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqadd,_u8,_x,)(pg, svundef_u8(), svundef_u8()); - // expected-error@+2 {{'svqadd_n_u8_x' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqadd_x' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqadd_n_u8_x' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqadd_x' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqadd,_n_u8,_x,)(pg, svundef_u8(), u8); - // expected-error@+2 {{'svtbx_u8' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svtbx' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svtbx_u8' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svtbx' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svtbx,_u8,,)(svundef_u8(), svundef_u8(), svundef_u8()); - // expected-error@+2 {{'svminp_u8_m' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svminp_m' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svminp_u8_m' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svminp_m' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svminp,_u8,_m,)(pg, svundef_u8(), svundef_u8()); - // expected-error@+2 {{'svminp_u8_x' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svminp_x' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svminp_u8_x' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svminp_x' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svminp,_u8,_x,)(pg, svundef_u8(), svundef_u8()); - // expected-error@+2 {{'svsqadd_u8_m' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svsqadd_m' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svsqadd_u8_m' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svsqadd_m' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svsqadd,_u8,_m,)(pg, svundef_u8(), svundef_s8()); - // expected-error@+2 {{'svsqadd_n_u8_m' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svsqadd_m' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svsqadd_n_u8_m' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svsqadd_m' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svsqadd,_n_u8,_m,)(pg, svundef_u8(), i8); - // expected-error@+2 {{'svsqadd_u8_z' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svsqadd_z' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svsqadd_u8_z' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svsqadd_z' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svsqadd,_u8,_z,)(pg, svundef_u8(), svundef_s8()); - // expected-error@+2 {{'svsqadd_n_u8_z' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svsqadd_z' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svsqadd_n_u8_z' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svsqadd_z' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svsqadd,_n_u8,_z,)(pg, svundef_u8(), i8); - // expected-error@+2 {{'svsqadd_u8_x' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svsqadd_x' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svsqadd_u8_x' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svsqadd_x' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svsqadd,_u8,_x,)(pg, svundef_u8(), svundef_s8()); - // expected-error@+2 {{'svsqadd_n_u8_x' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svsqadd_x' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svsqadd_n_u8_x' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svsqadd_x' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svsqadd,_n_u8,_x,)(pg, svundef_u8(), i8); - // expected-error@+2 {{'svqsub_u8_z' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqsub_z' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqsub_u8_z' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqsub_z' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqsub,_u8,_z,)(pg, svundef_u8(), svundef_u8()); - // expected-error@+2 {{'svqsub_u8_m' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqsub_m' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqsub_u8_m' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqsub_m' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqsub,_u8,_m,)(pg, svundef_u8(), svundef_u8()); - // expected-error@+2 {{'svqsub_u8_x' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqsub_x' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqsub_u8_x' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqsub_x' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqsub,_u8,_x,)(pg, svundef_u8(), svundef_u8()); - // expected-error@+2 {{'svqsub_n_u8_z' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqsub_z' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqsub_n_u8_z' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqsub_z' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqsub,_n_u8,_z,)(pg, svundef_u8(), u8); - // expected-error@+2 {{'svqsub_n_u8_m' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqsub_m' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqsub_n_u8_m' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqsub_m' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqsub,_n_u8,_m,)(pg, svundef_u8(), u8); - // expected-error@+2 {{'svqsub_n_u8_x' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqsub_x' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqsub_n_u8_x' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqsub_x' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqsub,_n_u8,_x,)(pg, svundef_u8(), u8); - // expected-error@+2 {{'sveor3_u8' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'sveor3' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'sveor3_u8' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'sveor3' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(sveor3,_u8,,)(svundef_u8(), svundef_u8(), svundef_u8()); - // expected-error@+2 {{'sveor3_n_u8' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'sveor3' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'sveor3_n_u8' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'sveor3' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(sveor3,_n_u8,,)(svundef_u8(), svundef_u8(), u8); - // expected-error@+2 {{'svhadd_u8_m' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svhadd_m' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svhadd_u8_m' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svhadd_m' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svhadd,_u8,_m,)(pg, svundef_u8(), svundef_u8()); - // expected-error@+2 {{'svhadd_n_u8_m' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svhadd_m' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svhadd_n_u8_m' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svhadd_m' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svhadd,_n_u8,_m,)(pg, svundef_u8(), u8); - // expected-error@+2 {{'svhadd_u8_z' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svhadd_z' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svhadd_u8_z' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svhadd_z' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svhadd,_u8,_z,)(pg, svundef_u8(), svundef_u8()); - // expected-error@+2 {{'svhadd_n_u8_z' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svhadd_z' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svhadd_n_u8_z' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svhadd_z' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svhadd,_n_u8,_z,)(pg, svundef_u8(), u8); - // expected-error@+2 {{'svhadd_u8_x' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svhadd_x' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svhadd_u8_x' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svhadd_x' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svhadd,_u8,_x,)(pg, svundef_u8(), svundef_u8()); - // expected-error@+2 {{'svhadd_n_u8_x' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svhadd_x' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svhadd_n_u8_x' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svhadd_x' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svhadd,_n_u8,_x,)(pg, svundef_u8(), u8); - // expected-error@+2 {{'svmaxp_u8_m' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svmaxp_m' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svmaxp_u8_m' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svmaxp_m' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svmaxp,_u8,_m,)(pg, svundef_u8(), svundef_u8()); - // expected-error@+2 {{'svmaxp_u8_x' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svmaxp_x' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svmaxp_u8_x' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svmaxp_x' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svmaxp,_u8,_x,)(pg, svundef_u8(), svundef_u8()); // expected-error@+2 {{'svmatch_u8' needs target feature sve,sve2}} // overload-error@+1 {{'svmatch' needs target feature sve,sve2}} SVE_ACLE_FUNC(svmatch,_u8,,)(pg, svundef_u8(), svundef_u8()); - // expected-error@+2 {{'svwhilerw_u8' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svwhilerw' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svwhilerw_u8' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svwhilerw' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svwhilerw,_u8,,)(const_u8_ptr, const_u8_ptr); - // expected-error@+2 {{'svrhadd_u8_m' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svrhadd_m' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svrhadd_u8_m' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svrhadd_m' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svrhadd,_u8,_m,)(pg, svundef_u8(), svundef_u8()); - // expected-error@+2 {{'svrhadd_n_u8_m' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svrhadd_m' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svrhadd_n_u8_m' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svrhadd_m' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svrhadd,_n_u8,_m,)(pg, svundef_u8(), u8); - // expected-error@+2 {{'svrhadd_u8_z' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svrhadd_z' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svrhadd_u8_z' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svrhadd_z' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svrhadd,_u8,_z,)(pg, svundef_u8(), svundef_u8()); - // expected-error@+2 {{'svrhadd_n_u8_z' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svrhadd_z' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svrhadd_n_u8_z' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svrhadd_z' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svrhadd,_n_u8,_z,)(pg, svundef_u8(), u8); - // expected-error@+2 {{'svrhadd_u8_x' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svrhadd_x' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svrhadd_u8_x' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svrhadd_x' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svrhadd,_u8,_x,)(pg, svundef_u8(), svundef_u8()); - // expected-error@+2 {{'svrhadd_n_u8_x' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svrhadd_x' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svrhadd_n_u8_x' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svrhadd_x' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svrhadd,_n_u8,_x,)(pg, svundef_u8(), u8); - // expected-error@+2 {{'svwhilewr_u8' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svwhilewr' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svwhilewr_u8' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svwhilewr' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svwhilewr,_u8,,)(const_u8_ptr, const_u8_ptr); // expected-error@+2 {{'svnmatch_u8' needs target feature sve,sve2}} // overload-error@+1 {{'svnmatch' needs target feature sve,sve2}} SVE_ACLE_FUNC(svnmatch,_u8,,)(pg, svundef_u8(), svundef_u8()); - // expected-error@+2 {{'svaba_u8' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svaba' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svaba_u8' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svaba' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svaba,_u8,,)(svundef_u8(), svundef_u8(), svundef_u8()); - // expected-error@+2 {{'svaba_n_u8' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svaba' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svaba_n_u8' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svaba' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svaba,_n_u8,,)(svundef_u8(), svundef_u8(), u8); - // expected-error@+2 {{'sveorbt_u8' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'sveorbt' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'sveorbt_u8' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'sveorbt' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(sveorbt,_u8,,)(svundef_u8(), svundef_u8(), svundef_u8()); - // expected-error@+2 {{'sveorbt_n_u8' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'sveorbt' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'sveorbt_n_u8' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'sveorbt' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(sveorbt,_n_u8,,)(svundef_u8(), svundef_u8(), u8); - // expected-error@+2 {{'svbsl_u8' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svbsl' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svbsl_u8' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svbsl' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svbsl,_u8,,)(svundef_u8(), svundef_u8(), svundef_u8()); - // expected-error@+2 {{'svbsl_n_u8' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svbsl' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svbsl_n_u8' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svbsl' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svbsl,_n_u8,,)(svundef_u8(), svundef_u8(), u8); - // expected-error@+2 {{'svhsub_u8_z' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svhsub_z' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svhsub_u8_z' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svhsub_z' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svhsub,_u8,_z,)(pg, svundef_u8(), svundef_u8()); - // expected-error@+2 {{'svhsub_u8_m' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svhsub_m' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svhsub_u8_m' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svhsub_m' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svhsub,_u8,_m,)(pg, svundef_u8(), svundef_u8()); - // expected-error@+2 {{'svhsub_u8_x' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svhsub_x' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svhsub_u8_x' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svhsub_x' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svhsub,_u8,_x,)(pg, svundef_u8(), svundef_u8()); - // expected-error@+2 {{'svhsub_n_u8_z' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svhsub_z' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svhsub_n_u8_z' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svhsub_z' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svhsub,_n_u8,_z,)(pg, svundef_u8(), u8); - // expected-error@+2 {{'svhsub_n_u8_m' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svhsub_m' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svhsub_n_u8_m' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svhsub_m' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svhsub,_n_u8,_m,)(pg, svundef_u8(), u8); - // expected-error@+2 {{'svhsub_n_u8_x' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svhsub_x' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svhsub_n_u8_x' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svhsub_x' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svhsub,_n_u8,_x,)(pg, svundef_u8(), u8); - // expected-error@+2 {{'svbsl2n_u8' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svbsl2n' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svbsl2n_u8' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svbsl2n' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svbsl2n,_u8,,)(svundef_u8(), svundef_u8(), svundef_u8()); - // expected-error@+2 {{'svbsl2n_n_u8' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svbsl2n' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svbsl2n_n_u8' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svbsl2n' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svbsl2n,_n_u8,,)(svundef_u8(), svundef_u8(), u8); - // expected-error@+2 {{'svbsl1n_u8' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svbsl1n' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svbsl1n_u8' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svbsl1n' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svbsl1n,_u8,,)(svundef_u8(), svundef_u8(), svundef_u8()); - // expected-error@+2 {{'svbsl1n_n_u8' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svbsl1n' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svbsl1n_n_u8' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svbsl1n' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svbsl1n,_n_u8,,)(svundef_u8(), svundef_u8(), u8); - // expected-error@+2 {{'svrshl_u8_z' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svrshl_z' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svrshl_u8_z' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svrshl_z' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svrshl,_u8,_z,)(pg, svundef_u8(), svundef_s8()); - // expected-error@+2 {{'svrshl_u8_m' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svrshl_m' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svrshl_u8_m' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svrshl_m' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svrshl,_u8,_m,)(pg, svundef_u8(), svundef_s8()); - // expected-error@+2 {{'svrshl_u8_x' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svrshl_x' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svrshl_u8_x' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svrshl_x' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svrshl,_u8,_x,)(pg, svundef_u8(), svundef_s8()); - // expected-error@+2 {{'svrshl_n_u8_z' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svrshl_z' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svrshl_n_u8_z' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svrshl_z' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svrshl,_n_u8,_z,)(pg, svundef_u8(), i8); - // expected-error@+2 {{'svrshl_n_u8_m' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svrshl_m' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svrshl_n_u8_m' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svrshl_m' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svrshl,_n_u8,_m,)(pg, svundef_u8(), i8); - // expected-error@+2 {{'svrshl_n_u8_x' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svrshl_x' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svrshl_n_u8_x' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svrshl_x' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svrshl,_n_u8,_x,)(pg, svundef_u8(), i8); - // expected-error@+2 {{'svqshl_u8_z' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqshl_z' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqshl_u8_z' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqshl_z' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqshl,_u8,_z,)(pg, svundef_u8(), svundef_s8()); - // expected-error@+2 {{'svqshl_u8_m' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqshl_m' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqshl_u8_m' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqshl_m' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqshl,_u8,_m,)(pg, svundef_u8(), svundef_s8()); - // expected-error@+2 {{'svqshl_u8_x' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqshl_x' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqshl_u8_x' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqshl_x' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqshl,_u8,_x,)(pg, svundef_u8(), svundef_s8()); - // expected-error@+2 {{'svqshl_n_u8_z' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqshl_z' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqshl_n_u8_z' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqshl_z' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqshl,_n_u8,_z,)(pg, svundef_u8(), i8); - // expected-error@+2 {{'svqshl_n_u8_m' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqshl_m' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqshl_n_u8_m' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqshl_m' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqshl,_n_u8,_m,)(pg, svundef_u8(), i8); - // expected-error@+2 {{'svqshl_n_u8_x' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqshl_x' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqshl_n_u8_x' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqshl_x' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqshl,_n_u8,_x,)(pg, svundef_u8(), i8); - // expected-error@+2 {{'svmullb_u16' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svmullb' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svmullb_u16' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svmullb' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svmullb,_u16,,)(svundef_u8(), svundef_u8()); - // expected-error@+2 {{'svmullb_n_u16' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svmullb' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svmullb_n_u16' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svmullb' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svmullb,_n_u16,,)(svundef_u8(), u8); - // expected-error@+2 {{'svpmullb_u16' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svpmullb' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svpmullb_u16' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svpmullb' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svpmullb,_u16,,)(svundef_u8(), svundef_u8()); - // expected-error@+2 {{'svpmullb_n_u16' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svpmullb' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svpmullb_n_u16' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svpmullb' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svpmullb,_n_u16,,)(svundef_u8(), u8); - // expected-error@+2 {{'svaddwb_u16' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svaddwb' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svaddwb_u16' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svaddwb' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svaddwb,_u16,,)(svundef_u16(), svundef_u8()); - // expected-error@+2 {{'svaddwb_n_u16' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svaddwb' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svaddwb_n_u16' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svaddwb' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svaddwb,_n_u16,,)(svundef_u16(), u8); - // expected-error@+2 {{'svsubhnb_u16' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svsubhnb' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svsubhnb_u16' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svsubhnb' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svsubhnb,_u16,,)(svundef_u16(), svundef_u16()); - // expected-error@+2 {{'svsubhnb_n_u16' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svsubhnb' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svsubhnb_n_u16' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svsubhnb' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svsubhnb,_n_u16,,)(svundef_u16(), u16); - // expected-error@+2 {{'svrsubhnt_u16' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svrsubhnt' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svrsubhnt_u16' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svrsubhnt' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svrsubhnt,_u16,,)(svundef_u8(), svundef_u16(), svundef_u16()); - // expected-error@+2 {{'svrsubhnt_n_u16' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svrsubhnt' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svrsubhnt_n_u16' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svrsubhnt' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svrsubhnt,_n_u16,,)(svundef_u8(), svundef_u16(), u16); - // expected-error@+2 {{'svnbsl_u16' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svnbsl' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svnbsl_u16' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svnbsl' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svnbsl,_u16,,)(svundef_u16(), svundef_u16(), svundef_u16()); - // expected-error@+2 {{'svnbsl_n_u16' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svnbsl' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svnbsl_n_u16' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svnbsl' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svnbsl,_n_u16,,)(svundef_u16(), svundef_u16(), u16); - // expected-error@+2 {{'svsubhnt_u16' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svsubhnt' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svsubhnt_u16' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svsubhnt' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svsubhnt,_u16,,)(svundef_u8(), svundef_u16(), svundef_u16()); - // expected-error@+2 {{'svsubhnt_n_u16' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svsubhnt' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svsubhnt_n_u16' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svsubhnt' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svsubhnt,_n_u16,,)(svundef_u8(), svundef_u16(), u16); - // expected-error@+2 {{'svtbl2_u16' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svtbl2' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svtbl2_u16' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svtbl2' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svtbl2,_u16,,)(svundef2_u16(), svundef_u16()); - // expected-error@+2 {{'svhsubr_u16_z' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svhsubr_z' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svhsubr_u16_z' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svhsubr_z' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svhsubr,_u16,_z,)(pg, svundef_u16(), svundef_u16()); - // expected-error@+2 {{'svhsubr_u16_m' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svhsubr_m' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svhsubr_u16_m' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svhsubr_m' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svhsubr,_u16,_m,)(pg, svundef_u16(), svundef_u16()); - // expected-error@+2 {{'svhsubr_u16_x' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svhsubr_x' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svhsubr_u16_x' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svhsubr_x' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svhsubr,_u16,_x,)(pg, svundef_u16(), svundef_u16()); - // expected-error@+2 {{'svhsubr_n_u16_z' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svhsubr_z' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svhsubr_n_u16_z' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svhsubr_z' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svhsubr,_n_u16,_z,)(pg, svundef_u16(), u16); - // expected-error@+2 {{'svhsubr_n_u16_m' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svhsubr_m' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svhsubr_n_u16_m' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svhsubr_m' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svhsubr,_n_u16,_m,)(pg, svundef_u16(), u16); - // expected-error@+2 {{'svhsubr_n_u16_x' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svhsubr_x' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svhsubr_n_u16_x' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svhsubr_x' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svhsubr,_n_u16,_x,)(pg, svundef_u16(), u16); - // expected-error@+2 {{'sveortb_u16' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'sveortb' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'sveortb_u16' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'sveortb' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(sveortb,_u16,,)(svundef_u16(), svundef_u16(), svundef_u16()); - // expected-error@+2 {{'sveortb_n_u16' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'sveortb' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'sveortb_n_u16' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'sveortb' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(sveortb,_n_u16,,)(svundef_u16(), svundef_u16(), u16); - // expected-error@+2 {{'svqxtnb_u16' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqxtnb' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqxtnb_u16' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqxtnb' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqxtnb,_u16,,)(svundef_u16()); - // expected-error@+2 {{'svmlalt_u16' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svmlalt' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svmlalt_u16' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svmlalt' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svmlalt,_u16,,)(svundef_u16(), svundef_u8(), svundef_u8()); - // expected-error@+2 {{'svmlalt_n_u16' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svmlalt' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svmlalt_n_u16' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svmlalt' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svmlalt,_n_u16,,)(svundef_u16(), svundef_u8(), u8); - // expected-error@+2 {{'svaddhnt_u16' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svaddhnt' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svaddhnt_u16' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svaddhnt' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svaddhnt,_u16,,)(svundef_u8(), svundef_u16(), svundef_u16()); - // expected-error@+2 {{'svaddhnt_n_u16' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svaddhnt' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svaddhnt_n_u16' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svaddhnt' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svaddhnt,_n_u16,,)(svundef_u8(), svundef_u16(), u16); - // expected-error@+2 {{'svbcax_u16' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svbcax' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svbcax_u16' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svbcax' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svbcax,_u16,,)(svundef_u16(), svundef_u16(), svundef_u16()); - // expected-error@+2 {{'svbcax_n_u16' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svbcax' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svbcax_n_u16' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svbcax' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svbcax,_n_u16,,)(svundef_u16(), svundef_u16(), u16); - // expected-error@+2 {{'svqxtnt_u16' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqxtnt' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqxtnt_u16' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqxtnt' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqxtnt,_u16,,)(svundef_u8(), svundef_u16()); - // expected-error@+2 {{'svqrshl_u16_z' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqrshl_z' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqrshl_u16_z' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqrshl_z' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqrshl,_u16,_z,)(pg, svundef_u16(), svundef_s16()); - // expected-error@+2 {{'svqrshl_u16_m' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqrshl_m' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqrshl_u16_m' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqrshl_m' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqrshl,_u16,_m,)(pg, svundef_u16(), svundef_s16()); - // expected-error@+2 {{'svqrshl_u16_x' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqrshl_x' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqrshl_u16_x' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqrshl_x' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqrshl,_u16,_x,)(pg, svundef_u16(), svundef_s16()); - // expected-error@+2 {{'svqrshl_n_u16_z' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqrshl_z' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqrshl_n_u16_z' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqrshl_z' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqrshl,_n_u16,_z,)(pg, svundef_u16(), i16); - // expected-error@+2 {{'svqrshl_n_u16_m' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqrshl_m' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqrshl_n_u16_m' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqrshl_m' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqrshl,_n_u16,_m,)(pg, svundef_u16(), i16); - // expected-error@+2 {{'svqrshl_n_u16_x' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqrshl_x' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqrshl_n_u16_x' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqrshl_x' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqrshl,_n_u16,_x,)(pg, svundef_u16(), i16); - // expected-error@+2 {{'svsublt_u16' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svsublt' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svsublt_u16' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svsublt' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svsublt,_u16,,)(svundef_u8(), svundef_u8()); - // expected-error@+2 {{'svsublt_n_u16' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svsublt' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svsublt_n_u16' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svsublt' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svsublt,_n_u16,,)(svundef_u8(), u8); - // expected-error@+2 {{'svadalp_u16_z' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svadalp_z' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svadalp_u16_z' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svadalp_z' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svadalp,_u16,_z,)(pg, svundef_u16(), svundef_u8()); - // expected-error@+2 {{'svadalp_u16_m' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svadalp_m' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svadalp_u16_m' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svadalp_m' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svadalp,_u16,_m,)(pg, svundef_u16(), svundef_u8()); - // expected-error@+2 {{'svadalp_u16_x' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svadalp_x' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svadalp_u16_x' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svadalp_x' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svadalp,_u16,_x,)(pg, svundef_u16(), svundef_u8()); - // expected-error@+2 {{'svpmullt_u16' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svpmullt' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svpmullt_u16' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svpmullt' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svpmullt,_u16,,)(svundef_u8(), svundef_u8()); - // expected-error@+2 {{'svpmullt_n_u16' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svpmullt' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svpmullt_n_u16' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svpmullt' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svpmullt,_n_u16,,)(svundef_u8(), u8); - // expected-error@+2 {{'svsubwt_u16' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svsubwt' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svsubwt_u16' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svsubwt' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svsubwt,_u16,,)(svundef_u16(), svundef_u8()); - // expected-error@+2 {{'svsubwt_n_u16' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svsubwt' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svsubwt_n_u16' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svsubwt' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svsubwt,_n_u16,,)(svundef_u16(), u8); - // expected-error@+2 {{'svqsubr_u16_z' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqsubr_z' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqsubr_u16_z' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqsubr_z' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqsubr,_u16,_z,)(pg, svundef_u16(), svundef_u16()); - // expected-error@+2 {{'svqsubr_u16_m' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqsubr_m' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqsubr_u16_m' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqsubr_m' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqsubr,_u16,_m,)(pg, svundef_u16(), svundef_u16()); - // expected-error@+2 {{'svqsubr_u16_x' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqsubr_x' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqsubr_u16_x' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqsubr_x' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqsubr,_u16,_x,)(pg, svundef_u16(), svundef_u16()); - // expected-error@+2 {{'svqsubr_n_u16_z' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqsubr_z' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqsubr_n_u16_z' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqsubr_z' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqsubr,_n_u16,_z,)(pg, svundef_u16(), u16); - // expected-error@+2 {{'svqsubr_n_u16_m' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqsubr_m' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqsubr_n_u16_m' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqsubr_m' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqsubr,_n_u16,_m,)(pg, svundef_u16(), u16); - // expected-error@+2 {{'svqsubr_n_u16_x' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqsubr_x' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqsubr_n_u16_x' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqsubr_x' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqsubr,_n_u16,_x,)(pg, svundef_u16(), u16); - // expected-error@+2 {{'svaddp_u16_m' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svaddp_m' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svaddp_u16_m' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svaddp_m' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svaddp,_u16,_m,)(pg, svundef_u16(), svundef_u16()); - // expected-error@+2 {{'svaddp_u16_x' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svaddp_x' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svaddp_u16_x' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svaddp_x' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svaddp,_u16,_x,)(pg, svundef_u16(), svundef_u16()); - // expected-error@+2 {{'svqadd_u16_m' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqadd_m' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqadd_u16_m' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqadd_m' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqadd,_u16,_m,)(pg, svundef_u16(), svundef_u16()); - // expected-error@+2 {{'svqadd_n_u16_m' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqadd_m' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqadd_n_u16_m' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqadd_m' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqadd,_n_u16,_m,)(pg, svundef_u16(), u16); - // expected-error@+2 {{'svqadd_u16_z' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqadd_z' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqadd_u16_z' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqadd_z' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqadd,_u16,_z,)(pg, svundef_u16(), svundef_u16()); - // expected-error@+2 {{'svqadd_n_u16_z' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqadd_z' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqadd_n_u16_z' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqadd_z' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqadd,_n_u16,_z,)(pg, svundef_u16(), u16); - // expected-error@+2 {{'svqadd_u16_x' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqadd_x' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqadd_u16_x' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqadd_x' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqadd,_u16,_x,)(pg, svundef_u16(), svundef_u16()); - // expected-error@+2 {{'svqadd_n_u16_x' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqadd_x' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqadd_n_u16_x' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqadd_x' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqadd,_n_u16,_x,)(pg, svundef_u16(), u16); - // expected-error@+2 {{'svabdlb_u16' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svabdlb' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svabdlb_u16' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svabdlb' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svabdlb,_u16,,)(svundef_u8(), svundef_u8()); - // expected-error@+2 {{'svabdlb_n_u16' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svabdlb' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svabdlb_n_u16' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svabdlb' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svabdlb,_n_u16,,)(svundef_u8(), u8); - // expected-error@+2 {{'svtbx_u16' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svtbx' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svtbx_u16' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svtbx' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svtbx,_u16,,)(svundef_u16(), svundef_u16(), svundef_u16()); - // expected-error@+2 {{'svabdlt_u16' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svabdlt' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svabdlt_u16' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svabdlt' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svabdlt,_u16,,)(svundef_u8(), svundef_u8()); - // expected-error@+2 {{'svabdlt_n_u16' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svabdlt' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svabdlt_n_u16' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svabdlt' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svabdlt,_n_u16,,)(svundef_u8(), u8); - // expected-error@+2 {{'svminp_u16_m' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svminp_m' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svminp_u16_m' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svminp_m' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svminp,_u16,_m,)(pg, svundef_u16(), svundef_u16()); - // expected-error@+2 {{'svminp_u16_x' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svminp_x' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svminp_u16_x' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svminp_x' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svminp,_u16,_x,)(pg, svundef_u16(), svundef_u16()); - // expected-error@+2 {{'svsqadd_u16_m' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svsqadd_m' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svsqadd_u16_m' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svsqadd_m' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svsqadd,_u16,_m,)(pg, svundef_u16(), svundef_s16()); - // expected-error@+2 {{'svsqadd_n_u16_m' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svsqadd_m' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svsqadd_n_u16_m' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svsqadd_m' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svsqadd,_n_u16,_m,)(pg, svundef_u16(), i16); - // expected-error@+2 {{'svsqadd_u16_z' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svsqadd_z' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svsqadd_u16_z' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svsqadd_z' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svsqadd,_u16,_z,)(pg, svundef_u16(), svundef_s16()); - // expected-error@+2 {{'svsqadd_n_u16_z' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svsqadd_z' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svsqadd_n_u16_z' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svsqadd_z' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svsqadd,_n_u16,_z,)(pg, svundef_u16(), i16); - // expected-error@+2 {{'svsqadd_u16_x' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svsqadd_x' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svsqadd_u16_x' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svsqadd_x' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svsqadd,_u16,_x,)(pg, svundef_u16(), svundef_s16()); - // expected-error@+2 {{'svsqadd_n_u16_x' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svsqadd_x' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svsqadd_n_u16_x' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svsqadd_x' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svsqadd,_n_u16,_x,)(pg, svundef_u16(), i16); - // expected-error@+2 {{'svqsub_u16_z' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqsub_z' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqsub_u16_z' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqsub_z' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqsub,_u16,_z,)(pg, svundef_u16(), svundef_u16()); - // expected-error@+2 {{'svqsub_u16_m' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqsub_m' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqsub_u16_m' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqsub_m' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqsub,_u16,_m,)(pg, svundef_u16(), svundef_u16()); - // expected-error@+2 {{'svqsub_u16_x' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqsub_x' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqsub_u16_x' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqsub_x' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqsub,_u16,_x,)(pg, svundef_u16(), svundef_u16()); - // expected-error@+2 {{'svqsub_n_u16_z' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqsub_z' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqsub_n_u16_z' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqsub_z' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqsub,_n_u16,_z,)(pg, svundef_u16(), u16); - // expected-error@+2 {{'svqsub_n_u16_m' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqsub_m' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqsub_n_u16_m' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqsub_m' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqsub,_n_u16,_m,)(pg, svundef_u16(), u16); - // expected-error@+2 {{'svqsub_n_u16_x' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqsub_x' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqsub_n_u16_x' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqsub_x' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqsub,_n_u16,_x,)(pg, svundef_u16(), u16); - // expected-error@+2 {{'svrsubhnb_u16' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svrsubhnb' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svrsubhnb_u16' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svrsubhnb' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svrsubhnb,_u16,,)(svundef_u16(), svundef_u16()); - // expected-error@+2 {{'svrsubhnb_n_u16' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svrsubhnb' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svrsubhnb_n_u16' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svrsubhnb' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svrsubhnb,_n_u16,,)(svundef_u16(), u16); - // expected-error@+2 {{'svaddhnb_u16' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svaddhnb' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svaddhnb_u16' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svaddhnb' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svaddhnb,_u16,,)(svundef_u16(), svundef_u16()); - // expected-error@+2 {{'svaddhnb_n_u16' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svaddhnb' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svaddhnb_n_u16' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svaddhnb' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svaddhnb,_n_u16,,)(svundef_u16(), u16); - // expected-error@+2 {{'svabalt_u16' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svabalt' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svabalt_u16' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svabalt' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svabalt,_u16,,)(svundef_u16(), svundef_u8(), svundef_u8()); - // expected-error@+2 {{'svabalt_n_u16' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svabalt' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svabalt_n_u16' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svabalt' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svabalt,_n_u16,,)(svundef_u16(), svundef_u8(), u8); - // expected-error@+2 {{'sveor3_u16' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'sveor3' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'sveor3_u16' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'sveor3' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(sveor3,_u16,,)(svundef_u16(), svundef_u16(), svundef_u16()); - // expected-error@+2 {{'sveor3_n_u16' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'sveor3' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'sveor3_n_u16' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'sveor3' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(sveor3,_n_u16,,)(svundef_u16(), svundef_u16(), u16); - // expected-error@+2 {{'svhadd_u16_m' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svhadd_m' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svhadd_u16_m' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svhadd_m' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svhadd,_u16,_m,)(pg, svundef_u16(), svundef_u16()); - // expected-error@+2 {{'svhadd_n_u16_m' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svhadd_m' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svhadd_n_u16_m' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svhadd_m' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svhadd,_n_u16,_m,)(pg, svundef_u16(), u16); - // expected-error@+2 {{'svhadd_u16_z' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svhadd_z' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svhadd_u16_z' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svhadd_z' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svhadd,_u16,_z,)(pg, svundef_u16(), svundef_u16()); - // expected-error@+2 {{'svhadd_n_u16_z' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svhadd_z' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svhadd_n_u16_z' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svhadd_z' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svhadd,_n_u16,_z,)(pg, svundef_u16(), u16); - // expected-error@+2 {{'svhadd_u16_x' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svhadd_x' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svhadd_u16_x' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svhadd_x' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svhadd,_u16,_x,)(pg, svundef_u16(), svundef_u16()); - // expected-error@+2 {{'svhadd_n_u16_x' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svhadd_x' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svhadd_n_u16_x' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svhadd_x' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svhadd,_n_u16,_x,)(pg, svundef_u16(), u16); - // expected-error@+2 {{'svmovlb_u16' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svmovlb' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svmovlb_u16' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svmovlb' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svmovlb,_u16,,)(svundef_u8()); - // expected-error@+2 {{'svmaxp_u16_m' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svmaxp_m' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svmaxp_u16_m' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svmaxp_m' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svmaxp,_u16,_m,)(pg, svundef_u16(), svundef_u16()); - // expected-error@+2 {{'svmaxp_u16_x' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svmaxp_x' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svmaxp_u16_x' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svmaxp_x' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svmaxp,_u16,_x,)(pg, svundef_u16(), svundef_u16()); - // expected-error@+2 {{'svmullt_u16' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svmullt' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svmullt_u16' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svmullt' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svmullt,_u16,,)(svundef_u8(), svundef_u8()); - // expected-error@+2 {{'svmullt_n_u16' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svmullt' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svmullt_n_u16' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svmullt' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svmullt,_n_u16,,)(svundef_u8(), u8); // expected-error@+2 {{'svmatch_u16' needs target feature sve,sve2}} // overload-error@+1 {{'svmatch' needs target feature sve,sve2}} SVE_ACLE_FUNC(svmatch,_u16,,)(pg, svundef_u16(), svundef_u16()); - // expected-error@+2 {{'svwhilerw_u16' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svwhilerw' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svwhilerw_u16' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svwhilerw' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svwhilerw,_u16,,)(const_u16_ptr, const_u16_ptr); - // expected-error@+2 {{'svrhadd_u16_m' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svrhadd_m' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svrhadd_u16_m' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svrhadd_m' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svrhadd,_u16,_m,)(pg, svundef_u16(), svundef_u16()); - // expected-error@+2 {{'svrhadd_n_u16_m' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svrhadd_m' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svrhadd_n_u16_m' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svrhadd_m' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svrhadd,_n_u16,_m,)(pg, svundef_u16(), u16); - // expected-error@+2 {{'svrhadd_u16_z' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svrhadd_z' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svrhadd_u16_z' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svrhadd_z' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svrhadd,_u16,_z,)(pg, svundef_u16(), svundef_u16()); - // expected-error@+2 {{'svrhadd_n_u16_z' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svrhadd_z' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svrhadd_n_u16_z' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svrhadd_z' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svrhadd,_n_u16,_z,)(pg, svundef_u16(), u16); - // expected-error@+2 {{'svrhadd_u16_x' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svrhadd_x' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svrhadd_u16_x' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svrhadd_x' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svrhadd,_u16,_x,)(pg, svundef_u16(), svundef_u16()); - // expected-error@+2 {{'svrhadd_n_u16_x' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svrhadd_x' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svrhadd_n_u16_x' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svrhadd_x' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svrhadd,_n_u16,_x,)(pg, svundef_u16(), u16); - // expected-error@+2 {{'svraddhnb_u16' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svraddhnb' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svraddhnb_u16' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svraddhnb' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svraddhnb,_u16,,)(svundef_u16(), svundef_u16()); - // expected-error@+2 {{'svraddhnb_n_u16' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svraddhnb' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svraddhnb_n_u16' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svraddhnb' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svraddhnb,_n_u16,,)(svundef_u16(), u16); - // expected-error@+2 {{'svwhilewr_u16' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svwhilewr' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svwhilewr_u16' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svwhilewr' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svwhilewr,_u16,,)(const_u16_ptr, const_u16_ptr); - // expected-error@+2 {{'svmlalb_u16' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svmlalb' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svmlalb_u16' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svmlalb' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svmlalb,_u16,,)(svundef_u16(), svundef_u8(), svundef_u8()); - // expected-error@+2 {{'svmlalb_n_u16' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svmlalb' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svmlalb_n_u16' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svmlalb' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svmlalb,_n_u16,,)(svundef_u16(), svundef_u8(), u8); - // expected-error@+2 {{'svsubwb_u16' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svsubwb' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svsubwb_u16' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svsubwb' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svsubwb,_u16,,)(svundef_u16(), svundef_u8()); - // expected-error@+2 {{'svsubwb_n_u16' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svsubwb' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svsubwb_n_u16' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svsubwb' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svsubwb,_n_u16,,)(svundef_u16(), u8); // expected-error@+2 {{'svnmatch_u16' needs target feature sve,sve2}} // overload-error@+1 {{'svnmatch' needs target feature sve,sve2}} SVE_ACLE_FUNC(svnmatch,_u16,,)(pg, svundef_u16(), svundef_u16()); - // expected-error@+2 {{'svaba_u16' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svaba' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svaba_u16' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svaba' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svaba,_u16,,)(svundef_u16(), svundef_u16(), svundef_u16()); - // expected-error@+2 {{'svaba_n_u16' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svaba' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svaba_n_u16' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svaba' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svaba,_n_u16,,)(svundef_u16(), svundef_u16(), u16); - // expected-error@+2 {{'svraddhnt_u16' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svraddhnt' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svraddhnt_u16' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svraddhnt' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svraddhnt,_u16,,)(svundef_u8(), svundef_u16(), svundef_u16()); - // expected-error@+2 {{'svraddhnt_n_u16' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svraddhnt' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svraddhnt_n_u16' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svraddhnt' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svraddhnt,_n_u16,,)(svundef_u8(), svundef_u16(), u16); - // expected-error@+2 {{'sveorbt_u16' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'sveorbt' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'sveorbt_u16' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'sveorbt' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(sveorbt,_u16,,)(svundef_u16(), svundef_u16(), svundef_u16()); - // expected-error@+2 {{'sveorbt_n_u16' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'sveorbt' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'sveorbt_n_u16' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'sveorbt' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(sveorbt,_n_u16,,)(svundef_u16(), svundef_u16(), u16); - // expected-error@+2 {{'svbsl_u16' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svbsl' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svbsl_u16' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svbsl' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svbsl,_u16,,)(svundef_u16(), svundef_u16(), svundef_u16()); - // expected-error@+2 {{'svbsl_n_u16' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svbsl' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svbsl_n_u16' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svbsl' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svbsl,_n_u16,,)(svundef_u16(), svundef_u16(), u16); - // expected-error@+2 {{'svhsub_u16_z' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svhsub_z' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svhsub_u16_z' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svhsub_z' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svhsub,_u16,_z,)(pg, svundef_u16(), svundef_u16()); - // expected-error@+2 {{'svhsub_u16_m' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svhsub_m' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svhsub_u16_m' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svhsub_m' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svhsub,_u16,_m,)(pg, svundef_u16(), svundef_u16()); - // expected-error@+2 {{'svhsub_u16_x' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svhsub_x' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svhsub_u16_x' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svhsub_x' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svhsub,_u16,_x,)(pg, svundef_u16(), svundef_u16()); - // expected-error@+2 {{'svhsub_n_u16_z' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svhsub_z' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svhsub_n_u16_z' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svhsub_z' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svhsub,_n_u16,_z,)(pg, svundef_u16(), u16); - // expected-error@+2 {{'svhsub_n_u16_m' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svhsub_m' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svhsub_n_u16_m' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svhsub_m' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svhsub,_n_u16,_m,)(pg, svundef_u16(), u16); - // expected-error@+2 {{'svhsub_n_u16_x' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svhsub_x' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svhsub_n_u16_x' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svhsub_x' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svhsub,_n_u16,_x,)(pg, svundef_u16(), u16); - // expected-error@+2 {{'svaddlb_u16' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svaddlb' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svaddlb_u16' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svaddlb' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svaddlb,_u16,,)(svundef_u8(), svundef_u8()); - // expected-error@+2 {{'svaddlb_n_u16' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svaddlb' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svaddlb_n_u16' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svaddlb' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svaddlb,_n_u16,,)(svundef_u8(), u8); - // expected-error@+2 {{'svbsl2n_u16' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svbsl2n' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svbsl2n_u16' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svbsl2n' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svbsl2n,_u16,,)(svundef_u16(), svundef_u16(), svundef_u16()); - // expected-error@+2 {{'svbsl2n_n_u16' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svbsl2n' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svbsl2n_n_u16' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svbsl2n' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svbsl2n,_n_u16,,)(svundef_u16(), svundef_u16(), u16); - // expected-error@+2 {{'svaddlt_u16' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svaddlt' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svaddlt_u16' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svaddlt' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svaddlt,_u16,,)(svundef_u8(), svundef_u8()); - // expected-error@+2 {{'svaddlt_n_u16' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svaddlt' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svaddlt_n_u16' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svaddlt' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svaddlt,_n_u16,,)(svundef_u8(), u8); - // expected-error@+2 {{'svabalb_u16' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svabalb' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svabalb_u16' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svabalb' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svabalb,_u16,,)(svundef_u16(), svundef_u8(), svundef_u8()); - // expected-error@+2 {{'svabalb_n_u16' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svabalb' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svabalb_n_u16' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svabalb' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svabalb,_n_u16,,)(svundef_u16(), svundef_u8(), u8); - // expected-error@+2 {{'svsublb_u16' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svsublb' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svsublb_u16' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svsublb' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svsublb,_u16,,)(svundef_u8(), svundef_u8()); - // expected-error@+2 {{'svsublb_n_u16' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svsublb' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svsublb_n_u16' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svsublb' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svsublb,_n_u16,,)(svundef_u8(), u8); - // expected-error@+2 {{'svbsl1n_u16' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svbsl1n' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svbsl1n_u16' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svbsl1n' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svbsl1n,_u16,,)(svundef_u16(), svundef_u16(), svundef_u16()); - // expected-error@+2 {{'svbsl1n_n_u16' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svbsl1n' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svbsl1n_n_u16' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svbsl1n' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svbsl1n,_n_u16,,)(svundef_u16(), svundef_u16(), u16); - // expected-error@+2 {{'svrshl_u16_z' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svrshl_z' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svrshl_u16_z' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svrshl_z' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svrshl,_u16,_z,)(pg, svundef_u16(), svundef_s16()); - // expected-error@+2 {{'svrshl_u16_m' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svrshl_m' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svrshl_u16_m' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svrshl_m' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svrshl,_u16,_m,)(pg, svundef_u16(), svundef_s16()); - // expected-error@+2 {{'svrshl_u16_x' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svrshl_x' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svrshl_u16_x' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svrshl_x' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svrshl,_u16,_x,)(pg, svundef_u16(), svundef_s16()); - // expected-error@+2 {{'svrshl_n_u16_z' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svrshl_z' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svrshl_n_u16_z' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svrshl_z' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svrshl,_n_u16,_z,)(pg, svundef_u16(), i16); - // expected-error@+2 {{'svrshl_n_u16_m' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svrshl_m' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svrshl_n_u16_m' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svrshl_m' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svrshl,_n_u16,_m,)(pg, svundef_u16(), i16); - // expected-error@+2 {{'svrshl_n_u16_x' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svrshl_x' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svrshl_n_u16_x' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svrshl_x' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svrshl,_n_u16,_x,)(pg, svundef_u16(), i16); - // expected-error@+2 {{'svaddwt_u16' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svaddwt' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svaddwt_u16' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svaddwt' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svaddwt,_u16,,)(svundef_u16(), svundef_u8()); - // expected-error@+2 {{'svaddwt_n_u16' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svaddwt' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svaddwt_n_u16' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svaddwt' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svaddwt,_n_u16,,)(svundef_u16(), u8); - // expected-error@+2 {{'svmlslb_u16' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svmlslb' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svmlslb_u16' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svmlslb' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svmlslb,_u16,,)(svundef_u16(), svundef_u8(), svundef_u8()); - // expected-error@+2 {{'svmlslb_n_u16' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svmlslb' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svmlslb_n_u16' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svmlslb' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svmlslb,_n_u16,,)(svundef_u16(), svundef_u8(), u8); - // expected-error@+2 {{'svmlslt_u16' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svmlslt' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svmlslt_u16' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svmlslt' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svmlslt,_u16,,)(svundef_u16(), svundef_u8(), svundef_u8()); - // expected-error@+2 {{'svmlslt_n_u16' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svmlslt' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svmlslt_n_u16' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svmlslt' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svmlslt,_n_u16,,)(svundef_u16(), svundef_u8(), u8); - // expected-error@+2 {{'svmovlt_u16' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svmovlt' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svmovlt_u16' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svmovlt' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svmovlt,_u16,,)(svundef_u8()); - // expected-error@+2 {{'svqshl_u16_z' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqshl_z' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqshl_u16_z' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqshl_z' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqshl,_u16,_z,)(pg, svundef_u16(), svundef_s16()); - // expected-error@+2 {{'svqshl_u16_m' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqshl_m' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqshl_u16_m' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqshl_m' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqshl,_u16,_m,)(pg, svundef_u16(), svundef_s16()); - // expected-error@+2 {{'svqshl_u16_x' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqshl_x' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqshl_u16_x' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqshl_x' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqshl,_u16,_x,)(pg, svundef_u16(), svundef_s16()); - // expected-error@+2 {{'svqshl_n_u16_z' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqshl_z' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqshl_n_u16_z' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqshl_z' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqshl,_n_u16,_z,)(pg, svundef_u16(), i16); - // expected-error@+2 {{'svqshl_n_u16_m' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqshl_m' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqshl_n_u16_m' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqshl_m' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqshl,_n_u16,_m,)(pg, svundef_u16(), i16); - // expected-error@+2 {{'svqshl_n_u16_x' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqshl_x' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqshl_n_u16_x' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqshl_x' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqshl,_n_u16,_x,)(pg, svundef_u16(), i16); - // expected-error@+2 {{'svmullb_u32' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svmullb' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svmullb_u32' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svmullb' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svmullb,_u32,,)(svundef_u16(), svundef_u16()); - // expected-error@+2 {{'svmullb_n_u32' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svmullb' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svmullb_n_u32' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svmullb' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svmullb,_n_u32,,)(svundef_u16(), u16); - // expected-error@+2 {{'svpmullb_pair_u32' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svpmullb_pair' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svpmullb_pair_u32' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svpmullb_pair' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svpmullb_pair,_u32,,)(svundef_u32(), svundef_u32()); - // expected-error@+2 {{'svpmullb_pair_n_u32' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svpmullb_pair' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svpmullb_pair_n_u32' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svpmullb_pair' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svpmullb_pair,_n_u32,,)(svundef_u32(), u32); - // expected-error@+2 {{'svaddwb_u32' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svaddwb' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svaddwb_u32' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svaddwb' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svaddwb,_u32,,)(svundef_u32(), svundef_u16()); - // expected-error@+2 {{'svaddwb_n_u32' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svaddwb' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svaddwb_n_u32' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svaddwb' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svaddwb,_n_u32,,)(svundef_u32(), u16); - // expected-error@+2 {{'svsubhnb_u32' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svsubhnb' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svsubhnb_u32' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svsubhnb' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svsubhnb,_u32,,)(svundef_u32(), svundef_u32()); - // expected-error@+2 {{'svsubhnb_n_u32' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svsubhnb' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svsubhnb_n_u32' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svsubhnb' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svsubhnb,_n_u32,,)(svundef_u32(), u32); - // expected-error@+2 {{'svrsubhnt_u32' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svrsubhnt' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svrsubhnt_u32' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svrsubhnt' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svrsubhnt,_u32,,)(svundef_u16(), svundef_u32(), svundef_u32()); - // expected-error@+2 {{'svrsubhnt_n_u32' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svrsubhnt' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svrsubhnt_n_u32' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svrsubhnt' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svrsubhnt,_n_u32,,)(svundef_u16(), svundef_u32(), u32); - // expected-error@+2 {{'svnbsl_u32' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svnbsl' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svnbsl_u32' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svnbsl' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svnbsl,_u32,,)(svundef_u32(), svundef_u32(), svundef_u32()); - // expected-error@+2 {{'svnbsl_n_u32' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svnbsl' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svnbsl_n_u32' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svnbsl' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svnbsl,_n_u32,,)(svundef_u32(), svundef_u32(), u32); - // expected-error@+2 {{'svsubhnt_u32' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svsubhnt' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svsubhnt_u32' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svsubhnt' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svsubhnt,_u32,,)(svundef_u16(), svundef_u32(), svundef_u32()); - // expected-error@+2 {{'svsubhnt_n_u32' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svsubhnt' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svsubhnt_n_u32' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svsubhnt' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svsubhnt,_n_u32,,)(svundef_u16(), svundef_u32(), u32); - // expected-error@+2 {{'svwhilegt_b8_u32' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svwhilegt_b8' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svwhilegt_b8_u32' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svwhilegt_b8' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svwhilegt_b8,_u32,,)(u32, u32); - // expected-error@+2 {{'svwhilegt_b16_u32' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svwhilegt_b16' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svwhilegt_b16_u32' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svwhilegt_b16' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svwhilegt_b16,_u32,,)(u32, u32); - // expected-error@+2 {{'svwhilegt_b32_u32' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svwhilegt_b32' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svwhilegt_b32_u32' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svwhilegt_b32' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svwhilegt_b32,_u32,,)(u32, u32); - // expected-error@+2 {{'svwhilegt_b64_u32' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svwhilegt_b64' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svwhilegt_b64_u32' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svwhilegt_b64' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svwhilegt_b64,_u32,,)(u32, u32); - // expected-error@+2 {{'svtbl2_u32' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svtbl2' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svtbl2_u32' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svtbl2' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svtbl2,_u32,,)(svundef2_u32(), svundef_u32()); - // expected-error@+2 {{'svhsubr_u32_z' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svhsubr_z' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svhsubr_u32_z' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svhsubr_z' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svhsubr,_u32,_z,)(pg, svundef_u32(), svundef_u32()); - // expected-error@+2 {{'svhsubr_u32_m' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svhsubr_m' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svhsubr_u32_m' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svhsubr_m' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svhsubr,_u32,_m,)(pg, svundef_u32(), svundef_u32()); - // expected-error@+2 {{'svhsubr_u32_x' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svhsubr_x' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svhsubr_u32_x' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svhsubr_x' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svhsubr,_u32,_x,)(pg, svundef_u32(), svundef_u32()); - // expected-error@+2 {{'svhsubr_n_u32_z' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svhsubr_z' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svhsubr_n_u32_z' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svhsubr_z' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svhsubr,_n_u32,_z,)(pg, svundef_u32(), u32); - // expected-error@+2 {{'svhsubr_n_u32_m' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svhsubr_m' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svhsubr_n_u32_m' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svhsubr_m' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svhsubr,_n_u32,_m,)(pg, svundef_u32(), u32); - // expected-error@+2 {{'svhsubr_n_u32_x' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svhsubr_x' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svhsubr_n_u32_x' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svhsubr_x' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svhsubr,_n_u32,_x,)(pg, svundef_u32(), u32); // expected-error@+2 {{'svhistcnt_u32_z' needs target feature sve,sve2}} // overload-error@+1 {{'svhistcnt_z' needs target feature sve,sve2}} SVE_ACLE_FUNC(svhistcnt,_u32,_z,)(pg, svundef_u32(), svundef_u32()); - // expected-error@+2 {{'sveortb_u32' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'sveortb' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'sveortb_u32' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'sveortb' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(sveortb,_u32,,)(svundef_u32(), svundef_u32(), svundef_u32()); - // expected-error@+2 {{'sveortb_n_u32' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'sveortb' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'sveortb_n_u32' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'sveortb' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(sveortb,_n_u32,,)(svundef_u32(), svundef_u32(), u32); - // expected-error@+2 {{'svqxtnb_u32' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqxtnb' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqxtnb_u32' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqxtnb' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqxtnb,_u32,,)(svundef_u32()); - // expected-error@+2 {{'svmlalt_u32' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svmlalt' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svmlalt_u32' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svmlalt' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svmlalt,_u32,,)(svundef_u32(), svundef_u16(), svundef_u16()); - // expected-error@+2 {{'svmlalt_n_u32' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svmlalt' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svmlalt_n_u32' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svmlalt' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svmlalt,_n_u32,,)(svundef_u32(), svundef_u16(), u16); - // expected-error@+2 {{'svaddhnt_u32' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svaddhnt' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svaddhnt_u32' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svaddhnt' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svaddhnt,_u32,,)(svundef_u16(), svundef_u32(), svundef_u32()); - // expected-error@+2 {{'svaddhnt_n_u32' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svaddhnt' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svaddhnt_n_u32' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svaddhnt' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svaddhnt,_n_u32,,)(svundef_u16(), svundef_u32(), u32); // expected-error@+2 {{'svldnt1uh_gather_u32base_u32' needs target feature sve,sve2}} // overload-error@+1 {{'svldnt1uh_gather_u32' needs target feature sve,sve2}} @@ -3478,230 +3478,230 @@ void test(svbool_t pg, const int8_t *const_i8_ptr, const uint8_t *const_u8_ptr, // expected-error@+2 {{'svldnt1uh_gather_u32base_index_u32' needs target feature sve,sve2}} // overload-error@+1 {{'svldnt1uh_gather_index_u32' needs target feature sve,sve2}} SVE_ACLE_FUNC(svldnt1uh_gather, _u32base, _index_u32, )(pg, svundef_u32(), i64); - // expected-error@+2 {{'svbcax_u32' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svbcax' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svbcax_u32' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svbcax' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svbcax,_u32,,)(svundef_u32(), svundef_u32(), svundef_u32()); - // expected-error@+2 {{'svbcax_n_u32' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svbcax' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svbcax_n_u32' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svbcax' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svbcax,_n_u32,,)(svundef_u32(), svundef_u32(), u32); - // expected-error@+2 {{'svqxtnt_u32' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqxtnt' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqxtnt_u32' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqxtnt' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqxtnt,_u32,,)(svundef_u16(), svundef_u32()); - // expected-error@+2 {{'svqrshl_u32_z' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqrshl_z' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqrshl_u32_z' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqrshl_z' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqrshl,_u32,_z,)(pg, svundef_u32(), svundef_s32()); - // expected-error@+2 {{'svqrshl_u32_m' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqrshl_m' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqrshl_u32_m' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqrshl_m' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqrshl,_u32,_m,)(pg, svundef_u32(), svundef_s32()); - // expected-error@+2 {{'svqrshl_u32_x' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqrshl_x' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqrshl_u32_x' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqrshl_x' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqrshl,_u32,_x,)(pg, svundef_u32(), svundef_s32()); - // expected-error@+2 {{'svqrshl_n_u32_z' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqrshl_z' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqrshl_n_u32_z' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqrshl_z' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqrshl,_n_u32,_z,)(pg, svundef_u32(), i32); - // expected-error@+2 {{'svqrshl_n_u32_m' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqrshl_m' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqrshl_n_u32_m' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqrshl_m' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqrshl,_n_u32,_m,)(pg, svundef_u32(), i32); - // expected-error@+2 {{'svqrshl_n_u32_x' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqrshl_x' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqrshl_n_u32_x' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqrshl_x' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqrshl,_n_u32,_x,)(pg, svundef_u32(), i32); - // expected-error@+2 {{'svsublt_u32' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svsublt' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svsublt_u32' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svsublt' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svsublt,_u32,,)(svundef_u16(), svundef_u16()); - // expected-error@+2 {{'svsublt_n_u32' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svsublt' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svsublt_n_u32' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svsublt' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svsublt,_n_u32,,)(svundef_u16(), u16); - // expected-error@+2 {{'svadalp_u32_z' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svadalp_z' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svadalp_u32_z' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svadalp_z' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svadalp,_u32,_z,)(pg, svundef_u32(), svundef_u16()); - // expected-error@+2 {{'svadalp_u32_m' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svadalp_m' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svadalp_u32_m' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svadalp_m' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svadalp,_u32,_m,)(pg, svundef_u32(), svundef_u16()); - // expected-error@+2 {{'svadalp_u32_x' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svadalp_x' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svadalp_u32_x' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svadalp_x' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svadalp,_u32,_x,)(pg, svundef_u32(), svundef_u16()); - // expected-error@+2 {{'svwhilege_b8_u32' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svwhilege_b8' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svwhilege_b8_u32' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svwhilege_b8' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svwhilege_b8,_u32,,)(u32, u32); - // expected-error@+2 {{'svwhilege_b16_u32' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svwhilege_b16' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svwhilege_b16_u32' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svwhilege_b16' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svwhilege_b16,_u32,,)(u32, u32); - // expected-error@+2 {{'svwhilege_b32_u32' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svwhilege_b32' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svwhilege_b32_u32' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svwhilege_b32' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svwhilege_b32,_u32,,)(u32, u32); - // expected-error@+2 {{'svwhilege_b64_u32' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svwhilege_b64' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svwhilege_b64_u32' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svwhilege_b64' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svwhilege_b64,_u32,,)(u32, u32); - // expected-error@+2 {{'svpmullt_pair_u32' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svpmullt_pair' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svpmullt_pair_u32' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svpmullt_pair' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svpmullt_pair,_u32,,)(svundef_u32(), svundef_u32()); - // expected-error@+2 {{'svpmullt_pair_n_u32' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svpmullt_pair' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svpmullt_pair_n_u32' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svpmullt_pair' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svpmullt_pair,_n_u32,,)(svundef_u32(), u32); - // expected-error@+2 {{'svsubwt_u32' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svsubwt' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svsubwt_u32' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svsubwt' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svsubwt,_u32,,)(svundef_u32(), svundef_u16()); - // expected-error@+2 {{'svsubwt_n_u32' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svsubwt' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svsubwt_n_u32' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svsubwt' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svsubwt,_n_u32,,)(svundef_u32(), u16); - // expected-error@+2 {{'svqsubr_u32_z' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqsubr_z' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqsubr_u32_z' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqsubr_z' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqsubr,_u32,_z,)(pg, svundef_u32(), svundef_u32()); - // expected-error@+2 {{'svqsubr_u32_m' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqsubr_m' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqsubr_u32_m' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqsubr_m' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqsubr,_u32,_m,)(pg, svundef_u32(), svundef_u32()); - // expected-error@+2 {{'svqsubr_u32_x' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqsubr_x' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqsubr_u32_x' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqsubr_x' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqsubr,_u32,_x,)(pg, svundef_u32(), svundef_u32()); - // expected-error@+2 {{'svqsubr_n_u32_z' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqsubr_z' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqsubr_n_u32_z' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqsubr_z' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqsubr,_n_u32,_z,)(pg, svundef_u32(), u32); - // expected-error@+2 {{'svqsubr_n_u32_m' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqsubr_m' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqsubr_n_u32_m' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqsubr_m' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqsubr,_n_u32,_m,)(pg, svundef_u32(), u32); - // expected-error@+2 {{'svqsubr_n_u32_x' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqsubr_x' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqsubr_n_u32_x' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqsubr_x' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqsubr,_n_u32,_x,)(pg, svundef_u32(), u32); - // expected-error@+2 {{'svadclt_u32' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svadclt' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svadclt_u32' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svadclt' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svadclt,_u32,,)(svundef_u32(), svundef_u32(), svundef_u32()); - // expected-error@+2 {{'svadclt_n_u32' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svadclt' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svadclt_n_u32' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svadclt' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svadclt,_n_u32,,)(svundef_u32(), svundef_u32(), u32); - // expected-error@+2 {{'svaddp_u32_m' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svaddp_m' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svaddp_u32_m' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svaddp_m' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svaddp,_u32,_m,)(pg, svundef_u32(), svundef_u32()); - // expected-error@+2 {{'svaddp_u32_x' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svaddp_x' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svaddp_u32_x' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svaddp_x' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svaddp,_u32,_x,)(pg, svundef_u32(), svundef_u32()); - // expected-error@+2 {{'svrecpe_u32_z' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svrecpe_z' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svrecpe_u32_z' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svrecpe_z' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svrecpe,_u32,_z,)(pg, svundef_u32()); - // expected-error@+2 {{'svrecpe_u32_m' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svrecpe_m' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svrecpe_u32_m' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svrecpe_m' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svrecpe,_u32,_m,)(svundef_u32(), pg, svundef_u32()); - // expected-error@+2 {{'svrecpe_u32_x' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svrecpe_x' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svrecpe_u32_x' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svrecpe_x' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svrecpe,_u32,_x,)(pg, svundef_u32()); - // expected-error@+2 {{'svqadd_u32_m' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqadd_m' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqadd_u32_m' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqadd_m' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqadd,_u32,_m,)(pg, svundef_u32(), svundef_u32()); - // expected-error@+2 {{'svqadd_n_u32_m' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqadd_m' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqadd_n_u32_m' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqadd_m' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqadd,_n_u32,_m,)(pg, svundef_u32(), u32); - // expected-error@+2 {{'svqadd_u32_z' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqadd_z' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqadd_u32_z' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqadd_z' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqadd,_u32,_z,)(pg, svundef_u32(), svundef_u32()); - // expected-error@+2 {{'svqadd_n_u32_z' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqadd_z' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqadd_n_u32_z' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqadd_z' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqadd,_n_u32,_z,)(pg, svundef_u32(), u32); - // expected-error@+2 {{'svqadd_u32_x' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqadd_x' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqadd_u32_x' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqadd_x' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqadd,_u32,_x,)(pg, svundef_u32(), svundef_u32()); - // expected-error@+2 {{'svqadd_n_u32_x' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqadd_x' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqadd_n_u32_x' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqadd_x' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqadd,_n_u32,_x,)(pg, svundef_u32(), u32); - // expected-error@+2 {{'svabdlb_u32' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svabdlb' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svabdlb_u32' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svabdlb' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svabdlb,_u32,,)(svundef_u16(), svundef_u16()); - // expected-error@+2 {{'svabdlb_n_u32' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svabdlb' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svabdlb_n_u32' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svabdlb' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svabdlb,_n_u32,,)(svundef_u16(), u16); - // expected-error@+2 {{'svtbx_u32' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svtbx' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svtbx_u32' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svtbx' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svtbx,_u32,,)(svundef_u32(), svundef_u32(), svundef_u32()); - // expected-error@+2 {{'svabdlt_u32' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svabdlt' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svabdlt_u32' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svabdlt' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svabdlt,_u32,,)(svundef_u16(), svundef_u16()); - // expected-error@+2 {{'svabdlt_n_u32' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svabdlt' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svabdlt_n_u32' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svabdlt' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svabdlt,_n_u32,,)(svundef_u16(), u16); - // expected-error@+2 {{'svminp_u32_m' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svminp_m' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svminp_u32_m' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svminp_m' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svminp,_u32,_m,)(pg, svundef_u32(), svundef_u32()); - // expected-error@+2 {{'svminp_u32_x' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svminp_x' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svminp_u32_x' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svminp_x' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svminp,_u32,_x,)(pg, svundef_u32(), svundef_u32()); - // expected-error@+2 {{'svsqadd_u32_m' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svsqadd_m' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svsqadd_u32_m' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svsqadd_m' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svsqadd,_u32,_m,)(pg, svundef_u32(), svundef_s32()); - // expected-error@+2 {{'svsqadd_n_u32_m' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svsqadd_m' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svsqadd_n_u32_m' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svsqadd_m' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svsqadd,_n_u32,_m,)(pg, svundef_u32(), i32); - // expected-error@+2 {{'svsqadd_u32_z' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svsqadd_z' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svsqadd_u32_z' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svsqadd_z' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svsqadd,_u32,_z,)(pg, svundef_u32(), svundef_s32()); - // expected-error@+2 {{'svsqadd_n_u32_z' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svsqadd_z' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svsqadd_n_u32_z' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svsqadd_z' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svsqadd,_n_u32,_z,)(pg, svundef_u32(), i32); - // expected-error@+2 {{'svsqadd_u32_x' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svsqadd_x' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svsqadd_u32_x' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svsqadd_x' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svsqadd,_u32,_x,)(pg, svundef_u32(), svundef_s32()); - // expected-error@+2 {{'svsqadd_n_u32_x' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svsqadd_x' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svsqadd_n_u32_x' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svsqadd_x' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svsqadd,_n_u32,_x,)(pg, svundef_u32(), i32); - // expected-error@+2 {{'svqsub_u32_z' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqsub_z' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqsub_u32_z' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqsub_z' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqsub,_u32,_z,)(pg, svundef_u32(), svundef_u32()); - // expected-error@+2 {{'svqsub_u32_m' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqsub_m' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqsub_u32_m' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqsub_m' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqsub,_u32,_m,)(pg, svundef_u32(), svundef_u32()); - // expected-error@+2 {{'svqsub_u32_x' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqsub_x' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqsub_u32_x' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqsub_x' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqsub,_u32,_x,)(pg, svundef_u32(), svundef_u32()); - // expected-error@+2 {{'svqsub_n_u32_z' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqsub_z' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqsub_n_u32_z' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqsub_z' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqsub,_n_u32,_z,)(pg, svundef_u32(), u32); - // expected-error@+2 {{'svqsub_n_u32_m' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqsub_m' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqsub_n_u32_m' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqsub_m' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqsub,_n_u32,_m,)(pg, svundef_u32(), u32); - // expected-error@+2 {{'svqsub_n_u32_x' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqsub_x' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqsub_n_u32_x' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqsub_x' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqsub,_n_u32,_x,)(pg, svundef_u32(), u32); - // expected-error@+2 {{'svrsubhnb_u32' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svrsubhnb' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svrsubhnb_u32' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svrsubhnb' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svrsubhnb,_u32,,)(svundef_u32(), svundef_u32()); - // expected-error@+2 {{'svrsubhnb_n_u32' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svrsubhnb' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svrsubhnb_n_u32' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svrsubhnb' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svrsubhnb,_n_u32,,)(svundef_u32(), u32); - // expected-error@+2 {{'svaddhnb_u32' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svaddhnb' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svaddhnb_u32' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svaddhnb' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svaddhnb,_u32,,)(svundef_u32(), svundef_u32()); - // expected-error@+2 {{'svaddhnb_n_u32' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svaddhnb' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svaddhnb_n_u32' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svaddhnb' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svaddhnb,_n_u32,,)(svundef_u32(), u32); - // expected-error@+2 {{'svabalt_u32' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svabalt' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svabalt_u32' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svabalt' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svabalt,_u32,,)(svundef_u32(), svundef_u16(), svundef_u16()); - // expected-error@+2 {{'svabalt_n_u32' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svabalt' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svabalt_n_u32' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svabalt' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svabalt,_n_u32,,)(svundef_u32(), svundef_u16(), u16); - // expected-error@+2 {{'sveor3_u32' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'sveor3' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'sveor3_u32' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'sveor3' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(sveor3,_u32,,)(svundef_u32(), svundef_u32(), svundef_u32()); - // expected-error@+2 {{'sveor3_n_u32' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'sveor3' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'sveor3_n_u32' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'sveor3' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(sveor3,_n_u32,,)(svundef_u32(), svundef_u32(), u32); - // expected-error@+2 {{'svhadd_u32_m' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svhadd_m' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svhadd_u32_m' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svhadd_m' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svhadd,_u32,_m,)(pg, svundef_u32(), svundef_u32()); - // expected-error@+2 {{'svhadd_n_u32_m' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svhadd_m' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svhadd_n_u32_m' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svhadd_m' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svhadd,_n_u32,_m,)(pg, svundef_u32(), u32); - // expected-error@+2 {{'svhadd_u32_z' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svhadd_z' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svhadd_u32_z' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svhadd_z' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svhadd,_u32,_z,)(pg, svundef_u32(), svundef_u32()); - // expected-error@+2 {{'svhadd_n_u32_z' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svhadd_z' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svhadd_n_u32_z' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svhadd_z' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svhadd,_n_u32,_z,)(pg, svundef_u32(), u32); - // expected-error@+2 {{'svhadd_u32_x' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svhadd_x' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svhadd_u32_x' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svhadd_x' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svhadd,_u32,_x,)(pg, svundef_u32(), svundef_u32()); - // expected-error@+2 {{'svhadd_n_u32_x' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svhadd_x' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svhadd_n_u32_x' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svhadd_x' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svhadd,_n_u32,_x,)(pg, svundef_u32(), u32); - // expected-error@+2 {{'svmovlb_u32' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svmovlb' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svmovlb_u32' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svmovlb' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svmovlb,_u32,,)(svundef_u16()); // expected-error@+2 {{'svstnt1_scatter_u32base_u32' needs target feature sve,sve2}} // overload-error@+1 {{'svstnt1_scatter' needs target feature sve,sve2}} @@ -3715,23 +3715,23 @@ void test(svbool_t pg, const int8_t *const_i8_ptr, const uint8_t *const_u8_ptr, // expected-error@+2 {{'svstnt1_scatter_u32base_index_u32' needs target feature sve,sve2}} // overload-error@+1 {{'svstnt1_scatter_index' needs target feature sve,sve2}} SVE_ACLE_FUNC(svstnt1_scatter, _u32base, _index, _u32)(pg, svundef_u32(), i64, svundef_u32()); - // expected-error@+2 {{'svmaxp_u32_m' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svmaxp_m' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svmaxp_u32_m' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svmaxp_m' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svmaxp,_u32,_m,)(pg, svundef_u32(), svundef_u32()); - // expected-error@+2 {{'svmaxp_u32_x' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svmaxp_x' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svmaxp_u32_x' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svmaxp_x' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svmaxp,_u32,_x,)(pg, svundef_u32(), svundef_u32()); - // expected-error@+2 {{'svsbclt_u32' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svsbclt' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svsbclt_u32' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svsbclt' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svsbclt,_u32,,)(svundef_u32(), svundef_u32(), svundef_u32()); - // expected-error@+2 {{'svsbclt_n_u32' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svsbclt' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svsbclt_n_u32' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svsbclt' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svsbclt,_n_u32,,)(svundef_u32(), svundef_u32(), u32); - // expected-error@+2 {{'svmullt_u32' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svmullt' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svmullt_u32' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svmullt' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svmullt,_u32,,)(svundef_u16(), svundef_u16()); - // expected-error@+2 {{'svmullt_n_u32' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svmullt' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svmullt_n_u32' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svmullt' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svmullt,_n_u32,,)(svundef_u16(), u16); // expected-error@+2 {{'svldnt1sh_gather_u32base_u32' needs target feature sve,sve2}} // overload-error@+1 {{'svldnt1sh_gather_u32' needs target feature sve,sve2}} @@ -3745,41 +3745,41 @@ void test(svbool_t pg, const int8_t *const_i8_ptr, const uint8_t *const_u8_ptr, // expected-error@+2 {{'svldnt1sh_gather_u32base_index_u32' needs target feature sve,sve2}} // overload-error@+1 {{'svldnt1sh_gather_index_u32' needs target feature sve,sve2}} SVE_ACLE_FUNC(svldnt1sh_gather, _u32base, _index_u32, )(pg, svundef_u32(), i64); - // expected-error@+2 {{'svwhilerw_u32' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svwhilerw' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svwhilerw_u32' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svwhilerw' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svwhilerw,_u32,,)(const_u32_ptr, const_u32_ptr); - // expected-error@+2 {{'svrhadd_u32_m' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svrhadd_m' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svrhadd_u32_m' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svrhadd_m' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svrhadd,_u32,_m,)(pg, svundef_u32(), svundef_u32()); - // expected-error@+2 {{'svrhadd_n_u32_m' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svrhadd_m' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svrhadd_n_u32_m' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svrhadd_m' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svrhadd,_n_u32,_m,)(pg, svundef_u32(), u32); - // expected-error@+2 {{'svrhadd_u32_z' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svrhadd_z' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svrhadd_u32_z' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svrhadd_z' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svrhadd,_u32,_z,)(pg, svundef_u32(), svundef_u32()); - // expected-error@+2 {{'svrhadd_n_u32_z' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svrhadd_z' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svrhadd_n_u32_z' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svrhadd_z' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svrhadd,_n_u32,_z,)(pg, svundef_u32(), u32); - // expected-error@+2 {{'svrhadd_u32_x' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svrhadd_x' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svrhadd_u32_x' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svrhadd_x' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svrhadd,_u32,_x,)(pg, svundef_u32(), svundef_u32()); - // expected-error@+2 {{'svrhadd_n_u32_x' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svrhadd_x' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svrhadd_n_u32_x' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svrhadd_x' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svrhadd,_n_u32,_x,)(pg, svundef_u32(), u32); - // expected-error@+2 {{'svraddhnb_u32' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svraddhnb' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svraddhnb_u32' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svraddhnb' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svraddhnb,_u32,,)(svundef_u32(), svundef_u32()); - // expected-error@+2 {{'svraddhnb_n_u32' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svraddhnb' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svraddhnb_n_u32' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svraddhnb' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svraddhnb,_n_u32,,)(svundef_u32(), u32); - // expected-error@+2 {{'svwhilewr_u32' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svwhilewr' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svwhilewr_u32' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svwhilewr' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svwhilewr,_u32,,)(const_u32_ptr, const_u32_ptr); - // expected-error@+2 {{'svmlalb_u32' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svmlalb' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svmlalb_u32' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svmlalb' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svmlalb,_u32,,)(svundef_u32(), svundef_u16(), svundef_u16()); - // expected-error@+2 {{'svmlalb_n_u32' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svmlalb' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svmlalb_n_u32' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svmlalb' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svmlalb,_n_u32,,)(svundef_u32(), svundef_u16(), u16); // expected-error@+2 {{'svldnt1sb_gather_u32base_u32' needs target feature sve,sve2}} // overload-error@+1 {{'svldnt1sb_gather_u32' needs target feature sve,sve2}} @@ -3790,11 +3790,11 @@ void test(svbool_t pg, const int8_t *const_i8_ptr, const uint8_t *const_u8_ptr, // expected-error@+2 {{'svldnt1sb_gather_u32base_offset_u32' needs target feature sve,sve2}} // overload-error@+1 {{'svldnt1sb_gather_offset_u32' needs target feature sve,sve2}} SVE_ACLE_FUNC(svldnt1sb_gather, _u32base, _offset_u32, )(pg, svundef_u32(), i64); - // expected-error@+2 {{'svsubwb_u32' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svsubwb' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svsubwb_u32' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svsubwb' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svsubwb,_u32,,)(svundef_u32(), svundef_u16()); - // expected-error@+2 {{'svsubwb_n_u32' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svsubwb' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svsubwb_n_u32' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svsubwb' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svsubwb,_n_u32,,)(svundef_u32(), u16); // expected-error@+2 {{'svldnt1ub_gather_u32base_u32' needs target feature sve,sve2}} // overload-error@+1 {{'svldnt1ub_gather_u32' needs target feature sve,sve2}} @@ -3805,53 +3805,53 @@ void test(svbool_t pg, const int8_t *const_i8_ptr, const uint8_t *const_u8_ptr, // expected-error@+2 {{'svldnt1ub_gather_u32base_offset_u32' needs target feature sve,sve2}} // overload-error@+1 {{'svldnt1ub_gather_offset_u32' needs target feature sve,sve2}} SVE_ACLE_FUNC(svldnt1ub_gather, _u32base, _offset_u32, )(pg, svundef_u32(), i64); - // expected-error@+2 {{'svaba_u32' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svaba' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svaba_u32' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svaba' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svaba,_u32,,)(svundef_u32(), svundef_u32(), svundef_u32()); - // expected-error@+2 {{'svaba_n_u32' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svaba' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svaba_n_u32' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svaba' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svaba,_n_u32,,)(svundef_u32(), svundef_u32(), u32); - // expected-error@+2 {{'svraddhnt_u32' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svraddhnt' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svraddhnt_u32' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svraddhnt' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svraddhnt,_u32,,)(svundef_u16(), svundef_u32(), svundef_u32()); - // expected-error@+2 {{'svraddhnt_n_u32' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svraddhnt' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svraddhnt_n_u32' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svraddhnt' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svraddhnt,_n_u32,,)(svundef_u16(), svundef_u32(), u32); - // expected-error@+2 {{'sveorbt_u32' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'sveorbt' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'sveorbt_u32' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'sveorbt' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(sveorbt,_u32,,)(svundef_u32(), svundef_u32(), svundef_u32()); - // expected-error@+2 {{'sveorbt_n_u32' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'sveorbt' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'sveorbt_n_u32' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'sveorbt' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(sveorbt,_n_u32,,)(svundef_u32(), svundef_u32(), u32); - // expected-error@+2 {{'svbsl_u32' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svbsl' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svbsl_u32' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svbsl' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svbsl,_u32,,)(svundef_u32(), svundef_u32(), svundef_u32()); - // expected-error@+2 {{'svbsl_n_u32' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svbsl' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svbsl_n_u32' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svbsl' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svbsl,_n_u32,,)(svundef_u32(), svundef_u32(), u32); - // expected-error@+2 {{'svadclb_u32' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svadclb' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svadclb_u32' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svadclb' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svadclb,_u32,,)(svundef_u32(), svundef_u32(), svundef_u32()); - // expected-error@+2 {{'svadclb_n_u32' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svadclb' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svadclb_n_u32' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svadclb' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svadclb,_n_u32,,)(svundef_u32(), svundef_u32(), u32); - // expected-error@+2 {{'svhsub_u32_z' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svhsub_z' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svhsub_u32_z' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svhsub_z' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svhsub,_u32,_z,)(pg, svundef_u32(), svundef_u32()); - // expected-error@+2 {{'svhsub_u32_m' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svhsub_m' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svhsub_u32_m' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svhsub_m' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svhsub,_u32,_m,)(pg, svundef_u32(), svundef_u32()); - // expected-error@+2 {{'svhsub_u32_x' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svhsub_x' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svhsub_u32_x' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svhsub_x' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svhsub,_u32,_x,)(pg, svundef_u32(), svundef_u32()); - // expected-error@+2 {{'svhsub_n_u32_z' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svhsub_z' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svhsub_n_u32_z' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svhsub_z' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svhsub,_n_u32,_z,)(pg, svundef_u32(), u32); - // expected-error@+2 {{'svhsub_n_u32_m' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svhsub_m' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svhsub_n_u32_m' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svhsub_m' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svhsub,_n_u32,_m,)(pg, svundef_u32(), u32); - // expected-error@+2 {{'svhsub_n_u32_x' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svhsub_x' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svhsub_n_u32_x' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svhsub_x' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svhsub,_n_u32,_x,)(pg, svundef_u32(), u32); // expected-error@+2 {{'svldnt1_gather_u32base_u32' needs target feature sve,sve2}} // overload-error@+1 {{'svldnt1_gather_u32' needs target feature sve,sve2}} @@ -3865,11 +3865,11 @@ void test(svbool_t pg, const int8_t *const_i8_ptr, const uint8_t *const_u8_ptr, // expected-error@+2 {{'svldnt1_gather_u32base_index_u32' needs target feature sve,sve2}} // overload-error@+1 {{'svldnt1_gather_index_u32' needs target feature sve,sve2}} SVE_ACLE_FUNC(svldnt1_gather, _u32base, _index_u32, )(pg, svundef_u32(), i64); - // expected-error@+2 {{'svaddlb_u32' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svaddlb' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svaddlb_u32' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svaddlb' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svaddlb,_u32,,)(svundef_u16(), svundef_u16()); - // expected-error@+2 {{'svaddlb_n_u32' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svaddlb' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svaddlb_n_u32' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svaddlb' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svaddlb,_n_u32,,)(svundef_u16(), u16); // expected-error@+2 {{'svstnt1h_scatter_u32base_u32' needs target feature sve,sve2}} // overload-error@+1 {{'svstnt1h_scatter' needs target feature sve,sve2}} @@ -3892,207 +3892,207 @@ void test(svbool_t pg, const int8_t *const_i8_ptr, const uint8_t *const_u8_ptr, // expected-error@+2 {{'svstnt1b_scatter_u32base_offset_u32' needs target feature sve,sve2}} // overload-error@+1 {{'svstnt1b_scatter_offset' needs target feature sve,sve2}} SVE_ACLE_FUNC(svstnt1b_scatter, _u32base, _offset, _u32)(pg, svundef_u32(), i64, svundef_u32()); - // expected-error@+2 {{'svbsl2n_u32' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svbsl2n' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svbsl2n_u32' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svbsl2n' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svbsl2n,_u32,,)(svundef_u32(), svundef_u32(), svundef_u32()); - // expected-error@+2 {{'svbsl2n_n_u32' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svbsl2n' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svbsl2n_n_u32' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svbsl2n' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svbsl2n,_n_u32,,)(svundef_u32(), svundef_u32(), u32); - // expected-error@+2 {{'svaddlt_u32' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svaddlt' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svaddlt_u32' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svaddlt' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svaddlt,_u32,,)(svundef_u16(), svundef_u16()); - // expected-error@+2 {{'svaddlt_n_u32' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svaddlt' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svaddlt_n_u32' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svaddlt' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svaddlt,_n_u32,,)(svundef_u16(), u16); - // expected-error@+2 {{'svabalb_u32' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svabalb' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svabalb_u32' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svabalb' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svabalb,_u32,,)(svundef_u32(), svundef_u16(), svundef_u16()); - // expected-error@+2 {{'svabalb_n_u32' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svabalb' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svabalb_n_u32' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svabalb' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svabalb,_n_u32,,)(svundef_u32(), svundef_u16(), u16); - // expected-error@+2 {{'svsublb_u32' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svsublb' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svsublb_u32' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svsublb' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svsublb,_u32,,)(svundef_u16(), svundef_u16()); - // expected-error@+2 {{'svsublb_n_u32' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svsublb' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svsublb_n_u32' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svsublb' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svsublb,_n_u32,,)(svundef_u16(), u16); - // expected-error@+2 {{'svsbclb_u32' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svsbclb' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svsbclb_u32' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svsbclb' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svsbclb,_u32,,)(svundef_u32(), svundef_u32(), svundef_u32()); - // expected-error@+2 {{'svsbclb_n_u32' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svsbclb' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svsbclb_n_u32' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svsbclb' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svsbclb,_n_u32,,)(svundef_u32(), svundef_u32(), u32); - // expected-error@+2 {{'svbsl1n_u32' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svbsl1n' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svbsl1n_u32' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svbsl1n' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svbsl1n,_u32,,)(svundef_u32(), svundef_u32(), svundef_u32()); - // expected-error@+2 {{'svbsl1n_n_u32' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svbsl1n' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svbsl1n_n_u32' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svbsl1n' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svbsl1n,_n_u32,,)(svundef_u32(), svundef_u32(), u32); - // expected-error@+2 {{'svrshl_u32_z' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svrshl_z' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svrshl_u32_z' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svrshl_z' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svrshl,_u32,_z,)(pg, svundef_u32(), svundef_s32()); - // expected-error@+2 {{'svrshl_u32_m' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svrshl_m' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svrshl_u32_m' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svrshl_m' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svrshl,_u32,_m,)(pg, svundef_u32(), svundef_s32()); - // expected-error@+2 {{'svrshl_u32_x' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svrshl_x' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svrshl_u32_x' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svrshl_x' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svrshl,_u32,_x,)(pg, svundef_u32(), svundef_s32()); - // expected-error@+2 {{'svrshl_n_u32_z' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svrshl_z' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svrshl_n_u32_z' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svrshl_z' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svrshl,_n_u32,_z,)(pg, svundef_u32(), i32); - // expected-error@+2 {{'svrshl_n_u32_m' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svrshl_m' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svrshl_n_u32_m' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svrshl_m' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svrshl,_n_u32,_m,)(pg, svundef_u32(), i32); - // expected-error@+2 {{'svrshl_n_u32_x' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svrshl_x' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svrshl_n_u32_x' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svrshl_x' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svrshl,_n_u32,_x,)(pg, svundef_u32(), i32); - // expected-error@+2 {{'svrsqrte_u32_z' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svrsqrte_z' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svrsqrte_u32_z' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svrsqrte_z' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svrsqrte,_u32,_z,)(pg, svundef_u32()); - // expected-error@+2 {{'svrsqrte_u32_m' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svrsqrte_m' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svrsqrte_u32_m' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svrsqrte_m' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svrsqrte,_u32,_m,)(svundef_u32(), pg, svundef_u32()); - // expected-error@+2 {{'svrsqrte_u32_x' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svrsqrte_x' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svrsqrte_u32_x' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svrsqrte_x' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svrsqrte,_u32,_x,)(pg, svundef_u32()); - // expected-error@+2 {{'svaddwt_u32' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svaddwt' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svaddwt_u32' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svaddwt' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svaddwt,_u32,,)(svundef_u32(), svundef_u16()); - // expected-error@+2 {{'svaddwt_n_u32' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svaddwt' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svaddwt_n_u32' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svaddwt' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svaddwt,_n_u32,,)(svundef_u32(), u16); - // expected-error@+2 {{'svmlslb_u32' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svmlslb' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svmlslb_u32' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svmlslb' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svmlslb,_u32,,)(svundef_u32(), svundef_u16(), svundef_u16()); - // expected-error@+2 {{'svmlslb_n_u32' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svmlslb' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svmlslb_n_u32' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svmlslb' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svmlslb,_n_u32,,)(svundef_u32(), svundef_u16(), u16); - // expected-error@+2 {{'svmlslt_u32' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svmlslt' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svmlslt_u32' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svmlslt' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svmlslt,_u32,,)(svundef_u32(), svundef_u16(), svundef_u16()); - // expected-error@+2 {{'svmlslt_n_u32' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svmlslt' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svmlslt_n_u32' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svmlslt' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svmlslt,_n_u32,,)(svundef_u32(), svundef_u16(), u16); - // expected-error@+2 {{'svmovlt_u32' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svmovlt' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svmovlt_u32' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svmovlt' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svmovlt,_u32,,)(svundef_u16()); - // expected-error@+2 {{'svqshl_u32_z' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqshl_z' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqshl_u32_z' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqshl_z' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqshl,_u32,_z,)(pg, svundef_u32(), svundef_s32()); - // expected-error@+2 {{'svqshl_u32_m' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqshl_m' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqshl_u32_m' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqshl_m' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqshl,_u32,_m,)(pg, svundef_u32(), svundef_s32()); - // expected-error@+2 {{'svqshl_u32_x' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqshl_x' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqshl_u32_x' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqshl_x' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqshl,_u32,_x,)(pg, svundef_u32(), svundef_s32()); - // expected-error@+2 {{'svqshl_n_u32_z' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqshl_z' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqshl_n_u32_z' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqshl_z' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqshl,_n_u32,_z,)(pg, svundef_u32(), i32); - // expected-error@+2 {{'svqshl_n_u32_m' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqshl_m' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqshl_n_u32_m' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqshl_m' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqshl,_n_u32,_m,)(pg, svundef_u32(), i32); - // expected-error@+2 {{'svqshl_n_u32_x' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqshl_x' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqshl_n_u32_x' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqshl_x' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqshl,_n_u32,_x,)(pg, svundef_u32(), i32); - // expected-error@+2 {{'svmullb_u64' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svmullb' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svmullb_u64' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svmullb' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svmullb,_u64,,)(svundef_u32(), svundef_u32()); - // expected-error@+2 {{'svmullb_n_u64' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svmullb' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svmullb_n_u64' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svmullb' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svmullb,_n_u64,,)(svundef_u32(), u32); - // expected-error@+2 {{'svpmullb_u64' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svpmullb' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svpmullb_u64' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svpmullb' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svpmullb,_u64,,)(svundef_u32(), svundef_u32()); - // expected-error@+2 {{'svpmullb_n_u64' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svpmullb' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svpmullb_n_u64' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svpmullb' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svpmullb,_n_u64,,)(svundef_u32(), u32); - // expected-error@+2 {{'svaddwb_u64' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svaddwb' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svaddwb_u64' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svaddwb' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svaddwb,_u64,,)(svundef_u64(), svundef_u32()); - // expected-error@+2 {{'svaddwb_n_u64' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svaddwb' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svaddwb_n_u64' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svaddwb' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svaddwb,_n_u64,,)(svundef_u64(), u32); - // expected-error@+2 {{'svsubhnb_u64' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svsubhnb' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svsubhnb_u64' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svsubhnb' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svsubhnb,_u64,,)(svundef_u64(), svundef_u64()); - // expected-error@+2 {{'svsubhnb_n_u64' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svsubhnb' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svsubhnb_n_u64' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svsubhnb' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svsubhnb,_n_u64,,)(svundef_u64(), u64); - // expected-error@+2 {{'svrsubhnt_u64' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svrsubhnt' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svrsubhnt_u64' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svrsubhnt' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svrsubhnt,_u64,,)(svundef_u32(), svundef_u64(), svundef_u64()); - // expected-error@+2 {{'svrsubhnt_n_u64' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svrsubhnt' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svrsubhnt_n_u64' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svrsubhnt' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svrsubhnt,_n_u64,,)(svundef_u32(), svundef_u64(), u64); - // expected-error@+2 {{'svnbsl_u64' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svnbsl' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svnbsl_u64' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svnbsl' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svnbsl,_u64,,)(svundef_u64(), svundef_u64(), svundef_u64()); - // expected-error@+2 {{'svnbsl_n_u64' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svnbsl' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svnbsl_n_u64' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svnbsl' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svnbsl,_n_u64,,)(svundef_u64(), svundef_u64(), u64); - // expected-error@+2 {{'svsubhnt_u64' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svsubhnt' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svsubhnt_u64' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svsubhnt' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svsubhnt,_u64,,)(svundef_u32(), svundef_u64(), svundef_u64()); - // expected-error@+2 {{'svsubhnt_n_u64' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svsubhnt' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svsubhnt_n_u64' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svsubhnt' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svsubhnt,_n_u64,,)(svundef_u32(), svundef_u64(), u64); - // expected-error@+2 {{'svwhilegt_b8_u64' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svwhilegt_b8' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svwhilegt_b8_u64' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svwhilegt_b8' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svwhilegt_b8,_u64,,)(u64, u64); - // expected-error@+2 {{'svwhilegt_b16_u64' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svwhilegt_b16' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svwhilegt_b16_u64' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svwhilegt_b16' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svwhilegt_b16,_u64,,)(u64, u64); - // expected-error@+2 {{'svwhilegt_b32_u64' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svwhilegt_b32' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svwhilegt_b32_u64' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svwhilegt_b32' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svwhilegt_b32,_u64,,)(u64, u64); - // expected-error@+2 {{'svwhilegt_b64_u64' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svwhilegt_b64' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svwhilegt_b64_u64' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svwhilegt_b64' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svwhilegt_b64,_u64,,)(u64, u64); - // expected-error@+2 {{'svtbl2_u64' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svtbl2' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svtbl2_u64' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svtbl2' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svtbl2,_u64,,)(svundef2_u64(), svundef_u64()); - // expected-error@+2 {{'svhsubr_u64_z' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svhsubr_z' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svhsubr_u64_z' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svhsubr_z' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svhsubr,_u64,_z,)(pg, svundef_u64(), svundef_u64()); - // expected-error@+2 {{'svhsubr_u64_m' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svhsubr_m' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svhsubr_u64_m' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svhsubr_m' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svhsubr,_u64,_m,)(pg, svundef_u64(), svundef_u64()); - // expected-error@+2 {{'svhsubr_u64_x' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svhsubr_x' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svhsubr_u64_x' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svhsubr_x' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svhsubr,_u64,_x,)(pg, svundef_u64(), svundef_u64()); - // expected-error@+2 {{'svhsubr_n_u64_z' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svhsubr_z' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svhsubr_n_u64_z' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svhsubr_z' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svhsubr,_n_u64,_z,)(pg, svundef_u64(), u64); - // expected-error@+2 {{'svhsubr_n_u64_m' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svhsubr_m' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svhsubr_n_u64_m' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svhsubr_m' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svhsubr,_n_u64,_m,)(pg, svundef_u64(), u64); - // expected-error@+2 {{'svhsubr_n_u64_x' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svhsubr_x' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svhsubr_n_u64_x' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svhsubr_x' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svhsubr,_n_u64,_x,)(pg, svundef_u64(), u64); // expected-error@+2 {{'svhistcnt_u64_z' needs target feature sve,sve2}} // overload-error@+1 {{'svhistcnt_z' needs target feature sve,sve2}} SVE_ACLE_FUNC(svhistcnt,_u64,_z,)(pg, svundef_u64(), svundef_u64()); - // expected-error@+2 {{'sveortb_u64' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'sveortb' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'sveortb_u64' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'sveortb' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(sveortb,_u64,,)(svundef_u64(), svundef_u64(), svundef_u64()); - // expected-error@+2 {{'sveortb_n_u64' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'sveortb' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'sveortb_n_u64' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'sveortb' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(sveortb,_n_u64,,)(svundef_u64(), svundef_u64(), u64); - // expected-error@+2 {{'svqxtnb_u64' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqxtnb' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqxtnb_u64' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqxtnb' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqxtnb,_u64,,)(svundef_u64()); - // expected-error@+2 {{'svmlalt_u64' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svmlalt' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svmlalt_u64' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svmlalt' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svmlalt,_u64,,)(svundef_u64(), svundef_u32(), svundef_u32()); - // expected-error@+2 {{'svmlalt_n_u64' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svmlalt' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svmlalt_n_u64' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svmlalt' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svmlalt,_n_u64,,)(svundef_u64(), svundef_u32(), u32); - // expected-error@+2 {{'svaddhnt_u64' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svaddhnt' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svaddhnt_u64' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svaddhnt' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svaddhnt,_u64,,)(svundef_u32(), svundef_u64(), svundef_u64()); - // expected-error@+2 {{'svaddhnt_n_u64' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svaddhnt' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svaddhnt_n_u64' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svaddhnt' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svaddhnt,_n_u64,,)(svundef_u32(), svundef_u64(), u64); // expected-error@+2 {{'svldnt1uh_gather_u64base_u64' needs target feature sve,sve2}} // overload-error@+1 {{'svldnt1uh_gather_u64' needs target feature sve,sve2}} @@ -4115,221 +4115,221 @@ void test(svbool_t pg, const int8_t *const_i8_ptr, const uint8_t *const_u8_ptr, // expected-error@+2 {{'svldnt1uh_gather_u64base_index_u64' needs target feature sve,sve2}} // overload-error@+1 {{'svldnt1uh_gather_index_u64' needs target feature sve,sve2}} SVE_ACLE_FUNC(svldnt1uh_gather, _u64base, _index_u64, )(pg, svundef_u64(), i64); - // expected-error@+2 {{'svbcax_u64' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svbcax' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svbcax_u64' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svbcax' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svbcax,_u64,,)(svundef_u64(), svundef_u64(), svundef_u64()); - // expected-error@+2 {{'svbcax_n_u64' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svbcax' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svbcax_n_u64' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svbcax' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svbcax,_n_u64,,)(svundef_u64(), svundef_u64(), u64); - // expected-error@+2 {{'svqxtnt_u64' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqxtnt' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqxtnt_u64' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqxtnt' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqxtnt,_u64,,)(svundef_u32(), svundef_u64()); - // expected-error@+2 {{'svqrshl_u64_z' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqrshl_z' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqrshl_u64_z' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqrshl_z' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqrshl,_u64,_z,)(pg, svundef_u64(), svundef_s64()); - // expected-error@+2 {{'svqrshl_u64_m' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqrshl_m' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqrshl_u64_m' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqrshl_m' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqrshl,_u64,_m,)(pg, svundef_u64(), svundef_s64()); - // expected-error@+2 {{'svqrshl_u64_x' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqrshl_x' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqrshl_u64_x' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqrshl_x' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqrshl,_u64,_x,)(pg, svundef_u64(), svundef_s64()); - // expected-error@+2 {{'svqrshl_n_u64_z' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqrshl_z' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqrshl_n_u64_z' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqrshl_z' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqrshl,_n_u64,_z,)(pg, svundef_u64(), i64); - // expected-error@+2 {{'svqrshl_n_u64_m' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqrshl_m' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqrshl_n_u64_m' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqrshl_m' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqrshl,_n_u64,_m,)(pg, svundef_u64(), i64); - // expected-error@+2 {{'svqrshl_n_u64_x' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqrshl_x' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqrshl_n_u64_x' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqrshl_x' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqrshl,_n_u64,_x,)(pg, svundef_u64(), i64); - // expected-error@+2 {{'svsublt_u64' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svsublt' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svsublt_u64' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svsublt' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svsublt,_u64,,)(svundef_u32(), svundef_u32()); - // expected-error@+2 {{'svsublt_n_u64' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svsublt' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svsublt_n_u64' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svsublt' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svsublt,_n_u64,,)(svundef_u32(), u32); - // expected-error@+2 {{'svadalp_u64_z' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svadalp_z' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svadalp_u64_z' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svadalp_z' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svadalp,_u64,_z,)(pg, svundef_u64(), svundef_u32()); - // expected-error@+2 {{'svadalp_u64_m' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svadalp_m' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svadalp_u64_m' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svadalp_m' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svadalp,_u64,_m,)(pg, svundef_u64(), svundef_u32()); - // expected-error@+2 {{'svadalp_u64_x' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svadalp_x' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svadalp_u64_x' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svadalp_x' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svadalp,_u64,_x,)(pg, svundef_u64(), svundef_u32()); - // expected-error@+2 {{'svwhilege_b8_u64' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svwhilege_b8' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svwhilege_b8_u64' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svwhilege_b8' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svwhilege_b8,_u64,,)(u64, u64); - // expected-error@+2 {{'svwhilege_b16_u64' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svwhilege_b16' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svwhilege_b16_u64' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svwhilege_b16' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svwhilege_b16,_u64,,)(u64, u64); - // expected-error@+2 {{'svwhilege_b32_u64' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svwhilege_b32' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svwhilege_b32_u64' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svwhilege_b32' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svwhilege_b32,_u64,,)(u64, u64); - // expected-error@+2 {{'svwhilege_b64_u64' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svwhilege_b64' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svwhilege_b64_u64' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svwhilege_b64' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svwhilege_b64,_u64,,)(u64, u64); - // expected-error@+2 {{'svpmullt_u64' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svpmullt' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svpmullt_u64' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svpmullt' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svpmullt,_u64,,)(svundef_u32(), svundef_u32()); - // expected-error@+2 {{'svpmullt_n_u64' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svpmullt' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svpmullt_n_u64' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svpmullt' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svpmullt,_n_u64,,)(svundef_u32(), u32); - // expected-error@+2 {{'svsubwt_u64' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svsubwt' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svsubwt_u64' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svsubwt' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svsubwt,_u64,,)(svundef_u64(), svundef_u32()); - // expected-error@+2 {{'svsubwt_n_u64' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svsubwt' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svsubwt_n_u64' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svsubwt' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svsubwt,_n_u64,,)(svundef_u64(), u32); - // expected-error@+2 {{'svqsubr_u64_z' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqsubr_z' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqsubr_u64_z' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqsubr_z' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqsubr,_u64,_z,)(pg, svundef_u64(), svundef_u64()); - // expected-error@+2 {{'svqsubr_u64_m' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqsubr_m' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqsubr_u64_m' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqsubr_m' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqsubr,_u64,_m,)(pg, svundef_u64(), svundef_u64()); - // expected-error@+2 {{'svqsubr_u64_x' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqsubr_x' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqsubr_u64_x' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqsubr_x' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqsubr,_u64,_x,)(pg, svundef_u64(), svundef_u64()); - // expected-error@+2 {{'svqsubr_n_u64_z' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqsubr_z' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqsubr_n_u64_z' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqsubr_z' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqsubr,_n_u64,_z,)(pg, svundef_u64(), u64); - // expected-error@+2 {{'svqsubr_n_u64_m' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqsubr_m' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqsubr_n_u64_m' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqsubr_m' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqsubr,_n_u64,_m,)(pg, svundef_u64(), u64); - // expected-error@+2 {{'svqsubr_n_u64_x' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqsubr_x' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqsubr_n_u64_x' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqsubr_x' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqsubr,_n_u64,_x,)(pg, svundef_u64(), u64); - // expected-error@+2 {{'svadclt_u64' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svadclt' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svadclt_u64' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svadclt' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svadclt,_u64,,)(svundef_u64(), svundef_u64(), svundef_u64()); - // expected-error@+2 {{'svadclt_n_u64' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svadclt' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svadclt_n_u64' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svadclt' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svadclt,_n_u64,,)(svundef_u64(), svundef_u64(), u64); - // expected-error@+2 {{'svaddp_u64_m' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svaddp_m' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svaddp_u64_m' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svaddp_m' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svaddp,_u64,_m,)(pg, svundef_u64(), svundef_u64()); - // expected-error@+2 {{'svaddp_u64_x' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svaddp_x' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svaddp_u64_x' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svaddp_x' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svaddp,_u64,_x,)(pg, svundef_u64(), svundef_u64()); - // expected-error@+2 {{'svqadd_u64_m' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqadd_m' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqadd_u64_m' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqadd_m' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqadd,_u64,_m,)(pg, svundef_u64(), svundef_u64()); - // expected-error@+2 {{'svqadd_n_u64_m' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqadd_m' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqadd_n_u64_m' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqadd_m' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqadd,_n_u64,_m,)(pg, svundef_u64(), u64); - // expected-error@+2 {{'svqadd_u64_z' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqadd_z' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqadd_u64_z' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqadd_z' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqadd,_u64,_z,)(pg, svundef_u64(), svundef_u64()); - // expected-error@+2 {{'svqadd_n_u64_z' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqadd_z' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqadd_n_u64_z' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqadd_z' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqadd,_n_u64,_z,)(pg, svundef_u64(), u64); - // expected-error@+2 {{'svqadd_u64_x' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqadd_x' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqadd_u64_x' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqadd_x' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqadd,_u64,_x,)(pg, svundef_u64(), svundef_u64()); - // expected-error@+2 {{'svqadd_n_u64_x' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqadd_x' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqadd_n_u64_x' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqadd_x' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqadd,_n_u64,_x,)(pg, svundef_u64(), u64); - // expected-error@+2 {{'svabdlb_u64' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svabdlb' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svabdlb_u64' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svabdlb' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svabdlb,_u64,,)(svundef_u32(), svundef_u32()); - // expected-error@+2 {{'svabdlb_n_u64' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svabdlb' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svabdlb_n_u64' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svabdlb' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svabdlb,_n_u64,,)(svundef_u32(), u32); - // expected-error@+2 {{'svtbx_u64' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svtbx' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svtbx_u64' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svtbx' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svtbx,_u64,,)(svundef_u64(), svundef_u64(), svundef_u64()); - // expected-error@+2 {{'svabdlt_u64' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svabdlt' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svabdlt_u64' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svabdlt' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svabdlt,_u64,,)(svundef_u32(), svundef_u32()); - // expected-error@+2 {{'svabdlt_n_u64' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svabdlt' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svabdlt_n_u64' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svabdlt' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svabdlt,_n_u64,,)(svundef_u32(), u32); - // expected-error@+2 {{'svminp_u64_m' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svminp_m' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svminp_u64_m' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svminp_m' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svminp,_u64,_m,)(pg, svundef_u64(), svundef_u64()); - // expected-error@+2 {{'svminp_u64_x' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svminp_x' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svminp_u64_x' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svminp_x' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svminp,_u64,_x,)(pg, svundef_u64(), svundef_u64()); - // expected-error@+2 {{'svsqadd_u64_m' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svsqadd_m' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svsqadd_u64_m' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svsqadd_m' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svsqadd,_u64,_m,)(pg, svundef_u64(), svundef_s64()); - // expected-error@+2 {{'svsqadd_n_u64_m' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svsqadd_m' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svsqadd_n_u64_m' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svsqadd_m' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svsqadd,_n_u64,_m,)(pg, svundef_u64(), i64); - // expected-error@+2 {{'svsqadd_u64_z' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svsqadd_z' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svsqadd_u64_z' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svsqadd_z' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svsqadd,_u64,_z,)(pg, svundef_u64(), svundef_s64()); - // expected-error@+2 {{'svsqadd_n_u64_z' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svsqadd_z' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svsqadd_n_u64_z' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svsqadd_z' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svsqadd,_n_u64,_z,)(pg, svundef_u64(), i64); - // expected-error@+2 {{'svsqadd_u64_x' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svsqadd_x' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svsqadd_u64_x' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svsqadd_x' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svsqadd,_u64,_x,)(pg, svundef_u64(), svundef_s64()); - // expected-error@+2 {{'svsqadd_n_u64_x' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svsqadd_x' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svsqadd_n_u64_x' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svsqadd_x' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svsqadd,_n_u64,_x,)(pg, svundef_u64(), i64); - // expected-error@+2 {{'svqsub_u64_z' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqsub_z' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqsub_u64_z' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqsub_z' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqsub,_u64,_z,)(pg, svundef_u64(), svundef_u64()); - // expected-error@+2 {{'svqsub_u64_m' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqsub_m' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqsub_u64_m' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqsub_m' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqsub,_u64,_m,)(pg, svundef_u64(), svundef_u64()); - // expected-error@+2 {{'svqsub_u64_x' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqsub_x' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqsub_u64_x' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqsub_x' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqsub,_u64,_x,)(pg, svundef_u64(), svundef_u64()); - // expected-error@+2 {{'svqsub_n_u64_z' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqsub_z' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqsub_n_u64_z' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqsub_z' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqsub,_n_u64,_z,)(pg, svundef_u64(), u64); - // expected-error@+2 {{'svqsub_n_u64_m' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqsub_m' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqsub_n_u64_m' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqsub_m' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqsub,_n_u64,_m,)(pg, svundef_u64(), u64); - // expected-error@+2 {{'svqsub_n_u64_x' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqsub_x' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqsub_n_u64_x' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqsub_x' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqsub,_n_u64,_x,)(pg, svundef_u64(), u64); - // expected-error@+2 {{'svrsubhnb_u64' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svrsubhnb' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svrsubhnb_u64' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svrsubhnb' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svrsubhnb,_u64,,)(svundef_u64(), svundef_u64()); - // expected-error@+2 {{'svrsubhnb_n_u64' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svrsubhnb' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svrsubhnb_n_u64' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svrsubhnb' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svrsubhnb,_n_u64,,)(svundef_u64(), u64); - // expected-error@+2 {{'svaddhnb_u64' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svaddhnb' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svaddhnb_u64' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svaddhnb' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svaddhnb,_u64,,)(svundef_u64(), svundef_u64()); - // expected-error@+2 {{'svaddhnb_n_u64' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svaddhnb' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svaddhnb_n_u64' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svaddhnb' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svaddhnb,_n_u64,,)(svundef_u64(), u64); - // expected-error@+2 {{'svabalt_u64' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svabalt' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svabalt_u64' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svabalt' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svabalt,_u64,,)(svundef_u64(), svundef_u32(), svundef_u32()); - // expected-error@+2 {{'svabalt_n_u64' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svabalt' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svabalt_n_u64' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svabalt' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svabalt,_n_u64,,)(svundef_u64(), svundef_u32(), u32); - // expected-error@+2 {{'sveor3_u64' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'sveor3' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'sveor3_u64' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'sveor3' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(sveor3,_u64,,)(svundef_u64(), svundef_u64(), svundef_u64()); - // expected-error@+2 {{'sveor3_n_u64' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'sveor3' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'sveor3_n_u64' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'sveor3' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(sveor3,_n_u64,,)(svundef_u64(), svundef_u64(), u64); - // expected-error@+2 {{'svhadd_u64_m' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svhadd_m' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svhadd_u64_m' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svhadd_m' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svhadd,_u64,_m,)(pg, svundef_u64(), svundef_u64()); - // expected-error@+2 {{'svhadd_n_u64_m' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svhadd_m' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svhadd_n_u64_m' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svhadd_m' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svhadd,_n_u64,_m,)(pg, svundef_u64(), u64); - // expected-error@+2 {{'svhadd_u64_z' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svhadd_z' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svhadd_u64_z' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svhadd_z' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svhadd,_u64,_z,)(pg, svundef_u64(), svundef_u64()); - // expected-error@+2 {{'svhadd_n_u64_z' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svhadd_z' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svhadd_n_u64_z' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svhadd_z' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svhadd,_n_u64,_z,)(pg, svundef_u64(), u64); - // expected-error@+2 {{'svhadd_u64_x' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svhadd_x' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svhadd_u64_x' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svhadd_x' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svhadd,_u64,_x,)(pg, svundef_u64(), svundef_u64()); - // expected-error@+2 {{'svhadd_n_u64_x' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svhadd_x' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svhadd_n_u64_x' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svhadd_x' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svhadd,_n_u64,_x,)(pg, svundef_u64(), u64); - // expected-error@+2 {{'svmovlb_u64' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svmovlb' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svmovlb_u64' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svmovlb' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svmovlb,_u64,,)(svundef_u32()); // expected-error@+2 {{'svstnt1_scatter_u64base_u64' needs target feature sve,sve2}} // overload-error@+1 {{'svstnt1_scatter' needs target feature sve,sve2}} @@ -4352,23 +4352,23 @@ void test(svbool_t pg, const int8_t *const_i8_ptr, const uint8_t *const_u8_ptr, // expected-error@+2 {{'svstnt1_scatter_u64base_index_u64' needs target feature sve,sve2}} // overload-error@+1 {{'svstnt1_scatter_index' needs target feature sve,sve2}} SVE_ACLE_FUNC(svstnt1_scatter, _u64base, _index, _u64)(pg, svundef_u64(), i64, svundef_u64()); - // expected-error@+2 {{'svmaxp_u64_m' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svmaxp_m' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svmaxp_u64_m' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svmaxp_m' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svmaxp,_u64,_m,)(pg, svundef_u64(), svundef_u64()); - // expected-error@+2 {{'svmaxp_u64_x' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svmaxp_x' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svmaxp_u64_x' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svmaxp_x' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svmaxp,_u64,_x,)(pg, svundef_u64(), svundef_u64()); - // expected-error@+2 {{'svsbclt_u64' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svsbclt' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svsbclt_u64' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svsbclt' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svsbclt,_u64,,)(svundef_u64(), svundef_u64(), svundef_u64()); - // expected-error@+2 {{'svsbclt_n_u64' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svsbclt' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svsbclt_n_u64' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svsbclt' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svsbclt,_n_u64,,)(svundef_u64(), svundef_u64(), u64); - // expected-error@+2 {{'svmullt_u64' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svmullt' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svmullt_u64' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svmullt' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svmullt,_u64,,)(svundef_u32(), svundef_u32()); - // expected-error@+2 {{'svmullt_n_u64' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svmullt' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svmullt_n_u64' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svmullt' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svmullt,_n_u64,,)(svundef_u32(), u32); // expected-error@+2 {{'svldnt1sh_gather_u64base_u64' needs target feature sve,sve2}} // overload-error@+1 {{'svldnt1sh_gather_u64' needs target feature sve,sve2}} @@ -4391,41 +4391,41 @@ void test(svbool_t pg, const int8_t *const_i8_ptr, const uint8_t *const_u8_ptr, // expected-error@+2 {{'svldnt1sh_gather_u64base_index_u64' needs target feature sve,sve2}} // overload-error@+1 {{'svldnt1sh_gather_index_u64' needs target feature sve,sve2}} SVE_ACLE_FUNC(svldnt1sh_gather, _u64base, _index_u64, )(pg, svundef_u64(), i64); - // expected-error@+2 {{'svwhilerw_u64' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svwhilerw' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svwhilerw_u64' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svwhilerw' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svwhilerw,_u64,,)(const_u64_ptr, const_u64_ptr); - // expected-error@+2 {{'svrhadd_u64_m' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svrhadd_m' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svrhadd_u64_m' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svrhadd_m' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svrhadd,_u64,_m,)(pg, svundef_u64(), svundef_u64()); - // expected-error@+2 {{'svrhadd_n_u64_m' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svrhadd_m' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svrhadd_n_u64_m' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svrhadd_m' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svrhadd,_n_u64,_m,)(pg, svundef_u64(), u64); - // expected-error@+2 {{'svrhadd_u64_z' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svrhadd_z' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svrhadd_u64_z' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svrhadd_z' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svrhadd,_u64,_z,)(pg, svundef_u64(), svundef_u64()); - // expected-error@+2 {{'svrhadd_n_u64_z' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svrhadd_z' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svrhadd_n_u64_z' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svrhadd_z' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svrhadd,_n_u64,_z,)(pg, svundef_u64(), u64); - // expected-error@+2 {{'svrhadd_u64_x' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svrhadd_x' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svrhadd_u64_x' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svrhadd_x' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svrhadd,_u64,_x,)(pg, svundef_u64(), svundef_u64()); - // expected-error@+2 {{'svrhadd_n_u64_x' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svrhadd_x' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svrhadd_n_u64_x' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svrhadd_x' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svrhadd,_n_u64,_x,)(pg, svundef_u64(), u64); - // expected-error@+2 {{'svraddhnb_u64' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svraddhnb' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svraddhnb_u64' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svraddhnb' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svraddhnb,_u64,,)(svundef_u64(), svundef_u64()); - // expected-error@+2 {{'svraddhnb_n_u64' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svraddhnb' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svraddhnb_n_u64' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svraddhnb' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svraddhnb,_n_u64,,)(svundef_u64(), u64); - // expected-error@+2 {{'svwhilewr_u64' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svwhilewr' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svwhilewr_u64' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svwhilewr' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svwhilewr,_u64,,)(const_u64_ptr, const_u64_ptr); - // expected-error@+2 {{'svmlalb_u64' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svmlalb' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svmlalb_u64' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svmlalb' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svmlalb,_u64,,)(svundef_u64(), svundef_u32(), svundef_u32()); - // expected-error@+2 {{'svmlalb_n_u64' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svmlalb' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svmlalb_n_u64' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svmlalb' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svmlalb,_n_u64,,)(svundef_u64(), svundef_u32(), u32); // expected-error@+2 {{'svldnt1sb_gather_u64base_u64' needs target feature sve,sve2}} // overload-error@+1 {{'svldnt1sb_gather_u64' needs target feature sve,sve2}} @@ -4439,11 +4439,11 @@ void test(svbool_t pg, const int8_t *const_i8_ptr, const uint8_t *const_u8_ptr, // expected-error@+2 {{'svldnt1sb_gather_u64base_offset_u64' needs target feature sve,sve2}} // overload-error@+1 {{'svldnt1sb_gather_offset_u64' needs target feature sve,sve2}} SVE_ACLE_FUNC(svldnt1sb_gather, _u64base, _offset_u64, )(pg, svundef_u64(), i64); - // expected-error@+2 {{'svsubwb_u64' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svsubwb' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svsubwb_u64' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svsubwb' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svsubwb,_u64,,)(svundef_u64(), svundef_u32()); - // expected-error@+2 {{'svsubwb_n_u64' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svsubwb' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svsubwb_n_u64' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svsubwb' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svsubwb,_n_u64,,)(svundef_u64(), u32); // expected-error@+2 {{'svldnt1ub_gather_u64base_u64' needs target feature sve,sve2}} // overload-error@+1 {{'svldnt1ub_gather_u64' needs target feature sve,sve2}} @@ -4457,23 +4457,23 @@ void test(svbool_t pg, const int8_t *const_i8_ptr, const uint8_t *const_u8_ptr, // expected-error@+2 {{'svldnt1ub_gather_u64base_offset_u64' needs target feature sve,sve2}} // overload-error@+1 {{'svldnt1ub_gather_offset_u64' needs target feature sve,sve2}} SVE_ACLE_FUNC(svldnt1ub_gather, _u64base, _offset_u64, )(pg, svundef_u64(), i64); - // expected-error@+2 {{'svaba_u64' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svaba' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svaba_u64' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svaba' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svaba,_u64,,)(svundef_u64(), svundef_u64(), svundef_u64()); - // expected-error@+2 {{'svaba_n_u64' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svaba' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svaba_n_u64' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svaba' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svaba,_n_u64,,)(svundef_u64(), svundef_u64(), u64); - // expected-error@+2 {{'svraddhnt_u64' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svraddhnt' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svraddhnt_u64' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svraddhnt' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svraddhnt,_u64,,)(svundef_u32(), svundef_u64(), svundef_u64()); - // expected-error@+2 {{'svraddhnt_n_u64' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svraddhnt' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svraddhnt_n_u64' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svraddhnt' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svraddhnt,_n_u64,,)(svundef_u32(), svundef_u64(), u64); - // expected-error@+2 {{'sveorbt_u64' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'sveorbt' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'sveorbt_u64' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'sveorbt' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(sveorbt,_u64,,)(svundef_u64(), svundef_u64(), svundef_u64()); - // expected-error@+2 {{'sveorbt_n_u64' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'sveorbt' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'sveorbt_n_u64' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'sveorbt' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(sveorbt,_n_u64,,)(svundef_u64(), svundef_u64(), u64); // expected-error@+2 {{'svldnt1sw_gather_u64base_u64' needs target feature sve,sve2}} // overload-error@+1 {{'svldnt1sw_gather_u64' needs target feature sve,sve2}} @@ -4496,35 +4496,35 @@ void test(svbool_t pg, const int8_t *const_i8_ptr, const uint8_t *const_u8_ptr, // expected-error@+2 {{'svldnt1sw_gather_u64base_index_u64' needs target feature sve,sve2}} // overload-error@+1 {{'svldnt1sw_gather_index_u64' needs target feature sve,sve2}} SVE_ACLE_FUNC(svldnt1sw_gather, _u64base, _index_u64, )(pg, svundef_u64(), i64); - // expected-error@+2 {{'svbsl_u64' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svbsl' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svbsl_u64' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svbsl' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svbsl,_u64,,)(svundef_u64(), svundef_u64(), svundef_u64()); - // expected-error@+2 {{'svbsl_n_u64' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svbsl' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svbsl_n_u64' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svbsl' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svbsl,_n_u64,,)(svundef_u64(), svundef_u64(), u64); - // expected-error@+2 {{'svadclb_u64' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svadclb' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svadclb_u64' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svadclb' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svadclb,_u64,,)(svundef_u64(), svundef_u64(), svundef_u64()); - // expected-error@+2 {{'svadclb_n_u64' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svadclb' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svadclb_n_u64' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svadclb' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svadclb,_n_u64,,)(svundef_u64(), svundef_u64(), u64); - // expected-error@+2 {{'svhsub_u64_z' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svhsub_z' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svhsub_u64_z' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svhsub_z' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svhsub,_u64,_z,)(pg, svundef_u64(), svundef_u64()); - // expected-error@+2 {{'svhsub_u64_m' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svhsub_m' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svhsub_u64_m' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svhsub_m' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svhsub,_u64,_m,)(pg, svundef_u64(), svundef_u64()); - // expected-error@+2 {{'svhsub_u64_x' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svhsub_x' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svhsub_u64_x' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svhsub_x' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svhsub,_u64,_x,)(pg, svundef_u64(), svundef_u64()); - // expected-error@+2 {{'svhsub_n_u64_z' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svhsub_z' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svhsub_n_u64_z' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svhsub_z' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svhsub,_n_u64,_z,)(pg, svundef_u64(), u64); - // expected-error@+2 {{'svhsub_n_u64_m' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svhsub_m' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svhsub_n_u64_m' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svhsub_m' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svhsub,_n_u64,_m,)(pg, svundef_u64(), u64); - // expected-error@+2 {{'svhsub_n_u64_x' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svhsub_x' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svhsub_n_u64_x' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svhsub_x' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svhsub,_n_u64,_x,)(pg, svundef_u64(), u64); // expected-error@+2 {{'svldnt1_gather_u64base_u64' needs target feature sve,sve2}} // overload-error@+1 {{'svldnt1_gather_u64' needs target feature sve,sve2}} @@ -4547,11 +4547,11 @@ void test(svbool_t pg, const int8_t *const_i8_ptr, const uint8_t *const_u8_ptr, // expected-error@+2 {{'svldnt1_gather_u64base_index_u64' needs target feature sve,sve2}} // overload-error@+1 {{'svldnt1_gather_index_u64' needs target feature sve,sve2}} SVE_ACLE_FUNC(svldnt1_gather, _u64base, _index_u64, )(pg, svundef_u64(), i64); - // expected-error@+2 {{'svaddlb_u64' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svaddlb' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svaddlb_u64' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svaddlb' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svaddlb,_u64,,)(svundef_u32(), svundef_u32()); - // expected-error@+2 {{'svaddlb_n_u64' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svaddlb' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svaddlb_n_u64' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svaddlb' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svaddlb,_n_u64,,)(svundef_u32(), u32); // expected-error@+2 {{'svldnt1uw_gather_u64base_u64' needs target feature sve,sve2}} // overload-error@+1 {{'svldnt1uw_gather_u64' needs target feature sve,sve2}} @@ -4607,17 +4607,17 @@ void test(svbool_t pg, const int8_t *const_i8_ptr, const uint8_t *const_u8_ptr, // expected-error@+2 {{'svstnt1b_scatter_u64base_offset_u64' needs target feature sve,sve2}} // overload-error@+1 {{'svstnt1b_scatter_offset' needs target feature sve,sve2}} SVE_ACLE_FUNC(svstnt1b_scatter, _u64base, _offset, _u64)(pg, svundef_u64(), i64, svundef_u64()); - // expected-error@+2 {{'svbsl2n_u64' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svbsl2n' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svbsl2n_u64' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svbsl2n' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svbsl2n,_u64,,)(svundef_u64(), svundef_u64(), svundef_u64()); - // expected-error@+2 {{'svbsl2n_n_u64' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svbsl2n' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svbsl2n_n_u64' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svbsl2n' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svbsl2n,_n_u64,,)(svundef_u64(), svundef_u64(), u64); - // expected-error@+2 {{'svaddlt_u64' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svaddlt' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svaddlt_u64' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svaddlt' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svaddlt,_u64,,)(svundef_u32(), svundef_u32()); - // expected-error@+2 {{'svaddlt_n_u64' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svaddlt' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svaddlt_n_u64' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svaddlt' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svaddlt,_n_u64,,)(svundef_u32(), u32); // expected-error@+2 {{'svstnt1w_scatter_u64base_u64' needs target feature sve,sve2}} // overload-error@+1 {{'svstnt1w_scatter' needs target feature sve,sve2}} @@ -4640,178 +4640,178 @@ void test(svbool_t pg, const int8_t *const_i8_ptr, const uint8_t *const_u8_ptr, // expected-error@+2 {{'svstnt1w_scatter_u64base_index_u64' needs target feature sve,sve2}} // overload-error@+1 {{'svstnt1w_scatter_index' needs target feature sve,sve2}} SVE_ACLE_FUNC(svstnt1w_scatter, _u64base, _index, _u64)(pg, svundef_u64(), i64, svundef_u64()); - // expected-error@+2 {{'svabalb_u64' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svabalb' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svabalb_u64' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svabalb' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svabalb,_u64,,)(svundef_u64(), svundef_u32(), svundef_u32()); - // expected-error@+2 {{'svabalb_n_u64' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svabalb' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svabalb_n_u64' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svabalb' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svabalb,_n_u64,,)(svundef_u64(), svundef_u32(), u32); - // expected-error@+2 {{'svsublb_u64' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svsublb' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svsublb_u64' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svsublb' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svsublb,_u64,,)(svundef_u32(), svundef_u32()); - // expected-error@+2 {{'svsublb_n_u64' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svsublb' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svsublb_n_u64' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svsublb' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svsublb,_n_u64,,)(svundef_u32(), u32); - // expected-error@+2 {{'svsbclb_u64' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svsbclb' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svsbclb_u64' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svsbclb' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svsbclb,_u64,,)(svundef_u64(), svundef_u64(), svundef_u64()); - // expected-error@+2 {{'svsbclb_n_u64' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svsbclb' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svsbclb_n_u64' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svsbclb' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svsbclb,_n_u64,,)(svundef_u64(), svundef_u64(), u64); - // expected-error@+2 {{'svbsl1n_u64' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svbsl1n' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svbsl1n_u64' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svbsl1n' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svbsl1n,_u64,,)(svundef_u64(), svundef_u64(), svundef_u64()); - // expected-error@+2 {{'svbsl1n_n_u64' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svbsl1n' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svbsl1n_n_u64' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svbsl1n' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svbsl1n,_n_u64,,)(svundef_u64(), svundef_u64(), u64); - // expected-error@+2 {{'svrshl_u64_z' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svrshl_z' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svrshl_u64_z' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svrshl_z' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svrshl,_u64,_z,)(pg, svundef_u64(), svundef_s64()); - // expected-error@+2 {{'svrshl_u64_m' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svrshl_m' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svrshl_u64_m' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svrshl_m' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svrshl,_u64,_m,)(pg, svundef_u64(), svundef_s64()); - // expected-error@+2 {{'svrshl_u64_x' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svrshl_x' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svrshl_u64_x' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svrshl_x' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svrshl,_u64,_x,)(pg, svundef_u64(), svundef_s64()); - // expected-error@+2 {{'svrshl_n_u64_z' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svrshl_z' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svrshl_n_u64_z' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svrshl_z' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svrshl,_n_u64,_z,)(pg, svundef_u64(), i64); - // expected-error@+2 {{'svrshl_n_u64_m' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svrshl_m' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svrshl_n_u64_m' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svrshl_m' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svrshl,_n_u64,_m,)(pg, svundef_u64(), i64); - // expected-error@+2 {{'svrshl_n_u64_x' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svrshl_x' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svrshl_n_u64_x' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svrshl_x' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svrshl,_n_u64,_x,)(pg, svundef_u64(), i64); - // expected-error@+2 {{'svaddwt_u64' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svaddwt' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svaddwt_u64' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svaddwt' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svaddwt,_u64,,)(svundef_u64(), svundef_u32()); - // expected-error@+2 {{'svaddwt_n_u64' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svaddwt' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svaddwt_n_u64' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svaddwt' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svaddwt,_n_u64,,)(svundef_u64(), u32); - // expected-error@+2 {{'svmlslb_u64' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svmlslb' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svmlslb_u64' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svmlslb' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svmlslb,_u64,,)(svundef_u64(), svundef_u32(), svundef_u32()); - // expected-error@+2 {{'svmlslb_n_u64' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svmlslb' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svmlslb_n_u64' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svmlslb' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svmlslb,_n_u64,,)(svundef_u64(), svundef_u32(), u32); - // expected-error@+2 {{'svmlslt_u64' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svmlslt' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svmlslt_u64' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svmlslt' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svmlslt,_u64,,)(svundef_u64(), svundef_u32(), svundef_u32()); - // expected-error@+2 {{'svmlslt_n_u64' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svmlslt' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svmlslt_n_u64' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svmlslt' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svmlslt,_n_u64,,)(svundef_u64(), svundef_u32(), u32); - // expected-error@+2 {{'svmovlt_u64' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svmovlt' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svmovlt_u64' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svmovlt' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svmovlt,_u64,,)(svundef_u32()); - // expected-error@+2 {{'svqshl_u64_z' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqshl_z' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqshl_u64_z' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqshl_z' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqshl,_u64,_z,)(pg, svundef_u64(), svundef_s64()); - // expected-error@+2 {{'svqshl_u64_m' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqshl_m' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqshl_u64_m' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqshl_m' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqshl,_u64,_m,)(pg, svundef_u64(), svundef_s64()); - // expected-error@+2 {{'svqshl_u64_x' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqshl_x' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqshl_u64_x' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqshl_x' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqshl,_u64,_x,)(pg, svundef_u64(), svundef_s64()); - // expected-error@+2 {{'svqshl_n_u64_z' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqshl_z' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqshl_n_u64_z' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqshl_z' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqshl,_n_u64,_z,)(pg, svundef_u64(), i64); - // expected-error@+2 {{'svqshl_n_u64_m' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqshl_m' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqshl_n_u64_m' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqshl_m' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqshl,_n_u64,_m,)(pg, svundef_u64(), i64); - // expected-error@+2 {{'svqshl_n_u64_x' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svqshl_x' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svqshl_n_u64_x' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svqshl_x' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svqshl,_n_u64,_x,)(pg, svundef_u64(), i64); - // expected-error@+2 {{'svlogb_f16_z' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svlogb_z' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svlogb_f16_z' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svlogb_z' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svlogb,_f16,_z,)(pg, svundef_f16()); - // expected-error@+2 {{'svlogb_f16_m' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svlogb_m' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svlogb_f16_m' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svlogb_m' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svlogb,_f16,_m,)(svundef_s16(), pg, svundef_f16()); - // expected-error@+2 {{'svlogb_f16_x' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svlogb_x' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svlogb_f16_x' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svlogb_x' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svlogb,_f16,_x,)(pg, svundef_f16()); - // expected-error@+2 {{'svminnmp_f16_m' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svminnmp_m' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svminnmp_f16_m' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svminnmp_m' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svminnmp,_f16,_m,)(pg, svundef_f16(), svundef_f16()); - // expected-error@+2 {{'svminnmp_f16_x' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svminnmp_x' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svminnmp_f16_x' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svminnmp_x' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svminnmp,_f16,_x,)(pg, svundef_f16(), svundef_f16()); - // expected-error@+2 {{'svtbl2_f16' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svtbl2' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svtbl2_f16' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svtbl2' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svtbl2,_f16,,)(svundef2_f16(), svundef_u16()); - // expected-error@+2 {{'svaddp_f16_m' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svaddp_m' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svaddp_f16_m' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svaddp_m' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svaddp,_f16,_m,)(pg, svundef_f16(), svundef_f16()); - // expected-error@+2 {{'svaddp_f16_x' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svaddp_x' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svaddp_f16_x' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svaddp_x' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svaddp,_f16,_x,)(pg, svundef_f16(), svundef_f16()); - // expected-error@+2 {{'svtbx_f16' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svtbx' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svtbx_f16' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svtbx' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svtbx,_f16,,)(svundef_f16(), svundef_f16(), svundef_u16()); - // expected-error@+2 {{'svminp_f16_m' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svminp_m' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svminp_f16_m' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svminp_m' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svminp,_f16,_m,)(pg, svundef_f16(), svundef_f16()); - // expected-error@+2 {{'svminp_f16_x' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svminp_x' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svminp_f16_x' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svminp_x' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svminp,_f16,_x,)(pg, svundef_f16(), svundef_f16()); - // expected-error@+2 {{'svmaxp_f16_m' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svmaxp_m' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svmaxp_f16_m' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svmaxp_m' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svmaxp,_f16,_m,)(pg, svundef_f16(), svundef_f16()); - // expected-error@+2 {{'svmaxp_f16_x' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svmaxp_x' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svmaxp_f16_x' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svmaxp_x' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svmaxp,_f16,_x,)(pg, svundef_f16(), svundef_f16()); - // expected-error@+2 {{'svmaxnmp_f16_m' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svmaxnmp_m' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svmaxnmp_f16_m' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svmaxnmp_m' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svmaxnmp,_f16,_m,)(pg, svundef_f16(), svundef_f16()); - // expected-error@+2 {{'svmaxnmp_f16_x' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svmaxnmp_x' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svmaxnmp_f16_x' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svmaxnmp_x' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svmaxnmp,_f16,_x,)(pg, svundef_f16(), svundef_f16()); - // expected-error@+2 {{'svwhilerw_f16' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svwhilerw' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svwhilerw_f16' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svwhilerw' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svwhilerw,_f16,,)(const_f16_ptr, const_f16_ptr); - // expected-error@+2 {{'svwhilewr_f16' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svwhilewr' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svwhilewr_f16' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svwhilewr' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svwhilewr,_f16,,)(const_f16_ptr, const_f16_ptr); - // expected-error@+2 {{'svcvtlt_f32_f16_m' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svcvtlt_f32_m' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svcvtlt_f32_f16_m' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svcvtlt_f32_m' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svcvtlt_f32,_f16,_m,)(svundef_f32(), pg, svundef_f16()); - // expected-error@+2 {{'svcvtlt_f32_f16_x' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svcvtlt_f32_x' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svcvtlt_f32_f16_x' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svcvtlt_f32_x' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svcvtlt_f32,_f16,_x,)(pg, svundef_f16()); - // expected-error@+2 {{'svlogb_f32_z' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svlogb_z' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svlogb_f32_z' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svlogb_z' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svlogb,_f32,_z,)(pg, svundef_f32()); - // expected-error@+2 {{'svlogb_f32_m' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svlogb_m' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svlogb_f32_m' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svlogb_m' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svlogb,_f32,_m,)(svundef_s32(), pg, svundef_f32()); - // expected-error@+2 {{'svlogb_f32_x' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svlogb_x' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svlogb_f32_x' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svlogb_x' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svlogb,_f32,_x,)(pg, svundef_f32()); - // expected-error@+2 {{'svminnmp_f32_m' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svminnmp_m' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svminnmp_f32_m' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svminnmp_m' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svminnmp,_f32,_m,)(pg, svundef_f32(), svundef_f32()); - // expected-error@+2 {{'svminnmp_f32_x' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svminnmp_x' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svminnmp_f32_x' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svminnmp_x' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svminnmp,_f32,_x,)(pg, svundef_f32(), svundef_f32()); - // expected-error@+2 {{'svtbl2_f32' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svtbl2' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svtbl2_f32' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svtbl2' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svtbl2,_f32,,)(svundef2_f32(), svundef_u32()); - // expected-error@+2 {{'svaddp_f32_m' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svaddp_m' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svaddp_f32_m' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svaddp_m' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svaddp,_f32,_m,)(pg, svundef_f32(), svundef_f32()); - // expected-error@+2 {{'svaddp_f32_x' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svaddp_x' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svaddp_f32_x' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svaddp_x' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svaddp,_f32,_x,)(pg, svundef_f32(), svundef_f32()); - // expected-error@+2 {{'svtbx_f32' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svtbx' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svtbx_f32' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svtbx' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svtbx,_f32,,)(svundef_f32(), svundef_f32(), svundef_u32()); - // expected-error@+2 {{'svminp_f32_m' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svminp_m' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svminp_f32_m' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svminp_m' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svminp,_f32,_m,)(pg, svundef_f32(), svundef_f32()); - // expected-error@+2 {{'svminp_f32_x' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svminp_x' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svminp_f32_x' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svminp_x' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svminp,_f32,_x,)(pg, svundef_f32(), svundef_f32()); // expected-error@+2 {{'svstnt1_scatter_u32base_f32' needs target feature sve,sve2}} // overload-error@+1 {{'svstnt1_scatter' needs target feature sve,sve2}} @@ -4825,35 +4825,35 @@ void test(svbool_t pg, const int8_t *const_i8_ptr, const uint8_t *const_u8_ptr, // expected-error@+2 {{'svstnt1_scatter_u32base_index_f32' needs target feature sve,sve2}} // overload-error@+1 {{'svstnt1_scatter_index' needs target feature sve,sve2}} SVE_ACLE_FUNC(svstnt1_scatter, _u32base, _index, _f32)(pg, svundef_u32(), i64, svundef_f32()); - // expected-error@+2 {{'svmaxp_f32_m' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svmaxp_m' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svmaxp_f32_m' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svmaxp_m' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svmaxp,_f32,_m,)(pg, svundef_f32(), svundef_f32()); - // expected-error@+2 {{'svmaxp_f32_x' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svmaxp_x' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svmaxp_f32_x' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svmaxp_x' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svmaxp,_f32,_x,)(pg, svundef_f32(), svundef_f32()); - // expected-error@+2 {{'svmaxnmp_f32_m' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svmaxnmp_m' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svmaxnmp_f32_m' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svmaxnmp_m' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svmaxnmp,_f32,_m,)(pg, svundef_f32(), svundef_f32()); - // expected-error@+2 {{'svmaxnmp_f32_x' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svmaxnmp_x' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svmaxnmp_f32_x' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svmaxnmp_x' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svmaxnmp,_f32,_x,)(pg, svundef_f32(), svundef_f32()); - // expected-error@+2 {{'svwhilerw_f32' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svwhilerw' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svwhilerw_f32' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svwhilerw' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svwhilerw,_f32,,)(const_f32_ptr, const_f32_ptr); - // expected-error@+2 {{'svcvtnt_f16_f32_m' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svcvtnt_f16_m' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svcvtnt_f16_f32_m' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svcvtnt_f16_m' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svcvtnt_f16,_f32,_m,)(svundef_f16(), pg, svundef_f32()); - // expected-error@+2 {{'svcvtnt_f16_f32_m' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svcvtnt_f16_m' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svcvtnt_f16_f32_m' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svcvtnt_f16_m' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svcvtnt_f16,_f32,_x,)(svundef_f16(), pg, svundef_f32()); - // expected-error@+2 {{'svwhilewr_f32' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svwhilewr' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svwhilewr_f32' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svwhilewr' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svwhilewr,_f32,,)(const_f32_ptr, const_f32_ptr); - // expected-error@+2 {{'svcvtlt_f64_f32_m' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svcvtlt_f64_m' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svcvtlt_f64_f32_m' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svcvtlt_f64_m' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svcvtlt_f64,_f32,_m,)(svundef_f64(), pg, svundef_f32()); - // expected-error@+2 {{'svcvtlt_f64_f32_x' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svcvtlt_f64_x' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svcvtlt_f64_f32_x' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svcvtlt_f64_x' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svcvtlt_f64,_f32,_x,)(pg, svundef_f32()); // expected-error@+2 {{'svldnt1_gather_u32base_f32' needs target feature sve,sve2}} // overload-error@+1 {{'svldnt1_gather_f32' needs target feature sve,sve2}} @@ -4868,38 +4868,38 @@ void test(svbool_t pg, const int8_t *const_i8_ptr, const uint8_t *const_u8_ptr, // overload-error@+1 {{'svldnt1_gather_index_f32' needs target feature sve,sve2}} SVE_ACLE_FUNC(svldnt1_gather, _u32base, _index_f32, )(pg, svundef_u32(), i64); - // expected-error@+2 {{'svlogb_f64_z' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svlogb_z' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svlogb_f64_z' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svlogb_z' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svlogb,_f64,_z,)(pg, svundef_f64()); - // expected-error@+2 {{'svlogb_f64_m' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svlogb_m' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svlogb_f64_m' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svlogb_m' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svlogb,_f64,_m,)(svundef_s64(), pg, svundef_f64()); - // expected-error@+2 {{'svlogb_f64_x' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svlogb_x' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svlogb_f64_x' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svlogb_x' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svlogb,_f64,_x,)(pg, svundef_f64()); - // expected-error@+2 {{'svminnmp_f64_m' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svminnmp_m' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svminnmp_f64_m' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svminnmp_m' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svminnmp,_f64,_m,)(pg, svundef_f64(), svundef_f64()); - // expected-error@+2 {{'svminnmp_f64_x' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svminnmp_x' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svminnmp_f64_x' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svminnmp_x' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svminnmp,_f64,_x,)(pg, svundef_f64(), svundef_f64()); - // expected-error@+2 {{'svtbl2_f64' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svtbl2' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svtbl2_f64' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svtbl2' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svtbl2,_f64,,)(svundef2_f64(), svundef_u64()); - // expected-error@+2 {{'svaddp_f64_m' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svaddp_m' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svaddp_f64_m' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svaddp_m' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svaddp,_f64,_m,)(pg, svundef_f64(), svundef_f64()); - // expected-error@+2 {{'svaddp_f64_x' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svaddp_x' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svaddp_f64_x' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svaddp_x' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svaddp,_f64,_x,)(pg, svundef_f64(), svundef_f64()); - // expected-error@+2 {{'svtbx_f64' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svtbx' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svtbx_f64' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svtbx' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svtbx,_f64,,)(svundef_f64(), svundef_f64(), svundef_u64()); - // expected-error@+2 {{'svminp_f64_m' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svminp_m' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svminp_f64_m' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svminp_m' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svminp,_f64,_m,)(pg, svundef_f64(), svundef_f64()); - // expected-error@+2 {{'svminp_f64_x' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svminp_x' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svminp_f64_x' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svminp_x' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svminp,_f64,_x,)(pg, svundef_f64(), svundef_f64()); // expected-error@+2 {{'svstnt1_scatter_u64base_f64' needs target feature sve,sve2}} // overload-error@+1 {{'svstnt1_scatter' needs target feature sve,sve2}} @@ -4922,38 +4922,38 @@ void test(svbool_t pg, const int8_t *const_i8_ptr, const uint8_t *const_u8_ptr, // expected-error@+2 {{'svstnt1_scatter_u64base_index_f64' needs target feature sve,sve2}} // overload-error@+1 {{'svstnt1_scatter_index' needs target feature sve,sve2}} SVE_ACLE_FUNC(svstnt1_scatter, _u64base, _index, _f64)(pg, svundef_u64(), i64, svundef_f64()); - // expected-error@+2 {{'svmaxp_f64_m' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svmaxp_m' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svmaxp_f64_m' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svmaxp_m' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svmaxp,_f64,_m,)(pg, svundef_f64(), svundef_f64()); - // expected-error@+2 {{'svmaxp_f64_x' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svmaxp_x' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svmaxp_f64_x' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svmaxp_x' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svmaxp,_f64,_x,)(pg, svundef_f64(), svundef_f64()); - // expected-error@+2 {{'svmaxnmp_f64_m' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svmaxnmp_m' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svmaxnmp_f64_m' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svmaxnmp_m' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svmaxnmp,_f64,_m,)(pg, svundef_f64(), svundef_f64()); - // expected-error@+2 {{'svmaxnmp_f64_x' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svmaxnmp_x' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svmaxnmp_f64_x' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svmaxnmp_x' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svmaxnmp,_f64,_x,)(pg, svundef_f64(), svundef_f64()); - // expected-error@+2 {{'svwhilerw_f64' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svwhilerw' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svwhilerw_f64' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svwhilerw' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svwhilerw,_f64,,)(const_f64_ptr, const_f64_ptr); - // expected-error@+2 {{'svcvtnt_f32_f64_m' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svcvtnt_f32_m' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svcvtnt_f32_f64_m' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svcvtnt_f32_m' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svcvtnt_f32,_f64,_m,)(svundef_f32(), pg, svundef_f64()); - // expected-error@+2 {{'svcvtnt_f32_f64_m' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svcvtnt_f32_m' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svcvtnt_f32_f64_m' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svcvtnt_f32_m' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svcvtnt_f32,_f64,_x,)(svundef_f32(), pg, svundef_f64()); - // expected-error@+2 {{'svwhilewr_f64' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svwhilewr' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svwhilewr_f64' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svwhilewr' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svwhilewr,_f64,,)(const_f64_ptr, const_f64_ptr); - // expected-error@+2 {{'svcvtx_f32_f64_z' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svcvtx_f32_z' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svcvtx_f32_f64_z' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svcvtx_f32_z' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svcvtx_f32,_f64,_z,)(pg, svundef_f64()); - // expected-error@+2 {{'svcvtx_f32_f64_m' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svcvtx_f32_m' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svcvtx_f32_f64_m' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svcvtx_f32_m' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svcvtx_f32,_f64,_m,)(svundef_f32(), pg, svundef_f64()); - // expected-error@+2 {{'svcvtx_f32_f64_x' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svcvtx_f32_x' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svcvtx_f32_f64_x' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svcvtx_f32_x' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svcvtx_f32,_f64,_x,)(pg, svundef_f64()); // expected-error@+2 {{'svldnt1_gather_u64base_f64' needs target feature sve,sve2}} // overload-error@+1 {{'svldnt1_gather_f64' needs target feature sve,sve2}} @@ -4976,10 +4976,10 @@ void test(svbool_t pg, const int8_t *const_i8_ptr, const uint8_t *const_u8_ptr, // expected-error@+2 {{'svldnt1_gather_u64base_index_f64' needs target feature sve,sve2}} // overload-error@+1 {{'svldnt1_gather_index_f64' needs target feature sve,sve2}} SVE_ACLE_FUNC(svldnt1_gather, _u64base, _index_f64, )(pg, svundef_u64(), i64); - // expected-error@+2 {{'svcvtxnt_f32_f64_m' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svcvtxnt_f32_m' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svcvtxnt_f32_f64_m' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svcvtxnt_f32_m' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svcvtxnt_f32,_f64,_m,)(svundef_f32(), pg, svundef_f64()); - // expected-error@+2 {{'svcvtxnt_f32_f64_m' needs target feature (sve,sve2)|sme}} - // overload-error@+1 {{'svcvtxnt_f32_m' needs target feature (sve,sve2)|sme}} + // expected-error@+2 {{'svcvtxnt_f32_f64_m' needs target feature (sve,(sve2|sme))|sme}} + // overload-error@+1 {{'svcvtxnt_f32_m' needs target feature (sve,(sve2|sme))|sme}} SVE_ACLE_FUNC(svcvtxnt_f32,_f64,_x,)(svundef_f32(), pg, svundef_f64()); } diff --git a/clang/test/Sema/aarch64-sve2-intrinsics/acle_sve2_aes_bitperm_sha3_sm4.cpp b/clang/test/Sema/aarch64-sve2-intrinsics/acle_sve2_aes_bitperm_sha3_sm4.cpp index b251701..014e7d4 100644 --- a/clang/test/Sema/aarch64-sve2-intrinsics/acle_sve2_aes_bitperm_sha3_sm4.cpp +++ b/clang/test/Sema/aarch64-sve2-intrinsics/acle_sve2_aes_bitperm_sha3_sm4.cpp @@ -119,10 +119,10 @@ void test(uint8_t u8, uint16_t u16, uint32_t u32, uint64_t u64) // expected-error@+2 {{'svpmullt_pair_n_u64' needs target feature (sve,sve-aes)|(sme,ssve-aes)}}} // overload-error@+1 {{'svpmullt_pair' needs target feature (sve,sve-aes)|(sme,ssve-aes)}}} SVE_ACLE_FUNC(svpmullt_pair,_n_u64,,)(svundef_u64(), u64); - // expected-error@+2 {{'svrax1_u64' needs target feature (sve,sve-sha3)|(sme,sve-sha3,sme2p1)}} - // overload-error@+1 {{'svrax1' needs target feature (sve,sve-sha3)|(sme,sve-sha3,sme2p1)}} + // expected-error@+2 {{'svrax1_u64' needs target feature (sve,sve-sha3)|(sme,sme2p1,sve-sha3)}} + // overload-error@+1 {{'svrax1' needs target feature (sve,sve-sha3)|(sme,sme2p1,sve-sha3)}} SVE_ACLE_FUNC(svrax1,_u64,,)(svundef_u64(), svundef_u64()); - // expected-error@+2 {{'svrax1_s64' needs target feature (sve,sve-sha3)|(sme,sve-sha3,sme2p1)}} - // overload-error@+1 {{'svrax1' needs target feature (sve,sve-sha3)|(sme,sve-sha3,sme2p1)}} + // expected-error@+2 {{'svrax1_s64' needs target feature (sve,sve-sha3)|(sme,sme2p1,sve-sha3)}} + // overload-error@+1 {{'svrax1' needs target feature (sve,sve-sha3)|(sme,sme2p1,sve-sha3)}} SVE_ACLE_FUNC(svrax1,_s64,,)(svundef_s64(), svundef_s64()); } diff --git a/clang/test/Sema/aarch64-sve2-intrinsics/acle_sve2_fp8.c b/clang/test/Sema/aarch64-sve2-intrinsics/acle_sve2_fp8.c index 192d200..684d990 100644 --- a/clang/test/Sema/aarch64-sve2-intrinsics/acle_sve2_fp8.c +++ b/clang/test/Sema/aarch64-sve2-intrinsics/acle_sve2_fp8.c @@ -6,30 +6,30 @@ void test_features(svmfloat8_t zn, svmfloat8_t zm, mfloat8_t x, fpm_t fpm) { svcvt1_bf16_mf8_fpm(zn, fpm); - // expected-error@-1 {{'svcvt1_bf16_mf8_fpm' needs target feature (sve,sve2,fp8)|(sme,sme2,fp8)}} + // expected-error@-1 {{'svcvt1_bf16_mf8_fpm' needs target feature (sve,(sve2|sme2),fp8)|(sme,sme2,fp8)}} svcvt2_bf16_mf8_fpm(zn, fpm); - // expected-error@-1 {{'svcvt2_bf16_mf8_fpm' needs target feature (sve,sve2,fp8)|(sme,sme2,fp8)}} + // expected-error@-1 {{'svcvt2_bf16_mf8_fpm' needs target feature (sve,(sve2|sme2),fp8)|(sme,sme2,fp8)}} svcvtlt1_bf16_mf8_fpm(zn, fpm); - // expected-error@-1 {{'svcvtlt1_bf16_mf8_fpm' needs target feature (sve,sve2,fp8)|(sme,sme2,fp8)}} + // expected-error@-1 {{'svcvtlt1_bf16_mf8_fpm' needs target feature (sve,(sve2|sme2),fp8)|(sme,sme2,fp8)}} svcvtlt2_bf16_mf8_fpm(zn, fpm); - // expected-error@-1 {{'svcvtlt2_bf16_mf8_fpm' needs target feature (sve,sve2,fp8)|(sme,sme2,fp8)}} + // expected-error@-1 {{'svcvtlt2_bf16_mf8_fpm' needs target feature (sve,(sve2|sme2),fp8)|(sme,sme2,fp8)}} svcvt1_f16_mf8_fpm(zn, fpm); - // expected-error@-1 {{'svcvt1_f16_mf8_fpm' needs target feature (sve,sve2,fp8)|(sme,sme2,fp8)}} + // expected-error@-1 {{'svcvt1_f16_mf8_fpm' needs target feature (sve,(sve2|sme2),fp8)|(sme,sme2,fp8)}} svcvt2_f16_mf8_fpm(zn, fpm); - // expected-error@-1 {{'svcvt2_f16_mf8_fpm' needs target feature (sve,sve2,fp8)|(sme,sme2,fp8)}} + // expected-error@-1 {{'svcvt2_f16_mf8_fpm' needs target feature (sve,(sve2|sme2),fp8)|(sme,sme2,fp8)}} svcvtlt1_f16_mf8_fpm(zn, fpm); - // expected-error@-1 {{'svcvtlt1_f16_mf8_fpm' needs target feature (sve,sve2,fp8)|(sme,sme2,fp8)}} + // expected-error@-1 {{'svcvtlt1_f16_mf8_fpm' needs target feature (sve,(sve2|sme2),fp8)|(sme,sme2,fp8)}} svcvtlt2_f16_mf8_fpm(zn, fpm); - // expected-error@-1 {{'svcvtlt2_f16_mf8_fpm' needs target feature (sve,sve2,fp8)|(sme,sme2,fp8)}} + // expected-error@-1 {{'svcvtlt2_f16_mf8_fpm' needs target feature (sve,(sve2|sme2),fp8)|(sme,sme2,fp8)}} svcvtn_mf8_bf16_x2_fpm(svcreate2(svundef_bf16(), svundef_bf16()), fpm); - // expected-error@-1 {{'svcvtn_mf8_bf16_x2_fpm' needs target feature (sve,sve2,fp8)|(sme,sme2,fp8)}} + // expected-error@-1 {{'svcvtn_mf8_bf16_x2_fpm' needs target feature (sve,(sve2|sme2),fp8)|(sme,sme2,fp8)}} svcvtn_mf8_f16_x2_fpm(svcreate2(svundef_f16(), svundef_f16()), fpm); - // expected-error@-1 {{'svcvtn_mf8_f16_x2_fpm' needs target feature (sve,sve2,fp8)|(sme,sme2,fp8)}} + // expected-error@-1 {{'svcvtn_mf8_f16_x2_fpm' needs target feature (sve,(sve2|sme2),fp8)|(sme,sme2,fp8)}} svcvtnb_mf8_f32_x2_fpm(svcreate2(svundef_f32(), svundef_f32()), fpm); - // expected-error@-1 {{'svcvtnb_mf8_f32_x2_fpm' needs target feature (sve,sve2,fp8)|(sme,sme2,fp8)}} + // expected-error@-1 {{'svcvtnb_mf8_f32_x2_fpm' needs target feature (sve,(sve2|sme2),fp8)|(sme,sme2,fp8)}} svcvtnt_mf8_f32_x2_fpm(zn, svcreate2(svundef_f32(), svundef_f32()), fpm); - // expected-error@-1 {{'svcvtnt_mf8_f32_x2_fpm' needs target feature (sve,sve2,fp8)|(sme,sme2,fp8)}} + // expected-error@-1 {{'svcvtnt_mf8_f32_x2_fpm' needs target feature (sve,(sve2|sme2),fp8)|(sme,sme2,fp8)}} svdot_f32_mf8_fpm(svundef_f32(), zn, zm, fpm); // expected-error@-1 {{'svdot_f32_mf8_fpm' needs target feature (sve,sve2,fp8dot4)|(sme,ssve-fp8dot4)}} diff --git a/clang/test/Sema/inline.c b/clang/test/Sema/inline.c index 804c510..6361db8 100644 --- a/clang/test/Sema/inline.c +++ b/clang/test/Sema/inline.c @@ -11,14 +11,14 @@ static int staticFunction(void); // expected-note + {{'staticFunction' declared static struct { int x; } staticStruct; // expected-note + {{'staticStruct' declared here}} inline int useStatic (void) { // expected-note 3 {{use 'static' to give inline function 'useStatic' internal linkage}} - staticFunction(); // expected-warning{{static function 'staticFunction' is used in an inline function with external linkage}} - (void)staticStruct.x; // expected-warning{{static variable 'staticStruct' is used in an inline function with external linkage}} - return staticVar; // expected-warning{{static variable 'staticVar' is used in an inline function with external linkage}} + staticFunction(); // expected-warning{{using static function 'staticFunction' in an inline function with external linkage is a C2y extension}} + (void)staticStruct.x; // expected-warning{{using static variable 'staticStruct' in an inline function with external linkage is a C2y extension}} + return staticVar; // expected-warning{{using static variable 'staticVar' in an inline function with external linkage is a C2y extension}} } extern inline int useStaticFromExtern (void) { // no suggestions - staticFunction(); // expected-warning{{static function 'staticFunction' is used in an inline function with external linkage}} - return staticVar; // expected-warning{{static variable 'staticVar' is used in an inline function with external linkage}} + staticFunction(); // expected-warning{{using static function 'staticFunction' in an inline function with external linkage is a C2y extension}} + return staticVar; // expected-warning{{using static variable 'staticVar' in an inline function with external linkage is a C2y extension}} } static inline int useStaticFromStatic (void) { @@ -67,8 +67,8 @@ inline int useStaticMainFile (void) { #pragma clang diagnostic warning "-Wstatic-in-inline" inline int useStaticAgain (void) { // expected-note 2 {{use 'static' to give inline function 'useStaticAgain' internal linkage}} - staticFunction(); // expected-warning{{static function 'staticFunction' is used in an inline function with external linkage}} - return staticVar; // expected-warning{{static variable 'staticVar' is used in an inline function with external linkage}} + staticFunction(); // expected-warning{{using static function 'staticFunction' in an inline function with external linkage is a C2y extension}} + return staticVar; // expected-warning{{using static variable 'staticVar' in an inline function with external linkage is a C2y extension}} } #pragma clang diagnostic pop @@ -86,8 +86,8 @@ extern inline void defineStaticVarInExtern(void) { // Check behavior of line markers. # 1 "XXX.h" 1 inline int useStaticMainFileInLineMarker(void) { // expected-note 2 {{use 'static' to give inline function 'useStaticMainFileInLineMarker' internal linkage}} - staticFunction(); // expected-warning{{static function 'staticFunction' is used in an inline function with external linkage}} - return staticVar; // expected-warning{{static variable 'staticVar' is used in an inline function with external linkage}} + staticFunction(); // expected-warning{{using static function 'staticFunction' in an inline function with external linkage is a C2y extension}} + return staticVar; // expected-warning{{using static variable 'staticVar' in an inline function with external linkage is a C2y extension}} } # 100 "inline.c" 2 diff --git a/clang/test/Sema/internal_linkage.c b/clang/test/Sema/internal_linkage.c index a1bff73..4ea8599 100644 --- a/clang/test/Sema/internal_linkage.c +++ b/clang/test/Sema/internal_linkage.c @@ -20,7 +20,7 @@ struct __attribute__((internal_linkage)) S { // expected-warning{{'internal_link __attribute__((internal_linkage("foo"))) int g(void) {} // expected-error{{'internal_linkage' attribute takes no arguments}} int var6 [[clang::internal_linkage]]; -int var7 [[clang::internal_linkage]] __attribute__((common)); // expected-error{{'clang::internal_linkage' and 'common' attributes are not compatible}} \ +int var7 [[clang::internal_linkage]] __attribute__((common)); // expected-error{{'common' and 'clang::internal_linkage' attributes are not compatible}} \ // expected-note{{conflicting attribute is here}} __attribute__((common)) int var8 [[clang::internal_linkage]]; // expected-error{{'clang::internal_linkage' and 'common' attributes are not compatible}} \ // expected-note{{conflicting attribute is here}} diff --git a/clang/test/SemaOpenACC/combined-construct-reduction-clause.cpp b/clang/test/SemaOpenACC/combined-construct-reduction-clause.cpp index 5aa90bd..1b50336 100644 --- a/clang/test/SemaOpenACC/combined-construct-reduction-clause.cpp +++ b/clang/test/SemaOpenACC/combined-construct-reduction-clause.cpp @@ -2,7 +2,7 @@ struct CompositeOfScalars { int I; - float F; + float F; // #COS_FLOAT short J; char C; double D; @@ -30,6 +30,11 @@ void uses(unsigned Parm) { for(int i = 0; i < 5; ++i); #pragma acc serial loop reduction(&: CoS, I, F) + // expected-error@-1{{variable of type 'float' referenced in OpenACC 'reduction' clause does not have a valid operation available}} + // expected-error@-2{{invalid operands to binary expression ('float' and 'float')}} + // expected-error@-3{{variable of type 'float' referenced in OpenACC 'reduction' clause does not have a valid operation available}} + // expected-note@#COS_FLOAT{{while forming combiner for compound type 'CompositeOfScalars'}} + // expected-error@-5{{invalid operands to binary expression ('float' and 'float')}} for(int i = 0; i < 5; ++i); #pragma acc kernels loop reduction(min: CoS, Array[I], Array[0:I]) @@ -166,19 +171,17 @@ void uses(unsigned Parm) { CompositeHasComposite CoCArr[5]; // expected-error@+4{{invalid type 'struct CompositeOfScalars' used in OpenACC 'reduction' variable reference; type is not a scalar value}} - // expected-note@+3{{used as element type of array type 'CompositeHasComposite'}} + // expected-note@+3{{used as element type of array type 'CompositeHasComposite[5]'}} // expected-note@#COS_FIELD{{used as field 'COS' of composite 'CompositeHasComposite'}} // expected-note@+1{{OpenACC 'reduction' variable reference must be a scalar variable or a composite of scalars, or an array, sub-array, or element of scalar types}} #pragma acc parallel loop reduction(+:CoCArr) for(int i = 0; i < 5; ++i); - // expected-error@+4{{invalid type 'struct CompositeOfScalars' used in OpenACC 'reduction' variable reference; type is not a scalar value}} - // expected-note@+3{{used as element type of array type 'CompositeHasComposite[5]'}} + // expected-error@+3{{invalid type 'struct CompositeOfScalars' used in OpenACC 'reduction' variable reference; type is not a scalar value}} // expected-note@#COS_FIELD{{used as field 'COS' of composite 'CompositeHasComposite'}} // expected-note@+1{{OpenACC 'reduction' variable reference must be a scalar variable or a composite of scalars, or an array, sub-array, or element of scalar types}} #pragma acc parallel loop reduction(+:CoCArr[3]) for(int i = 0; i < 5; ++i); - // expected-error@+4{{invalid type 'struct CompositeOfScalars' used in OpenACC 'reduction' variable reference; type is not a scalar value}} - // expected-note@+3{{used as element type of sub-array type 'CompositeHasComposite'}} + // expected-error@+3{{invalid type 'struct CompositeOfScalars' used in OpenACC 'reduction' variable reference; type is not a scalar value}} // expected-note@#COS_FIELD{{used as field 'COS' of composite 'CompositeHasComposite'}} // expected-note@+1{{OpenACC 'reduction' variable reference must be a scalar variable or a composite of scalars, or an array, sub-array, or element of scalar types}} #pragma acc parallel loop reduction(+:CoCArr[1:1]) diff --git a/clang/test/SemaOpenACC/compute-construct-clause-ast.cpp b/clang/test/SemaOpenACC/compute-construct-clause-ast.cpp index babff53..c4ff12d 100644 --- a/clang/test/SemaOpenACC/compute-construct-clause-ast.cpp +++ b/clang/test/SemaOpenACC/compute-construct-clause-ast.cpp @@ -86,15 +86,6 @@ void NormalFunc(int i, float f) { // CHECK-NEXT: CXXBoolLiteralExpr // CHECK-NEXT: NullStmt -#pragma acc serial reduction(|: f) - while(true); - // CHECK-NEXT: OpenACCComputeConstruct{{.*}}serial - // CHECK-NEXT: reduction clause Operator: | - // CHECK-NEXT: DeclRefExpr{{.*}} 'float' lvalue ParmVar{{.*}} 'f' 'float' - // CHECK-NEXT: WhileStmt - // CHECK-NEXT: CXXBoolLiteralExpr - // CHECK-NEXT: NullStmt - #pragma acc parallel reduction(^: i) while(true); @@ -283,16 +274,6 @@ void TemplFunc() { // CHECK-NEXT: CXXBoolLiteralExpr // CHECK-NEXT: NullStmt -#pragma acc parallel reduction(&: T::SomeFloat) - while(true); - // CHECK-NEXT: OpenACCComputeConstruct{{.*}}parallel - // CHECK-NEXT: reduction clause Operator: & - // CHECK-NEXT: DependentScopeDeclRefExpr{{.*}} '<dependent type>' lvalue - // CHECK-NEXT: NestedNameSpecifier TypeSpec 'T' - // CHECK-NEXT: WhileStmt - // CHECK-NEXT: CXXBoolLiteralExpr - // CHECK-NEXT: NullStmt - #pragma acc serial reduction(|: i) while(true); // CHECK-NEXT: OpenACCComputeConstruct{{.*}}serial @@ -475,14 +456,6 @@ void TemplFunc() { // CHECK-NEXT: CXXBoolLiteralExpr // CHECK-NEXT: NullStmt - // CHECK-NEXT: OpenACCComputeConstruct{{.*}}parallel - // CHECK-NEXT: reduction clause Operator: & - // CHECK-NEXT: DeclRefExpr{{.*}} 'const float' lvalue Var{{.*}} 'SomeFloat' 'const float' - // CHECK-NEXT: NestedNameSpecifier TypeSpec 'InstTy' - // CHECK-NEXT: WhileStmt - // CHECK-NEXT: CXXBoolLiteralExpr - // CHECK-NEXT: NullStmt - // CHECK-NEXT: OpenACCComputeConstruct{{.*}}serial // CHECK-NEXT: reduction clause Operator: | // CHECK-NEXT: DeclRefExpr{{.*}} 'typename InstTy::IntTy':'int' lvalue Var{{.*}} 'i' 'typename InstTy::IntTy':'int' diff --git a/clang/test/SemaOpenACC/compute-construct-reduction-clause.c b/clang/test/SemaOpenACC/compute-construct-reduction-clause.c index 07cb498..96c01d0 100644 --- a/clang/test/SemaOpenACC/compute-construct-reduction-clause.c +++ b/clang/test/SemaOpenACC/compute-construct-reduction-clause.c @@ -2,7 +2,7 @@ struct CompositeOfScalars { int I; - float F; + float F; // #COS_FLOAT short J; char C; double D; @@ -58,6 +58,11 @@ void uses(unsigned Parm) { // Vars in a reduction must be a scalar or a composite of scalars. #pragma acc parallel reduction(&: CoS, I, F) + // expected-error@-1{{variable of type 'float' referenced in OpenACC 'reduction' clause does not have a valid operation available}} + // expected-error@-2{{invalid operands to binary expression ('float' and 'float')}} + // expected-error@-3{{variable of type 'float' referenced in OpenACC 'reduction' clause does not have a valid operation available}} + // expected-note@#COS_FLOAT{{while forming combiner for compound type 'CompositeOfScalars'}} + // expected-error@-5{{invalid operands to binary expression ('float' and 'float')}} while (1); // expected-error@+3{{invalid type 'struct CompositeOfScalars' used in OpenACC 'reduction' variable reference; type is not a scalar value}} // expected-note@#COS_FIELD{{used as field 'COS' of composite 'CompositeHasComposite'}} @@ -69,13 +74,18 @@ void uses(unsigned Parm) { while (1); #pragma acc parallel reduction(&: CoS, Array[I], Array[0:I]) + // expected-error@-1{{variable of type 'float' referenced in OpenACC 'reduction' clause does not have a valid operation available}} + // expected-note@#COS_FLOAT{{while forming combiner for compound type 'CompositeOfScalars'}} + // expected-error@-3{{invalid operands to binary expression ('float' and 'float')}} while (1); struct CompositeHasComposite ChCArray[5]; - // expected-error@+4{{invalid type 'struct CompositeOfScalars' used in OpenACC 'reduction' variable reference; type is not a scalar value}} - // expected-note@+3{{used as element type of sub-array type 'struct CompositeHasComposite'}} + // expected-error@+6{{invalid type 'struct CompositeOfScalars' used in OpenACC 'reduction' variable reference; type is not a scalar value}} // expected-note@#COS_FIELD{{used as field 'COS' of composite 'CompositeHasComposite'}} - // expected-note@+1{{OpenACC 'reduction' variable reference must be a scalar variable or a composite of scalars, or an array, sub-array, or element of scalar types}} + // expected-note@+4{{OpenACC 'reduction' variable reference must be a scalar variable or a composite of scalars, or an array, sub-array, or element of scalar types}} + // expected-error@+3{{variable of type 'float' referenced in OpenACC 'reduction' clause does not have a valid operation available}} + // expected-note@#COS_FLOAT{{while forming combiner for compound type 'CompositeOfScalars'}} + // expected-error@+1{{invalid operands to binary expression ('float' and 'float')}} #pragma acc parallel reduction(&: CoS, Array[I], ChCArray[0:I]) while (1); diff --git a/clang/test/SemaOpenACC/compute-construct-reduction-clause.cpp b/clang/test/SemaOpenACC/compute-construct-reduction-clause.cpp index 9c2f3d9..e3a487a 100644 --- a/clang/test/SemaOpenACC/compute-construct-reduction-clause.cpp +++ b/clang/test/SemaOpenACC/compute-construct-reduction-clause.cpp @@ -2,7 +2,7 @@ struct CompositeOfScalars { int I; - float F; + float F; // #COS_FLOAT short J; char C; double D; @@ -61,6 +61,11 @@ void uses(unsigned Parm) { // Vars in a reduction must be a scalar or a composite of scalars. #pragma acc parallel reduction(&: CoS, I, F) + // expected-error@-1{{variable of type 'float' referenced in OpenACC 'reduction' clause does not have a valid operation available}} + // expected-error@-2{{invalid operands to binary expression ('float' and 'float')}} + // expected-error@-3{{variable of type 'float' referenced in OpenACC 'reduction' clause does not have a valid operation available}} + // expected-note@#COS_FLOAT{{while forming combiner for compound type 'CompositeOfScalars'}} + // expected-error@-5{{invalid operands to binary expression ('float' and 'float')}} while (1); // expected-error@+3{{invalid type 'struct CompositeOfScalars' used in OpenACC 'reduction' variable reference; type is not a scalar value}} // expected-note@#COS_FIELD{{used as field 'COS' of composite 'CompositeHasComposite'}} @@ -71,6 +76,9 @@ void uses(unsigned Parm) { while (1); #pragma acc parallel reduction(&: CoS, Array[I], Array[0:I]) + // expected-error@-1{{variable of type 'float' referenced in OpenACC 'reduction' clause does not have a valid operation available}} + // expected-note@#COS_FLOAT{{while forming combiner for compound type 'CompositeOfScalars'}} + // expected-error@-3{{invalid operands to binary expression ('float' and 'float')}} while (1); // expected-error@+1{{OpenACC variable is not a valid variable name, sub-array, array element, or composite variable member}} @@ -91,19 +99,17 @@ void uses(unsigned Parm) { CompositeHasComposite CoCArr[5]; // expected-error@+4{{invalid type 'struct CompositeOfScalars' used in OpenACC 'reduction' variable reference; type is not a scalar value}} - // expected-note@+3{{used as element type of array type 'CompositeHasComposite'}} + // expected-note@+3{{used as element type of array type 'CompositeHasComposite[5]'}} // expected-note@#COS_FIELD{{used as field 'COS' of composite 'CompositeHasComposite'}} // expected-note@+1{{OpenACC 'reduction' variable reference must be a scalar variable or a composite of scalars, or an array, sub-array, or element of scalar types}} #pragma acc parallel reduction(+:CoCArr) while (1); - // expected-error@+4{{invalid type 'struct CompositeOfScalars' used in OpenACC 'reduction' variable reference; type is not a scalar value}} - // expected-note@+3{{used as element type of array type 'CompositeHasComposite[5]'}} + // expected-error@+3{{invalid type 'struct CompositeOfScalars' used in OpenACC 'reduction' variable reference; type is not a scalar value}} // expected-note@#COS_FIELD{{used as field 'COS' of composite 'CompositeHasComposite'}} // expected-note@+1{{OpenACC 'reduction' variable reference must be a scalar variable or a composite of scalars, or an array, sub-array, or element of scalar types}} #pragma acc parallel reduction(+:CoCArr[3]) while (1); - // expected-error@+4{{invalid type 'struct CompositeOfScalars' used in OpenACC 'reduction' variable reference; type is not a scalar value}} - // expected-note@+3{{used as element type of sub-array type 'CompositeHasComposite'}} + // expected-error@+3{{invalid type 'struct CompositeOfScalars' used in OpenACC 'reduction' variable reference; type is not a scalar value}} // expected-note@#COS_FIELD{{used as field 'COS' of composite 'CompositeHasComposite'}} // expected-note@+1{{OpenACC 'reduction' variable reference must be a scalar variable or a composite of scalars, or an array, sub-array, or element of scalar types}} #pragma acc parallel reduction(+:CoCArr[1:1]) @@ -121,7 +127,7 @@ void uses(unsigned Parm) { int *IPtrArr[5]; // expected-error@+3{{invalid type 'int *' used in OpenACC 'reduction' variable reference; type is not a scalar value, or array of scalars, or composite of scalars}} - // expected-note@+2{{used as element type of array type 'int *'}} + // expected-note@+2{{used as element type of array type 'int *[5]'}} // expected-note@+1{{OpenACC 'reduction' variable reference must be a scalar variable or a composite of scalars, or an array, sub-array, or element of scalar types}} #pragma acc parallel reduction(+:IPtrArr) while (1); @@ -136,7 +142,7 @@ void uses(unsigned Parm) { HasPtr HPArr[5]; // expected-error@+4{{invalid type 'int *' used in OpenACC 'reduction' variable reference; type is not a scalar value}} - // expected-note@+3{{used as element type of array type 'HasPtr'}} + // expected-note@+3{{used as element type of array type 'HasPtr[5]'}} // expected-note@#HASPTR{{used as field 'I' of composite 'HasPtr'}} // expected-note@+1{{OpenACC 'reduction' variable reference must be a scalar variable or a composite of scalars, or an array, sub-array, or element of scalar types}} #pragma acc parallel reduction(+:HPArr) @@ -152,7 +158,7 @@ void uses(unsigned Parm) { #pragma acc parallel reduction(+:CplxI) while (1); // expected-error@+3{{invalid type '_Complex int' used in OpenACC 'reduction' variable reference; type is not a scalar value}} - // expected-note@+2{{used as element type of array type '_Complex int'}} + // expected-note@+2{{used as element type of array type '_Complex int[5]'}} // expected-note@+1{{OpenACC 'reduction' variable reference must be a scalar variable or a composite of scalars, or an array, sub-array, or element of scalar types}} #pragma acc parallel reduction(+:CplxIArr) while (1); @@ -161,7 +167,7 @@ void uses(unsigned Parm) { #pragma acc parallel reduction(+:CplxF) while (1); // expected-error@+3{{invalid type '_Complex float' used in OpenACC 'reduction' variable reference; type is not a scalar value}} - // expected-note@+2{{used as element type of array type '_Complex float'}} + // expected-note@+2{{used as element type of array type '_Complex float[5]'}} // expected-note@+1{{OpenACC 'reduction' variable reference must be a scalar variable or a composite of scalars, or an array, sub-array, or element of scalar types}} #pragma acc parallel reduction(+:CplxFArr) while (1); @@ -213,6 +219,9 @@ void TemplUses(T Parm, U CoS, V ChC) { // Vars in a reduction must be a scalar or a composite of scalars. #pragma acc parallel reduction(&: CoS, Var, Parm) + // expected-error@-1{{variable of type 'float' referenced in OpenACC 'reduction' clause does not have a valid operation available}} + // expected-note@#COS_FLOAT{{while forming combiner for compound type 'CompositeOfScalars'}} + // expected-error@-3{{invalid operands to binary expression ('float' and 'float')}} while (1); // expected-error@+3{{invalid type 'struct CompositeOfScalars' used in OpenACC 'reduction' variable reference; type is not a scalar value}} // expected-note@#COS_FIELD{{used as field 'COS' of composite 'CompositeHasComposite'}} @@ -225,6 +234,9 @@ void TemplUses(T Parm, U CoS, V ChC) { while (1); #pragma acc parallel reduction(&: CoS, Array[Var], Array[0:Var]) + // expected-error@-1{{variable of type 'float' referenced in OpenACC 'reduction' clause does not have a valid operation available}} + // expected-note@#COS_FLOAT{{while forming combiner for compound type 'CompositeOfScalars'}} + // expected-error@-3{{invalid operands to binary expression ('float' and 'float')}} while (1); // expected-error@+1{{OpenACC variable is not a valid variable name, sub-array, array element, or composite variable member}} @@ -242,6 +254,50 @@ void TemplUses(T Parm, U CoS, V ChC) { // expected-error@+1{{OpenACC variable is not a valid variable name, sub-array, array element, or composite variable member}} #pragma acc parallel reduction(&: ChCPtr->COS) while (1); + + T ThreeDArray[3][4][5]; + + // expected-error@+3{{invalid type 'int[4][5]' used in OpenACC 'reduction' variable reference; type is not a scalar value}} + // expected-note@+2{{used as element type of array type 'int[3][4][5]'}} + // expected-note@+1{{OpenACC 'reduction' variable reference must be a scalar variable or a composite of scalars, or an array, sub-array, or element of scalar types}} +#pragma acc parallel reduction(+:ThreeDArray) + while (1); + // expected-error@+3{{invalid type 'int[5]' used in OpenACC 'reduction' variable reference; type is not a scalar value}} + // expected-note@+2{{used as element type of array type 'int[4][5]'}} + // expected-note@+1{{OpenACC 'reduction' variable reference must be a scalar variable or a composite of scalars, or an array, sub-array, or element of scalar types}} +#pragma acc parallel reduction(+:ThreeDArray[1:1]) + while (1); + // expected-error@+3{{invalid type 'int[5]' used in OpenACC 'reduction' variable reference; type is not a scalar value}} + // expected-note@+2{{used as element type of array type 'int[4][5]'}} + // expected-note@+1{{OpenACC 'reduction' variable reference must be a scalar variable or a composite of scalars, or an array, sub-array, or element of scalar types}} +#pragma acc parallel reduction(+:ThreeDArray[1]) + while (1); + +#pragma acc parallel reduction(+:ThreeDArray[1:1][1]) + while (1); +#pragma acc parallel reduction(+:ThreeDArray[1:1][1:1]) + while (1); +#pragma acc parallel reduction(+:ThreeDArray[1][1]) + while (1); +#pragma acc parallel reduction(+:ThreeDArray[1][1:1]) + while (1); + +#pragma acc parallel reduction(+:ThreeDArray[1:1][1][1:1]) + while (1); +#pragma acc parallel reduction(+:ThreeDArray[1:1][1][1]) + while (1); +#pragma acc parallel reduction(+:ThreeDArray[1:1][1:1][1:1]) + while (1); +#pragma acc parallel reduction(+:ThreeDArray[1:1][1:1][1]) + while (1); +#pragma acc parallel reduction(+:ThreeDArray[1][1][1:1]) + while (1); +#pragma acc parallel reduction(+:ThreeDArray[1][1][1]) + while (1); +#pragma acc parallel reduction(+:ThreeDArray[1][1:1][1:1]) + while (1); +#pragma acc parallel reduction(+:ThreeDArray[1][1:1][1]) + while (1); } void inst() { diff --git a/clang/test/SemaOpenACC/loop-construct-reduction-ast.cpp b/clang/test/SemaOpenACC/loop-construct-reduction-ast.cpp index 4afb370..2daa56b4 100644 --- a/clang/test/SemaOpenACC/loop-construct-reduction-ast.cpp +++ b/clang/test/SemaOpenACC/loop-construct-reduction-ast.cpp @@ -102,24 +102,6 @@ void NormalFunc(int i, float f) { // CHECK-NEXT: DeclRefExpr{{.*}}'i' 'int' // CHECK-NEXT: NullStmt -#pragma acc loop reduction(|: f) - for(int i = 0; i < 5; ++i); - // CHECK-NEXT: OpenACCLoopConstruct{{.*}}<orphan> - // CHECK-NEXT: reduction clause Operator: | - // CHECK-NEXT: DeclRefExpr{{.*}} 'float' lvalue ParmVar{{.*}} 'f' 'float' - // CHECK-NEXT: ForStmt - // CHECK-NEXT: DeclStmt - // CHECK-NEXT: VarDecl{{.*}} i 'int' - // CHECK-NEXT: IntegerLiteral{{.*}} 'int' 0 - // CHECK-NEXT: <<<NULL>>> - // CHECK-NEXT: BinaryOperator{{.*}}'<' - // CHECK-NEXT: ImplicitCastExpr - // CHECK-NEXT: DeclRefExpr{{.*}}'i' 'int' - // CHECK-NEXT: IntegerLiteral{{.*}} 'int' 5 - // CHECK-NEXT: UnaryOperator{{.*}}++ - // CHECK-NEXT: DeclRefExpr{{.*}}'i' 'int' - // CHECK-NEXT: NullStmt - #pragma acc loop reduction(^: i) for(int i = 0; i < 5; ++i); @@ -267,25 +249,6 @@ void TemplFunc() { // CHECK-NEXT: DeclRefExpr{{.*}}'i' 'int' // CHECK-NEXT: NullStmt -#pragma acc loop reduction(&: T::SomeFloat) - for(int i = 0; i < 5; ++i); - // CHECK-NEXT: OpenACCLoopConstruct{{.*}}<orphan> - // CHECK-NEXT: reduction clause Operator: & - // CHECK-NEXT: DependentScopeDeclRefExpr{{.*}} '<dependent type>' lvalue - // CHECK-NEXT: NestedNameSpecifier TypeSpec 'T' - // CHECK-NEXT: ForStmt - // CHECK-NEXT: DeclStmt - // CHECK-NEXT: VarDecl{{.*}} i 'int' - // CHECK-NEXT: IntegerLiteral{{.*}} 'int' 0 - // CHECK-NEXT: <<<NULL>>> - // CHECK-NEXT: BinaryOperator{{.*}}'<' - // CHECK-NEXT: ImplicitCastExpr - // CHECK-NEXT: DeclRefExpr{{.*}}'i' 'int' - // CHECK-NEXT: IntegerLiteral{{.*}} 'int' 5 - // CHECK-NEXT: UnaryOperator{{.*}}++ - // CHECK-NEXT: DeclRefExpr{{.*}}'i' 'int' - // CHECK-NEXT: NullStmt - #pragma acc loop reduction(|: i) for(int i = 0; i < 5; ++i); // CHECK-NEXT: OpenACCLoopConstruct{{.*}}<orphan> @@ -440,23 +403,6 @@ void TemplFunc() { // CHECK-NEXT: NullStmt // // CHECK-NEXT: OpenACCLoopConstruct{{.*}}<orphan> - // CHECK-NEXT: reduction clause Operator: & - // CHECK-NEXT: DeclRefExpr{{.*}} 'const float' lvalue Var{{.*}} 'SomeFloat' 'const float' - // CHECK-NEXT: NestedNameSpecifier TypeSpec 'InstTy' - // CHECK-NEXT: ForStmt - // CHECK-NEXT: DeclStmt - // CHECK-NEXT: VarDecl{{.*}} i 'int' - // CHECK-NEXT: IntegerLiteral{{.*}} 'int' 0 - // CHECK-NEXT: <<<NULL>>> - // CHECK-NEXT: BinaryOperator{{.*}}'<' - // CHECK-NEXT: ImplicitCastExpr - // CHECK-NEXT: DeclRefExpr{{.*}}'i' 'int' - // CHECK-NEXT: IntegerLiteral{{.*}} 'int' 5 - // CHECK-NEXT: UnaryOperator{{.*}}++ - // CHECK-NEXT: DeclRefExpr{{.*}}'i' 'int' - // CHECK-NEXT: NullStmt - // - // CHECK-NEXT: OpenACCLoopConstruct{{.*}}<orphan> // CHECK-NEXT: reduction clause Operator: | // CHECK-NEXT: DeclRefExpr{{.*}} 'typename InstTy::IntTy':'int' lvalue Var{{.*}} 'i' 'typename InstTy::IntTy':'int' // CHECK-NEXT: ForStmt diff --git a/clang/test/SemaOpenACC/loop-construct-reduction-clause.cpp b/clang/test/SemaOpenACC/loop-construct-reduction-clause.cpp index 2a07c2c..f2dd928 100644 --- a/clang/test/SemaOpenACC/loop-construct-reduction-clause.cpp +++ b/clang/test/SemaOpenACC/loop-construct-reduction-clause.cpp @@ -153,19 +153,17 @@ void uses() { CompositeHasComposite CoCArr[5]; // expected-error@+4{{invalid type 'struct CompositeOfScalars' used in OpenACC 'reduction' variable reference; type is not a scalar value}} - // expected-note@+3{{used as element type of array type 'CompositeHasComposite'}} + // expected-note@+3{{used as element type of array type 'CompositeHasComposite[5]'}} // expected-note@#COS_FIELD{{used as field 'COS' of composite 'CompositeHasComposite'}} // expected-note@+1{{OpenACC 'reduction' variable reference must be a scalar variable or a composite of scalars, or an array, sub-array, or element of scalar types}} #pragma acc loop reduction(+:CoCArr) for(int i = 0; i < 5; ++i); - // expected-error@+4{{invalid type 'struct CompositeOfScalars' used in OpenACC 'reduction' variable reference; type is not a scalar value}} - // expected-note@+3{{used as element type of array type 'CompositeHasComposite[5]'}} + // expected-error@+3{{invalid type 'struct CompositeOfScalars' used in OpenACC 'reduction' variable reference; type is not a scalar value}} // expected-note@#COS_FIELD{{used as field 'COS' of composite 'CompositeHasComposite'}} // expected-note@+1{{OpenACC 'reduction' variable reference must be a scalar variable or a composite of scalars, or an array, sub-array, or element of scalar types}} #pragma acc loop reduction(+:CoCArr[3]) for(int i = 0; i < 5; ++i); - // expected-error@+4{{invalid type 'struct CompositeOfScalars' used in OpenACC 'reduction' variable reference; type is not a scalar value}} - // expected-note@+3{{used as element type of sub-array type 'CompositeHasComposite'}} + // expected-error@+3{{invalid type 'struct CompositeOfScalars' used in OpenACC 'reduction' variable reference; type is not a scalar value}} // expected-note@#COS_FIELD{{used as field 'COS' of composite 'CompositeHasComposite'}} // expected-note@+1{{OpenACC 'reduction' variable reference must be a scalar variable or a composite of scalars, or an array, sub-array, or element of scalar types}} #pragma acc loop reduction(+:CoCArr[1:1]) diff --git a/clang/test/SemaOpenCL/address-spaces.cl b/clang/test/SemaOpenCL/address-spaces.cl index 86435b7..6c3ee89 100644 --- a/clang/test/SemaOpenCL/address-spaces.cl +++ b/clang/test/SemaOpenCL/address-spaces.cl @@ -265,7 +265,8 @@ void func_multiple_addr2(void) { __attribute__((opencl_private)) private_int_t var5; // expected-warning {{multiple identical address spaces specified for type}} __attribute__((opencl_private)) private_int_t *var6; // expected-warning {{multiple identical address spaces specified for type}} #if __OPENCL_CPP_VERSION__ - __global int [[clang::opencl_private]] var7; // expected-error {{multiple address spaces specified for type}} + __global int [[clang::opencl_private]] var7; // expected-error {{multiple address spaces specified for type}} \ + // expected-error {{function scope variable cannot be declared in global address space}} __global int [[clang::opencl_private]] *var8; // expected-error {{multiple address spaces specified for type}} private_int_t [[clang::opencl_private]] var9; // expected-warning {{multiple identical address spaces specified for type}} private_int_t [[clang::opencl_private]] *var10; // expected-warning {{multiple identical address spaces specified for type}} diff --git a/clang/test/SemaOpenCL/builtins-image-load-param-gfx1100-err.cl b/clang/test/SemaOpenCL/builtins-image-load-param-gfx1100-err.cl new file mode 100644 index 0000000..8f609dc --- /dev/null +++ b/clang/test/SemaOpenCL/builtins-image-load-param-gfx1100-err.cl @@ -0,0 +1,194 @@ +// RUN: %clang_cc1 -triple amdgcn-- -target-cpu gfx1100 -S -verify=expected -o - %s +// REQUIRES: amdgpu-registered-target + +typedef int int4 __attribute__((ext_vector_type(4))); +typedef float float4 __attribute__((ext_vector_type(4))); +typedef half half4 __attribute__((ext_vector_type(4))); + +float test_builtin_image_load_2d(float f32, int i32, __amdgpu_texture_t tex) { + + return __builtin_amdgcn_image_load_2d_f32_i32(i32, i32, i32, tex, 106, 103); //expected-error{{argument to '__builtin_amdgcn_image_load_2d_f32_i32' must be a constant integer}} +} +float4 test_builtin_image_load_2d_1(float4 v4f32, int i32, __amdgpu_texture_t tex) { + + return __builtin_amdgcn_image_load_2d_v4f32_i32(100, i32, i32, tex, i32, 110); //expected-error{{argument to '__builtin_amdgcn_image_load_2d_v4f32_i32' must be a constant integer}} +} +half4 test_builtin_image_load_2d_2(half4 v4f16, int i32, __amdgpu_texture_t tex) { + + return __builtin_amdgcn_image_load_2d_v4f16_i32(100, i32, i32, tex, 120, i32); //expected-error{{argument to '__builtin_amdgcn_image_load_2d_v4f16_i32' must be a constant integer}} +} + + +float test_builtin_image_load_2darray(float f32, int i32, __amdgpu_texture_t tex) { + + return __builtin_amdgcn_image_load_2darray_f32_i32(100, i32, i32, i32, tex, i32, 110); //expected-error{{argument to '__builtin_amdgcn_image_load_2darray_f32_i32' must be a constant integer}} +} +float4 test_builtin_image_load_2darray_1(float4 v4f32, int i32, __amdgpu_texture_t tex) { + + return __builtin_amdgcn_image_load_2darray_v4f32_i32(100, i32, i32, i32, tex, i32, 110); //expected-error{{argument to '__builtin_amdgcn_image_load_2darray_v4f32_i32' must be a constant integer}} +} +half4 test_builtin_image_load_2darray_2(half4 v4f16, int i32, __amdgpu_texture_t tex) { + + return __builtin_amdgcn_image_load_2darray_v4f16_i32(100, i32, i32, i32, tex, 120, i32); //expected-error{{argument to '__builtin_amdgcn_image_load_2darray_v4f16_i32' must be a constant integer}} +} + +float4 test_builtin_image_load_1d_1(float4 v4f32, int i32, __amdgpu_texture_t tex) { + + return __builtin_amdgcn_image_load_1d_v4f32_i32(i32, i32, tex, 120, i32); //expected-error{{argument to '__builtin_amdgcn_image_load_1d_v4f32_i32' must be a constant integer}} +} +half4 test_builtin_image_load_1d_2(half4 v4f16, int i32, __amdgpu_texture_t tex) { + + return __builtin_amdgcn_image_load_1d_v4f16_i32(100, i32, tex, 120, i32); //expected-error{{argument to '__builtin_amdgcn_image_load_1d_v4f16_i32' must be a constant integer}} +} + +float4 test_builtin_image_load_1darray_1(float4 v4f32, int i32, __amdgpu_texture_t tex) { + + return __builtin_amdgcn_image_load_1darray_v4f32_i32(100, i32, i32, tex, i32, 110); //expected-error{{argument to '__builtin_amdgcn_image_load_1darray_v4f32_i32' must be a constant integer}} +} +half4 test_builtin_image_load_1darray_2(half4 v4f16, int i32, __amdgpu_texture_t tex) { + + return __builtin_amdgcn_image_load_1darray_v4f16_i32(100, i32, i32, tex, i32, 110); //expected-error{{argument to '__builtin_amdgcn_image_load_1darray_v4f16_i32' must be a constant integer}} +} + +float4 test_builtin_image_load_3d_1(float4 v4f32, int i32, __amdgpu_texture_t tex) { + + return __builtin_amdgcn_image_load_3d_v4f32_i32(100, i32, i32, i32, tex, 120, i32); //expected-error{{argument to '__builtin_amdgcn_image_load_3d_v4f32_i32' must be a constant integer}} +} +half4 test_builtin_image_load_3d_2(half4 v4f16, int i32, __amdgpu_texture_t tex) { + + return __builtin_amdgcn_image_load_3d_v4f16_i32(i32, i32, i32, i32, tex, 120, i32); //expected-error{{argument to '__builtin_amdgcn_image_load_3d_v4f16_i32' must be a constant integer}} +} + +float4 test_builtin_image_load_cube_1(float4 v4f32, int i32, __amdgpu_texture_t tex) { + + return __builtin_amdgcn_image_load_cube_v4f32_i32(i32, i32, i32, i32, tex, 120, 110); //expected-error{{argument to '__builtin_amdgcn_image_load_cube_v4f32_i32' must be a constant integer}} +} +half4 test_builtin_image_load_cube_2(half4 v4f16, int i32, __amdgpu_texture_t tex) { + + return __builtin_amdgcn_image_load_cube_v4f16_i32(i32, i32, i32, i32, tex, 120, 110); //expected-error{{argument to '__builtin_amdgcn_image_load_cube_v4f16_i32' must be a constant integer}} +} + +float4 test_builtin_image_load_mip_1d_1(float4 v4f32, int i32, __amdgpu_texture_t tex) { + + return __builtin_amdgcn_image_load_mip_1d_v4f32_i32(i32, i32, i32, tex, 120, i32); //expected-error{{argument to '__builtin_amdgcn_image_load_mip_1d_v4f32_i32' must be a constant integer}} +} +half4 test_builtin_image_load_mip_1d_2(half4 v4f16, int i32, __amdgpu_texture_t tex) { + + return __builtin_amdgcn_image_load_mip_1d_v4f16_i32(100, i32, i32, tex, 120, i32); //expected-error{{argument to '__builtin_amdgcn_image_load_mip_1d_v4f16_i32' must be a constant integer}} +} + +float4 test_builtin_image_load_mip_1darray_1(float4 v4f32, int i32, __amdgpu_texture_t tex) { + + return __builtin_amdgcn_image_load_mip_1darray_v4f32_i32(i32, i32, i32, i32, tex, i32, 110); //expected-error{{argument to '__builtin_amdgcn_image_load_mip_1darray_v4f32_i32' must be a constant integer}} +} +half4 test_builtin_image_load_mip_1darray_2(half4 v4f16, int i32, __amdgpu_texture_t tex) { + + return __builtin_amdgcn_image_load_mip_1darray_v4f16_i32(100, i32, i32, i32, tex, i32, 110); //expected-error{{argument to '__builtin_amdgcn_image_load_mip_1darray_v4f16_i32' must be a constant integer}} +} + +float test_builtin_image_load_mip_2d(float f32, int i32, __amdgpu_texture_t tex) { + + return __builtin_amdgcn_image_load_mip_2d_f32_i32(i32, i32, i32, i32, tex, 120, i32); //expected-error{{argument to '__builtin_amdgcn_image_load_mip_2d_f32_i32' must be a constant integer}} +} +float4 test_builtin_image_load_mip_2d_1(float4 v4f32, int i32, __amdgpu_texture_t tex) { + + return __builtin_amdgcn_image_load_mip_2d_v4f32_i32(100, i32, i32, i32, tex, 120, i32); //expected-error{{argument to '__builtin_amdgcn_image_load_mip_2d_v4f32_i32' must be a constant integer}} +} +half4 test_builtin_image_load_mip_2d_2(half4 v4f16, int i32, __amdgpu_texture_t tex) { + + return __builtin_amdgcn_image_load_mip_2d_v4f16_i32(i32, i32, i32, i32, tex, 120, 110); //expected-error{{argument to '__builtin_amdgcn_image_load_mip_2d_v4f16_i32' must be a constant integer}} +} + +float test_builtin_image_load_mip_2darray(float f32, int i32, __amdgpu_texture_t tex) { + + return __builtin_amdgcn_image_load_mip_2darray_f32_i32(i32, i32, i32, i32, i32, tex, 120, 110); //expected-error{{argument to '__builtin_amdgcn_image_load_mip_2darray_f32_i32' must be a constant integer}} +} +float4 test_builtin_image_load_mip_2darray_1(float4 v4f32, int i32, __amdgpu_texture_t tex) { + + return __builtin_amdgcn_image_load_mip_2darray_v4f32_i32(100, i32, i32, i32, i32, tex, 120, i32); //expected-error{{argument to '__builtin_amdgcn_image_load_mip_2darray_v4f32_i32' must be a constant integer}} +} +half4 test_builtin_image_load_mip_2darray_2(half4 v4f16, int i32, __amdgpu_texture_t tex) { + + return __builtin_amdgcn_image_load_mip_2darray_v4f16_i32(100, i32, i32, i32, i32, tex, 120, i32); //expected-error{{argument to '__builtin_amdgcn_image_load_mip_2darray_v4f16_i32' must be a constant integer}} +} + +float4 test_builtin_image_load_mip_3d_1(float4 v4f32, int i32, __amdgpu_texture_t tex) { + + return __builtin_amdgcn_image_load_mip_3d_v4f32_i32(i32, i32, i32, i32, i32, tex, i32, 110); //expected-error{{argument to '__builtin_amdgcn_image_load_mip_3d_v4f32_i32' must be a constant integer}} +} +half4 test_builtin_image_load_mip_3d_2(half4 v4f16, int i32, __amdgpu_texture_t tex) { + + return __builtin_amdgcn_image_load_mip_3d_v4f16_i32(i32, i32, i32, i32, i32, tex, i32, 110); //expected-error{{argument to '__builtin_amdgcn_image_load_mip_3d_v4f16_i32' must be a constant integer}} +} + +float4 test_builtin_image_load_mip_cube_1(float4 v4f32, int i32, __amdgpu_texture_t tex) { + + return __builtin_amdgcn_image_load_mip_cube_v4f32_i32(i32, i32, i32, i32, i32, tex, 120, i32); //expected-error{{argument to '__builtin_amdgcn_image_load_mip_cube_v4f32_i32' must be a constant integer}} +} +half4 test_builtin_image_load_mip_cube_2(half4 v4f16, int i32, __amdgpu_texture_t tex) { + + return __builtin_amdgcn_image_load_mip_cube_v4f16_i32(100, i32, i32, i32, i32, tex, 120, i32); //expected-error{{argument to '__builtin_amdgcn_image_load_mip_cube_v4f16_i32' must be a constant integer}} +} + +float test_builtin_image_sample_2d(float f32, int i32, __amdgpu_texture_t tex, int4 vec4i32) { + + return __builtin_amdgcn_image_sample_2d_f32_f32(i32, f32, f32, tex, vec4i32, 0, 106, 103); //expected-error{{argument to '__builtin_amdgcn_image_sample_2d_f32_f32' must be a constant integer}} +} +float4 test_builtin_image_sample_2d_1(float4 v4f32, float f32, int i32, __amdgpu_texture_t tex, int4 vec4i32) { + + return __builtin_amdgcn_image_sample_2d_v4f32_f32(100, f32, f32, tex, vec4i32, 0, i32, 110); //expected-error{{argument to '__builtin_amdgcn_image_sample_2d_v4f32_f32' must be a constant integer}} +} +half4 test_builtin_image_sample_2d_2(half4 v4f16, float f32, int i32, __amdgpu_texture_t tex, int4 vec4i32) { + + return __builtin_amdgcn_image_sample_2d_v4f16_f32(100, f32, f32, tex, vec4i32, 0, 120, i32); //expected-error{{argument to '__builtin_amdgcn_image_sample_2d_v4f16_f32' must be a constant integer}} +} + +float test_builtin_image_sample_2darray(float f32, int i32, __amdgpu_texture_t tex, int4 vec4i32) { + + return __builtin_amdgcn_image_sample_2darray_f32_f32(100, f32, f32, f32, tex, vec4i32, 0, i32, 110); //expected-error{{argument to '__builtin_amdgcn_image_sample_2darray_f32_f32' must be a constant integer}} +} +float4 test_builtin_image_sample_2darray_1(float4 v4f32, float f32, int i32, __amdgpu_texture_t tex, int4 vec4i32) { + + return __builtin_amdgcn_image_sample_2darray_v4f32_f32(100, f32, f32, f32, tex, vec4i32, 0, i32, 110); //expected-error{{argument to '__builtin_amdgcn_image_sample_2darray_v4f32_f32' must be a constant integer}} +} +half4 test_builtin_image_sample_2darray_2(half4 v4f16, float f32, int i32, __amdgpu_texture_t tex, int4 vec4i32) { + + return __builtin_amdgcn_image_sample_2darray_v4f16_f32(100, f32, f32, f32, tex, vec4i32, 0, 120, i32); //expected-error{{argument to '__builtin_amdgcn_image_sample_2darray_v4f16_f32' must be a constant integer}} +} + +float4 test_builtin_image_sample_1d_1(float4 v4f32, float f32, int i32, __amdgpu_texture_t tex, int4 vec4i32) { + + return __builtin_amdgcn_image_sample_1d_v4f32_f32(i32, f32, tex, vec4i32, 0, 120, i32); //expected-error{{argument to '__builtin_amdgcn_image_sample_1d_v4f32_f32' must be a constant integer}} +} +half4 test_builtin_image_sample_1d_2(half4 v4f16, float f32, int i32, __amdgpu_texture_t tex, int4 vec4i32) { + + return __builtin_amdgcn_image_sample_1d_v4f16_f32(100, f32, tex, vec4i32, 0, 120, i32); //expected-error{{argument to '__builtin_amdgcn_image_sample_1d_v4f16_f32' must be a constant integer}} +} + +float4 test_builtin_image_sample_1darray_1(float4 v4f32, float f32, int i32, __amdgpu_texture_t tex, int4 vec4i32) { + + return __builtin_amdgcn_image_sample_1darray_v4f32_f32(100, f32, f32, tex, vec4i32, 0, i32, 110); //expected-error{{argument to '__builtin_amdgcn_image_sample_1darray_v4f32_f32' must be a constant integer}} +} +half4 test_builtin_image_sample_1darray_2(half4 v4f16, float f32, int i32, __amdgpu_texture_t tex, int4 vec4i32) { + + return __builtin_amdgcn_image_sample_1darray_v4f16_f32(100, f32, f32, tex, vec4i32, 0, i32, 110); //expected-error{{argument to '__builtin_amdgcn_image_sample_1darray_v4f16_f32' must be a constant integer}} +} + +float4 test_builtin_image_sample_3d_1(float4 v4f32, float f32, int i32, __amdgpu_texture_t tex, int4 vec4i32) { + + return __builtin_amdgcn_image_sample_3d_v4f32_f32(100, f32, f32, f32, tex, vec4i32, 0, 120, i32); //expected-error{{argument to '__builtin_amdgcn_image_sample_3d_v4f32_f32' must be a constant integer}} +} +half4 test_builtin_image_sample_3d_2(half4 v4f16, float f32, int i32, __amdgpu_texture_t tex, int4 vec4i32) { + + return __builtin_amdgcn_image_sample_3d_v4f16_f32(i32, f32, f32, f32, tex, vec4i32, 0, 120, i32); //expected-error{{argument to '__builtin_amdgcn_image_sample_3d_v4f16_f32' must be a constant integer}} +} + +float4 test_builtin_image_sample_cube_1(float4 v4f32, float f32, int i32, __amdgpu_texture_t tex, int4 vec4i32) { + + return __builtin_amdgcn_image_sample_cube_v4f32_f32(i32, f32, f32, f32, tex, vec4i32, 0, 120, 110); //expected-error{{argument to '__builtin_amdgcn_image_sample_cube_v4f32_f32' must be a constant integer}} +} +half4 test_builtin_image_sample_cube_2(half4 v4f16, float f32, int i32, __amdgpu_texture_t tex, int4 vec4i32) { + + return __builtin_amdgcn_image_sample_cube_v4f16_f32(i32, f32, f32, f32, tex, vec4i32, 0, 120, 110); //expected-error{{argument to '__builtin_amdgcn_image_sample_cube_v4f16_f32' must be a constant integer}} +} + diff --git a/clang/test/SemaOpenCL/builtins-image-load-param-gfx942-err.cl b/clang/test/SemaOpenCL/builtins-image-load-param-gfx942-err.cl new file mode 100644 index 0000000..b878002 --- /dev/null +++ b/clang/test/SemaOpenCL/builtins-image-load-param-gfx942-err.cl @@ -0,0 +1,219 @@ +// RUN: %clang_cc1 -triple amdgcn-- -target-cpu gfx942 -verify -S -o - %s +// REQUIRES: amdgpu-registered-target + +typedef int int4 __attribute__((ext_vector_type(4))); +typedef float float4 __attribute__((ext_vector_type(4))); +typedef half half4 __attribute__((ext_vector_type(4))); + +float test_builtin_image_load_2d(float f32, int i32, __amdgpu_texture_t tex) { + + return __builtin_amdgcn_image_load_2d_f32_i32(i32, i32, i32, tex, 106, 103); //expected-error{{'test_builtin_image_load_2d' needs target feature image-insts}} +} +float4 test_builtin_image_load_2d_1(float4 v4f32, int i32, __amdgpu_texture_t tex) { + + return __builtin_amdgcn_image_load_2d_v4f32_i32(100, i32, i32, tex, i32, 110); //expected-error{{'test_builtin_image_load_2d_1' needs target feature image-insts}} +} +half4 test_builtin_image_load_2d_2(half4 v4f16, int i32, __amdgpu_texture_t tex) { + + return __builtin_amdgcn_image_load_2d_v4f16_i32(100, i32, i32, tex, 120, i32); //expected-error{{'test_builtin_image_load_2d_2' needs target feature image-insts}} +} + + +float test_builtin_image_load_2darray(float f32, int i32, __amdgpu_texture_t tex) { + + return __builtin_amdgcn_image_load_2darray_f32_i32(100, i32, i32, i32, tex, i32, 110); //expected-error{{'test_builtin_image_load_2darray' needs target feature image-insts}} +} +float4 test_builtin_image_load_2darray_1(float4 v4f32, int i32, __amdgpu_texture_t tex) { + + return __builtin_amdgcn_image_load_2darray_v4f32_i32(100, i32, i32, i32, tex, i32, 110); //expected-error{{'test_builtin_image_load_2darray_1' needs target feature image-insts}} +} +half4 test_builtin_image_load_2darray_2(half4 v4f16, int i32, __amdgpu_texture_t tex) { + + return __builtin_amdgcn_image_load_2darray_v4f16_i32(100, i32, i32, i32, tex, 120, i32); //expected-error{{'test_builtin_image_load_2darray_2' needs target feature image-insts}} +} + +float4 test_builtin_image_load_1d_1(float4 v4f32, int i32, __amdgpu_texture_t tex) { + + return __builtin_amdgcn_image_load_1d_v4f32_i32(i32, i32, tex, 120, i32); //expected-error{{'test_builtin_image_load_1d_1' needs target feature image-insts}} +} +half4 test_builtin_image_load_1d_2(half4 v4f16, int i32, __amdgpu_texture_t tex) { + + return __builtin_amdgcn_image_load_1d_v4f16_i32(100, i32, tex, 120, i32); //expected-error{{'test_builtin_image_load_1d_2' needs target feature image-insts}} +} + +float4 test_builtin_image_load_1darray_1(float4 v4f32, int i32, __amdgpu_texture_t tex) { + + return __builtin_amdgcn_image_load_1darray_v4f32_i32(100, i32, i32, tex, i32, 110); //expected-error{{'test_builtin_image_load_1darray_1' needs target feature image-insts}} +} +half4 test_builtin_image_load_1darray_2(half4 v4f16, int i32, __amdgpu_texture_t tex) { + + return __builtin_amdgcn_image_load_1darray_v4f16_i32(100, i32, i32, tex, i32, 110); //expected-error{{'test_builtin_image_load_1darray_2' needs target feature image-insts}} +} + +float4 test_builtin_image_load_3d_1(float4 v4f32, int i32, __amdgpu_texture_t tex) { + + return __builtin_amdgcn_image_load_3d_v4f32_i32(100, i32, i32, i32, tex, 120, i32); //expected-error{{'test_builtin_image_load_3d_1' needs target feature image-insts}} +} +half4 test_builtin_image_load_3d_2(half4 v4f16, int i32, __amdgpu_texture_t tex) { + + return __builtin_amdgcn_image_load_3d_v4f16_i32(i32, i32, i32, i32, tex, 120, i32); //expected-error{{'test_builtin_image_load_3d_2' needs target feature image-insts}} +} + +float4 test_builtin_image_load_cube_1(float4 v4f32, int i32, __amdgpu_texture_t tex) { + + return __builtin_amdgcn_image_load_cube_v4f32_i32(i32, i32, i32, i32, tex, 120, 110); //expected-error{{'test_builtin_image_load_cube_1' needs target feature image-insts}} +} +half4 test_builtin_image_load_cube_2(half4 v4f16, int i32, __amdgpu_texture_t tex) { + + return __builtin_amdgcn_image_load_cube_v4f16_i32(i32, i32, i32, i32, tex, 120, 110); //expected-error{{'test_builtin_image_load_cube_2' needs target feature image-insts}} +} + +float4 test_builtin_image_load_mip_1d_1(float4 v4f32, int i32, __amdgpu_texture_t tex) { + + return __builtin_amdgcn_image_load_mip_1d_v4f32_i32(i32, i32, i32, tex, 120, i32); //expected-error{{'test_builtin_image_load_mip_1d_1' needs target feature image-insts}} +} +half4 test_builtin_image_load_mip_1d_2(half4 v4f16, int i32, __amdgpu_texture_t tex) { + + return __builtin_amdgcn_image_load_mip_1d_v4f16_i32(100, i32, i32, tex, 120, i32); //expected-error{{'test_builtin_image_load_mip_1d_2' needs target feature image-insts}} +} + +float4 test_builtin_image_load_mip_1darray_1(float4 v4f32, int i32, __amdgpu_texture_t tex) { + + return __builtin_amdgcn_image_load_mip_1darray_v4f32_i32(i32, i32, i32, i32, tex, i32, 110); //expected-error{{'test_builtin_image_load_mip_1darray_1' needs target feature image-insts}} +} +half4 test_builtin_image_load_mip_1darray_2(half4 v4f16, int i32, __amdgpu_texture_t tex) { + + return __builtin_amdgcn_image_load_mip_1darray_v4f16_i32(100, i32, i32, i32, tex, i32, 110); //expected-error{{'test_builtin_image_load_mip_1darray_2' needs target feature image-insts}} +} + +float test_builtin_image_load_mip_2d(float f32, int i32, __amdgpu_texture_t tex) { + + return __builtin_amdgcn_image_load_mip_2d_f32_i32(i32, i32, i32, i32, tex, 120, i32); //expected-error{{'test_builtin_image_load_mip_2d' needs target feature image-insts}} +} +float4 test_builtin_image_load_mip_2d_1(float4 v4f32, int i32, __amdgpu_texture_t tex) { + + return __builtin_amdgcn_image_load_mip_2d_v4f32_i32(100, i32, i32, i32, tex, 120, i32); //expected-error{{'test_builtin_image_load_mip_2d_1' needs target feature image-insts}} +} +half4 test_builtin_image_load_mip_2d_2(half4 v4f16, int i32, __amdgpu_texture_t tex) { + + return __builtin_amdgcn_image_load_mip_2d_v4f16_i32(i32, i32, i32, i32, tex, 120, 110); //expected-error{{'test_builtin_image_load_mip_2d_2' needs target feature image-insts}} +} + +float test_builtin_image_load_mip_2darray(float f32, int i32, __amdgpu_texture_t tex) { + + return __builtin_amdgcn_image_load_mip_2darray_f32_i32(i32, i32, i32, i32, i32, tex, 120, 110); //expected-error{{'test_builtin_image_load_mip_2darray' needs target feature image-insts}} +} +float4 test_builtin_image_load_mip_2darray_1(float4 v4f32, int i32, __amdgpu_texture_t tex) { + + return __builtin_amdgcn_image_load_mip_2darray_v4f32_i32(100, i32, i32, i32, i32, tex, 120, i32); //expected-error{{'test_builtin_image_load_mip_2darray_1' needs target feature image-insts}} +} +half4 test_builtin_image_load_mip_2darray_2(half4 v4f16, int i32, __amdgpu_texture_t tex) { + + return __builtin_amdgcn_image_load_mip_2darray_v4f16_i32(100, i32, i32, i32, i32, tex, 120, i32); //expected-error{{'test_builtin_image_load_mip_2darray_2' needs target feature image-insts}} +} + +float4 test_builtin_image_load_mip_3d_1(float4 v4f32, int i32, __amdgpu_texture_t tex) { + + return __builtin_amdgcn_image_load_mip_3d_v4f32_i32(i32, i32, i32, i32, i32, tex, i32, 110); //expected-error{{'test_builtin_image_load_mip_3d_1' needs target feature image-insts}} +} +half4 test_builtin_image_load_mip_3d_2(half4 v4f16, int i32, __amdgpu_texture_t tex) { + + return __builtin_amdgcn_image_load_mip_3d_v4f16_i32(i32, i32, i32, i32, i32, tex, i32, 110); //expected-error{{'test_builtin_image_load_mip_3d_2' needs target feature image-insts}} +} + +float4 test_builtin_image_load_mip_cube_1(float4 v4f32, int i32, __amdgpu_texture_t tex) { + + return __builtin_amdgcn_image_load_mip_cube_v4f32_i32(i32, i32, i32, i32, i32, tex, 120, i32); //expected-error{{'test_builtin_image_load_mip_cube_1' needs target feature image-insts}} +} +half4 test_builtin_image_load_mip_cube_2(half4 v4f16, int i32, __amdgpu_texture_t tex) { + + return __builtin_amdgcn_image_load_mip_cube_v4f16_i32(100, i32, i32, i32, i32, tex, 120, i32); //expected-error{{'test_builtin_image_load_mip_cube_2' needs target feature image-insts}} +} + +float test_builtin_image_load_2d_gfx(float f32, int i32, __amdgpu_texture_t tex) { + + return __builtin_amdgcn_image_load_2d_f32_i32(12, i32, i32, tex, 106, 103); //expected-error{{'test_builtin_image_load_2d_gfx' needs target feature image-insts}} +} +float4 test_builtin_image_load_2d_gfx_1(float4 v4f32, int i32, __amdgpu_texture_t tex) { + + return __builtin_amdgcn_image_load_2d_v4f32_i32(100, i32, i32, tex, 120, 110); //expected-error{{'test_builtin_image_load_2d_gfx_1' needs target feature image-insts}} +} +half4 test_builtin_image_load_2d_gfx_2(half4 v4f16, int i32, __amdgpu_texture_t tex) { + + return __builtin_amdgcn_image_load_2d_v4f16_i32(100, i32, i32, tex, 120, 110); //expected-error{{'test_builtin_image_load_2d_gfx_2' needs target feature image-insts}} +} + +float test_builtin_image_sample_2d(float f32, int i32, __amdgpu_texture_t tex, int4 vec4i32) { + + return __builtin_amdgcn_image_sample_2d_f32_f32(i32, f32, f32, tex, vec4i32, 0, 106, 103); //expected-error{{'test_builtin_image_sample_2d' needs target feature image-insts}} +} +float4 test_builtin_image_sample_2d_1(float4 v4f32, float f32, int i32, __amdgpu_texture_t tex, int4 vec4i32) { + + return __builtin_amdgcn_image_sample_2d_v4f32_f32(100, f32, f32, tex, vec4i32, 0, i32, 110); //expected-error{{'test_builtin_image_sample_2d_1' needs target feature image-insts}} +} +half4 test_builtin_image_sample_2d_2(half4 v4f16, float f32, int i32, __amdgpu_texture_t tex, int4 vec4i32) { + + return __builtin_amdgcn_image_sample_2d_v4f16_f32(100, f32, f32, tex, vec4i32, 0, 120, i32); //expected-error{{'test_builtin_image_sample_2d_2' needs target feature image-insts}} +} + +float test_builtin_image_sample_2darray(float f32, int i32, __amdgpu_texture_t tex, int4 vec4i32) { + + return __builtin_amdgcn_image_sample_2darray_f32_f32(100, f32, f32, f32, tex, vec4i32, 0, i32, 110); //expected-error{{'test_builtin_image_sample_2darray' needs target feature image-insts}} +} +float4 test_builtin_image_sample_2darray_1(float4 v4f32, float f32, int i32, __amdgpu_texture_t tex, int4 vec4i32) { + + return __builtin_amdgcn_image_sample_2darray_v4f32_f32(100, f32, f32, f32, tex, vec4i32, 0, i32, 110); //expected-error{{'test_builtin_image_sample_2darray_1' needs target feature image-insts}} +} +half4 test_builtin_image_sample_2darray_2(half4 v4f16, float f32, int i32, __amdgpu_texture_t tex, int4 vec4i32) { + + return __builtin_amdgcn_image_sample_2darray_v4f16_f32(100, f32, f32, f32, tex, vec4i32, 0, 120, i32); //expected-error{{'test_builtin_image_sample_2darray_2' needs target feature image-insts}} +} + +float4 test_builtin_image_sample_1d_1(float4 v4f32, float f32, int i32, __amdgpu_texture_t tex, int4 vec4i32) { + + return __builtin_amdgcn_image_sample_1d_v4f32_f32(i32, f32, tex, vec4i32, 0, 120, i32); //expected-error{{'test_builtin_image_sample_1d_1' needs target feature image-insts}} +} +half4 test_builtin_image_sample_1d_2(half4 v4f16, float f32, int i32, __amdgpu_texture_t tex, int4 vec4i32) { + + return __builtin_amdgcn_image_sample_1d_v4f16_f32(100, f32, tex, vec4i32, 0, 120, i32); //expected-error{{'test_builtin_image_sample_1d_2' needs target feature image-insts}} +} + +float4 test_builtin_image_sample_1darray_1(float4 v4f32, float f32, int i32, __amdgpu_texture_t tex, int4 vec4i32) { + + return __builtin_amdgcn_image_sample_1darray_v4f32_f32(100, f32, f32, tex, vec4i32, 0, i32, 110); //expected-error{{'test_builtin_image_sample_1darray_1' needs target feature image-insts}} +} +half4 test_builtin_image_sample_1darray_2(half4 v4f16, float f32, int i32, __amdgpu_texture_t tex, int4 vec4i32) { + + return __builtin_amdgcn_image_sample_1darray_v4f16_f32(100, f32, f32, tex, vec4i32, 0, i32, 110); //expected-error{{'test_builtin_image_sample_1darray_2' needs target feature image-insts}} +} + +float4 test_builtin_image_sample_3d_1(float4 v4f32, float f32, int i32, __amdgpu_texture_t tex, int4 vec4i32) { + + return __builtin_amdgcn_image_sample_3d_v4f32_f32(100, f32, f32, f32, tex, vec4i32, 0, 120, i32); //expected-error{{'test_builtin_image_sample_3d_1' needs target feature image-insts}} +} +half4 test_builtin_image_sample_3d_2(half4 v4f16, float f32, int i32, __amdgpu_texture_t tex, int4 vec4i32) { + + return __builtin_amdgcn_image_sample_3d_v4f16_f32(i32, f32, f32, f32, tex, vec4i32, 0, 120, i32); //expected-error{{'test_builtin_image_sample_3d_2' needs target feature image-insts}} +} + +float4 test_builtin_image_sample_cube_1(float4 v4f32, float f32, int i32, __amdgpu_texture_t tex, int4 vec4i32) { + + return __builtin_amdgcn_image_sample_cube_v4f32_f32(i32, f32, f32, f32, tex, vec4i32, 0, 120, 110); //expected-error{{'test_builtin_image_sample_cube_1' needs target feature image-insts}} +} +half4 test_builtin_image_sample_cube_2(half4 v4f16, float f32, int i32, __amdgpu_texture_t tex, int4 vec4i32) { + + return __builtin_amdgcn_image_sample_cube_v4f16_f32(i32, f32, f32, f32, tex, vec4i32, 0, 120, 110); //expected-error{{'test_builtin_image_sample_cube_2' needs target feature image-insts}} +} + +float test_builtin_image_sample_2d_gfx(float f32, int i32, __amdgpu_texture_t tex, int4 vec4i32) { + + return __builtin_amdgcn_image_sample_2d_f32_f32(100, f32, f32, tex, vec4i32, 0, 120, 110); //expected-error{{'test_builtin_image_sample_2d_gfx' needs target feature image-insts}} +} +float4 test_builtin_image_sample_2d_gfx_1(float4 v4f32, float f32, int i32, __amdgpu_texture_t tex, int4 vec4i32) { + + return __builtin_amdgcn_image_sample_2d_v4f32_f32(100, f32, f32, tex, vec4i32, 0, 120, 110); //expected-error{{'test_builtin_image_sample_2d_gfx_1' needs target feature image-insts}} +} +half4 test_builtin_image_sample_2d_gfx_2(half4 v4f16, float f32, int i32, __amdgpu_texture_t tex, int4 vec4i32) { + + return __builtin_amdgcn_image_sample_2d_v4f16_f32(100, f32, f32, tex, vec4i32, 0, 120, 110); //expected-error{{'test_builtin_image_sample_2d_gfx_2' needs target feature image-insts}} +} diff --git a/clang/test/SemaOpenCL/builtins-image-store-param-gfx1100-err.cl b/clang/test/SemaOpenCL/builtins-image-store-param-gfx1100-err.cl new file mode 100644 index 0000000..4f6347e --- /dev/null +++ b/clang/test/SemaOpenCL/builtins-image-store-param-gfx1100-err.cl @@ -0,0 +1,129 @@ +// RUN: %clang_cc1 -triple amdgcn-- -target-cpu gfx1100 -S -verify=expected -o - %s +// REQUIRES: amdgpu-registered-target + +typedef float float4 __attribute__((ext_vector_type(4))); +typedef half half4 __attribute__((ext_vector_type(4))); + +void test_builtin_image_store_2d(float f32, int i32, __amdgpu_texture_t tex) { + + return __builtin_amdgcn_image_store_2d_f32_i32(f32, i32, i32, i32, tex, 106, 103); //expected-error{{argument to '__builtin_amdgcn_image_store_2d_f32_i32' must be a constant integer}} +} +void test_builtin_image_store_2d_1(float4 v4f32, int i32, __amdgpu_texture_t tex) { + + return __builtin_amdgcn_image_store_2d_v4f32_i32(v4f32, 100, i32, i32, tex, i32, 110); //expected-error{{argument to '__builtin_amdgcn_image_store_2d_v4f32_i32' must be a constant integer}} +} +void test_builtin_image_store_2d_2(half4 v4f16, int i32, __amdgpu_texture_t tex) { + + return __builtin_amdgcn_image_store_2d_v4f16_i32(v4f16, 100, i32, i32, tex, 120, i32); //expected-error{{argument to '__builtin_amdgcn_image_store_2d_v4f16_i32' must be a constant integer}} +} + +void test_builtin_image_store_2darray(float f32, int i32, __amdgpu_texture_t tex) { + + return __builtin_amdgcn_image_store_2darray_f32_i32(f32, 100, i32, i32, i32, tex, i32, 110); //expected-error{{argument to '__builtin_amdgcn_image_store_2darray_f32_i32' must be a constant integer}} +} +void test_builtin_image_store_2darray_1(float4 v4f32, int i32, __amdgpu_texture_t tex) { + + return __builtin_amdgcn_image_store_2darray_v4f32_i32(v4f32, 100, i32, i32, i32, tex, i32, 110); //expected-error{{argument to '__builtin_amdgcn_image_store_2darray_v4f32_i32' must be a constant integer}} +} +void test_builtin_image_store_2darray_2(half4 v4f16, int i32, __amdgpu_texture_t tex) { + + return __builtin_amdgcn_image_store_2darray_v4f16_i32(v4f16, 100, i32, i32, i32, tex, 120, i32); //expected-error{{argument to '__builtin_amdgcn_image_store_2darray_v4f16_i32' must be a constant integer}} +} + +void test_builtin_image_store_1d_1(float4 v4f32, int i32, __amdgpu_texture_t tex) { + + return __builtin_amdgcn_image_store_1d_v4f32_i32(v4f32, i32, i32, tex, 120, i32); //expected-error{{argument to '__builtin_amdgcn_image_store_1d_v4f32_i32' must be a constant integer}} +} +void test_builtin_image_store_1d_2(half4 v4f16, int i32, __amdgpu_texture_t tex) { + + return __builtin_amdgcn_image_store_1d_v4f16_i32(v4f16, 100, i32, tex, 120, i32); //expected-error{{argument to '__builtin_amdgcn_image_store_1d_v4f16_i32' must be a constant integer}} +} + +void test_builtin_image_store_1darray_1(float4 v4f32, int i32, __amdgpu_texture_t tex) { + + return __builtin_amdgcn_image_store_1darray_v4f32_i32(v4f32, 100, i32, i32, tex, i32, 110); //expected-error{{argument to '__builtin_amdgcn_image_store_1darray_v4f32_i32' must be a constant integer}} +} +void test_builtin_image_store_1darray_2(half4 v4f16, int i32, __amdgpu_texture_t tex) { + + return __builtin_amdgcn_image_store_1darray_v4f16_i32(v4f16, 100, i32, i32, tex, i32, 110); //expected-error{{argument to '__builtin_amdgcn_image_store_1darray_v4f16_i32' must be a constant integer}} +} + +void test_builtin_image_store_3d_1(float4 v4f32, int i32, __amdgpu_texture_t tex) { + + return __builtin_amdgcn_image_store_3d_v4f32_i32(v4f32, 100, i32, i32, i32, tex, 120, i32); //expected-error{{argument to '__builtin_amdgcn_image_store_3d_v4f32_i32' must be a constant integer}} +} +void test_builtin_image_store_3d_2(half4 v4f16, int i32, __amdgpu_texture_t tex) { + + return __builtin_amdgcn_image_store_3d_v4f16_i32(v4f16, i32, i32, i32, i32, tex, 120, i32); //expected-error{{argument to '__builtin_amdgcn_image_store_3d_v4f16_i32' must be a constant integer}} +} + +void test_builtin_image_store_cube_1(float4 v4f32, int i32, __amdgpu_texture_t tex) { + + return __builtin_amdgcn_image_store_cube_v4f32_i32(v4f32, i32, i32, i32, i32, tex, 120, 110); //expected-error{{argument to '__builtin_amdgcn_image_store_cube_v4f32_i32' must be a constant integer}} +} +void test_builtin_image_store_cube_2(half4 v4f16, int i32, __amdgpu_texture_t tex) { + + return __builtin_amdgcn_image_store_cube_v4f16_i32(v4f16, i32, i32, i32, i32, tex, 120, 110); //expected-error{{argument to '__builtin_amdgcn_image_store_cube_v4f16_i32' must be a constant integer}} +} + +void test_builtin_image_store_mip_1d_1(float4 v4f32, int i32, __amdgpu_texture_t tex) { + + return __builtin_amdgcn_image_store_mip_1d_v4f32_i32(v4f32, i32, i32, i32, tex, 120, i32); //expected-error{{argument to '__builtin_amdgcn_image_store_mip_1d_v4f32_i32' must be a constant integer}} +} +void test_builtin_image_store_mip_1d_2(half4 v4f16, int i32, __amdgpu_texture_t tex) { + + return __builtin_amdgcn_image_store_mip_1d_v4f16_i32(v4f16, 100, i32, i32, tex, 120, i32); //expected-error{{argument to '__builtin_amdgcn_image_store_mip_1d_v4f16_i32' must be a constant integer}} +} + +void test_builtin_image_store_mip_1darray_1(float4 v4f32, int i32, __amdgpu_texture_t tex) { + + return __builtin_amdgcn_image_store_mip_1darray_v4f32_i32(v4f32, i32, i32, i32, i32, tex, i32, 110); //expected-error{{argument to '__builtin_amdgcn_image_store_mip_1darray_v4f32_i32' must be a constant integer}} +} +void test_builtin_image_store_mip_1darray_2(half4 v4f16, int i32, __amdgpu_texture_t tex) { + + return __builtin_amdgcn_image_store_mip_1darray_v4f16_i32(v4f16, 100, i32, i32, i32, tex, i32, 110); //expected-error{{argument to '__builtin_amdgcn_image_store_mip_1darray_v4f16_i32' must be a constant integer}} +} + +void test_builtin_image_store_mip_2d(float f32, int i32, __amdgpu_texture_t tex) { + + return __builtin_amdgcn_image_store_mip_2d_f32_i32(f32, i32, i32, i32, i32, tex, 120, i32); //expected-error{{argument to '__builtin_amdgcn_image_store_mip_2d_f32_i32' must be a constant integer}} +} +void test_builtin_image_store_mip_2d_1(float4 v4f32, int i32, __amdgpu_texture_t tex) { + + return __builtin_amdgcn_image_store_mip_2d_v4f32_i32(v4f32, 100, i32, i32, i32, tex, 120, i32); //expected-error{{argument to '__builtin_amdgcn_image_store_mip_2d_v4f32_i32' must be a constant integer}} +} +void test_builtin_image_store_mip_2d_2(half4 v4f16, int i32, __amdgpu_texture_t tex) { + + return __builtin_amdgcn_image_store_mip_2d_v4f16_i32(v4f16, i32, i32, i32, i32, tex, 120, 110); //expected-error{{argument to '__builtin_amdgcn_image_store_mip_2d_v4f16_i32' must be a constant integer}} +} + +void test_builtin_image_store_mip_2darray(float f32, int i32, __amdgpu_texture_t tex) { + + return __builtin_amdgcn_image_store_mip_2darray_f32_i32(f32, i32, i32, i32, i32, i32, tex, 120, 110); //expected-error{{argument to '__builtin_amdgcn_image_store_mip_2darray_f32_i32' must be a constant integer}} +} +void test_builtin_image_store_mip_2darray_1(float4 v4f32, int i32, __amdgpu_texture_t tex) { + + return __builtin_amdgcn_image_store_mip_2darray_v4f32_i32(v4f32, 100, i32, i32, i32, i32, tex, 120, i32); //expected-error{{argument to '__builtin_amdgcn_image_store_mip_2darray_v4f32_i32' must be a constant integer}} +} +void test_builtin_image_store_mip_2darray_2(half4 v4f16, int i32, __amdgpu_texture_t tex) { + + return __builtin_amdgcn_image_store_mip_2darray_v4f16_i32(v4f16, 100, i32, i32, i32, i32, tex, 120, i32); //expected-error{{argument to '__builtin_amdgcn_image_store_mip_2darray_v4f16_i32' must be a constant integer}} +} + +void test_builtin_image_store_mip_3d_1(float4 v4f32, int i32, __amdgpu_texture_t tex) { + + return __builtin_amdgcn_image_store_mip_3d_v4f32_i32(v4f32, i32, i32, i32, i32, i32, tex, i32, 110); //expected-error{{argument to '__builtin_amdgcn_image_store_mip_3d_v4f32_i32' must be a constant integer}} +} +void test_builtin_image_store_mip_3d_2(half4 v4f16, int i32, __amdgpu_texture_t tex) { + + return __builtin_amdgcn_image_store_mip_3d_v4f16_i32(v4f16, i32, i32, i32, i32, i32, tex, i32, 110); //expected-error{{argument to '__builtin_amdgcn_image_store_mip_3d_v4f16_i32' must be a constant integer}} +} + +void test_builtin_image_store_mip_cube_1(float4 v4f32, int i32, __amdgpu_texture_t tex) { + + return __builtin_amdgcn_image_store_mip_cube_v4f32_i32(v4f32, i32, i32, i32, i32, i32, tex, 120, i32); //expected-error{{argument to '__builtin_amdgcn_image_store_mip_cube_v4f32_i32' must be a constant integer}} +} +void test_builtin_image_store_mip_cube_2(half4 v4f16, int i32, __amdgpu_texture_t tex) { + + return __builtin_amdgcn_image_store_mip_cube_v4f16_i32(v4f16, 100, i32, i32, i32, i32, tex, 120, i32); //expected-error{{argument to '__builtin_amdgcn_image_store_mip_cube_v4f16_i32' must be a constant integer}} +} diff --git a/clang/test/SemaOpenCL/builtins-image-store-param-gfx942-err.cl b/clang/test/SemaOpenCL/builtins-image-store-param-gfx942-err.cl new file mode 100644 index 0000000..d0085e5 --- /dev/null +++ b/clang/test/SemaOpenCL/builtins-image-store-param-gfx942-err.cl @@ -0,0 +1,129 @@ +// RUN: %clang_cc1 -triple amdgcn-- -target-cpu gfx942 -S -verify -o - %s +// REQUIRES: amdgpu-registered-target + +typedef float float4 __attribute__((ext_vector_type(4))); +typedef half half4 __attribute__((ext_vector_type(4))); + +void test_builtin_image_store_2d(float f32, int i32, __amdgpu_texture_t tex) { + + return __builtin_amdgcn_image_store_2d_f32_i32(f32, i32, i32, i32, tex, 106, 103); //expected-error{{'test_builtin_image_store_2d' needs target feature image-insts}} +} +void test_builtin_image_store_2d_1(float4 v4f32, int i32, __amdgpu_texture_t tex) { + + return __builtin_amdgcn_image_store_2d_v4f32_i32(v4f32, 100, i32, i32, tex, i32, 110); //expected-error{{'test_builtin_image_store_2d_1' needs target feature image-insts}} +} +void test_builtin_image_store_2d_2(half4 v4f16, int i32, __amdgpu_texture_t tex) { + + return __builtin_amdgcn_image_store_2d_v4f16_i32(v4f16, 100, i32, i32, tex, 120, i32); //expected-error{{'test_builtin_image_store_2d_2' needs target feature image-insts}} +} + +void test_builtin_image_store_2darray(float f32, int i32, __amdgpu_texture_t tex) { + + return __builtin_amdgcn_image_store_2darray_f32_i32(f32, 100, i32, i32, i32, tex, i32, 110); //expected-error{{'test_builtin_image_store_2darray' needs target feature image-insts}} +} +void test_builtin_image_store_2darray_1(float4 v4f32, int i32, __amdgpu_texture_t tex) { + + return __builtin_amdgcn_image_store_2darray_v4f32_i32(v4f32, 100, i32, i32, i32, tex, i32, 110); //expected-error{{'test_builtin_image_store_2darray_1' needs target feature image-insts}} +} +void test_builtin_image_store_2darray_2(half4 v4f16, int i32, __amdgpu_texture_t tex) { + + return __builtin_amdgcn_image_store_2darray_v4f16_i32(v4f16, 100, i32, i32, i32, tex, 120, i32); //expected-error{{'test_builtin_image_store_2darray_2' needs target feature image-insts}} +} + +void test_builtin_image_store_1d_1(float4 v4f32, int i32, __amdgpu_texture_t tex) { + + return __builtin_amdgcn_image_store_1d_v4f32_i32(v4f32, i32, i32, tex, 120, i32); //expected-error{{'test_builtin_image_store_1d_1' needs target feature image-insts}} +} +void test_builtin_image_store_1d_2(half4 v4f16, int i32, __amdgpu_texture_t tex) { + + return __builtin_amdgcn_image_store_1d_v4f16_i32(v4f16, 100, i32, tex, 120, i32); //expected-error{{'test_builtin_image_store_1d_2' needs target feature image-insts}} +} + +void test_builtin_image_store_1darray_1(float4 v4f32, int i32, __amdgpu_texture_t tex) { + + return __builtin_amdgcn_image_store_1darray_v4f32_i32(v4f32, 100, i32, i32, tex, i32, 110); //expected-error{{'test_builtin_image_store_1darray_1' needs target feature image-insts}} +} +void test_builtin_image_store_1darray_2(half4 v4f16, int i32, __amdgpu_texture_t tex) { + + return __builtin_amdgcn_image_store_1darray_v4f16_i32(v4f16, 100, i32, i32, tex, i32, 110); //expected-error{{'test_builtin_image_store_1darray_2' needs target feature image-insts}} +} + +void test_builtin_image_store_3d_1(float4 v4f32, int i32, __amdgpu_texture_t tex) { + + return __builtin_amdgcn_image_store_3d_v4f32_i32(v4f32, 100, i32, i32, i32, tex, 120, i32); //expected-error{{'test_builtin_image_store_3d_1' needs target feature image-insts}} +} +void test_builtin_image_store_3d_2(half4 v4f16, int i32, __amdgpu_texture_t tex) { + + return __builtin_amdgcn_image_store_3d_v4f16_i32(v4f16, i32, i32, i32, i32, tex, 120, i32); //expected-error{{'test_builtin_image_store_3d_2' needs target feature image-insts}} +} + +void test_builtin_image_store_cube_1(float4 v4f32, int i32, __amdgpu_texture_t tex) { + + return __builtin_amdgcn_image_store_cube_v4f32_i32(v4f32, i32, i32, i32, i32, tex, 120, 110); //expected-error{{'test_builtin_image_store_cube_1' needs target feature image-insts}} +} +void test_builtin_image_store_cube_2(half4 v4f16, int i32, __amdgpu_texture_t tex) { + + return __builtin_amdgcn_image_store_cube_v4f16_i32(v4f16, i32, i32, i32, i32, tex, 120, 110); //expected-error{{'test_builtin_image_store_cube_2' needs target feature image-insts}} +} + +void test_builtin_image_store_mip_1d_1(float4 v4f32, int i32, __amdgpu_texture_t tex) { + + return __builtin_amdgcn_image_store_mip_1d_v4f32_i32(v4f32, i32, i32, i32, tex, 120, i32); //expected-error{{'test_builtin_image_store_mip_1d_1' needs target feature image-insts}} +} +void test_builtin_image_store_mip_1d_2(half4 v4f16, int i32, __amdgpu_texture_t tex) { + + return __builtin_amdgcn_image_store_mip_1d_v4f16_i32(v4f16, 100, i32, i32, tex, 120, i32); //expected-error{{'test_builtin_image_store_mip_1d_2' needs target feature image-insts}} +} + +void test_builtin_image_store_mip_1darray_1(float4 v4f32, int i32, __amdgpu_texture_t tex) { + + return __builtin_amdgcn_image_store_mip_1darray_v4f32_i32(v4f32, i32, i32, i32, i32, tex, i32, 110); //expected-error{{'test_builtin_image_store_mip_1darray_1' needs target feature image-insts}} +} +void test_builtin_image_store_mip_1darray_2(half4 v4f16, int i32, __amdgpu_texture_t tex) { + + return __builtin_amdgcn_image_store_mip_1darray_v4f16_i32(v4f16, 100, i32, i32, i32, tex, i32, 110); //expected-error{{'test_builtin_image_store_mip_1darray_2' needs target feature image-insts}} +} + +void test_builtin_image_store_mip_2d(float f32, int i32, __amdgpu_texture_t tex) { + + return __builtin_amdgcn_image_store_mip_2d_f32_i32(f32, i32, i32, i32, i32, tex, 120, i32); //expected-error{{'test_builtin_image_store_mip_2d' needs target feature image-insts}} +} +void test_builtin_image_store_mip_2d_1(float4 v4f32, int i32, __amdgpu_texture_t tex) { + + return __builtin_amdgcn_image_store_mip_2d_v4f32_i32(v4f32, 100, i32, i32, i32, tex, 120, i32); //expected-error{{'test_builtin_image_store_mip_2d_1' needs target feature image-insts}} +} +void test_builtin_image_store_mip_2d_2(half4 v4f16, int i32, __amdgpu_texture_t tex) { + + return __builtin_amdgcn_image_store_mip_2d_v4f16_i32(v4f16, i32, i32, i32, i32, tex, 120, 110); //expected-error{{'test_builtin_image_store_mip_2d_2' needs target feature image-insts}} +} + +void test_builtin_image_store_mip_2darray(float f32, int i32, __amdgpu_texture_t tex) { + + return __builtin_amdgcn_image_store_mip_2darray_f32_i32(f32, i32, i32, i32, i32, i32, tex, 120, 110); //expected-error{{'test_builtin_image_store_mip_2darray' needs target feature image-insts}} +} +void test_builtin_image_store_mip_2darray_1(float4 v4f32, int i32, __amdgpu_texture_t tex) { + + return __builtin_amdgcn_image_store_mip_2darray_v4f32_i32(v4f32, 100, i32, i32, i32, i32, tex, 120, i32); //expected-error{{'test_builtin_image_store_mip_2darray_1' needs target feature image-insts}} +} +void test_builtin_image_store_mip_2darray_2(half4 v4f16, int i32, __amdgpu_texture_t tex) { + + return __builtin_amdgcn_image_store_mip_2darray_v4f16_i32(v4f16, 100, i32, i32, i32, i32, tex, 120, i32); //expected-error{{'test_builtin_image_store_mip_2darray_2' needs target feature image-insts}} +} + +void test_builtin_image_store_mip_3d_1(float4 v4f32, int i32, __amdgpu_texture_t tex) { + + return __builtin_amdgcn_image_store_mip_3d_v4f32_i32(v4f32, i32, i32, i32, i32, i32, tex, i32, 110); //expected-error{{'test_builtin_image_store_mip_3d_1' needs target feature image-insts}} +} +void test_builtin_image_store_mip_3d_2(half4 v4f16, int i32, __amdgpu_texture_t tex) { + + return __builtin_amdgcn_image_store_mip_3d_v4f16_i32(v4f16, i32, i32, i32, i32, i32, tex, i32, 110); //expected-error{{'test_builtin_image_store_mip_3d_2' needs target feature image-insts}} +} + +void test_builtin_image_store_mip_cube_1(float4 v4f32, int i32, __amdgpu_texture_t tex) { + + return __builtin_amdgcn_image_store_mip_cube_v4f32_i32(v4f32, i32, i32, i32, i32, i32, tex, 120, i32); //expected-error{{'test_builtin_image_store_mip_cube_1' needs target feature image-insts}} +} +void test_builtin_image_store_mip_cube_2(half4 v4f16, int i32, __amdgpu_texture_t tex) { + + return __builtin_amdgcn_image_store_mip_cube_v4f16_i32(v4f16, 100, i32, i32, i32, i32, tex, 120, i32); //expected-error{{'test_builtin_image_store_mip_cube_2' needs target feature image-insts}} +} diff --git a/clang/utils/TableGen/SveEmitter.cpp b/clang/utils/TableGen/SveEmitter.cpp index 553c7a3..b1e94e0 100644 --- a/clang/utils/TableGen/SveEmitter.cpp +++ b/clang/utils/TableGen/SveEmitter.cpp @@ -994,8 +994,29 @@ Intrinsic::Intrinsic(StringRef Name, StringRef Proto, uint64_t MergeTy, auto FormatGuard = [](StringRef Guard, StringRef Base) -> std::string { if (Guard.empty() || Guard == Base) return Guard.str(); - if (Guard.contains('|')) - return Base.str() + ",(" + Guard.str() + ")"; + + unsigned Depth = 0; + for (auto &C : Guard) { + switch (C) { + default: + break; + case '|': + if (Depth == 0) + // Group top-level ORs before ANDing with the base feature. + return Base.str() + ",(" + Guard.str() + ")"; + break; + case '(': + ++Depth; + break; + case ')': + if (Depth == 0) + llvm_unreachable("Mismatched parentheses!"); + + --Depth; + break; + } + } + return Base.str() + "," + Guard.str(); }; diff --git a/clang/www/c_status.html b/clang/www/c_status.html index 380f664..b803962 100644 --- a/clang/www/c_status.html +++ b/clang/www/c_status.html @@ -339,7 +339,7 @@ conformance.</p> <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> + <td class="full" align="center">Yes</td> </tr> <tr> <td>static_assert without UB</td> @@ -349,7 +349,7 @@ conformance.</p> <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> + <td class="unreleased" align="center">Clang 22</td> </tr> <tr> <td>Generic replacement (v. 2 of quasi-literals)</td> @@ -359,17 +359,7 @@ conformance.</p> <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> + <td class="full" align="center">Yes</td> </tr> </table> </details> |