diff --git a/drivers/ivb/SOURCE b/drivers/ivb/SOURCE deleted file mode 100644 index 366afb0..0000000 --- a/drivers/ivb/SOURCE +++ /dev/null @@ -1 +0,0 @@ -065e4eb diff --git a/drivers/ivb/i686/d3dadapter9.so.1 b/drivers/ivb/i686/d3dadapter9.so.1 deleted file mode 100755 index 8ed3a9e..0000000 Binary files a/drivers/ivb/i686/d3dadapter9.so.1 and /dev/null differ diff --git a/drivers/ivb/i686/libvulkan_intel_hasvk13.so b/drivers/ivb/i686/libvulkan_intel_hasvk13.so deleted file mode 100755 index 331dcfa..0000000 Binary files a/drivers/ivb/i686/libvulkan_intel_hasvk13.so and /dev/null differ diff --git a/drivers/ivb/update.sh b/drivers/ivb/update.sh deleted file mode 100755 index 33085a0..0000000 --- a/drivers/ivb/update.sh +++ /dev/null @@ -1,38 +0,0 @@ -#!/usr/bin/env bash -# Copy the release build of the intel-hard-graphics mesa fork into this -# directory; hw-ivb-drivers turns the files into the system's Vulkan (hasvk), -# Direct3D 9 (gallium nine) and OpenCL (rusticl) drivers. -# -# drivers/ivb/update.sh ninja + install both release builds, copy -# nixos-rebuild switch then -# -# The release builds are configured in the fork (meson setup release / -# release32, see its flake's release shells, pinned to this system's nixpkgs). -set -euo pipefail -here=$(cd "$(dirname "$0")" && pwd) -fork=${IVB_FORK:-/mnt/HDD/linuxdata/Projects_XFS/Drivers/intel-hard-graphics} - -stage() { # build dir, profile, arch dir, files... - local build=$1 profile=$2 arch=$3 - shift 3 - local tmp - tmp=$(mktemp -d) - (cd "$fork" && nix develop ".profiles/$profile" -c ninja -C "$build" && - nix develop ".profiles/$profile" -c meson install -C "$build" --no-rebuild \ - --destdir "$tmp" --quiet) - mkdir -p "$here/$arch" - for f in "$@"; do - install -m 0755 "$tmp/usr/local/lib/$f" "$here/$arch/$(basename "$f")" - done - rm -rf "$tmp" -} - -stage release release x86_64 \ - libvulkan_intel_hasvk13.so d3d/d3dadapter9.so.1 libRusticlOpenCL.so.1 -stage release32 release-i686 i686 \ - libvulkan_intel_hasvk13.so d3d/d3dadapter9.so.1 - -(cd "$fork" && printf '%s\n' "$(jj log -r @- --no-graph -T 'commit_id.short() ++ " " ++ description.first_line()' 2>/dev/null || - git rev-parse --short HEAD 2>/dev/null)") > "$here/SOURCE" -ls -la "$here"/x86_64 "$here"/i686 -echo "source: $(cat "$here/SOURCE")" diff --git a/drivers/ivb/x86_64/d3dadapter9.so.1 b/drivers/ivb/x86_64/d3dadapter9.so.1 deleted file mode 100755 index d232d8f..0000000 Binary files a/drivers/ivb/x86_64/d3dadapter9.so.1 and /dev/null differ diff --git a/drivers/ivb/x86_64/libRusticlOpenCL.so.1 b/drivers/ivb/x86_64/libRusticlOpenCL.so.1 deleted file mode 100755 index 6f4baf3..0000000 Binary files a/drivers/ivb/x86_64/libRusticlOpenCL.so.1 and /dev/null differ diff --git a/drivers/ivb/x86_64/libvulkan_intel_hasvk13.so b/drivers/ivb/x86_64/libvulkan_intel_hasvk13.so deleted file mode 100755 index beec307..0000000 Binary files a/drivers/ivb/x86_64/libvulkan_intel_hasvk13.so and /dev/null differ diff --git a/drivers/pocl-gen7/SOURCE b/drivers/pocl-gen7/SOURCE deleted file mode 100644 index 4a0489c..0000000 --- a/drivers/pocl-gen7/SOURCE +++ /dev/null @@ -1,2 +0,0 @@ -pocl f621e6b531a3 gen7: the recorder saves a program's source before building it, so a compiler crash still leaves it -libgbe c3af170fe1e9 backend: lock the clang stage of programNewFromSource like the other entry points (it resets and parses process-wide llvm::cl options, so two programs built at once raced); report a failed link with the builtin library as a build error instead of an empty, successful program diff --git a/drivers/pocl-gen7/lib/beignet/beignet.bc b/drivers/pocl-gen7/lib/beignet/beignet.bc deleted file mode 100644 index e3be577..0000000 Binary files a/drivers/pocl-gen7/lib/beignet/beignet.bc and /dev/null differ diff --git a/drivers/pocl-gen7/lib/beignet/beignet.pch b/drivers/pocl-gen7/lib/beignet/beignet.pch deleted file mode 100644 index a1d49c5..0000000 Binary files a/drivers/pocl-gen7/lib/beignet/beignet.pch and /dev/null differ diff --git a/drivers/pocl-gen7/lib/beignet/beignet_20.bc b/drivers/pocl-gen7/lib/beignet/beignet_20.bc deleted file mode 100644 index 985d794..0000000 Binary files a/drivers/pocl-gen7/lib/beignet/beignet_20.bc and /dev/null differ diff --git a/drivers/pocl-gen7/lib/beignet/beignet_20.pch b/drivers/pocl-gen7/lib/beignet/beignet_20.pch deleted file mode 100644 index aa4fb83..0000000 Binary files a/drivers/pocl-gen7/lib/beignet/beignet_20.pch and /dev/null differ diff --git a/drivers/pocl-gen7/lib/beignet/include/ocl.h b/drivers/pocl-gen7/lib/beignet/include/ocl.h deleted file mode 100644 index 484562a..0000000 --- a/drivers/pocl-gen7/lib/beignet/include/ocl.h +++ /dev/null @@ -1,140 +0,0 @@ -/* - * Copyright © 2012 - 2014 Intel Corporation - * - * This library is free software; you can redistribute it and/or - * modify it under the terms of the GNU Lesser General Public - * License as published by the Free Software Foundation; either - * version 2.1 of the License, or (at your option) any later version. - * - * This library is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU - * Lesser General Public License for more details. - * - * You should have received a copy of the GNU Lesser General Public - * License along with this library. If not, see . - * - */ -#ifndef __OCL_H__ -#define __OCL_H__ - -/* LLVM 3.9 has these pre defined undef them first */ -#ifdef cl_khr_3d_image_writes -#undef cl_khr_3d_image_writes -#endif -#ifdef cl_khr_byte_addressable_store -#undef cl_khr_byte_addressable_store -#endif -#ifdef cl_khr_fp16 -#undef cl_khr_fp16 -#endif -#ifdef cl_khr_fp64 -#undef cl_khr_fp64 -#endif -#ifdef cl_khr_global_int32_base_atomics -#undef cl_khr_global_int32_base_atomics -#endif -#ifdef cl_khr_global_int32_extended_atomics -#undef cl_khr_global_int32_extended_atomics -#endif -#ifdef cl_khr_gl_sharing -#undef cl_khr_gl_sharing -#endif -#ifdef cl_khr_icd -#undef cl_khr_icd -#endif -#ifdef cl_khr_local_int32_base_atomics -#undef cl_khr_local_int32_base_atomics -#endif -#ifdef cl_khr_local_int32_extended_atomics -#undef cl_khr_local_int32_extended_atomics -#endif - -#ifdef cl_khr_d3d10_sharing -#undef cl_khr_d3d10_sharing -#endif -#ifdef cl_khr_gl_event -#undef cl_khr_gl_event -#endif -#ifdef cl_khr_int64_base_atomics -#undef cl_khr_int64_base_atomics -#endif -#ifdef cl_khr_int64_extended_atomics -#undef cl_khr_int64_extended_atomics -#endif - -#ifdef cl_khr_d3d11_sharing -#undef cl_khr_d3d11_sharing -#endif -#ifdef cl_khr_depth_images -#undef cl_khr_depth_images -#endif -#ifdef cl_khr_dx9_media_sharing -#undef cl_khr_dx9_media_sharing -#endif -#ifdef cl_khr_gl_depth_images -#undef cl_khr_gl_depth_images -#endif -#ifdef cl_khr_spir -#undef cl_khr_spir -#endif - -#include "ocl_defines.h" -#include "ocl_types.h" -#include "ocl_as.h" -#include "ocl_async.h" -#include "ocl_common.h" -#include "ocl_convert.h" -#include "ocl_float.h" -#include "ocl_geometric.h" -#include "ocl_image.h" -#include "ocl_integer.h" -#include "ocl_memcpy.h" -#include "ocl_memset.h" -#include "ocl_misc.h" -#include "ocl_printf.h" -#include "ocl_relational.h" -#include "ocl_sync.h" -#if (__OPENCL_C_VERSION__ >= 200 && __OPENCL_C_VERSION__ < 300) -#include "ocl_vload_20.h" -#include "ocl_atom_20.h" -#include "ocl_pipe.h" -#include "ocl_math_20.h" -#include "ocl_enqueue.h" -#else -#include "ocl_vload.h" -#include "ocl_atom.h" -#include "ocl_math.h" -#endif -#include "ocl_workitem.h" -#include "ocl_simd.h" -#include "ocl_work_group.h" - -/* Move these out from ocl_defines.h for only one define */ -#define cl_khr_global_int32_base_atomics -#define cl_khr_global_int32_extended_atomics -#define cl_khr_local_int32_base_atomics -#define cl_khr_local_int32_extended_atomics -#define cl_khr_byte_addressable_store -#define cl_khr_icd -#define cl_khr_gl_sharing -#define cl_khr_spir -#define cl_khr_fp16 -#define cl_khr_3d_image_writes -#define cl_intel_subgroups -#define cl_intel_subgroups_short -#define cl_intel_planar_yuv -#define cl_intel_media_block_io - -#if __clang_major__*10 + __clang_minor__ > 40 -#define cl_intel_required_subgroup_size -#endif - -#pragma OPENCL EXTENSION cl_khr_fp64 : disable -#pragma OPENCL EXTENSION cl_khr_fp16 : disable -/* OpenCL C 3.0: clang keeps fp64 on because this library declares double - functions; kernels must not see the feature the device lacks */ -#if (__OPENCL_C_VERSION__ >= 300) -#undef __opencl_c_fp64 -#endif -#endif diff --git a/drivers/pocl-gen7/lib/beignet/include/ocl_as.h b/drivers/pocl-gen7/lib/beignet/include/ocl_as.h deleted file mode 100644 index 6e2271f..0000000 --- a/drivers/pocl-gen7/lib/beignet/include/ocl_as.h +++ /dev/null @@ -1,646 +0,0 @@ - -/* - * Copyright © 2012 - 2014 Intel Corporatio - * - * This library is free software; you can redistribute it and/or - * modify it under the terms of the GNU Lesser General Public - * License as published by the Free Software Foundation; either - * version 2.1 of the License, or (at your option) any later version. - * - * This library is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU - * Lesser General Public License for more details. - * - * You should have received a copy of the GNU Lesser General Public - * License along with this library. If not, see . - * - */ - -#ifndef __OCL_AS_H__ -#define __OCL_AS_H__ -#include "ocl_types.h" - -OVERLOADABLE uchar as_uchar(char v); -OVERLOADABLE char as_char(uchar v); -OVERLOADABLE ushort as_ushort(short v); -OVERLOADABLE char2 as_char2(short v); -OVERLOADABLE uchar2 as_uchar2(short v); -OVERLOADABLE half as_half(short v); -OVERLOADABLE short as_short(ushort v); -OVERLOADABLE char2 as_char2(ushort v); -OVERLOADABLE uchar2 as_uchar2(ushort v); -OVERLOADABLE half as_half(ushort v); -OVERLOADABLE short as_short(char2 v); -OVERLOADABLE ushort as_ushort(char2 v); -OVERLOADABLE uchar2 as_uchar2(char2 v); -OVERLOADABLE half as_half(char2 v); -OVERLOADABLE short as_short(uchar2 v); -OVERLOADABLE ushort as_ushort(uchar2 v); -OVERLOADABLE char2 as_char2(uchar2 v); -OVERLOADABLE half as_half(uchar2 v); -OVERLOADABLE short as_short(half v); -OVERLOADABLE ushort as_ushort(half v); -OVERLOADABLE char2 as_char2(half v); -OVERLOADABLE uchar2 as_uchar2(half v); -OVERLOADABLE uint as_uint(int v); -OVERLOADABLE short2 as_short2(int v); -OVERLOADABLE ushort2 as_ushort2(int v); -OVERLOADABLE char3 as_char3(int v); -OVERLOADABLE char4 as_char4(int v); -OVERLOADABLE uchar3 as_uchar3(int v); -OVERLOADABLE uchar4 as_uchar4(int v); -OVERLOADABLE float as_float(int v); -OVERLOADABLE half2 as_half2(int v); -OVERLOADABLE int as_int(uint v); -OVERLOADABLE short2 as_short2(uint v); -OVERLOADABLE ushort2 as_ushort2(uint v); -OVERLOADABLE char3 as_char3(uint v); -OVERLOADABLE char4 as_char4(uint v); -OVERLOADABLE uchar3 as_uchar3(uint v); -OVERLOADABLE uchar4 as_uchar4(uint v); -OVERLOADABLE float as_float(uint v); -OVERLOADABLE half2 as_half2(uint v); -OVERLOADABLE int as_int(short2 v); -OVERLOADABLE uint as_uint(short2 v); -OVERLOADABLE ushort2 as_ushort2(short2 v); -OVERLOADABLE char3 as_char3(short2 v); -OVERLOADABLE char4 as_char4(short2 v); -OVERLOADABLE uchar3 as_uchar3(short2 v); -OVERLOADABLE uchar4 as_uchar4(short2 v); -OVERLOADABLE float as_float(short2 v); -OVERLOADABLE half2 as_half2(short2 v); -OVERLOADABLE int as_int(ushort2 v); -OVERLOADABLE uint as_uint(ushort2 v); -OVERLOADABLE short2 as_short2(ushort2 v); -OVERLOADABLE char3 as_char3(ushort2 v); -OVERLOADABLE char4 as_char4(ushort2 v); -OVERLOADABLE uchar3 as_uchar3(ushort2 v); -OVERLOADABLE uchar4 as_uchar4(ushort2 v); -OVERLOADABLE float as_float(ushort2 v); -OVERLOADABLE half2 as_half2(ushort2 v); -OVERLOADABLE int as_int(char3 v); -OVERLOADABLE uint as_uint(char3 v); -OVERLOADABLE short2 as_short2(char3 v); -OVERLOADABLE ushort2 as_ushort2(char3 v); -OVERLOADABLE uchar3 as_uchar3(char3 v); -OVERLOADABLE uchar4 as_uchar4(char3 v); -OVERLOADABLE float as_float(char3 v); -OVERLOADABLE half2 as_half2(char3 v); -OVERLOADABLE int as_int(char4 v); -OVERLOADABLE uint as_uint(char4 v); -OVERLOADABLE short2 as_short2(char4 v); -OVERLOADABLE ushort2 as_ushort2(char4 v); -OVERLOADABLE uchar3 as_uchar3(char4 v); -OVERLOADABLE uchar4 as_uchar4(char4 v); -OVERLOADABLE float as_float(char4 v); -OVERLOADABLE half2 as_half2(char4 v); -OVERLOADABLE int as_int(uchar3 v); -OVERLOADABLE uint as_uint(uchar3 v); -OVERLOADABLE short2 as_short2(uchar3 v); -OVERLOADABLE ushort2 as_ushort2(uchar3 v); -OVERLOADABLE char3 as_char3(uchar3 v); -OVERLOADABLE char4 as_char4(uchar3 v); -OVERLOADABLE float as_float(uchar3 v); -OVERLOADABLE half2 as_half2(uchar3 v); -OVERLOADABLE int as_int(uchar4 v); -OVERLOADABLE uint as_uint(uchar4 v); -OVERLOADABLE short2 as_short2(uchar4 v); -OVERLOADABLE ushort2 as_ushort2(uchar4 v); -OVERLOADABLE char3 as_char3(uchar4 v); -OVERLOADABLE char4 as_char4(uchar4 v); -OVERLOADABLE float as_float(uchar4 v); -OVERLOADABLE half2 as_half2(uchar4 v); -OVERLOADABLE int as_int(float v); -OVERLOADABLE uint as_uint(float v); -OVERLOADABLE short2 as_short2(float v); -OVERLOADABLE ushort2 as_ushort2(float v); -OVERLOADABLE char3 as_char3(float v); -OVERLOADABLE char4 as_char4(float v); -OVERLOADABLE uchar3 as_uchar3(float v); -OVERLOADABLE uchar4 as_uchar4(float v); -OVERLOADABLE half2 as_half2(float v); -OVERLOADABLE int as_int(half2 v); -OVERLOADABLE uint as_uint(half2 v); -OVERLOADABLE short2 as_short2(half2 v); -OVERLOADABLE ushort2 as_ushort2(half2 v); -OVERLOADABLE char3 as_char3(half2 v); -OVERLOADABLE char4 as_char4(half2 v); -OVERLOADABLE uchar3 as_uchar3(half2 v); -OVERLOADABLE uchar4 as_uchar4(half2 v); -OVERLOADABLE float as_float(half2 v); -OVERLOADABLE ulong as_ulong(long v); -OVERLOADABLE int2 as_int2(long v); -OVERLOADABLE uint2 as_uint2(long v); -OVERLOADABLE short3 as_short3(long v); -OVERLOADABLE short4 as_short4(long v); -OVERLOADABLE ushort3 as_ushort3(long v); -OVERLOADABLE ushort4 as_ushort4(long v); -OVERLOADABLE char8 as_char8(long v); -OVERLOADABLE uchar8 as_uchar8(long v); -OVERLOADABLE double as_double(long v); -OVERLOADABLE float2 as_float2(long v); -OVERLOADABLE half3 as_half3(long v); -OVERLOADABLE half4 as_half4(long v); -OVERLOADABLE long as_long(ulong v); -OVERLOADABLE int2 as_int2(ulong v); -OVERLOADABLE uint2 as_uint2(ulong v); -OVERLOADABLE short3 as_short3(ulong v); -OVERLOADABLE short4 as_short4(ulong v); -OVERLOADABLE ushort3 as_ushort3(ulong v); -OVERLOADABLE ushort4 as_ushort4(ulong v); -OVERLOADABLE char8 as_char8(ulong v); -OVERLOADABLE uchar8 as_uchar8(ulong v); -OVERLOADABLE double as_double(ulong v); -OVERLOADABLE float2 as_float2(ulong v); -OVERLOADABLE half3 as_half3(ulong v); -OVERLOADABLE half4 as_half4(ulong v); -OVERLOADABLE long as_long(int2 v); -OVERLOADABLE ulong as_ulong(int2 v); -OVERLOADABLE uint2 as_uint2(int2 v); -OVERLOADABLE short3 as_short3(int2 v); -OVERLOADABLE short4 as_short4(int2 v); -OVERLOADABLE ushort3 as_ushort3(int2 v); -OVERLOADABLE ushort4 as_ushort4(int2 v); -OVERLOADABLE char8 as_char8(int2 v); -OVERLOADABLE uchar8 as_uchar8(int2 v); -OVERLOADABLE double as_double(int2 v); -OVERLOADABLE float2 as_float2(int2 v); -OVERLOADABLE half3 as_half3(int2 v); -OVERLOADABLE half4 as_half4(int2 v); -OVERLOADABLE long as_long(uint2 v); -OVERLOADABLE ulong as_ulong(uint2 v); -OVERLOADABLE int2 as_int2(uint2 v); -OVERLOADABLE short3 as_short3(uint2 v); -OVERLOADABLE short4 as_short4(uint2 v); -OVERLOADABLE ushort3 as_ushort3(uint2 v); -OVERLOADABLE ushort4 as_ushort4(uint2 v); -OVERLOADABLE char8 as_char8(uint2 v); -OVERLOADABLE uchar8 as_uchar8(uint2 v); -OVERLOADABLE double as_double(uint2 v); -OVERLOADABLE float2 as_float2(uint2 v); -OVERLOADABLE half3 as_half3(uint2 v); -OVERLOADABLE half4 as_half4(uint2 v); -OVERLOADABLE long as_long(short3 v); -OVERLOADABLE ulong as_ulong(short3 v); -OVERLOADABLE int2 as_int2(short3 v); -OVERLOADABLE uint2 as_uint2(short3 v); -OVERLOADABLE ushort3 as_ushort3(short3 v); -OVERLOADABLE ushort4 as_ushort4(short3 v); -OVERLOADABLE char8 as_char8(short3 v); -OVERLOADABLE uchar8 as_uchar8(short3 v); -OVERLOADABLE double as_double(short3 v); -OVERLOADABLE float2 as_float2(short3 v); -OVERLOADABLE half3 as_half3(short3 v); -OVERLOADABLE half4 as_half4(short3 v); -OVERLOADABLE long as_long(short4 v); -OVERLOADABLE ulong as_ulong(short4 v); -OVERLOADABLE int2 as_int2(short4 v); -OVERLOADABLE uint2 as_uint2(short4 v); -OVERLOADABLE ushort3 as_ushort3(short4 v); -OVERLOADABLE ushort4 as_ushort4(short4 v); -OVERLOADABLE char8 as_char8(short4 v); -OVERLOADABLE uchar8 as_uchar8(short4 v); -OVERLOADABLE double as_double(short4 v); -OVERLOADABLE float2 as_float2(short4 v); -OVERLOADABLE half3 as_half3(short4 v); -OVERLOADABLE half4 as_half4(short4 v); -OVERLOADABLE long as_long(ushort3 v); -OVERLOADABLE ulong as_ulong(ushort3 v); -OVERLOADABLE int2 as_int2(ushort3 v); -OVERLOADABLE uint2 as_uint2(ushort3 v); -OVERLOADABLE short3 as_short3(ushort3 v); -OVERLOADABLE short4 as_short4(ushort3 v); -OVERLOADABLE char8 as_char8(ushort3 v); -OVERLOADABLE uchar8 as_uchar8(ushort3 v); -OVERLOADABLE double as_double(ushort3 v); -OVERLOADABLE float2 as_float2(ushort3 v); -OVERLOADABLE half3 as_half3(ushort3 v); -OVERLOADABLE half4 as_half4(ushort3 v); -OVERLOADABLE long as_long(ushort4 v); -OVERLOADABLE ulong as_ulong(ushort4 v); -OVERLOADABLE int2 as_int2(ushort4 v); -OVERLOADABLE uint2 as_uint2(ushort4 v); -OVERLOADABLE short3 as_short3(ushort4 v); -OVERLOADABLE short4 as_short4(ushort4 v); -OVERLOADABLE char8 as_char8(ushort4 v); -OVERLOADABLE uchar8 as_uchar8(ushort4 v); -OVERLOADABLE double as_double(ushort4 v); -OVERLOADABLE float2 as_float2(ushort4 v); -OVERLOADABLE half3 as_half3(ushort4 v); -OVERLOADABLE half4 as_half4(ushort4 v); -OVERLOADABLE long as_long(char8 v); -OVERLOADABLE ulong as_ulong(char8 v); -OVERLOADABLE int2 as_int2(char8 v); -OVERLOADABLE uint2 as_uint2(char8 v); -OVERLOADABLE short3 as_short3(char8 v); -OVERLOADABLE short4 as_short4(char8 v); -OVERLOADABLE ushort3 as_ushort3(char8 v); -OVERLOADABLE ushort4 as_ushort4(char8 v); -OVERLOADABLE uchar8 as_uchar8(char8 v); -OVERLOADABLE double as_double(char8 v); -OVERLOADABLE float2 as_float2(char8 v); -OVERLOADABLE half3 as_half3(char8 v); -OVERLOADABLE half4 as_half4(char8 v); -OVERLOADABLE long as_long(uchar8 v); -OVERLOADABLE ulong as_ulong(uchar8 v); -OVERLOADABLE int2 as_int2(uchar8 v); -OVERLOADABLE uint2 as_uint2(uchar8 v); -OVERLOADABLE short3 as_short3(uchar8 v); -OVERLOADABLE short4 as_short4(uchar8 v); -OVERLOADABLE ushort3 as_ushort3(uchar8 v); -OVERLOADABLE ushort4 as_ushort4(uchar8 v); -OVERLOADABLE char8 as_char8(uchar8 v); -OVERLOADABLE double as_double(uchar8 v); -OVERLOADABLE float2 as_float2(uchar8 v); -OVERLOADABLE half3 as_half3(uchar8 v); -OVERLOADABLE half4 as_half4(uchar8 v); -OVERLOADABLE long as_long(double v); -OVERLOADABLE ulong as_ulong(double v); -OVERLOADABLE int2 as_int2(double v); -OVERLOADABLE uint2 as_uint2(double v); -OVERLOADABLE short3 as_short3(double v); -OVERLOADABLE short4 as_short4(double v); -OVERLOADABLE ushort3 as_ushort3(double v); -OVERLOADABLE ushort4 as_ushort4(double v); -OVERLOADABLE char8 as_char8(double v); -OVERLOADABLE uchar8 as_uchar8(double v); -OVERLOADABLE float2 as_float2(double v); -OVERLOADABLE half3 as_half3(double v); -OVERLOADABLE half4 as_half4(double v); -OVERLOADABLE long as_long(float2 v); -OVERLOADABLE ulong as_ulong(float2 v); -OVERLOADABLE int2 as_int2(float2 v); -OVERLOADABLE uint2 as_uint2(float2 v); -OVERLOADABLE short3 as_short3(float2 v); -OVERLOADABLE short4 as_short4(float2 v); -OVERLOADABLE ushort3 as_ushort3(float2 v); -OVERLOADABLE ushort4 as_ushort4(float2 v); -OVERLOADABLE char8 as_char8(float2 v); -OVERLOADABLE uchar8 as_uchar8(float2 v); -OVERLOADABLE double as_double(float2 v); -OVERLOADABLE half3 as_half3(float2 v); -OVERLOADABLE half4 as_half4(float2 v); -OVERLOADABLE long as_long(half3 v); -OVERLOADABLE ulong as_ulong(half3 v); -OVERLOADABLE int2 as_int2(half3 v); -OVERLOADABLE uint2 as_uint2(half3 v); -OVERLOADABLE short3 as_short3(half3 v); -OVERLOADABLE short4 as_short4(half3 v); -OVERLOADABLE ushort3 as_ushort3(half3 v); -OVERLOADABLE ushort4 as_ushort4(half3 v); -OVERLOADABLE char8 as_char8(half3 v); -OVERLOADABLE uchar8 as_uchar8(half3 v); -OVERLOADABLE double as_double(half3 v); -OVERLOADABLE float2 as_float2(half3 v); -OVERLOADABLE long as_long(half4 v); -OVERLOADABLE ulong as_ulong(half4 v); -OVERLOADABLE int2 as_int2(half4 v); -OVERLOADABLE uint2 as_uint2(half4 v); -OVERLOADABLE short3 as_short3(half4 v); -OVERLOADABLE short4 as_short4(half4 v); -OVERLOADABLE ushort3 as_ushort3(half4 v); -OVERLOADABLE ushort4 as_ushort4(half4 v); -OVERLOADABLE char8 as_char8(half4 v); -OVERLOADABLE uchar8 as_uchar8(half4 v); -OVERLOADABLE double as_double(half4 v); -OVERLOADABLE float2 as_float2(half4 v); -OVERLOADABLE ulong2 as_ulong2(long2 v); -OVERLOADABLE int3 as_int3(long2 v); -OVERLOADABLE int4 as_int4(long2 v); -OVERLOADABLE uint3 as_uint3(long2 v); -OVERLOADABLE uint4 as_uint4(long2 v); -OVERLOADABLE short8 as_short8(long2 v); -OVERLOADABLE ushort8 as_ushort8(long2 v); -OVERLOADABLE char16 as_char16(long2 v); -OVERLOADABLE uchar16 as_uchar16(long2 v); -OVERLOADABLE double2 as_double2(long2 v); -OVERLOADABLE float3 as_float3(long2 v); -OVERLOADABLE float4 as_float4(long2 v); -OVERLOADABLE half8 as_half8(long2 v); -OVERLOADABLE long2 as_long2(ulong2 v); -OVERLOADABLE int3 as_int3(ulong2 v); -OVERLOADABLE int4 as_int4(ulong2 v); -OVERLOADABLE uint3 as_uint3(ulong2 v); -OVERLOADABLE uint4 as_uint4(ulong2 v); -OVERLOADABLE short8 as_short8(ulong2 v); -OVERLOADABLE ushort8 as_ushort8(ulong2 v); -OVERLOADABLE char16 as_char16(ulong2 v); -OVERLOADABLE uchar16 as_uchar16(ulong2 v); -OVERLOADABLE double2 as_double2(ulong2 v); -OVERLOADABLE float3 as_float3(ulong2 v); -OVERLOADABLE float4 as_float4(ulong2 v); -OVERLOADABLE half8 as_half8(ulong2 v); -OVERLOADABLE long2 as_long2(int3 v); -OVERLOADABLE ulong2 as_ulong2(int3 v); -OVERLOADABLE uint3 as_uint3(int3 v); -OVERLOADABLE uint4 as_uint4(int3 v); -OVERLOADABLE short8 as_short8(int3 v); -OVERLOADABLE ushort8 as_ushort8(int3 v); -OVERLOADABLE char16 as_char16(int3 v); -OVERLOADABLE uchar16 as_uchar16(int3 v); -OVERLOADABLE double2 as_double2(int3 v); -OVERLOADABLE float3 as_float3(int3 v); -OVERLOADABLE float4 as_float4(int3 v); -OVERLOADABLE half8 as_half8(int3 v); -OVERLOADABLE long2 as_long2(int4 v); -OVERLOADABLE ulong2 as_ulong2(int4 v); -OVERLOADABLE uint3 as_uint3(int4 v); -OVERLOADABLE uint4 as_uint4(int4 v); -OVERLOADABLE short8 as_short8(int4 v); -OVERLOADABLE ushort8 as_ushort8(int4 v); -OVERLOADABLE char16 as_char16(int4 v); -OVERLOADABLE uchar16 as_uchar16(int4 v); -OVERLOADABLE double2 as_double2(int4 v); -OVERLOADABLE float3 as_float3(int4 v); -OVERLOADABLE float4 as_float4(int4 v); -OVERLOADABLE half8 as_half8(int4 v); -OVERLOADABLE long2 as_long2(uint3 v); -OVERLOADABLE ulong2 as_ulong2(uint3 v); -OVERLOADABLE int3 as_int3(uint3 v); -OVERLOADABLE int4 as_int4(uint3 v); -OVERLOADABLE short8 as_short8(uint3 v); -OVERLOADABLE ushort8 as_ushort8(uint3 v); -OVERLOADABLE char16 as_char16(uint3 v); -OVERLOADABLE uchar16 as_uchar16(uint3 v); -OVERLOADABLE double2 as_double2(uint3 v); -OVERLOADABLE float3 as_float3(uint3 v); -OVERLOADABLE float4 as_float4(uint3 v); -OVERLOADABLE half8 as_half8(uint3 v); -OVERLOADABLE long2 as_long2(uint4 v); -OVERLOADABLE ulong2 as_ulong2(uint4 v); -OVERLOADABLE int3 as_int3(uint4 v); -OVERLOADABLE int4 as_int4(uint4 v); -OVERLOADABLE short8 as_short8(uint4 v); -OVERLOADABLE ushort8 as_ushort8(uint4 v); -OVERLOADABLE char16 as_char16(uint4 v); -OVERLOADABLE uchar16 as_uchar16(uint4 v); -OVERLOADABLE double2 as_double2(uint4 v); -OVERLOADABLE float3 as_float3(uint4 v); -OVERLOADABLE float4 as_float4(uint4 v); -OVERLOADABLE half8 as_half8(uint4 v); -OVERLOADABLE long2 as_long2(short8 v); -OVERLOADABLE ulong2 as_ulong2(short8 v); -OVERLOADABLE int3 as_int3(short8 v); -OVERLOADABLE int4 as_int4(short8 v); -OVERLOADABLE uint3 as_uint3(short8 v); -OVERLOADABLE uint4 as_uint4(short8 v); -OVERLOADABLE ushort8 as_ushort8(short8 v); -OVERLOADABLE char16 as_char16(short8 v); -OVERLOADABLE uchar16 as_uchar16(short8 v); -OVERLOADABLE double2 as_double2(short8 v); -OVERLOADABLE float3 as_float3(short8 v); -OVERLOADABLE float4 as_float4(short8 v); -OVERLOADABLE half8 as_half8(short8 v); -OVERLOADABLE long2 as_long2(ushort8 v); -OVERLOADABLE ulong2 as_ulong2(ushort8 v); -OVERLOADABLE int3 as_int3(ushort8 v); -OVERLOADABLE int4 as_int4(ushort8 v); -OVERLOADABLE uint3 as_uint3(ushort8 v); -OVERLOADABLE uint4 as_uint4(ushort8 v); -OVERLOADABLE short8 as_short8(ushort8 v); -OVERLOADABLE char16 as_char16(ushort8 v); -OVERLOADABLE uchar16 as_uchar16(ushort8 v); -OVERLOADABLE double2 as_double2(ushort8 v); -OVERLOADABLE float3 as_float3(ushort8 v); -OVERLOADABLE float4 as_float4(ushort8 v); -OVERLOADABLE half8 as_half8(ushort8 v); -OVERLOADABLE long2 as_long2(char16 v); -OVERLOADABLE ulong2 as_ulong2(char16 v); -OVERLOADABLE int3 as_int3(char16 v); -OVERLOADABLE int4 as_int4(char16 v); -OVERLOADABLE uint3 as_uint3(char16 v); -OVERLOADABLE uint4 as_uint4(char16 v); -OVERLOADABLE short8 as_short8(char16 v); -OVERLOADABLE ushort8 as_ushort8(char16 v); -OVERLOADABLE uchar16 as_uchar16(char16 v); -OVERLOADABLE double2 as_double2(char16 v); -OVERLOADABLE float3 as_float3(char16 v); -OVERLOADABLE float4 as_float4(char16 v); -OVERLOADABLE half8 as_half8(char16 v); -OVERLOADABLE long2 as_long2(uchar16 v); -OVERLOADABLE ulong2 as_ulong2(uchar16 v); -OVERLOADABLE int3 as_int3(uchar16 v); -OVERLOADABLE int4 as_int4(uchar16 v); -OVERLOADABLE uint3 as_uint3(uchar16 v); -OVERLOADABLE uint4 as_uint4(uchar16 v); -OVERLOADABLE short8 as_short8(uchar16 v); -OVERLOADABLE ushort8 as_ushort8(uchar16 v); -OVERLOADABLE char16 as_char16(uchar16 v); -OVERLOADABLE double2 as_double2(uchar16 v); -OVERLOADABLE float3 as_float3(uchar16 v); -OVERLOADABLE float4 as_float4(uchar16 v); -OVERLOADABLE half8 as_half8(uchar16 v); -OVERLOADABLE long2 as_long2(double2 v); -OVERLOADABLE ulong2 as_ulong2(double2 v); -OVERLOADABLE int3 as_int3(double2 v); -OVERLOADABLE int4 as_int4(double2 v); -OVERLOADABLE uint3 as_uint3(double2 v); -OVERLOADABLE uint4 as_uint4(double2 v); -OVERLOADABLE short8 as_short8(double2 v); -OVERLOADABLE ushort8 as_ushort8(double2 v); -OVERLOADABLE char16 as_char16(double2 v); -OVERLOADABLE uchar16 as_uchar16(double2 v); -OVERLOADABLE float3 as_float3(double2 v); -OVERLOADABLE float4 as_float4(double2 v); -OVERLOADABLE half8 as_half8(double2 v); -OVERLOADABLE long2 as_long2(float3 v); -OVERLOADABLE ulong2 as_ulong2(float3 v); -OVERLOADABLE int3 as_int3(float3 v); -OVERLOADABLE int4 as_int4(float3 v); -OVERLOADABLE uint3 as_uint3(float3 v); -OVERLOADABLE uint4 as_uint4(float3 v); -OVERLOADABLE short8 as_short8(float3 v); -OVERLOADABLE ushort8 as_ushort8(float3 v); -OVERLOADABLE char16 as_char16(float3 v); -OVERLOADABLE uchar16 as_uchar16(float3 v); -OVERLOADABLE double2 as_double2(float3 v); -OVERLOADABLE half8 as_half8(float3 v); -OVERLOADABLE long2 as_long2(float4 v); -OVERLOADABLE ulong2 as_ulong2(float4 v); -OVERLOADABLE int3 as_int3(float4 v); -OVERLOADABLE int4 as_int4(float4 v); -OVERLOADABLE uint3 as_uint3(float4 v); -OVERLOADABLE uint4 as_uint4(float4 v); -OVERLOADABLE short8 as_short8(float4 v); -OVERLOADABLE ushort8 as_ushort8(float4 v); -OVERLOADABLE char16 as_char16(float4 v); -OVERLOADABLE uchar16 as_uchar16(float4 v); -OVERLOADABLE double2 as_double2(float4 v); -OVERLOADABLE half8 as_half8(float4 v); -OVERLOADABLE long2 as_long2(half8 v); -OVERLOADABLE ulong2 as_ulong2(half8 v); -OVERLOADABLE int3 as_int3(half8 v); -OVERLOADABLE int4 as_int4(half8 v); -OVERLOADABLE uint3 as_uint3(half8 v); -OVERLOADABLE uint4 as_uint4(half8 v); -OVERLOADABLE short8 as_short8(half8 v); -OVERLOADABLE ushort8 as_ushort8(half8 v); -OVERLOADABLE char16 as_char16(half8 v); -OVERLOADABLE uchar16 as_uchar16(half8 v); -OVERLOADABLE double2 as_double2(half8 v); -OVERLOADABLE float3 as_float3(half8 v); -OVERLOADABLE float4 as_float4(half8 v); -OVERLOADABLE ulong3 as_ulong3(long3 v); -OVERLOADABLE ulong4 as_ulong4(long3 v); -OVERLOADABLE int8 as_int8(long3 v); -OVERLOADABLE uint8 as_uint8(long3 v); -OVERLOADABLE short16 as_short16(long3 v); -OVERLOADABLE ushort16 as_ushort16(long3 v); -OVERLOADABLE double3 as_double3(long3 v); -OVERLOADABLE double4 as_double4(long3 v); -OVERLOADABLE float8 as_float8(long3 v); -OVERLOADABLE half16 as_half16(long3 v); -OVERLOADABLE ulong3 as_ulong3(long4 v); -OVERLOADABLE ulong4 as_ulong4(long4 v); -OVERLOADABLE int8 as_int8(long4 v); -OVERLOADABLE uint8 as_uint8(long4 v); -OVERLOADABLE short16 as_short16(long4 v); -OVERLOADABLE ushort16 as_ushort16(long4 v); -OVERLOADABLE double3 as_double3(long4 v); -OVERLOADABLE double4 as_double4(long4 v); -OVERLOADABLE float8 as_float8(long4 v); -OVERLOADABLE half16 as_half16(long4 v); -OVERLOADABLE long3 as_long3(ulong3 v); -OVERLOADABLE long4 as_long4(ulong3 v); -OVERLOADABLE int8 as_int8(ulong3 v); -OVERLOADABLE uint8 as_uint8(ulong3 v); -OVERLOADABLE short16 as_short16(ulong3 v); -OVERLOADABLE ushort16 as_ushort16(ulong3 v); -OVERLOADABLE double3 as_double3(ulong3 v); -OVERLOADABLE double4 as_double4(ulong3 v); -OVERLOADABLE float8 as_float8(ulong3 v); -OVERLOADABLE half16 as_half16(ulong3 v); -OVERLOADABLE long3 as_long3(ulong4 v); -OVERLOADABLE long4 as_long4(ulong4 v); -OVERLOADABLE int8 as_int8(ulong4 v); -OVERLOADABLE uint8 as_uint8(ulong4 v); -OVERLOADABLE short16 as_short16(ulong4 v); -OVERLOADABLE ushort16 as_ushort16(ulong4 v); -OVERLOADABLE double3 as_double3(ulong4 v); -OVERLOADABLE double4 as_double4(ulong4 v); -OVERLOADABLE float8 as_float8(ulong4 v); -OVERLOADABLE half16 as_half16(ulong4 v); -OVERLOADABLE long3 as_long3(int8 v); -OVERLOADABLE long4 as_long4(int8 v); -OVERLOADABLE ulong3 as_ulong3(int8 v); -OVERLOADABLE ulong4 as_ulong4(int8 v); -OVERLOADABLE uint8 as_uint8(int8 v); -OVERLOADABLE short16 as_short16(int8 v); -OVERLOADABLE ushort16 as_ushort16(int8 v); -OVERLOADABLE double3 as_double3(int8 v); -OVERLOADABLE double4 as_double4(int8 v); -OVERLOADABLE float8 as_float8(int8 v); -OVERLOADABLE half16 as_half16(int8 v); -OVERLOADABLE long3 as_long3(uint8 v); -OVERLOADABLE long4 as_long4(uint8 v); -OVERLOADABLE ulong3 as_ulong3(uint8 v); -OVERLOADABLE ulong4 as_ulong4(uint8 v); -OVERLOADABLE int8 as_int8(uint8 v); -OVERLOADABLE short16 as_short16(uint8 v); -OVERLOADABLE ushort16 as_ushort16(uint8 v); -OVERLOADABLE double3 as_double3(uint8 v); -OVERLOADABLE double4 as_double4(uint8 v); -OVERLOADABLE float8 as_float8(uint8 v); -OVERLOADABLE half16 as_half16(uint8 v); -OVERLOADABLE long3 as_long3(short16 v); -OVERLOADABLE long4 as_long4(short16 v); -OVERLOADABLE ulong3 as_ulong3(short16 v); -OVERLOADABLE ulong4 as_ulong4(short16 v); -OVERLOADABLE int8 as_int8(short16 v); -OVERLOADABLE uint8 as_uint8(short16 v); -OVERLOADABLE ushort16 as_ushort16(short16 v); -OVERLOADABLE double3 as_double3(short16 v); -OVERLOADABLE double4 as_double4(short16 v); -OVERLOADABLE float8 as_float8(short16 v); -OVERLOADABLE half16 as_half16(short16 v); -OVERLOADABLE long3 as_long3(ushort16 v); -OVERLOADABLE long4 as_long4(ushort16 v); -OVERLOADABLE ulong3 as_ulong3(ushort16 v); -OVERLOADABLE ulong4 as_ulong4(ushort16 v); -OVERLOADABLE int8 as_int8(ushort16 v); -OVERLOADABLE uint8 as_uint8(ushort16 v); -OVERLOADABLE short16 as_short16(ushort16 v); -OVERLOADABLE double3 as_double3(ushort16 v); -OVERLOADABLE double4 as_double4(ushort16 v); -OVERLOADABLE float8 as_float8(ushort16 v); -OVERLOADABLE half16 as_half16(ushort16 v); -OVERLOADABLE long3 as_long3(double3 v); -OVERLOADABLE long4 as_long4(double3 v); -OVERLOADABLE ulong3 as_ulong3(double3 v); -OVERLOADABLE ulong4 as_ulong4(double3 v); -OVERLOADABLE int8 as_int8(double3 v); -OVERLOADABLE uint8 as_uint8(double3 v); -OVERLOADABLE short16 as_short16(double3 v); -OVERLOADABLE ushort16 as_ushort16(double3 v); -OVERLOADABLE float8 as_float8(double3 v); -OVERLOADABLE half16 as_half16(double3 v); -OVERLOADABLE long3 as_long3(double4 v); -OVERLOADABLE long4 as_long4(double4 v); -OVERLOADABLE ulong3 as_ulong3(double4 v); -OVERLOADABLE ulong4 as_ulong4(double4 v); -OVERLOADABLE int8 as_int8(double4 v); -OVERLOADABLE uint8 as_uint8(double4 v); -OVERLOADABLE short16 as_short16(double4 v); -OVERLOADABLE ushort16 as_ushort16(double4 v); -OVERLOADABLE float8 as_float8(double4 v); -OVERLOADABLE half16 as_half16(double4 v); -OVERLOADABLE long3 as_long3(float8 v); -OVERLOADABLE long4 as_long4(float8 v); -OVERLOADABLE ulong3 as_ulong3(float8 v); -OVERLOADABLE ulong4 as_ulong4(float8 v); -OVERLOADABLE int8 as_int8(float8 v); -OVERLOADABLE uint8 as_uint8(float8 v); -OVERLOADABLE short16 as_short16(float8 v); -OVERLOADABLE ushort16 as_ushort16(float8 v); -OVERLOADABLE double3 as_double3(float8 v); -OVERLOADABLE double4 as_double4(float8 v); -OVERLOADABLE half16 as_half16(float8 v); -OVERLOADABLE long3 as_long3(half16 v); -OVERLOADABLE long4 as_long4(half16 v); -OVERLOADABLE ulong3 as_ulong3(half16 v); -OVERLOADABLE ulong4 as_ulong4(half16 v); -OVERLOADABLE int8 as_int8(half16 v); -OVERLOADABLE uint8 as_uint8(half16 v); -OVERLOADABLE short16 as_short16(half16 v); -OVERLOADABLE ushort16 as_ushort16(half16 v); -OVERLOADABLE double3 as_double3(half16 v); -OVERLOADABLE double4 as_double4(half16 v); -OVERLOADABLE float8 as_float8(half16 v); -OVERLOADABLE ulong8 as_ulong8(long8 v); -OVERLOADABLE int16 as_int16(long8 v); -OVERLOADABLE uint16 as_uint16(long8 v); -OVERLOADABLE double8 as_double8(long8 v); -OVERLOADABLE float16 as_float16(long8 v); -OVERLOADABLE long8 as_long8(ulong8 v); -OVERLOADABLE int16 as_int16(ulong8 v); -OVERLOADABLE uint16 as_uint16(ulong8 v); -OVERLOADABLE double8 as_double8(ulong8 v); -OVERLOADABLE float16 as_float16(ulong8 v); -OVERLOADABLE long8 as_long8(int16 v); -OVERLOADABLE ulong8 as_ulong8(int16 v); -OVERLOADABLE uint16 as_uint16(int16 v); -OVERLOADABLE double8 as_double8(int16 v); -OVERLOADABLE float16 as_float16(int16 v); -OVERLOADABLE long8 as_long8(uint16 v); -OVERLOADABLE ulong8 as_ulong8(uint16 v); -OVERLOADABLE int16 as_int16(uint16 v); -OVERLOADABLE double8 as_double8(uint16 v); -OVERLOADABLE float16 as_float16(uint16 v); -OVERLOADABLE long8 as_long8(double8 v); -OVERLOADABLE ulong8 as_ulong8(double8 v); -OVERLOADABLE int16 as_int16(double8 v); -OVERLOADABLE uint16 as_uint16(double8 v); -OVERLOADABLE float16 as_float16(double8 v); -OVERLOADABLE long8 as_long8(float16 v); -OVERLOADABLE ulong8 as_ulong8(float16 v); -OVERLOADABLE int16 as_int16(float16 v); -OVERLOADABLE uint16 as_uint16(float16 v); -OVERLOADABLE double8 as_double8(float16 v); -OVERLOADABLE ulong16 as_ulong16(long16 v); -OVERLOADABLE double16 as_double16(long16 v); -OVERLOADABLE long16 as_long16(ulong16 v); -OVERLOADABLE double16 as_double16(ulong16 v); -OVERLOADABLE long16 as_long16(double16 v); -OVERLOADABLE ulong16 as_ulong16(double16 v); -#endif /* __OCL_AS_H__ */ diff --git a/drivers/pocl-gen7/lib/beignet/include/ocl_async.h b/drivers/pocl-gen7/lib/beignet/include/ocl_async.h deleted file mode 100644 index 6e49bcd..0000000 --- a/drivers/pocl-gen7/lib/beignet/include/ocl_async.h +++ /dev/null @@ -1,67 +0,0 @@ -/* - * Copyright © 2012 - 2014 Intel Corporation - * - * This library is free software; you can redistribute it and/or - * modify it under the terms of the GNU Lesser General Public - * License as published by the Free Software Foundation; either - * version 2.1 of the License, or (at your option) any later version. - * - * This library is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU - * Lesser General Public License for more details. - * - * You should have received a copy of the GNU Lesser General Public - * License along with this library. If not, see . - * - */ -#ifndef __OCL_ASYNC_H__ -#define __OCL_ASYNC_H__ - -#include "ocl_types.h" - -#define DEFN(TYPE) \ -OVERLOADABLE event_t async_work_group_copy (local TYPE *dst, const global TYPE *src, \ - size_t num, event_t event); \ -OVERLOADABLE event_t async_work_group_copy (global TYPE *dst, const local TYPE *src, \ - size_t num, event_t event); \ -OVERLOADABLE event_t async_work_group_strided_copy (local TYPE *dst, const global TYPE *src, \ - size_t num, size_t src_stride, event_t event); \ -OVERLOADABLE event_t async_work_group_strided_copy (global TYPE *dst, const local TYPE *src, \ - size_t num, size_t dst_stride, event_t event); \ - -#define DEF(TYPE) \ - DEFN(TYPE); DEFN(TYPE##2); DEFN(TYPE##3); DEFN(TYPE##4); DEFN(TYPE##8); DEFN(TYPE##16); -DEF(char) -DEF(uchar) -DEF(short) -DEF(ushort) -DEF(int) -DEF(uint) -DEF(long) -DEF(ulong) -DEF(float) -DEF(double) -#undef DEFN -#undef DEF - -OVERLOADABLE void wait_group_events (int num_events, event_t *event_list); - -#define DEFN(TYPE) \ -OVERLOADABLE void prefetch(const global TYPE *p, size_t num); -#define DEF(TYPE) \ -DEFN(TYPE); DEFN(TYPE##2); DEFN(TYPE##3); DEFN(TYPE##4); DEFN(TYPE##8); DEFN(TYPE##16) -DEF(char); -DEF(uchar); -DEF(short); -DEF(ushort); -DEF(int); -DEF(uint); -DEF(long); -DEF(ulong); -DEF(float); -DEF(double); -#undef DEFN -#undef DEF - -#endif diff --git a/drivers/pocl-gen7/lib/beignet/include/ocl_atom.h b/drivers/pocl-gen7/lib/beignet/include/ocl_atom.h deleted file mode 100644 index d0f6b10..0000000 --- a/drivers/pocl-gen7/lib/beignet/include/ocl_atom.h +++ /dev/null @@ -1,102 +0,0 @@ -/* - * Copyright © 2012 - 2014 Intel Corporation - * - * This library is free software; you can redistribute it and/or - * modify it under the terms of the GNU Lesser General Public - * License as published by the Free Software Foundation; either - * version 2.1 of the License, or (at your option) any later version. - * - * This library is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU - * Lesser General Public License for more details. - * - * You should have received a copy of the GNU Lesser General Public - * License along with this library. If not, see . - * - */ -#ifndef __OCL_ATOM_H__ -#define __OCL_ATOM_H__ -#include "ocl_types.h" - -///////////////////////////////////////////////////////////////////////////// -// Atomic functions -///////////////////////////////////////////////////////////////////////////// - -OVERLOADABLE uint atomic_add(volatile __global uint *p, uint val); -OVERLOADABLE uint atomic_add(volatile __local uint *p, uint val); -OVERLOADABLE int atomic_add(volatile __global int *p, int val); -OVERLOADABLE int atomic_add(volatile __local int *p, int val); - -OVERLOADABLE uint atomic_sub(volatile __global uint *p, uint val); -OVERLOADABLE uint atomic_sub(volatile __local uint *p, uint val); -OVERLOADABLE int atomic_sub(volatile __global int *p, int val); -OVERLOADABLE int atomic_sub(volatile __local int *p, int val); - -OVERLOADABLE uint atomic_and(volatile __global uint *p, uint val); -OVERLOADABLE uint atomic_and(volatile __local uint *p, uint val); -OVERLOADABLE int atomic_and(volatile __global int *p, int val); -OVERLOADABLE int atomic_and(volatile __local int *p, int val); - -OVERLOADABLE uint atomic_or(volatile __global uint *p, uint val); -OVERLOADABLE uint atomic_or(volatile __local uint *p, uint val); -OVERLOADABLE int atomic_or(volatile __global int *p, int val); -OVERLOADABLE int atomic_or(volatile __local int *p, int val); - -OVERLOADABLE uint atomic_xor(volatile __global uint *p, uint val); -OVERLOADABLE uint atomic_xor(volatile __local uint *p, uint val); -OVERLOADABLE int atomic_xor(volatile __global int *p, int val); -OVERLOADABLE int atomic_xor(volatile __local int *p, int val); - -OVERLOADABLE uint atomic_xchg(volatile __global uint *p, uint val); -OVERLOADABLE uint atomic_xchg(volatile __local uint *p, uint val); -OVERLOADABLE int atomic_xchg(volatile __global int *p, int val); -OVERLOADABLE int atomic_xchg(volatile __local int *p, int val); - -OVERLOADABLE int atomic_min(volatile __global int *p, int val); -OVERLOADABLE int atomic_min(volatile __local int *p, int val); - -OVERLOADABLE int atomic_max(volatile __global int *p, int val); -OVERLOADABLE int atomic_max(volatile __local int *p, int val); - -OVERLOADABLE uint atomic_min(volatile __global uint *p, uint val); -OVERLOADABLE uint atomic_min(volatile __local uint *p, uint val); - -OVERLOADABLE uint atomic_max(volatile __global uint *p, uint val); -OVERLOADABLE uint atomic_max(volatile __local uint *p, uint val); - -OVERLOADABLE float atomic_xchg (volatile __global float *p, float val); -OVERLOADABLE float atomic_xchg (volatile __local float *p, float val); - -OVERLOADABLE uint atomic_inc (volatile __global uint *p); -OVERLOADABLE uint atomic_inc (volatile __local uint *p); -OVERLOADABLE int atomic_inc (volatile __global int *p); -OVERLOADABLE int atomic_inc (volatile __local int *p); - -OVERLOADABLE uint atomic_dec (volatile __global uint *p); -OVERLOADABLE uint atomic_dec (volatile __local uint *p); -OVERLOADABLE int atomic_dec (volatile __global int *p); -OVERLOADABLE int atomic_dec (volatile __local int *p); - -OVERLOADABLE uint atomic_cmpxchg (volatile __global uint *p, uint cmp, uint val); -OVERLOADABLE uint atomic_cmpxchg (volatile __local uint *p, uint cmp, uint val); -OVERLOADABLE int atomic_cmpxchg (volatile __global int *p, int cmp, int val); -OVERLOADABLE int atomic_cmpxchg (volatile __local int *p, int cmp, int val); - - -// XXX for conformance test -// The following atom_xxx api is on OpenCL spec 1.0. -#define atom_add atomic_add -#define atom_sub atomic_sub -#define atom_and atomic_and -#define atom_or atomic_or -#define atom_xor atomic_xor -#define atom_xchg atomic_xchg -#define atom_min atomic_min -#define atom_max atomic_max -#define atom_inc atomic_inc -#define atom_dec atomic_dec -#define atom_cmpxchg atomic_cmpxchg - - -#endif /* __OCL_ATOM_H__ */ diff --git a/drivers/pocl-gen7/lib/beignet/include/ocl_atom_20.h b/drivers/pocl-gen7/lib/beignet/include/ocl_atom_20.h deleted file mode 100644 index 9e34c31..0000000 --- a/drivers/pocl-gen7/lib/beignet/include/ocl_atom_20.h +++ /dev/null @@ -1,188 +0,0 @@ -/* - * Copyright © 2012 - 2014 Intel Corporation - * - * This library is free software; you can redistribute it and/or - * modify it under the terms of the GNU Lesser General Public - * License as published by the Free Software Foundation; either - * version 2.1 of the License, or (at your option) any later version. - * - * This library is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU - * Lesser General Public License for more details. - * - * You should have received a copy of the GNU Lesser General Public - * License along with this library. If not, see . - * - */ -#ifndef __OCL_ATOM20_H__ -#define __OCL_ATOM20_H__ -#include "ocl_types.h" - -///////////////////////////////////////////////////////////////////////////// -// Atomic functions -///////////////////////////////////////////////////////////////////////////// - -OVERLOADABLE uint atomic_add(volatile __global uint *p, uint val); -OVERLOADABLE uint atomic_add(volatile __local uint *p, uint val); -OVERLOADABLE int atomic_add(volatile __global int *p, int val); -OVERLOADABLE int atomic_add(volatile __local int *p, int val); - -OVERLOADABLE uint atomic_sub(volatile __global uint *p, uint val); -OVERLOADABLE uint atomic_sub(volatile __local uint *p, uint val); -OVERLOADABLE int atomic_sub(volatile __global int *p, int val); -OVERLOADABLE int atomic_sub(volatile __local int *p, int val); - -OVERLOADABLE uint atomic_and(volatile __global uint *p, uint val); -OVERLOADABLE uint atomic_and(volatile __local uint *p, uint val); -OVERLOADABLE int atomic_and(volatile __global int *p, int val); -OVERLOADABLE int atomic_and(volatile __local int *p, int val); - -OVERLOADABLE uint atomic_or(volatile __global uint *p, uint val); -OVERLOADABLE uint atomic_or(volatile __local uint *p, uint val); -OVERLOADABLE int atomic_or(volatile __global int *p, int val); -OVERLOADABLE int atomic_or(volatile __local int *p, int val); - -OVERLOADABLE uint atomic_xor(volatile __global uint *p, uint val); -OVERLOADABLE uint atomic_xor(volatile __local uint *p, uint val); -OVERLOADABLE int atomic_xor(volatile __global int *p, int val); -OVERLOADABLE int atomic_xor(volatile __local int *p, int val); - -OVERLOADABLE uint atomic_xchg(volatile __global uint *p, uint val); -OVERLOADABLE uint atomic_xchg(volatile __local uint *p, uint val); -OVERLOADABLE int atomic_xchg(volatile __global int *p, int val); -OVERLOADABLE int atomic_xchg(volatile __local int *p, int val); - -OVERLOADABLE int atomic_min(volatile __global int *p, int val); -OVERLOADABLE int atomic_min(volatile __local int *p, int val); - -OVERLOADABLE int atomic_max(volatile __global int *p, int val); -OVERLOADABLE int atomic_max(volatile __local int *p, int val); - -OVERLOADABLE uint atomic_min(volatile __global uint *p, uint val); -OVERLOADABLE uint atomic_min(volatile __local uint *p, uint val); - -OVERLOADABLE uint atomic_max(volatile __global uint *p, uint val); -OVERLOADABLE uint atomic_max(volatile __local uint *p, uint val); - -OVERLOADABLE float atomic_xchg (volatile __global float *p, float val); -OVERLOADABLE float atomic_xchg (volatile __local float *p, float val); - -OVERLOADABLE uint atomic_inc (volatile __global uint *p); -OVERLOADABLE uint atomic_inc (volatile __local uint *p); -OVERLOADABLE int atomic_inc (volatile __global int *p); -OVERLOADABLE int atomic_inc (volatile __local int *p); - -OVERLOADABLE uint atomic_dec (volatile __global uint *p); -OVERLOADABLE uint atomic_dec (volatile __local uint *p); -OVERLOADABLE int atomic_dec (volatile __global int *p); -OVERLOADABLE int atomic_dec (volatile __local int *p); - -OVERLOADABLE uint atomic_cmpxchg (volatile __global uint *p, uint cmp, uint val); -OVERLOADABLE uint atomic_cmpxchg (volatile __local uint *p, uint cmp, uint val); -OVERLOADABLE int atomic_cmpxchg (volatile __global int *p, int cmp, int val); -OVERLOADABLE int atomic_cmpxchg (volatile __local int *p, int cmp, int val); - - -// XXX for conformance test -// The following atom_xxx api is on OpenCL spec 1.0. -#define atom_add atomic_add -#define atom_sub atomic_sub -#define atom_and atomic_and -#define atom_or atomic_or -#define atom_xor atomic_xor -#define atom_xchg atomic_xchg -#define atom_min atomic_min -#define atom_max atomic_max -#define atom_inc atomic_inc -#define atom_dec atomic_dec -#define atom_cmpxchg atomic_cmpxchg - -//OpenCL 2.0 features -#define ATOMIC_GEN_FUNCTIONS(ATYPE, CTYPE, POSTFIX) \ -CTYPE __gen_ocl_atomic_exchange##POSTFIX(volatile ATYPE *p, CTYPE val, int order, int scope); \ -CTYPE __gen_ocl_atomic_fetch_add##POSTFIX(volatile ATYPE *p, CTYPE val, int order, int scope); \ -CTYPE __gen_ocl_atomic_fetch_sub##POSTFIX(volatile ATYPE *p, CTYPE val, int order, int scope); \ -CTYPE __gen_ocl_atomic_fetch_or##POSTFIX(volatile ATYPE *p, CTYPE val, int order, int scope); \ -CTYPE __gen_ocl_atomic_fetch_xor##POSTFIX(volatile ATYPE *p, CTYPE val, int order, int scope); \ -CTYPE __gen_ocl_atomic_fetch_and##POSTFIX(volatile ATYPE *p, CTYPE val, int order, int scope); \ -CTYPE __gen_ocl_atomic_fetch_imin##POSTFIX(volatile ATYPE *p, CTYPE val, int order, int scope); \ -CTYPE __gen_ocl_atomic_fetch_umin##POSTFIX(volatile ATYPE *p, CTYPE val, int order, int scope); \ -CTYPE __gen_ocl_atomic_fetch_imax##POSTFIX(volatile ATYPE *p, CTYPE val, int order, int scope); \ -CTYPE __gen_ocl_atomic_fetch_umax##POSTFIX(volatile ATYPE *p, CTYPE val, int order, int scope);\ -CTYPE __gen_ocl_atomic_compare_exchange_strong##POSTFIX(volatile ATYPE* object, CTYPE expected, CTYPE desired, int sucess, int failure, int scope); \ -CTYPE __gen_ocl_atomic_compare_exchange_weak##POSTFIX(volatile ATYPE* object, CTYPE expected, CTYPE desired, int sucess, int failure, int scope); - -ATOMIC_GEN_FUNCTIONS(atomic_int, int, 32) -#ifndef DISABLE_ATOMIC_INT64 -ATOMIC_GEN_FUNCTIONS(atomic_long, long, 64) -#endif -float __gen_ocl_atomic_exchangef(volatile atomic_int *p, float val, int order, int scope); -float __gen_ocl_atomic_fetch_addf(volatile atomic_int *p, float val, int order, int scope); - -#undef ATOMIC_GEN_FUNCTIONS - -/* only used to initialize global address space */ -//#define ATOMIC_VAR_INIT(C value) -#define ATOMIC_VAR_INIT -#define ATOMIC_FLAG_INIT 0 - -//store -#define ATOMIC_FUNCTIONS(ATYPE, CTYPE, MTYPE1, MTYPE2) \ -OVERLOADABLE void atomic_init(volatile ATYPE *object, CTYPE desired); \ -OVERLOADABLE void atomic_store(volatile ATYPE *object, CTYPE desired); \ -OVERLOADABLE void atomic_store_explicit(volatile ATYPE *object, CTYPE desired, memory_order order); \ -OVERLOADABLE void atomic_store_explicit(volatile ATYPE *object, CTYPE desired, memory_order order, memory_scope scope); \ -OVERLOADABLE CTYPE atomic_load(volatile ATYPE *object); \ -OVERLOADABLE CTYPE atomic_load_explicit(volatile ATYPE *object, memory_order order); \ -OVERLOADABLE CTYPE atomic_load_explicit(volatile ATYPE *object, memory_order order, memory_scope scope); \ -OVERLOADABLE CTYPE atomic_exchange(volatile ATYPE *object, CTYPE desired); \ -OVERLOADABLE CTYPE atomic_exchange_explicit(volatile ATYPE *object, CTYPE desired, memory_order order); \ -OVERLOADABLE CTYPE atomic_exchange_explicit(volatile ATYPE *object, CTYPE desired, memory_order order, memory_scope scope); \ -OVERLOADABLE bool atomic_compare_exchange_strong(volatile ATYPE *object, CTYPE *expected, CTYPE desired); \ -OVERLOADABLE bool atomic_compare_exchange_strong_explicit(volatile ATYPE *object, CTYPE *expected, CTYPE desired, memory_order success, memory_order failure); \ -OVERLOADABLE bool atomic_compare_exchange_strong_explicit(volatile ATYPE *object, CTYPE *expected, CTYPE desired, memory_order success, memory_order failure, memory_scope scope); \ -OVERLOADABLE bool atomic_compare_exchange_weak(volatile ATYPE *object, CTYPE *expected, CTYPE desired); \ -OVERLOADABLE bool atomic_compare_exchange_weak_explicit(volatile ATYPE *object, CTYPE *expected, CTYPE desired, memory_order success, memory_order failure); \ -OVERLOADABLE bool atomic_compare_exchange_weak_explicit(volatile ATYPE *object, CTYPE *expected, CTYPE desired, memory_order success, memory_order failure, memory_scope scope); \ -OVERLOADABLE CTYPE atomic_fetch_add(volatile ATYPE *object, MTYPE1 desired); \ -OVERLOADABLE CTYPE atomic_fetch_add_explicit(volatile ATYPE *object, MTYPE1 desired, memory_order order); \ -OVERLOADABLE CTYPE atomic_fetch_add_explicit(volatile ATYPE *object, MTYPE1 desired, memory_order order, memory_scope scope); \ -OVERLOADABLE CTYPE atomic_fetch_sub(volatile ATYPE *object, MTYPE1 desired); \ -OVERLOADABLE CTYPE atomic_fetch_sub_explicit(volatile ATYPE *object, MTYPE1 desired, memory_order order); \ -OVERLOADABLE CTYPE atomic_fetch_sub_explicit(volatile ATYPE *object, MTYPE1 desired, memory_order order, memory_scope scope); \ -OVERLOADABLE CTYPE atomic_fetch_or(volatile ATYPE *object, MTYPE2 desired); \ -OVERLOADABLE CTYPE atomic_fetch_or_explicit(volatile ATYPE *object, MTYPE2 desired, memory_order order); \ -OVERLOADABLE CTYPE atomic_fetch_or_explicit(volatile ATYPE *object, MTYPE2 desired, memory_order order, memory_scope scope); \ -OVERLOADABLE CTYPE atomic_fetch_xor(volatile ATYPE *object, MTYPE2 desired); \ -OVERLOADABLE CTYPE atomic_fetch_xor_explicit(volatile ATYPE *object, MTYPE2 desired, memory_order order); \ -OVERLOADABLE CTYPE atomic_fetch_xor_explicit(volatile ATYPE *object, MTYPE2 desired, memory_order order, memory_scope scope); \ -OVERLOADABLE CTYPE atomic_fetch_and(volatile ATYPE *object, MTYPE2 desired); \ -OVERLOADABLE CTYPE atomic_fetch_and_explicit(volatile ATYPE *object, MTYPE2 desired, memory_order order); \ -OVERLOADABLE CTYPE atomic_fetch_and_explicit(volatile ATYPE *object, MTYPE2 desired, memory_order order, memory_scope scope); \ -OVERLOADABLE CTYPE atomic_fetch_min(volatile ATYPE *object, MTYPE2 desired); \ -OVERLOADABLE CTYPE atomic_fetch_min_explicit(volatile ATYPE *object, MTYPE2 desired, memory_order order); \ -OVERLOADABLE CTYPE atomic_fetch_min_explicit(volatile ATYPE *object, MTYPE2 desired, memory_order order, memory_scope scope); \ -OVERLOADABLE CTYPE atomic_fetch_max(volatile ATYPE *object, MTYPE2 desired); \ -OVERLOADABLE CTYPE atomic_fetch_max_explicit(volatile ATYPE *object, MTYPE2 desired, memory_order order); \ -OVERLOADABLE CTYPE atomic_fetch_max_explicit(volatile ATYPE *object, MTYPE2 desired, memory_order order, memory_scope scope); - -ATOMIC_FUNCTIONS(atomic_int, int, int, int) -ATOMIC_FUNCTIONS(atomic_uint, uint, uint, uint) -#ifndef DISABLE_ATOMIC_INT64 -ATOMIC_FUNCTIONS(atomic_long, long, long, long) -ATOMIC_FUNCTIONS(atomic_ulong, ulong, ulong, ulong) -#endif -ATOMIC_FUNCTIONS(atomic_float, float, float, float) -#undef ATOMIC_FUNCTIONS - - -OVERLOADABLE bool atomic_flag_test_and_set(volatile atomic_flag *object); -OVERLOADABLE bool atomic_flag_test_and_set_explicit(volatile atomic_flag *object, memory_order order); -OVERLOADABLE bool atomic_flag_test_and_set_explicit(volatile atomic_flag *object, memory_order order, memory_scope scope); -OVERLOADABLE void atomic_flag_clear(volatile atomic_flag *object); -OVERLOADABLE void atomic_flag_clear_explicit(volatile atomic_flag *object, memory_order order); -OVERLOADABLE void atomic_flag_clear_explicit(volatile atomic_flag *object, memory_order order, memory_scope scope); - -OVERLOADABLE void atomic_work_item_fence(cl_mem_fence_flags flags, memory_order order, memory_scope scope); -#endif /* __OCL_ATOM20_H__ */ diff --git a/drivers/pocl-gen7/lib/beignet/include/ocl_common.h b/drivers/pocl-gen7/lib/beignet/include/ocl_common.h deleted file mode 100644 index f37067f..0000000 --- a/drivers/pocl-gen7/lib/beignet/include/ocl_common.h +++ /dev/null @@ -1,370 +0,0 @@ -/* - * Copyright © 2012 - 2014 Intel Corporation - * - * This library is free software; you can redistribute it and/or - * modify it under the terms of the GNU Lesser General Public - * License as published by the Free Software Foundation; either - * version 2.1 of the License, or (at your option) any later version. - * - * This library is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU - * Lesser General Public License for more details. - * - * You should have received a copy of the GNU Lesser General Public - * License along with this library. If not, see . - * - */ -#ifndef __OCL_COMMON_H__ -#define __OCL_COMMON_H__ - -#include "ocl_types.h" - -///////////////////////////////////////////////////////////////////////////// -// Common Functions -///////////////////////////////////////////////////////////////////////////// -OVERLOADABLE float step(float edge, float x); -OVERLOADABLE float max(float a, float b); -OVERLOADABLE float min(float a, float b); -OVERLOADABLE float mix(float x, float y, float a); -OVERLOADABLE float clamp(float v, float l, float u); - -OVERLOADABLE float degrees(float radians); -OVERLOADABLE float radians(float degrees); -OVERLOADABLE float smoothstep(float e0, float e1, float x); - -OVERLOADABLE float sign(float x); - -// Half half version. -OVERLOADABLE half step(half edge, half x); -OVERLOADABLE half max(half a, half b); -OVERLOADABLE half min(half a, half b); -OVERLOADABLE half mix(half x, half y, half a); -OVERLOADABLE half clamp(half v, half l, half u); - -OVERLOADABLE half degrees(half radians); -OVERLOADABLE half radians(half degrees); -OVERLOADABLE half smoothstep(half e0, half e1, half x); - -OVERLOADABLE half sign(half x); - -OVERLOADABLE double step(double edge, double x); -OVERLOADABLE double max(double a, double b); -OVERLOADABLE double min(double a, double b); -OVERLOADABLE double mix(double x, double y, double a); -OVERLOADABLE double clamp(double v, double l, double u); -OVERLOADABLE double degrees(double radians); -OVERLOADABLE double radians(double degrees); -OVERLOADABLE double smoothstep(double e0, double e1, double x); -OVERLOADABLE double sign(double x); - -//Begin from this part is autogenerated. -//Don't modify it manually. -//common builtin functions -//gentype clamp (gentype x, gentype minval, gentype maxval) - -OVERLOADABLE float2 clamp (float2 param0, float2 param1, float2 param2); -OVERLOADABLE float3 clamp (float3 param0, float3 param1, float3 param2); -OVERLOADABLE float4 clamp (float4 param0, float4 param1, float4 param2); -OVERLOADABLE float8 clamp (float8 param0, float8 param1, float8 param2); -OVERLOADABLE float16 clamp (float16 param0, float16 param1, float16 param2); -OVERLOADABLE double2 clamp (double2 param0, double2 param1, double2 param2); -OVERLOADABLE double3 clamp (double3 param0, double3 param1, double3 param2); -OVERLOADABLE double4 clamp (double4 param0, double4 param1, double4 param2); -OVERLOADABLE double8 clamp (double8 param0, double8 param1, double8 param2); -OVERLOADABLE double16 clamp (double16 param0, double16 param1, double16 param2); -OVERLOADABLE half2 clamp (half2 param0, half2 param1, half2 param2); -OVERLOADABLE half3 clamp (half3 param0, half3 param1, half3 param2); -OVERLOADABLE half4 clamp (half4 param0, half4 param1, half4 param2); -OVERLOADABLE half8 clamp (half8 param0, half8 param1, half8 param2); -OVERLOADABLE half16 clamp (half16 param0, half16 param1, half16 param2); - -//gentypef clamp (gentypef x, float minval, float maxval) - -OVERLOADABLE float2 clamp (float2 param0, float param1, float param2); -OVERLOADABLE float3 clamp (float3 param0, float param1, float param2); -OVERLOADABLE float4 clamp (float4 param0, float param1, float param2); -OVERLOADABLE float8 clamp (float8 param0, float param1, float param2); -OVERLOADABLE float16 clamp (float16 param0, float param1, float param2); - -//gentypeh clamp (gentypeh x, half minval, half maxval) - -OVERLOADABLE half2 clamp (half2 param0, half param1, half param2); -OVERLOADABLE half3 clamp (half3 param0, half param1, half param2); -OVERLOADABLE half4 clamp (half4 param0, half param1, half param2); -OVERLOADABLE half8 clamp (half8 param0, half param1, half param2); -OVERLOADABLE half16 clamp (half16 param0, half param1, half param2); - -//gentyped clamp (gentyped x, double minval, double maxval) - -OVERLOADABLE double2 clamp (double2 param0, double param1, double param2); -OVERLOADABLE double3 clamp (double3 param0, double param1, double param2); -OVERLOADABLE double4 clamp (double4 param0, double param1, double param2); -OVERLOADABLE double8 clamp (double8 param0, double param1, double param2); -OVERLOADABLE double16 clamp (double16 param0, double param1, double param2); - -//gentype degrees (gentype radians) - -OVERLOADABLE float2 degrees (float2 param0); -OVERLOADABLE float3 degrees (float3 param0); -OVERLOADABLE float4 degrees (float4 param0); -OVERLOADABLE float8 degrees (float8 param0); -OVERLOADABLE float16 degrees (float16 param0); -OVERLOADABLE double2 degrees (double2 param0); -OVERLOADABLE double3 degrees (double3 param0); -OVERLOADABLE double4 degrees (double4 param0); -OVERLOADABLE double8 degrees (double8 param0); -OVERLOADABLE double16 degrees (double16 param0); -OVERLOADABLE half2 degrees (half2 param0); -OVERLOADABLE half3 degrees (half3 param0); -OVERLOADABLE half4 degrees (half4 param0); -OVERLOADABLE half8 degrees (half8 param0); -OVERLOADABLE half16 degrees (half16 param0); - -//gentype max (gentype x, gentype y) - -OVERLOADABLE float2 max (float2 param0, float2 param1); -OVERLOADABLE float3 max (float3 param0, float3 param1); -OVERLOADABLE float4 max (float4 param0, float4 param1); -OVERLOADABLE float8 max (float8 param0, float8 param1); -OVERLOADABLE float16 max (float16 param0, float16 param1); -OVERLOADABLE double2 max (double2 param0, double2 param1); -OVERLOADABLE double3 max (double3 param0, double3 param1); -OVERLOADABLE double4 max (double4 param0, double4 param1); -OVERLOADABLE double8 max (double8 param0, double8 param1); -OVERLOADABLE double16 max (double16 param0, double16 param1); -OVERLOADABLE half2 max (half2 param0, half2 param1); -OVERLOADABLE half3 max (half3 param0, half3 param1); -OVERLOADABLE half4 max (half4 param0, half4 param1); -OVERLOADABLE half8 max (half8 param0, half8 param1); -OVERLOADABLE half16 max (half16 param0, half16 param1); - -//gentypef max (gentypef x, float y) - -OVERLOADABLE float2 max (float2 param0, float param1); -OVERLOADABLE float3 max (float3 param0, float param1); -OVERLOADABLE float4 max (float4 param0, float param1); -OVERLOADABLE float8 max (float8 param0, float param1); -OVERLOADABLE float16 max (float16 param0, float param1); - -//gentypeh max (gentypeh x, half y) - -OVERLOADABLE half2 max (half2 param0, half param1); -OVERLOADABLE half3 max (half3 param0, half param1); -OVERLOADABLE half4 max (half4 param0, half param1); -OVERLOADABLE half8 max (half8 param0, half param1); -OVERLOADABLE half16 max (half16 param0, half param1); - -//gentyped max (gentyped x, double y) - -OVERLOADABLE double2 max (double2 param0, double param1); -OVERLOADABLE double3 max (double3 param0, double param1); -OVERLOADABLE double4 max (double4 param0, double param1); -OVERLOADABLE double8 max (double8 param0, double param1); -OVERLOADABLE double16 max (double16 param0, double param1); - -//gentype min (gentype x, gentype y) - -OVERLOADABLE float2 min (float2 param0, float2 param1); -OVERLOADABLE float3 min (float3 param0, float3 param1); -OVERLOADABLE float4 min (float4 param0, float4 param1); -OVERLOADABLE float8 min (float8 param0, float8 param1); -OVERLOADABLE float16 min (float16 param0, float16 param1); -OVERLOADABLE double2 min (double2 param0, double2 param1); -OVERLOADABLE double3 min (double3 param0, double3 param1); -OVERLOADABLE double4 min (double4 param0, double4 param1); -OVERLOADABLE double8 min (double8 param0, double8 param1); -OVERLOADABLE double16 min (double16 param0, double16 param1); -OVERLOADABLE half2 min (half2 param0, half2 param1); -OVERLOADABLE half3 min (half3 param0, half3 param1); -OVERLOADABLE half4 min (half4 param0, half4 param1); -OVERLOADABLE half8 min (half8 param0, half8 param1); -OVERLOADABLE half16 min (half16 param0, half16 param1); - -//gentypef min (gentypef x, float y) - -OVERLOADABLE float2 min (float2 param0, float param1); -OVERLOADABLE float3 min (float3 param0, float param1); -OVERLOADABLE float4 min (float4 param0, float param1); -OVERLOADABLE float8 min (float8 param0, float param1); -OVERLOADABLE float16 min (float16 param0, float param1); - -//gentypeh min (gentypeh x, half y) - -OVERLOADABLE half2 min (half2 param0, half param1); -OVERLOADABLE half3 min (half3 param0, half param1); -OVERLOADABLE half4 min (half4 param0, half param1); -OVERLOADABLE half8 min (half8 param0, half param1); -OVERLOADABLE half16 min (half16 param0, half param1); - -//gentyped min (gentyped x, double y) - -OVERLOADABLE double2 min (double2 param0, double param1); -OVERLOADABLE double3 min (double3 param0, double param1); -OVERLOADABLE double4 min (double4 param0, double param1); -OVERLOADABLE double8 min (double8 param0, double param1); -OVERLOADABLE double16 min (double16 param0, double param1); - -//gentype mix (gentype x, gentype y, gentype a) - -OVERLOADABLE float2 mix (float2 param0, float2 param1, float2 param2); -OVERLOADABLE float3 mix (float3 param0, float3 param1, float3 param2); -OVERLOADABLE float4 mix (float4 param0, float4 param1, float4 param2); -OVERLOADABLE float8 mix (float8 param0, float8 param1, float8 param2); -OVERLOADABLE float16 mix (float16 param0, float16 param1, float16 param2); -OVERLOADABLE double2 mix (double2 param0, double2 param1, double2 param2); -OVERLOADABLE double3 mix (double3 param0, double3 param1, double3 param2); -OVERLOADABLE double4 mix (double4 param0, double4 param1, double4 param2); -OVERLOADABLE double8 mix (double8 param0, double8 param1, double8 param2); -OVERLOADABLE double16 mix (double16 param0, double16 param1, double16 param2); -OVERLOADABLE half2 mix (half2 param0, half2 param1, half2 param2); -OVERLOADABLE half3 mix (half3 param0, half3 param1, half3 param2); -OVERLOADABLE half4 mix (half4 param0, half4 param1, half4 param2); -OVERLOADABLE half8 mix (half8 param0, half8 param1, half8 param2); -OVERLOADABLE half16 mix (half16 param0, half16 param1, half16 param2); - -//gentypef mix (gentypef x, gentypef y, float a) - -OVERLOADABLE float2 mix (float2 param0, float2 param1, float param2); -OVERLOADABLE float3 mix (float3 param0, float3 param1, float param2); -OVERLOADABLE float4 mix (float4 param0, float4 param1, float param2); -OVERLOADABLE float8 mix (float8 param0, float8 param1, float param2); -OVERLOADABLE float16 mix (float16 param0, float16 param1, float param2); - -//gentypeh mix (gentypeh x, gentypeh y, half a) - -OVERLOADABLE half2 mix (half2 param0, half2 param1, half param2); -OVERLOADABLE half3 mix (half3 param0, half3 param1, half param2); -OVERLOADABLE half4 mix (half4 param0, half4 param1, half param2); -OVERLOADABLE half8 mix (half8 param0, half8 param1, half param2); -OVERLOADABLE half16 mix (half16 param0, half16 param1, half param2); - -//gentyped mix (gentyped x, gentyped y, double a) - -OVERLOADABLE double2 mix (double2 param0, double2 param1, double param2); -OVERLOADABLE double3 mix (double3 param0, double3 param1, double param2); -OVERLOADABLE double4 mix (double4 param0, double4 param1, double param2); -OVERLOADABLE double8 mix (double8 param0, double8 param1, double param2); -OVERLOADABLE double16 mix (double16 param0, double16 param1, double param2); - -//gentype radians (gentype degrees) - -OVERLOADABLE float2 radians (float2 param0); -OVERLOADABLE float3 radians (float3 param0); -OVERLOADABLE float4 radians (float4 param0); -OVERLOADABLE float8 radians (float8 param0); -OVERLOADABLE float16 radians (float16 param0); -OVERLOADABLE double2 radians (double2 param0); -OVERLOADABLE double3 radians (double3 param0); -OVERLOADABLE double4 radians (double4 param0); -OVERLOADABLE double8 radians (double8 param0); -OVERLOADABLE double16 radians (double16 param0); -OVERLOADABLE half2 radians (half2 param0); -OVERLOADABLE half3 radians (half3 param0); -OVERLOADABLE half4 radians (half4 param0); -OVERLOADABLE half8 radians (half8 param0); -OVERLOADABLE half16 radians (half16 param0); - -//gentype step (gentype edge, gentype x) - -OVERLOADABLE float2 step (float2 param0, float2 param1); -OVERLOADABLE float3 step (float3 param0, float3 param1); -OVERLOADABLE float4 step (float4 param0, float4 param1); -OVERLOADABLE float8 step (float8 param0, float8 param1); -OVERLOADABLE float16 step (float16 param0, float16 param1); -OVERLOADABLE double2 step (double2 param0, double2 param1); -OVERLOADABLE double3 step (double3 param0, double3 param1); -OVERLOADABLE double4 step (double4 param0, double4 param1); -OVERLOADABLE double8 step (double8 param0, double8 param1); -OVERLOADABLE double16 step (double16 param0, double16 param1); -OVERLOADABLE half2 step (half2 param0, half2 param1); -OVERLOADABLE half3 step (half3 param0, half3 param1); -OVERLOADABLE half4 step (half4 param0, half4 param1); -OVERLOADABLE half8 step (half8 param0, half8 param1); -OVERLOADABLE half16 step (half16 param0, half16 param1); - -//gentypef step (float edge, gentypef x) - -OVERLOADABLE float2 step (float param0, float2 param1); -OVERLOADABLE float3 step (float param0, float3 param1); -OVERLOADABLE float4 step (float param0, float4 param1); -OVERLOADABLE float8 step (float param0, float8 param1); -OVERLOADABLE float16 step (float param0, float16 param1); - -//gentypeh step (half edge, gentypeh x) - -OVERLOADABLE half2 step (half param0, half2 param1); -OVERLOADABLE half3 step (half param0, half3 param1); -OVERLOADABLE half4 step (half param0, half4 param1); -OVERLOADABLE half8 step (half param0, half8 param1); -OVERLOADABLE half16 step (half param0, half16 param1); - -//gentyped step (double edge, gentyped x) - -OVERLOADABLE double2 step (double param0, double2 param1); -OVERLOADABLE double3 step (double param0, double3 param1); -OVERLOADABLE double4 step (double param0, double4 param1); -OVERLOADABLE double8 step (double param0, double8 param1); -OVERLOADABLE double16 step (double param0, double16 param1); - -//gentype smoothstep (gentype edge0, gentype edge1, gentype x) - -OVERLOADABLE float2 smoothstep (float2 param0, float2 param1, float2 param2); -OVERLOADABLE float3 smoothstep (float3 param0, float3 param1, float3 param2); -OVERLOADABLE float4 smoothstep (float4 param0, float4 param1, float4 param2); -OVERLOADABLE float8 smoothstep (float8 param0, float8 param1, float8 param2); -OVERLOADABLE float16 smoothstep (float16 param0, float16 param1, float16 param2); -OVERLOADABLE double2 smoothstep (double2 param0, double2 param1, double2 param2); -OVERLOADABLE double3 smoothstep (double3 param0, double3 param1, double3 param2); -OVERLOADABLE double4 smoothstep (double4 param0, double4 param1, double4 param2); -OVERLOADABLE double8 smoothstep (double8 param0, double8 param1, double8 param2); -OVERLOADABLE double16 smoothstep (double16 param0, double16 param1, double16 param2); -OVERLOADABLE half2 smoothstep (half2 param0, half2 param1, half2 param2); -OVERLOADABLE half3 smoothstep (half3 param0, half3 param1, half3 param2); -OVERLOADABLE half4 smoothstep (half4 param0, half4 param1, half4 param2); -OVERLOADABLE half8 smoothstep (half8 param0, half8 param1, half8 param2); -OVERLOADABLE half16 smoothstep (half16 param0, half16 param1, half16 param2); - -//gentypef smoothstep (float edge0, float edge1, gentypef x) - -OVERLOADABLE float2 smoothstep (float param0, float param1, float2 param2); -OVERLOADABLE float3 smoothstep (float param0, float param1, float3 param2); -OVERLOADABLE float4 smoothstep (float param0, float param1, float4 param2); -OVERLOADABLE float8 smoothstep (float param0, float param1, float8 param2); -OVERLOADABLE float16 smoothstep (float param0, float param1, float16 param2); - -//gentypeh smoothstep (half edge0, half edge1, gentypeh x) - -OVERLOADABLE half2 smoothstep (half param0, half param1, half2 param2); -OVERLOADABLE half3 smoothstep (half param0, half param1, half3 param2); -OVERLOADABLE half4 smoothstep (half param0, half param1, half4 param2); -OVERLOADABLE half8 smoothstep (half param0, half param1, half8 param2); -OVERLOADABLE half16 smoothstep (half param0, half param1, half16 param2); - -//gentyped smoothstep (double edge0, double edge1, gentyped x) - -OVERLOADABLE double2 smoothstep (double param0, double param1, double2 param2); -OVERLOADABLE double3 smoothstep (double param0, double param1, double3 param2); -OVERLOADABLE double4 smoothstep (double param0, double param1, double4 param2); -OVERLOADABLE double8 smoothstep (double param0, double param1, double8 param2); -OVERLOADABLE double16 smoothstep (double param0, double param1, double16 param2); - -//gentype sign (gentype x) - -OVERLOADABLE float2 sign (float2 param0); -OVERLOADABLE float3 sign (float3 param0); -OVERLOADABLE float4 sign (float4 param0); -OVERLOADABLE float8 sign (float8 param0); -OVERLOADABLE float16 sign (float16 param0); -OVERLOADABLE double2 sign (double2 param0); -OVERLOADABLE double3 sign (double3 param0); -OVERLOADABLE double4 sign (double4 param0); -OVERLOADABLE double8 sign (double8 param0); -OVERLOADABLE double16 sign (double16 param0); -OVERLOADABLE half2 sign (half2 param0); -OVERLOADABLE half3 sign (half3 param0); -OVERLOADABLE half4 sign (half4 param0); -OVERLOADABLE half8 sign (half8 param0); -OVERLOADABLE half16 sign (half16 param0); - -#endif diff --git a/drivers/pocl-gen7/lib/beignet/include/ocl_convert.h b/drivers/pocl-gen7/lib/beignet/include/ocl_convert.h deleted file mode 100644 index bc04529..0000000 --- a/drivers/pocl-gen7/lib/beignet/include/ocl_convert.h +++ /dev/null @@ -1,6279 +0,0 @@ - -/* - * Copyright © 2012 - 2014 Intel Corporatio - * - * This library is free software; you can redistribute it and/or - * modify it under the terms of the GNU Lesser General Public - * License as published by the Free Software Foundation; either - * version 2.1 of the License, or (at your option) any later version. - * - * This library is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU - * Lesser General Public License for more details. - * - * You should have received a copy of the GNU Lesser General Public - * License along with this library. If not, see . - * - */ - -#ifndef __OCL_CONVERT_H__ -#define __OCL_CONVERT_H__ -#include "ocl_types.h" - -OVERLOADABLE long convert_long(long v); -OVERLOADABLE ulong convert_ulong(long v); -OVERLOADABLE int convert_int(long v); -OVERLOADABLE uint convert_uint(long v); -OVERLOADABLE short convert_short(long v); -OVERLOADABLE ushort convert_ushort(long v); -OVERLOADABLE char convert_char(long v); -OVERLOADABLE uchar convert_uchar(long v); -OVERLOADABLE double convert_double(long v); -OVERLOADABLE float convert_float(long v); -OVERLOADABLE half convert_half(long v); -OVERLOADABLE long convert_long(ulong v); -OVERLOADABLE ulong convert_ulong(ulong v); -OVERLOADABLE int convert_int(ulong v); -OVERLOADABLE uint convert_uint(ulong v); -OVERLOADABLE short convert_short(ulong v); -OVERLOADABLE ushort convert_ushort(ulong v); -OVERLOADABLE char convert_char(ulong v); -OVERLOADABLE uchar convert_uchar(ulong v); -OVERLOADABLE double convert_double(ulong v); -OVERLOADABLE float convert_float(ulong v); -OVERLOADABLE half convert_half(ulong v); -OVERLOADABLE long convert_long(int v); -OVERLOADABLE ulong convert_ulong(int v); -OVERLOADABLE int convert_int(int v); -OVERLOADABLE uint convert_uint(int v); -OVERLOADABLE short convert_short(int v); -OVERLOADABLE ushort convert_ushort(int v); -OVERLOADABLE char convert_char(int v); -OVERLOADABLE uchar convert_uchar(int v); -OVERLOADABLE double convert_double(int v); -OVERLOADABLE float convert_float(int v); -OVERLOADABLE half convert_half(int v); -OVERLOADABLE long convert_long(uint v); -OVERLOADABLE ulong convert_ulong(uint v); -OVERLOADABLE int convert_int(uint v); -OVERLOADABLE uint convert_uint(uint v); -OVERLOADABLE short convert_short(uint v); -OVERLOADABLE ushort convert_ushort(uint v); -OVERLOADABLE char convert_char(uint v); -OVERLOADABLE uchar convert_uchar(uint v); -OVERLOADABLE double convert_double(uint v); -OVERLOADABLE float convert_float(uint v); -OVERLOADABLE half convert_half(uint v); -OVERLOADABLE long convert_long(short v); -OVERLOADABLE ulong convert_ulong(short v); -OVERLOADABLE int convert_int(short v); -OVERLOADABLE uint convert_uint(short v); -OVERLOADABLE short convert_short(short v); -OVERLOADABLE ushort convert_ushort(short v); -OVERLOADABLE char convert_char(short v); -OVERLOADABLE uchar convert_uchar(short v); -OVERLOADABLE double convert_double(short v); -OVERLOADABLE float convert_float(short v); -OVERLOADABLE half convert_half(short v); -OVERLOADABLE long convert_long(ushort v); -OVERLOADABLE ulong convert_ulong(ushort v); -OVERLOADABLE int convert_int(ushort v); -OVERLOADABLE uint convert_uint(ushort v); -OVERLOADABLE short convert_short(ushort v); -OVERLOADABLE ushort convert_ushort(ushort v); -OVERLOADABLE char convert_char(ushort v); -OVERLOADABLE uchar convert_uchar(ushort v); -OVERLOADABLE double convert_double(ushort v); -OVERLOADABLE float convert_float(ushort v); -OVERLOADABLE half convert_half(ushort v); -OVERLOADABLE long convert_long(char v); -OVERLOADABLE ulong convert_ulong(char v); -OVERLOADABLE int convert_int(char v); -OVERLOADABLE uint convert_uint(char v); -OVERLOADABLE short convert_short(char v); -OVERLOADABLE ushort convert_ushort(char v); -OVERLOADABLE char convert_char(char v); -OVERLOADABLE uchar convert_uchar(char v); -OVERLOADABLE double convert_double(char v); -OVERLOADABLE float convert_float(char v); -OVERLOADABLE half convert_half(char v); -OVERLOADABLE long convert_long(uchar v); -OVERLOADABLE ulong convert_ulong(uchar v); -OVERLOADABLE int convert_int(uchar v); -OVERLOADABLE uint convert_uint(uchar v); -OVERLOADABLE short convert_short(uchar v); -OVERLOADABLE ushort convert_ushort(uchar v); -OVERLOADABLE char convert_char(uchar v); -OVERLOADABLE uchar convert_uchar(uchar v); -OVERLOADABLE double convert_double(uchar v); -OVERLOADABLE float convert_float(uchar v); -OVERLOADABLE half convert_half(uchar v); -OVERLOADABLE long convert_long(double v); -OVERLOADABLE ulong convert_ulong(double v); -OVERLOADABLE int convert_int(double v); -OVERLOADABLE uint convert_uint(double v); -OVERLOADABLE short convert_short(double v); -OVERLOADABLE ushort convert_ushort(double v); -OVERLOADABLE char convert_char(double v); -OVERLOADABLE uchar convert_uchar(double v); -OVERLOADABLE double convert_double(double v); -OVERLOADABLE float convert_float(double v); -OVERLOADABLE half convert_half(double v); -OVERLOADABLE long convert_long(float v); -OVERLOADABLE ulong convert_ulong(float v); -OVERLOADABLE int convert_int(float v); -OVERLOADABLE uint convert_uint(float v); -OVERLOADABLE short convert_short(float v); -OVERLOADABLE ushort convert_ushort(float v); -OVERLOADABLE char convert_char(float v); -OVERLOADABLE uchar convert_uchar(float v); -OVERLOADABLE double convert_double(float v); -OVERLOADABLE float convert_float(float v); -OVERLOADABLE half convert_half(float v); -OVERLOADABLE long convert_long(half v); -OVERLOADABLE ulong convert_ulong(half v); -OVERLOADABLE int convert_int(half v); -OVERLOADABLE uint convert_uint(half v); -OVERLOADABLE short convert_short(half v); -OVERLOADABLE ushort convert_ushort(half v); -OVERLOADABLE char convert_char(half v); -OVERLOADABLE uchar convert_uchar(half v); -OVERLOADABLE double convert_double(half v); -OVERLOADABLE float convert_float(half v); -OVERLOADABLE half convert_half(half v); -OVERLOADABLE long2 convert_long2(long2 v); -OVERLOADABLE ulong2 convert_ulong2(long2 v); -OVERLOADABLE int2 convert_int2(long2 v); -OVERLOADABLE uint2 convert_uint2(long2 v); -OVERLOADABLE short2 convert_short2(long2 v); -OVERLOADABLE ushort2 convert_ushort2(long2 v); -OVERLOADABLE char2 convert_char2(long2 v); -OVERLOADABLE uchar2 convert_uchar2(long2 v); -OVERLOADABLE double2 convert_double2(long2 v); -OVERLOADABLE float2 convert_float2(long2 v); -OVERLOADABLE half2 convert_half2(long2 v); -OVERLOADABLE long2 convert_long2(ulong2 v); -OVERLOADABLE ulong2 convert_ulong2(ulong2 v); -OVERLOADABLE int2 convert_int2(ulong2 v); -OVERLOADABLE uint2 convert_uint2(ulong2 v); -OVERLOADABLE short2 convert_short2(ulong2 v); -OVERLOADABLE ushort2 convert_ushort2(ulong2 v); -OVERLOADABLE char2 convert_char2(ulong2 v); -OVERLOADABLE uchar2 convert_uchar2(ulong2 v); -OVERLOADABLE double2 convert_double2(ulong2 v); -OVERLOADABLE float2 convert_float2(ulong2 v); -OVERLOADABLE half2 convert_half2(ulong2 v); -OVERLOADABLE long2 convert_long2(int2 v); -OVERLOADABLE ulong2 convert_ulong2(int2 v); -OVERLOADABLE int2 convert_int2(int2 v); -OVERLOADABLE uint2 convert_uint2(int2 v); -OVERLOADABLE short2 convert_short2(int2 v); -OVERLOADABLE ushort2 convert_ushort2(int2 v); -OVERLOADABLE char2 convert_char2(int2 v); -OVERLOADABLE uchar2 convert_uchar2(int2 v); -OVERLOADABLE double2 convert_double2(int2 v); -OVERLOADABLE float2 convert_float2(int2 v); -OVERLOADABLE half2 convert_half2(int2 v); -OVERLOADABLE long2 convert_long2(uint2 v); -OVERLOADABLE ulong2 convert_ulong2(uint2 v); -OVERLOADABLE int2 convert_int2(uint2 v); -OVERLOADABLE uint2 convert_uint2(uint2 v); -OVERLOADABLE short2 convert_short2(uint2 v); -OVERLOADABLE ushort2 convert_ushort2(uint2 v); -OVERLOADABLE char2 convert_char2(uint2 v); -OVERLOADABLE uchar2 convert_uchar2(uint2 v); -OVERLOADABLE double2 convert_double2(uint2 v); -OVERLOADABLE float2 convert_float2(uint2 v); -OVERLOADABLE half2 convert_half2(uint2 v); -OVERLOADABLE long2 convert_long2(short2 v); -OVERLOADABLE ulong2 convert_ulong2(short2 v); -OVERLOADABLE int2 convert_int2(short2 v); -OVERLOADABLE uint2 convert_uint2(short2 v); -OVERLOADABLE short2 convert_short2(short2 v); -OVERLOADABLE ushort2 convert_ushort2(short2 v); -OVERLOADABLE char2 convert_char2(short2 v); -OVERLOADABLE uchar2 convert_uchar2(short2 v); -OVERLOADABLE double2 convert_double2(short2 v); -OVERLOADABLE float2 convert_float2(short2 v); -OVERLOADABLE half2 convert_half2(short2 v); -OVERLOADABLE long2 convert_long2(ushort2 v); -OVERLOADABLE ulong2 convert_ulong2(ushort2 v); -OVERLOADABLE int2 convert_int2(ushort2 v); -OVERLOADABLE uint2 convert_uint2(ushort2 v); -OVERLOADABLE short2 convert_short2(ushort2 v); -OVERLOADABLE ushort2 convert_ushort2(ushort2 v); -OVERLOADABLE char2 convert_char2(ushort2 v); -OVERLOADABLE uchar2 convert_uchar2(ushort2 v); -OVERLOADABLE double2 convert_double2(ushort2 v); -OVERLOADABLE float2 convert_float2(ushort2 v); -OVERLOADABLE half2 convert_half2(ushort2 v); -OVERLOADABLE long2 convert_long2(char2 v); -OVERLOADABLE ulong2 convert_ulong2(char2 v); -OVERLOADABLE int2 convert_int2(char2 v); -OVERLOADABLE uint2 convert_uint2(char2 v); -OVERLOADABLE short2 convert_short2(char2 v); -OVERLOADABLE ushort2 convert_ushort2(char2 v); -OVERLOADABLE char2 convert_char2(char2 v); -OVERLOADABLE uchar2 convert_uchar2(char2 v); -OVERLOADABLE double2 convert_double2(char2 v); -OVERLOADABLE float2 convert_float2(char2 v); -OVERLOADABLE half2 convert_half2(char2 v); -OVERLOADABLE long2 convert_long2(uchar2 v); -OVERLOADABLE ulong2 convert_ulong2(uchar2 v); -OVERLOADABLE int2 convert_int2(uchar2 v); -OVERLOADABLE uint2 convert_uint2(uchar2 v); -OVERLOADABLE short2 convert_short2(uchar2 v); -OVERLOADABLE ushort2 convert_ushort2(uchar2 v); -OVERLOADABLE char2 convert_char2(uchar2 v); -OVERLOADABLE uchar2 convert_uchar2(uchar2 v); -OVERLOADABLE double2 convert_double2(uchar2 v); -OVERLOADABLE float2 convert_float2(uchar2 v); -OVERLOADABLE half2 convert_half2(uchar2 v); -OVERLOADABLE long2 convert_long2(double2 v); -OVERLOADABLE ulong2 convert_ulong2(double2 v); -OVERLOADABLE int2 convert_int2(double2 v); -OVERLOADABLE uint2 convert_uint2(double2 v); -OVERLOADABLE short2 convert_short2(double2 v); -OVERLOADABLE ushort2 convert_ushort2(double2 v); -OVERLOADABLE char2 convert_char2(double2 v); -OVERLOADABLE uchar2 convert_uchar2(double2 v); -OVERLOADABLE double2 convert_double2(double2 v); -OVERLOADABLE float2 convert_float2(double2 v); -OVERLOADABLE half2 convert_half2(double2 v); -OVERLOADABLE long2 convert_long2(float2 v); -OVERLOADABLE ulong2 convert_ulong2(float2 v); -OVERLOADABLE int2 convert_int2(float2 v); -OVERLOADABLE uint2 convert_uint2(float2 v); -OVERLOADABLE short2 convert_short2(float2 v); -OVERLOADABLE ushort2 convert_ushort2(float2 v); -OVERLOADABLE char2 convert_char2(float2 v); -OVERLOADABLE uchar2 convert_uchar2(float2 v); -OVERLOADABLE double2 convert_double2(float2 v); -OVERLOADABLE float2 convert_float2(float2 v); -OVERLOADABLE half2 convert_half2(float2 v); -OVERLOADABLE long2 convert_long2(half2 v); -OVERLOADABLE ulong2 convert_ulong2(half2 v); -OVERLOADABLE int2 convert_int2(half2 v); -OVERLOADABLE uint2 convert_uint2(half2 v); -OVERLOADABLE short2 convert_short2(half2 v); -OVERLOADABLE ushort2 convert_ushort2(half2 v); -OVERLOADABLE char2 convert_char2(half2 v); -OVERLOADABLE uchar2 convert_uchar2(half2 v); -OVERLOADABLE double2 convert_double2(half2 v); -OVERLOADABLE float2 convert_float2(half2 v); -OVERLOADABLE half2 convert_half2(half2 v); -OVERLOADABLE long3 convert_long3(long3 v); -OVERLOADABLE ulong3 convert_ulong3(long3 v); -OVERLOADABLE int3 convert_int3(long3 v); -OVERLOADABLE uint3 convert_uint3(long3 v); -OVERLOADABLE short3 convert_short3(long3 v); -OVERLOADABLE ushort3 convert_ushort3(long3 v); -OVERLOADABLE char3 convert_char3(long3 v); -OVERLOADABLE uchar3 convert_uchar3(long3 v); -OVERLOADABLE double3 convert_double3(long3 v); -OVERLOADABLE float3 convert_float3(long3 v); -OVERLOADABLE half3 convert_half3(long3 v); -OVERLOADABLE long3 convert_long3(ulong3 v); -OVERLOADABLE ulong3 convert_ulong3(ulong3 v); -OVERLOADABLE int3 convert_int3(ulong3 v); -OVERLOADABLE uint3 convert_uint3(ulong3 v); -OVERLOADABLE short3 convert_short3(ulong3 v); -OVERLOADABLE ushort3 convert_ushort3(ulong3 v); -OVERLOADABLE char3 convert_char3(ulong3 v); -OVERLOADABLE uchar3 convert_uchar3(ulong3 v); -OVERLOADABLE double3 convert_double3(ulong3 v); -OVERLOADABLE float3 convert_float3(ulong3 v); -OVERLOADABLE half3 convert_half3(ulong3 v); -OVERLOADABLE long3 convert_long3(int3 v); -OVERLOADABLE ulong3 convert_ulong3(int3 v); -OVERLOADABLE int3 convert_int3(int3 v); -OVERLOADABLE uint3 convert_uint3(int3 v); -OVERLOADABLE short3 convert_short3(int3 v); -OVERLOADABLE ushort3 convert_ushort3(int3 v); -OVERLOADABLE char3 convert_char3(int3 v); -OVERLOADABLE uchar3 convert_uchar3(int3 v); -OVERLOADABLE double3 convert_double3(int3 v); -OVERLOADABLE float3 convert_float3(int3 v); -OVERLOADABLE half3 convert_half3(int3 v); -OVERLOADABLE long3 convert_long3(uint3 v); -OVERLOADABLE ulong3 convert_ulong3(uint3 v); -OVERLOADABLE int3 convert_int3(uint3 v); -OVERLOADABLE uint3 convert_uint3(uint3 v); -OVERLOADABLE short3 convert_short3(uint3 v); -OVERLOADABLE ushort3 convert_ushort3(uint3 v); -OVERLOADABLE char3 convert_char3(uint3 v); -OVERLOADABLE uchar3 convert_uchar3(uint3 v); -OVERLOADABLE double3 convert_double3(uint3 v); -OVERLOADABLE float3 convert_float3(uint3 v); -OVERLOADABLE half3 convert_half3(uint3 v); -OVERLOADABLE long3 convert_long3(short3 v); -OVERLOADABLE ulong3 convert_ulong3(short3 v); -OVERLOADABLE int3 convert_int3(short3 v); -OVERLOADABLE uint3 convert_uint3(short3 v); -OVERLOADABLE short3 convert_short3(short3 v); -OVERLOADABLE ushort3 convert_ushort3(short3 v); -OVERLOADABLE char3 convert_char3(short3 v); -OVERLOADABLE uchar3 convert_uchar3(short3 v); -OVERLOADABLE double3 convert_double3(short3 v); -OVERLOADABLE float3 convert_float3(short3 v); -OVERLOADABLE half3 convert_half3(short3 v); -OVERLOADABLE long3 convert_long3(ushort3 v); -OVERLOADABLE ulong3 convert_ulong3(ushort3 v); -OVERLOADABLE int3 convert_int3(ushort3 v); -OVERLOADABLE uint3 convert_uint3(ushort3 v); -OVERLOADABLE short3 convert_short3(ushort3 v); -OVERLOADABLE ushort3 convert_ushort3(ushort3 v); -OVERLOADABLE char3 convert_char3(ushort3 v); -OVERLOADABLE uchar3 convert_uchar3(ushort3 v); -OVERLOADABLE double3 convert_double3(ushort3 v); -OVERLOADABLE float3 convert_float3(ushort3 v); -OVERLOADABLE half3 convert_half3(ushort3 v); -OVERLOADABLE long3 convert_long3(char3 v); -OVERLOADABLE ulong3 convert_ulong3(char3 v); -OVERLOADABLE int3 convert_int3(char3 v); -OVERLOADABLE uint3 convert_uint3(char3 v); -OVERLOADABLE short3 convert_short3(char3 v); -OVERLOADABLE ushort3 convert_ushort3(char3 v); -OVERLOADABLE char3 convert_char3(char3 v); -OVERLOADABLE uchar3 convert_uchar3(char3 v); -OVERLOADABLE double3 convert_double3(char3 v); -OVERLOADABLE float3 convert_float3(char3 v); -OVERLOADABLE half3 convert_half3(char3 v); -OVERLOADABLE long3 convert_long3(uchar3 v); -OVERLOADABLE ulong3 convert_ulong3(uchar3 v); -OVERLOADABLE int3 convert_int3(uchar3 v); -OVERLOADABLE uint3 convert_uint3(uchar3 v); -OVERLOADABLE short3 convert_short3(uchar3 v); -OVERLOADABLE ushort3 convert_ushort3(uchar3 v); -OVERLOADABLE char3 convert_char3(uchar3 v); -OVERLOADABLE uchar3 convert_uchar3(uchar3 v); -OVERLOADABLE double3 convert_double3(uchar3 v); -OVERLOADABLE float3 convert_float3(uchar3 v); -OVERLOADABLE half3 convert_half3(uchar3 v); -OVERLOADABLE long3 convert_long3(double3 v); -OVERLOADABLE ulong3 convert_ulong3(double3 v); -OVERLOADABLE int3 convert_int3(double3 v); -OVERLOADABLE uint3 convert_uint3(double3 v); -OVERLOADABLE short3 convert_short3(double3 v); -OVERLOADABLE ushort3 convert_ushort3(double3 v); -OVERLOADABLE char3 convert_char3(double3 v); -OVERLOADABLE uchar3 convert_uchar3(double3 v); -OVERLOADABLE double3 convert_double3(double3 v); -OVERLOADABLE float3 convert_float3(double3 v); -OVERLOADABLE half3 convert_half3(double3 v); -OVERLOADABLE long3 convert_long3(float3 v); -OVERLOADABLE ulong3 convert_ulong3(float3 v); -OVERLOADABLE int3 convert_int3(float3 v); -OVERLOADABLE uint3 convert_uint3(float3 v); -OVERLOADABLE short3 convert_short3(float3 v); -OVERLOADABLE ushort3 convert_ushort3(float3 v); -OVERLOADABLE char3 convert_char3(float3 v); -OVERLOADABLE uchar3 convert_uchar3(float3 v); -OVERLOADABLE double3 convert_double3(float3 v); -OVERLOADABLE float3 convert_float3(float3 v); -OVERLOADABLE half3 convert_half3(float3 v); -OVERLOADABLE long3 convert_long3(half3 v); -OVERLOADABLE ulong3 convert_ulong3(half3 v); -OVERLOADABLE int3 convert_int3(half3 v); -OVERLOADABLE uint3 convert_uint3(half3 v); -OVERLOADABLE short3 convert_short3(half3 v); -OVERLOADABLE ushort3 convert_ushort3(half3 v); -OVERLOADABLE char3 convert_char3(half3 v); -OVERLOADABLE uchar3 convert_uchar3(half3 v); -OVERLOADABLE double3 convert_double3(half3 v); -OVERLOADABLE float3 convert_float3(half3 v); -OVERLOADABLE half3 convert_half3(half3 v); -OVERLOADABLE long4 convert_long4(long4 v); -OVERLOADABLE ulong4 convert_ulong4(long4 v); -OVERLOADABLE int4 convert_int4(long4 v); -OVERLOADABLE uint4 convert_uint4(long4 v); -OVERLOADABLE short4 convert_short4(long4 v); -OVERLOADABLE ushort4 convert_ushort4(long4 v); -OVERLOADABLE char4 convert_char4(long4 v); -OVERLOADABLE uchar4 convert_uchar4(long4 v); -OVERLOADABLE double4 convert_double4(long4 v); -OVERLOADABLE float4 convert_float4(long4 v); -OVERLOADABLE half4 convert_half4(long4 v); -OVERLOADABLE long4 convert_long4(ulong4 v); -OVERLOADABLE ulong4 convert_ulong4(ulong4 v); -OVERLOADABLE int4 convert_int4(ulong4 v); -OVERLOADABLE uint4 convert_uint4(ulong4 v); -OVERLOADABLE short4 convert_short4(ulong4 v); -OVERLOADABLE ushort4 convert_ushort4(ulong4 v); -OVERLOADABLE char4 convert_char4(ulong4 v); -OVERLOADABLE uchar4 convert_uchar4(ulong4 v); -OVERLOADABLE double4 convert_double4(ulong4 v); -OVERLOADABLE float4 convert_float4(ulong4 v); -OVERLOADABLE half4 convert_half4(ulong4 v); -OVERLOADABLE long4 convert_long4(int4 v); -OVERLOADABLE ulong4 convert_ulong4(int4 v); -OVERLOADABLE int4 convert_int4(int4 v); -OVERLOADABLE uint4 convert_uint4(int4 v); -OVERLOADABLE short4 convert_short4(int4 v); -OVERLOADABLE ushort4 convert_ushort4(int4 v); -OVERLOADABLE char4 convert_char4(int4 v); -OVERLOADABLE uchar4 convert_uchar4(int4 v); -OVERLOADABLE double4 convert_double4(int4 v); -OVERLOADABLE float4 convert_float4(int4 v); -OVERLOADABLE half4 convert_half4(int4 v); -OVERLOADABLE long4 convert_long4(uint4 v); -OVERLOADABLE ulong4 convert_ulong4(uint4 v); -OVERLOADABLE int4 convert_int4(uint4 v); -OVERLOADABLE uint4 convert_uint4(uint4 v); -OVERLOADABLE short4 convert_short4(uint4 v); -OVERLOADABLE ushort4 convert_ushort4(uint4 v); -OVERLOADABLE char4 convert_char4(uint4 v); -OVERLOADABLE uchar4 convert_uchar4(uint4 v); -OVERLOADABLE double4 convert_double4(uint4 v); -OVERLOADABLE float4 convert_float4(uint4 v); -OVERLOADABLE half4 convert_half4(uint4 v); -OVERLOADABLE long4 convert_long4(short4 v); -OVERLOADABLE ulong4 convert_ulong4(short4 v); -OVERLOADABLE int4 convert_int4(short4 v); -OVERLOADABLE uint4 convert_uint4(short4 v); -OVERLOADABLE short4 convert_short4(short4 v); -OVERLOADABLE ushort4 convert_ushort4(short4 v); -OVERLOADABLE char4 convert_char4(short4 v); -OVERLOADABLE uchar4 convert_uchar4(short4 v); -OVERLOADABLE double4 convert_double4(short4 v); -OVERLOADABLE float4 convert_float4(short4 v); -OVERLOADABLE half4 convert_half4(short4 v); -OVERLOADABLE long4 convert_long4(ushort4 v); -OVERLOADABLE ulong4 convert_ulong4(ushort4 v); -OVERLOADABLE int4 convert_int4(ushort4 v); -OVERLOADABLE uint4 convert_uint4(ushort4 v); -OVERLOADABLE short4 convert_short4(ushort4 v); -OVERLOADABLE ushort4 convert_ushort4(ushort4 v); -OVERLOADABLE char4 convert_char4(ushort4 v); -OVERLOADABLE uchar4 convert_uchar4(ushort4 v); -OVERLOADABLE double4 convert_double4(ushort4 v); -OVERLOADABLE float4 convert_float4(ushort4 v); -OVERLOADABLE half4 convert_half4(ushort4 v); -OVERLOADABLE long4 convert_long4(char4 v); -OVERLOADABLE ulong4 convert_ulong4(char4 v); -OVERLOADABLE int4 convert_int4(char4 v); -OVERLOADABLE uint4 convert_uint4(char4 v); -OVERLOADABLE short4 convert_short4(char4 v); -OVERLOADABLE ushort4 convert_ushort4(char4 v); -OVERLOADABLE char4 convert_char4(char4 v); -OVERLOADABLE uchar4 convert_uchar4(char4 v); -OVERLOADABLE double4 convert_double4(char4 v); -OVERLOADABLE float4 convert_float4(char4 v); -OVERLOADABLE half4 convert_half4(char4 v); -OVERLOADABLE long4 convert_long4(uchar4 v); -OVERLOADABLE ulong4 convert_ulong4(uchar4 v); -OVERLOADABLE int4 convert_int4(uchar4 v); -OVERLOADABLE uint4 convert_uint4(uchar4 v); -OVERLOADABLE short4 convert_short4(uchar4 v); -OVERLOADABLE ushort4 convert_ushort4(uchar4 v); -OVERLOADABLE char4 convert_char4(uchar4 v); -OVERLOADABLE uchar4 convert_uchar4(uchar4 v); -OVERLOADABLE double4 convert_double4(uchar4 v); -OVERLOADABLE float4 convert_float4(uchar4 v); -OVERLOADABLE half4 convert_half4(uchar4 v); -OVERLOADABLE long4 convert_long4(double4 v); -OVERLOADABLE ulong4 convert_ulong4(double4 v); -OVERLOADABLE int4 convert_int4(double4 v); -OVERLOADABLE uint4 convert_uint4(double4 v); -OVERLOADABLE short4 convert_short4(double4 v); -OVERLOADABLE ushort4 convert_ushort4(double4 v); -OVERLOADABLE char4 convert_char4(double4 v); -OVERLOADABLE uchar4 convert_uchar4(double4 v); -OVERLOADABLE double4 convert_double4(double4 v); -OVERLOADABLE float4 convert_float4(double4 v); -OVERLOADABLE half4 convert_half4(double4 v); -OVERLOADABLE long4 convert_long4(float4 v); -OVERLOADABLE ulong4 convert_ulong4(float4 v); -OVERLOADABLE int4 convert_int4(float4 v); -OVERLOADABLE uint4 convert_uint4(float4 v); -OVERLOADABLE short4 convert_short4(float4 v); -OVERLOADABLE ushort4 convert_ushort4(float4 v); -OVERLOADABLE char4 convert_char4(float4 v); -OVERLOADABLE uchar4 convert_uchar4(float4 v); -OVERLOADABLE double4 convert_double4(float4 v); -OVERLOADABLE float4 convert_float4(float4 v); -OVERLOADABLE half4 convert_half4(float4 v); -OVERLOADABLE long4 convert_long4(half4 v); -OVERLOADABLE ulong4 convert_ulong4(half4 v); -OVERLOADABLE int4 convert_int4(half4 v); -OVERLOADABLE uint4 convert_uint4(half4 v); -OVERLOADABLE short4 convert_short4(half4 v); -OVERLOADABLE ushort4 convert_ushort4(half4 v); -OVERLOADABLE char4 convert_char4(half4 v); -OVERLOADABLE uchar4 convert_uchar4(half4 v); -OVERLOADABLE double4 convert_double4(half4 v); -OVERLOADABLE float4 convert_float4(half4 v); -OVERLOADABLE half4 convert_half4(half4 v); -OVERLOADABLE long8 convert_long8(long8 v); -OVERLOADABLE ulong8 convert_ulong8(long8 v); -OVERLOADABLE int8 convert_int8(long8 v); -OVERLOADABLE uint8 convert_uint8(long8 v); -OVERLOADABLE short8 convert_short8(long8 v); -OVERLOADABLE ushort8 convert_ushort8(long8 v); -OVERLOADABLE char8 convert_char8(long8 v); -OVERLOADABLE uchar8 convert_uchar8(long8 v); -OVERLOADABLE double8 convert_double8(long8 v); -OVERLOADABLE float8 convert_float8(long8 v); -OVERLOADABLE half8 convert_half8(long8 v); -OVERLOADABLE long8 convert_long8(ulong8 v); -OVERLOADABLE ulong8 convert_ulong8(ulong8 v); -OVERLOADABLE int8 convert_int8(ulong8 v); -OVERLOADABLE uint8 convert_uint8(ulong8 v); -OVERLOADABLE short8 convert_short8(ulong8 v); -OVERLOADABLE ushort8 convert_ushort8(ulong8 v); -OVERLOADABLE char8 convert_char8(ulong8 v); -OVERLOADABLE uchar8 convert_uchar8(ulong8 v); -OVERLOADABLE double8 convert_double8(ulong8 v); -OVERLOADABLE float8 convert_float8(ulong8 v); -OVERLOADABLE half8 convert_half8(ulong8 v); -OVERLOADABLE long8 convert_long8(int8 v); -OVERLOADABLE ulong8 convert_ulong8(int8 v); -OVERLOADABLE int8 convert_int8(int8 v); -OVERLOADABLE uint8 convert_uint8(int8 v); -OVERLOADABLE short8 convert_short8(int8 v); -OVERLOADABLE ushort8 convert_ushort8(int8 v); -OVERLOADABLE char8 convert_char8(int8 v); -OVERLOADABLE uchar8 convert_uchar8(int8 v); -OVERLOADABLE double8 convert_double8(int8 v); -OVERLOADABLE float8 convert_float8(int8 v); -OVERLOADABLE half8 convert_half8(int8 v); -OVERLOADABLE long8 convert_long8(uint8 v); -OVERLOADABLE ulong8 convert_ulong8(uint8 v); -OVERLOADABLE int8 convert_int8(uint8 v); -OVERLOADABLE uint8 convert_uint8(uint8 v); -OVERLOADABLE short8 convert_short8(uint8 v); -OVERLOADABLE ushort8 convert_ushort8(uint8 v); -OVERLOADABLE char8 convert_char8(uint8 v); -OVERLOADABLE uchar8 convert_uchar8(uint8 v); -OVERLOADABLE double8 convert_double8(uint8 v); -OVERLOADABLE float8 convert_float8(uint8 v); -OVERLOADABLE half8 convert_half8(uint8 v); -OVERLOADABLE long8 convert_long8(short8 v); -OVERLOADABLE ulong8 convert_ulong8(short8 v); -OVERLOADABLE int8 convert_int8(short8 v); -OVERLOADABLE uint8 convert_uint8(short8 v); -OVERLOADABLE short8 convert_short8(short8 v); -OVERLOADABLE ushort8 convert_ushort8(short8 v); -OVERLOADABLE char8 convert_char8(short8 v); -OVERLOADABLE uchar8 convert_uchar8(short8 v); -OVERLOADABLE double8 convert_double8(short8 v); -OVERLOADABLE float8 convert_float8(short8 v); -OVERLOADABLE half8 convert_half8(short8 v); -OVERLOADABLE long8 convert_long8(ushort8 v); -OVERLOADABLE ulong8 convert_ulong8(ushort8 v); -OVERLOADABLE int8 convert_int8(ushort8 v); -OVERLOADABLE uint8 convert_uint8(ushort8 v); -OVERLOADABLE short8 convert_short8(ushort8 v); -OVERLOADABLE ushort8 convert_ushort8(ushort8 v); -OVERLOADABLE char8 convert_char8(ushort8 v); -OVERLOADABLE uchar8 convert_uchar8(ushort8 v); -OVERLOADABLE double8 convert_double8(ushort8 v); -OVERLOADABLE float8 convert_float8(ushort8 v); -OVERLOADABLE half8 convert_half8(ushort8 v); -OVERLOADABLE long8 convert_long8(char8 v); -OVERLOADABLE ulong8 convert_ulong8(char8 v); -OVERLOADABLE int8 convert_int8(char8 v); -OVERLOADABLE uint8 convert_uint8(char8 v); -OVERLOADABLE short8 convert_short8(char8 v); -OVERLOADABLE ushort8 convert_ushort8(char8 v); -OVERLOADABLE char8 convert_char8(char8 v); -OVERLOADABLE uchar8 convert_uchar8(char8 v); -OVERLOADABLE double8 convert_double8(char8 v); -OVERLOADABLE float8 convert_float8(char8 v); -OVERLOADABLE half8 convert_half8(char8 v); -OVERLOADABLE long8 convert_long8(uchar8 v); -OVERLOADABLE ulong8 convert_ulong8(uchar8 v); -OVERLOADABLE int8 convert_int8(uchar8 v); -OVERLOADABLE uint8 convert_uint8(uchar8 v); -OVERLOADABLE short8 convert_short8(uchar8 v); -OVERLOADABLE ushort8 convert_ushort8(uchar8 v); -OVERLOADABLE char8 convert_char8(uchar8 v); -OVERLOADABLE uchar8 convert_uchar8(uchar8 v); -OVERLOADABLE double8 convert_double8(uchar8 v); -OVERLOADABLE float8 convert_float8(uchar8 v); -OVERLOADABLE half8 convert_half8(uchar8 v); -OVERLOADABLE long8 convert_long8(double8 v); -OVERLOADABLE ulong8 convert_ulong8(double8 v); -OVERLOADABLE int8 convert_int8(double8 v); -OVERLOADABLE uint8 convert_uint8(double8 v); -OVERLOADABLE short8 convert_short8(double8 v); -OVERLOADABLE ushort8 convert_ushort8(double8 v); -OVERLOADABLE char8 convert_char8(double8 v); -OVERLOADABLE uchar8 convert_uchar8(double8 v); -OVERLOADABLE double8 convert_double8(double8 v); -OVERLOADABLE float8 convert_float8(double8 v); -OVERLOADABLE half8 convert_half8(double8 v); -OVERLOADABLE long8 convert_long8(float8 v); -OVERLOADABLE ulong8 convert_ulong8(float8 v); -OVERLOADABLE int8 convert_int8(float8 v); -OVERLOADABLE uint8 convert_uint8(float8 v); -OVERLOADABLE short8 convert_short8(float8 v); -OVERLOADABLE ushort8 convert_ushort8(float8 v); -OVERLOADABLE char8 convert_char8(float8 v); -OVERLOADABLE uchar8 convert_uchar8(float8 v); -OVERLOADABLE double8 convert_double8(float8 v); -OVERLOADABLE float8 convert_float8(float8 v); -OVERLOADABLE half8 convert_half8(float8 v); -OVERLOADABLE long8 convert_long8(half8 v); -OVERLOADABLE ulong8 convert_ulong8(half8 v); -OVERLOADABLE int8 convert_int8(half8 v); -OVERLOADABLE uint8 convert_uint8(half8 v); -OVERLOADABLE short8 convert_short8(half8 v); -OVERLOADABLE ushort8 convert_ushort8(half8 v); -OVERLOADABLE char8 convert_char8(half8 v); -OVERLOADABLE uchar8 convert_uchar8(half8 v); -OVERLOADABLE double8 convert_double8(half8 v); -OVERLOADABLE float8 convert_float8(half8 v); -OVERLOADABLE half8 convert_half8(half8 v); -OVERLOADABLE long16 convert_long16(long16 v); -OVERLOADABLE ulong16 convert_ulong16(long16 v); -OVERLOADABLE int16 convert_int16(long16 v); -OVERLOADABLE uint16 convert_uint16(long16 v); -OVERLOADABLE short16 convert_short16(long16 v); -OVERLOADABLE ushort16 convert_ushort16(long16 v); -OVERLOADABLE char16 convert_char16(long16 v); -OVERLOADABLE uchar16 convert_uchar16(long16 v); -OVERLOADABLE double16 convert_double16(long16 v); -OVERLOADABLE float16 convert_float16(long16 v); -OVERLOADABLE half16 convert_half16(long16 v); -OVERLOADABLE long16 convert_long16(ulong16 v); -OVERLOADABLE ulong16 convert_ulong16(ulong16 v); -OVERLOADABLE int16 convert_int16(ulong16 v); -OVERLOADABLE uint16 convert_uint16(ulong16 v); -OVERLOADABLE short16 convert_short16(ulong16 v); -OVERLOADABLE ushort16 convert_ushort16(ulong16 v); -OVERLOADABLE char16 convert_char16(ulong16 v); -OVERLOADABLE uchar16 convert_uchar16(ulong16 v); -OVERLOADABLE double16 convert_double16(ulong16 v); -OVERLOADABLE float16 convert_float16(ulong16 v); -OVERLOADABLE half16 convert_half16(ulong16 v); -OVERLOADABLE long16 convert_long16(int16 v); -OVERLOADABLE ulong16 convert_ulong16(int16 v); -OVERLOADABLE int16 convert_int16(int16 v); -OVERLOADABLE uint16 convert_uint16(int16 v); -OVERLOADABLE short16 convert_short16(int16 v); -OVERLOADABLE ushort16 convert_ushort16(int16 v); -OVERLOADABLE char16 convert_char16(int16 v); -OVERLOADABLE uchar16 convert_uchar16(int16 v); -OVERLOADABLE double16 convert_double16(int16 v); -OVERLOADABLE float16 convert_float16(int16 v); -OVERLOADABLE half16 convert_half16(int16 v); -OVERLOADABLE long16 convert_long16(uint16 v); -OVERLOADABLE ulong16 convert_ulong16(uint16 v); -OVERLOADABLE int16 convert_int16(uint16 v); -OVERLOADABLE uint16 convert_uint16(uint16 v); -OVERLOADABLE short16 convert_short16(uint16 v); -OVERLOADABLE ushort16 convert_ushort16(uint16 v); -OVERLOADABLE char16 convert_char16(uint16 v); -OVERLOADABLE uchar16 convert_uchar16(uint16 v); -OVERLOADABLE double16 convert_double16(uint16 v); -OVERLOADABLE float16 convert_float16(uint16 v); -OVERLOADABLE half16 convert_half16(uint16 v); -OVERLOADABLE long16 convert_long16(short16 v); -OVERLOADABLE ulong16 convert_ulong16(short16 v); -OVERLOADABLE int16 convert_int16(short16 v); -OVERLOADABLE uint16 convert_uint16(short16 v); -OVERLOADABLE short16 convert_short16(short16 v); -OVERLOADABLE ushort16 convert_ushort16(short16 v); -OVERLOADABLE char16 convert_char16(short16 v); -OVERLOADABLE uchar16 convert_uchar16(short16 v); -OVERLOADABLE double16 convert_double16(short16 v); -OVERLOADABLE float16 convert_float16(short16 v); -OVERLOADABLE half16 convert_half16(short16 v); -OVERLOADABLE long16 convert_long16(ushort16 v); -OVERLOADABLE ulong16 convert_ulong16(ushort16 v); -OVERLOADABLE int16 convert_int16(ushort16 v); -OVERLOADABLE uint16 convert_uint16(ushort16 v); -OVERLOADABLE short16 convert_short16(ushort16 v); -OVERLOADABLE ushort16 convert_ushort16(ushort16 v); -OVERLOADABLE char16 convert_char16(ushort16 v); -OVERLOADABLE uchar16 convert_uchar16(ushort16 v); -OVERLOADABLE double16 convert_double16(ushort16 v); -OVERLOADABLE float16 convert_float16(ushort16 v); -OVERLOADABLE half16 convert_half16(ushort16 v); -OVERLOADABLE long16 convert_long16(char16 v); -OVERLOADABLE ulong16 convert_ulong16(char16 v); -OVERLOADABLE int16 convert_int16(char16 v); -OVERLOADABLE uint16 convert_uint16(char16 v); -OVERLOADABLE short16 convert_short16(char16 v); -OVERLOADABLE ushort16 convert_ushort16(char16 v); -OVERLOADABLE char16 convert_char16(char16 v); -OVERLOADABLE uchar16 convert_uchar16(char16 v); -OVERLOADABLE double16 convert_double16(char16 v); -OVERLOADABLE float16 convert_float16(char16 v); -OVERLOADABLE half16 convert_half16(char16 v); -OVERLOADABLE long16 convert_long16(uchar16 v); -OVERLOADABLE ulong16 convert_ulong16(uchar16 v); -OVERLOADABLE int16 convert_int16(uchar16 v); -OVERLOADABLE uint16 convert_uint16(uchar16 v); -OVERLOADABLE short16 convert_short16(uchar16 v); -OVERLOADABLE ushort16 convert_ushort16(uchar16 v); -OVERLOADABLE char16 convert_char16(uchar16 v); -OVERLOADABLE uchar16 convert_uchar16(uchar16 v); -OVERLOADABLE double16 convert_double16(uchar16 v); -OVERLOADABLE float16 convert_float16(uchar16 v); -OVERLOADABLE half16 convert_half16(uchar16 v); -OVERLOADABLE long16 convert_long16(double16 v); -OVERLOADABLE ulong16 convert_ulong16(double16 v); -OVERLOADABLE int16 convert_int16(double16 v); -OVERLOADABLE uint16 convert_uint16(double16 v); -OVERLOADABLE short16 convert_short16(double16 v); -OVERLOADABLE ushort16 convert_ushort16(double16 v); -OVERLOADABLE char16 convert_char16(double16 v); -OVERLOADABLE uchar16 convert_uchar16(double16 v); -OVERLOADABLE double16 convert_double16(double16 v); -OVERLOADABLE float16 convert_float16(double16 v); -OVERLOADABLE half16 convert_half16(double16 v); -OVERLOADABLE long16 convert_long16(float16 v); -OVERLOADABLE ulong16 convert_ulong16(float16 v); -OVERLOADABLE int16 convert_int16(float16 v); -OVERLOADABLE uint16 convert_uint16(float16 v); -OVERLOADABLE short16 convert_short16(float16 v); -OVERLOADABLE ushort16 convert_ushort16(float16 v); -OVERLOADABLE char16 convert_char16(float16 v); -OVERLOADABLE uchar16 convert_uchar16(float16 v); -OVERLOADABLE double16 convert_double16(float16 v); -OVERLOADABLE float16 convert_float16(float16 v); -OVERLOADABLE half16 convert_half16(float16 v); -OVERLOADABLE long16 convert_long16(half16 v); -OVERLOADABLE ulong16 convert_ulong16(half16 v); -OVERLOADABLE int16 convert_int16(half16 v); -OVERLOADABLE uint16 convert_uint16(half16 v); -OVERLOADABLE short16 convert_short16(half16 v); -OVERLOADABLE ushort16 convert_ushort16(half16 v); -OVERLOADABLE char16 convert_char16(half16 v); -OVERLOADABLE uchar16 convert_uchar16(half16 v); -OVERLOADABLE double16 convert_double16(half16 v); -OVERLOADABLE float16 convert_float16(half16 v); -OVERLOADABLE half16 convert_half16(half16 v); - -/* The sat cvt supported by HW. */ -#define DEF(DSTTYPE, SRCTYPE) \ -OVERLOADABLE DSTTYPE convert_ ## DSTTYPE ## _sat(SRCTYPE x); -DEF(char, uchar); -DEF(char, short); -DEF(char, ushort); -DEF(char, int); -DEF(char, uint); -DEF(char, float); -DEF(uchar, char); -DEF(uchar, short); -DEF(uchar, ushort); -DEF(uchar, int); -DEF(uchar, uint); -DEF(uchar, float); -DEF(short, ushort); -DEF(short, int); -DEF(short, uint); -DEF(short, float); -DEF(short, double); -DEF(ushort, short); -DEF(ushort, int); -DEF(ushort, uint); -DEF(ushort, float); -DEF(ushort, double); -DEF(int, uint); -DEF(int, float); -DEF(int, double); -DEF(uint, int); -DEF(uint, float); -DEF(uint, double); -DEF(char, half); -DEF(uchar, half); -DEF(short, half); -DEF(ushort, half); -DEF(int, half); -DEF(uint, half); -#undef DEF - -#define DEF(DSTTYPE, SRCTYPE, MIN, MAX) OVERLOADABLE DSTTYPE convert_ ## DSTTYPE ## _sat(SRCTYPE x); - -DEF(char, long, -128, 127); -DEF(uchar, long, 0, 255); -DEF(short, long, -32768, 32767); -DEF(ushort, long, 0, 65535); -DEF(int, long, -0x7fffffff-1, 0x7fffffff); -DEF(uint, long, 0, 0xffffffffu); -#undef DEF - - -#define DEF(DSTTYPE, SRCTYPE, SRC_MIN, SRC_MAX, DST_MIN, DST_MAX) OVERLOADABLE DSTTYPE convert_ ## DSTTYPE ## _sat(SRCTYPE x); - -DEF(long, float, -0x1.0p63, 0x1.0p63, 0x8000000000000000, 0x7fffffffffffffff); -DEF(ulong, float, 0, 0x1.0p64, 0, 0xffffffffffffffff); -DEF(char, double, -0x1.0p7, 0x1.0p7, 0x80, 0x7F); -DEF(uchar, double, 0, 0x1.0p8, 0, 0xFF); -DEF(long, double, -0x1.0p63, 0x1.0p63, 0x8000000000000000, 0x7FFFFFFFFFFFFFFF); -DEF(ulong, double, 0, 0x1.0p64, 0, 0xFFFFFFFFFFFFFFFF); -#undef DEF - -#define DEF(DSTTYPE, SRCTYPE, MAX) OVERLOADABLE DSTTYPE convert_ ## DSTTYPE ## _sat(SRCTYPE x); - -DEF(char, ulong, 127); -DEF(uchar, ulong, 255); -DEF(short, ulong, 32767); -DEF(ushort, ulong, 65535); -DEF(int, ulong, 0x7fffffff); -DEF(uint, ulong, 0xffffffffu); -#undef DEF - -OVERLOADABLE long convert_long_sat(ulong x); -#define DEF(DSTTYPE, SRCTYPE) OVERLOADABLE DSTTYPE convert_ ## DSTTYPE ## _sat(SRCTYPE x); - - DEF(ushort, char); - DEF(uint, char); - DEF(uint, short); - DEF(ulong, char); - DEF(ulong, short); - DEF(ulong, int); - DEF(ulong, long); - #undef DEF - -#define DEF(DSTTYPE, SRCTYPE) OVERLOADABLE DSTTYPE convert_ ## DSTTYPE ## _sat(SRCTYPE x); - -DEF(char, char); -DEF(uchar, uchar); -DEF(short, char); -DEF(short, uchar); -DEF(short, short); -DEF(ushort, uchar); -DEF(ushort, ushort); -DEF(int, char); -DEF(int, uchar); -DEF(int, short); -DEF(int, ushort); -DEF(int, int); -DEF(uint, uchar); -DEF(uint, ushort); -DEF(uint, uint); -DEF(long, char); -DEF(long, uchar); -DEF(long, short); -DEF(long, ushort); -DEF(long, int); -DEF(long, uint); -DEF(long, long); -DEF(ulong, uchar); -DEF(ulong, ushort); -DEF(ulong, uint); -DEF(ulong, ulong); -#undef DEF - - - OVERLOADABLE long convert_long_sat(half x); - OVERLOADABLE ulong convert_ulong_sat(half x); - -OVERLOADABLE long2 convert_long2_sat(long2 v); -OVERLOADABLE ulong2 convert_ulong2_sat(long2 v); -OVERLOADABLE int2 convert_int2_sat(long2 v); -OVERLOADABLE uint2 convert_uint2_sat(long2 v); -OVERLOADABLE short2 convert_short2_sat(long2 v); -OVERLOADABLE ushort2 convert_ushort2_sat(long2 v); -OVERLOADABLE char2 convert_char2_sat(long2 v); -OVERLOADABLE uchar2 convert_uchar2_sat(long2 v); -OVERLOADABLE long2 convert_long2_sat(ulong2 v); -OVERLOADABLE ulong2 convert_ulong2_sat(ulong2 v); -OVERLOADABLE int2 convert_int2_sat(ulong2 v); -OVERLOADABLE uint2 convert_uint2_sat(ulong2 v); -OVERLOADABLE short2 convert_short2_sat(ulong2 v); -OVERLOADABLE ushort2 convert_ushort2_sat(ulong2 v); -OVERLOADABLE char2 convert_char2_sat(ulong2 v); -OVERLOADABLE uchar2 convert_uchar2_sat(ulong2 v); -OVERLOADABLE long2 convert_long2_sat(int2 v); -OVERLOADABLE ulong2 convert_ulong2_sat(int2 v); -OVERLOADABLE int2 convert_int2_sat(int2 v); -OVERLOADABLE uint2 convert_uint2_sat(int2 v); -OVERLOADABLE short2 convert_short2_sat(int2 v); -OVERLOADABLE ushort2 convert_ushort2_sat(int2 v); -OVERLOADABLE char2 convert_char2_sat(int2 v); -OVERLOADABLE uchar2 convert_uchar2_sat(int2 v); -OVERLOADABLE long2 convert_long2_sat(uint2 v); -OVERLOADABLE ulong2 convert_ulong2_sat(uint2 v); -OVERLOADABLE int2 convert_int2_sat(uint2 v); -OVERLOADABLE uint2 convert_uint2_sat(uint2 v); -OVERLOADABLE short2 convert_short2_sat(uint2 v); -OVERLOADABLE ushort2 convert_ushort2_sat(uint2 v); -OVERLOADABLE char2 convert_char2_sat(uint2 v); -OVERLOADABLE uchar2 convert_uchar2_sat(uint2 v); -OVERLOADABLE long2 convert_long2_sat(short2 v); -OVERLOADABLE ulong2 convert_ulong2_sat(short2 v); -OVERLOADABLE int2 convert_int2_sat(short2 v); -OVERLOADABLE uint2 convert_uint2_sat(short2 v); -OVERLOADABLE short2 convert_short2_sat(short2 v); -OVERLOADABLE ushort2 convert_ushort2_sat(short2 v); -OVERLOADABLE char2 convert_char2_sat(short2 v); -OVERLOADABLE uchar2 convert_uchar2_sat(short2 v); -OVERLOADABLE long2 convert_long2_sat(ushort2 v); -OVERLOADABLE ulong2 convert_ulong2_sat(ushort2 v); -OVERLOADABLE int2 convert_int2_sat(ushort2 v); -OVERLOADABLE uint2 convert_uint2_sat(ushort2 v); -OVERLOADABLE short2 convert_short2_sat(ushort2 v); -OVERLOADABLE ushort2 convert_ushort2_sat(ushort2 v); -OVERLOADABLE char2 convert_char2_sat(ushort2 v); -OVERLOADABLE uchar2 convert_uchar2_sat(ushort2 v); -OVERLOADABLE long2 convert_long2_sat(char2 v); -OVERLOADABLE ulong2 convert_ulong2_sat(char2 v); -OVERLOADABLE int2 convert_int2_sat(char2 v); -OVERLOADABLE uint2 convert_uint2_sat(char2 v); -OVERLOADABLE short2 convert_short2_sat(char2 v); -OVERLOADABLE ushort2 convert_ushort2_sat(char2 v); -OVERLOADABLE char2 convert_char2_sat(char2 v); -OVERLOADABLE uchar2 convert_uchar2_sat(char2 v); -OVERLOADABLE long2 convert_long2_sat(uchar2 v); -OVERLOADABLE ulong2 convert_ulong2_sat(uchar2 v); -OVERLOADABLE int2 convert_int2_sat(uchar2 v); -OVERLOADABLE uint2 convert_uint2_sat(uchar2 v); -OVERLOADABLE short2 convert_short2_sat(uchar2 v); -OVERLOADABLE ushort2 convert_ushort2_sat(uchar2 v); -OVERLOADABLE char2 convert_char2_sat(uchar2 v); -OVERLOADABLE uchar2 convert_uchar2_sat(uchar2 v); -OVERLOADABLE long2 convert_long2_sat(double2 v); -OVERLOADABLE ulong2 convert_ulong2_sat(double2 v); -OVERLOADABLE int2 convert_int2_sat(double2 v); -OVERLOADABLE uint2 convert_uint2_sat(double2 v); -OVERLOADABLE short2 convert_short2_sat(double2 v); -OVERLOADABLE ushort2 convert_ushort2_sat(double2 v); -OVERLOADABLE char2 convert_char2_sat(double2 v); -OVERLOADABLE uchar2 convert_uchar2_sat(double2 v); -OVERLOADABLE long2 convert_long2_sat(float2 v); -OVERLOADABLE ulong2 convert_ulong2_sat(float2 v); -OVERLOADABLE int2 convert_int2_sat(float2 v); -OVERLOADABLE uint2 convert_uint2_sat(float2 v); -OVERLOADABLE short2 convert_short2_sat(float2 v); -OVERLOADABLE ushort2 convert_ushort2_sat(float2 v); -OVERLOADABLE char2 convert_char2_sat(float2 v); -OVERLOADABLE uchar2 convert_uchar2_sat(float2 v); -OVERLOADABLE long2 convert_long2_sat(half2 v); -OVERLOADABLE ulong2 convert_ulong2_sat(half2 v); -OVERLOADABLE int2 convert_int2_sat(half2 v); -OVERLOADABLE uint2 convert_uint2_sat(half2 v); -OVERLOADABLE short2 convert_short2_sat(half2 v); -OVERLOADABLE ushort2 convert_ushort2_sat(half2 v); -OVERLOADABLE char2 convert_char2_sat(half2 v); -OVERLOADABLE uchar2 convert_uchar2_sat(half2 v); -OVERLOADABLE long3 convert_long3_sat(long3 v); -OVERLOADABLE ulong3 convert_ulong3_sat(long3 v); -OVERLOADABLE int3 convert_int3_sat(long3 v); -OVERLOADABLE uint3 convert_uint3_sat(long3 v); -OVERLOADABLE short3 convert_short3_sat(long3 v); -OVERLOADABLE ushort3 convert_ushort3_sat(long3 v); -OVERLOADABLE char3 convert_char3_sat(long3 v); -OVERLOADABLE uchar3 convert_uchar3_sat(long3 v); -OVERLOADABLE long3 convert_long3_sat(ulong3 v); -OVERLOADABLE ulong3 convert_ulong3_sat(ulong3 v); -OVERLOADABLE int3 convert_int3_sat(ulong3 v); -OVERLOADABLE uint3 convert_uint3_sat(ulong3 v); -OVERLOADABLE short3 convert_short3_sat(ulong3 v); -OVERLOADABLE ushort3 convert_ushort3_sat(ulong3 v); -OVERLOADABLE char3 convert_char3_sat(ulong3 v); -OVERLOADABLE uchar3 convert_uchar3_sat(ulong3 v); -OVERLOADABLE long3 convert_long3_sat(int3 v); -OVERLOADABLE ulong3 convert_ulong3_sat(int3 v); -OVERLOADABLE int3 convert_int3_sat(int3 v); -OVERLOADABLE uint3 convert_uint3_sat(int3 v); -OVERLOADABLE short3 convert_short3_sat(int3 v); -OVERLOADABLE ushort3 convert_ushort3_sat(int3 v); -OVERLOADABLE char3 convert_char3_sat(int3 v); -OVERLOADABLE uchar3 convert_uchar3_sat(int3 v); -OVERLOADABLE long3 convert_long3_sat(uint3 v); -OVERLOADABLE ulong3 convert_ulong3_sat(uint3 v); -OVERLOADABLE int3 convert_int3_sat(uint3 v); -OVERLOADABLE uint3 convert_uint3_sat(uint3 v); -OVERLOADABLE short3 convert_short3_sat(uint3 v); -OVERLOADABLE ushort3 convert_ushort3_sat(uint3 v); -OVERLOADABLE char3 convert_char3_sat(uint3 v); -OVERLOADABLE uchar3 convert_uchar3_sat(uint3 v); -OVERLOADABLE long3 convert_long3_sat(short3 v); -OVERLOADABLE ulong3 convert_ulong3_sat(short3 v); -OVERLOADABLE int3 convert_int3_sat(short3 v); -OVERLOADABLE uint3 convert_uint3_sat(short3 v); -OVERLOADABLE short3 convert_short3_sat(short3 v); -OVERLOADABLE ushort3 convert_ushort3_sat(short3 v); -OVERLOADABLE char3 convert_char3_sat(short3 v); -OVERLOADABLE uchar3 convert_uchar3_sat(short3 v); -OVERLOADABLE long3 convert_long3_sat(ushort3 v); -OVERLOADABLE ulong3 convert_ulong3_sat(ushort3 v); -OVERLOADABLE int3 convert_int3_sat(ushort3 v); -OVERLOADABLE uint3 convert_uint3_sat(ushort3 v); -OVERLOADABLE short3 convert_short3_sat(ushort3 v); -OVERLOADABLE ushort3 convert_ushort3_sat(ushort3 v); -OVERLOADABLE char3 convert_char3_sat(ushort3 v); -OVERLOADABLE uchar3 convert_uchar3_sat(ushort3 v); -OVERLOADABLE long3 convert_long3_sat(char3 v); -OVERLOADABLE ulong3 convert_ulong3_sat(char3 v); -OVERLOADABLE int3 convert_int3_sat(char3 v); -OVERLOADABLE uint3 convert_uint3_sat(char3 v); -OVERLOADABLE short3 convert_short3_sat(char3 v); -OVERLOADABLE ushort3 convert_ushort3_sat(char3 v); -OVERLOADABLE char3 convert_char3_sat(char3 v); -OVERLOADABLE uchar3 convert_uchar3_sat(char3 v); -OVERLOADABLE long3 convert_long3_sat(uchar3 v); -OVERLOADABLE ulong3 convert_ulong3_sat(uchar3 v); -OVERLOADABLE int3 convert_int3_sat(uchar3 v); -OVERLOADABLE uint3 convert_uint3_sat(uchar3 v); -OVERLOADABLE short3 convert_short3_sat(uchar3 v); -OVERLOADABLE ushort3 convert_ushort3_sat(uchar3 v); -OVERLOADABLE char3 convert_char3_sat(uchar3 v); -OVERLOADABLE uchar3 convert_uchar3_sat(uchar3 v); -OVERLOADABLE long3 convert_long3_sat(double3 v); -OVERLOADABLE ulong3 convert_ulong3_sat(double3 v); -OVERLOADABLE int3 convert_int3_sat(double3 v); -OVERLOADABLE uint3 convert_uint3_sat(double3 v); -OVERLOADABLE short3 convert_short3_sat(double3 v); -OVERLOADABLE ushort3 convert_ushort3_sat(double3 v); -OVERLOADABLE char3 convert_char3_sat(double3 v); -OVERLOADABLE uchar3 convert_uchar3_sat(double3 v); -OVERLOADABLE long3 convert_long3_sat(float3 v); -OVERLOADABLE ulong3 convert_ulong3_sat(float3 v); -OVERLOADABLE int3 convert_int3_sat(float3 v); -OVERLOADABLE uint3 convert_uint3_sat(float3 v); -OVERLOADABLE short3 convert_short3_sat(float3 v); -OVERLOADABLE ushort3 convert_ushort3_sat(float3 v); -OVERLOADABLE char3 convert_char3_sat(float3 v); -OVERLOADABLE uchar3 convert_uchar3_sat(float3 v); -OVERLOADABLE long3 convert_long3_sat(half3 v); -OVERLOADABLE ulong3 convert_ulong3_sat(half3 v); -OVERLOADABLE int3 convert_int3_sat(half3 v); -OVERLOADABLE uint3 convert_uint3_sat(half3 v); -OVERLOADABLE short3 convert_short3_sat(half3 v); -OVERLOADABLE ushort3 convert_ushort3_sat(half3 v); -OVERLOADABLE char3 convert_char3_sat(half3 v); -OVERLOADABLE uchar3 convert_uchar3_sat(half3 v); -OVERLOADABLE long4 convert_long4_sat(long4 v); -OVERLOADABLE ulong4 convert_ulong4_sat(long4 v); -OVERLOADABLE int4 convert_int4_sat(long4 v); -OVERLOADABLE uint4 convert_uint4_sat(long4 v); -OVERLOADABLE short4 convert_short4_sat(long4 v); -OVERLOADABLE ushort4 convert_ushort4_sat(long4 v); -OVERLOADABLE char4 convert_char4_sat(long4 v); -OVERLOADABLE uchar4 convert_uchar4_sat(long4 v); -OVERLOADABLE long4 convert_long4_sat(ulong4 v); -OVERLOADABLE ulong4 convert_ulong4_sat(ulong4 v); -OVERLOADABLE int4 convert_int4_sat(ulong4 v); -OVERLOADABLE uint4 convert_uint4_sat(ulong4 v); -OVERLOADABLE short4 convert_short4_sat(ulong4 v); -OVERLOADABLE ushort4 convert_ushort4_sat(ulong4 v); -OVERLOADABLE char4 convert_char4_sat(ulong4 v); -OVERLOADABLE uchar4 convert_uchar4_sat(ulong4 v); -OVERLOADABLE long4 convert_long4_sat(int4 v); -OVERLOADABLE ulong4 convert_ulong4_sat(int4 v); -OVERLOADABLE int4 convert_int4_sat(int4 v); -OVERLOADABLE uint4 convert_uint4_sat(int4 v); -OVERLOADABLE short4 convert_short4_sat(int4 v); -OVERLOADABLE ushort4 convert_ushort4_sat(int4 v); -OVERLOADABLE char4 convert_char4_sat(int4 v); -OVERLOADABLE uchar4 convert_uchar4_sat(int4 v); -OVERLOADABLE long4 convert_long4_sat(uint4 v); -OVERLOADABLE ulong4 convert_ulong4_sat(uint4 v); -OVERLOADABLE int4 convert_int4_sat(uint4 v); -OVERLOADABLE uint4 convert_uint4_sat(uint4 v); -OVERLOADABLE short4 convert_short4_sat(uint4 v); -OVERLOADABLE ushort4 convert_ushort4_sat(uint4 v); -OVERLOADABLE char4 convert_char4_sat(uint4 v); -OVERLOADABLE uchar4 convert_uchar4_sat(uint4 v); -OVERLOADABLE long4 convert_long4_sat(short4 v); -OVERLOADABLE ulong4 convert_ulong4_sat(short4 v); -OVERLOADABLE int4 convert_int4_sat(short4 v); -OVERLOADABLE uint4 convert_uint4_sat(short4 v); -OVERLOADABLE short4 convert_short4_sat(short4 v); -OVERLOADABLE ushort4 convert_ushort4_sat(short4 v); -OVERLOADABLE char4 convert_char4_sat(short4 v); -OVERLOADABLE uchar4 convert_uchar4_sat(short4 v); -OVERLOADABLE long4 convert_long4_sat(ushort4 v); -OVERLOADABLE ulong4 convert_ulong4_sat(ushort4 v); -OVERLOADABLE int4 convert_int4_sat(ushort4 v); -OVERLOADABLE uint4 convert_uint4_sat(ushort4 v); -OVERLOADABLE short4 convert_short4_sat(ushort4 v); -OVERLOADABLE ushort4 convert_ushort4_sat(ushort4 v); -OVERLOADABLE char4 convert_char4_sat(ushort4 v); -OVERLOADABLE uchar4 convert_uchar4_sat(ushort4 v); -OVERLOADABLE long4 convert_long4_sat(char4 v); -OVERLOADABLE ulong4 convert_ulong4_sat(char4 v); -OVERLOADABLE int4 convert_int4_sat(char4 v); -OVERLOADABLE uint4 convert_uint4_sat(char4 v); -OVERLOADABLE short4 convert_short4_sat(char4 v); -OVERLOADABLE ushort4 convert_ushort4_sat(char4 v); -OVERLOADABLE char4 convert_char4_sat(char4 v); -OVERLOADABLE uchar4 convert_uchar4_sat(char4 v); -OVERLOADABLE long4 convert_long4_sat(uchar4 v); -OVERLOADABLE ulong4 convert_ulong4_sat(uchar4 v); -OVERLOADABLE int4 convert_int4_sat(uchar4 v); -OVERLOADABLE uint4 convert_uint4_sat(uchar4 v); -OVERLOADABLE short4 convert_short4_sat(uchar4 v); -OVERLOADABLE ushort4 convert_ushort4_sat(uchar4 v); -OVERLOADABLE char4 convert_char4_sat(uchar4 v); -OVERLOADABLE uchar4 convert_uchar4_sat(uchar4 v); -OVERLOADABLE long4 convert_long4_sat(double4 v); -OVERLOADABLE ulong4 convert_ulong4_sat(double4 v); -OVERLOADABLE int4 convert_int4_sat(double4 v); -OVERLOADABLE uint4 convert_uint4_sat(double4 v); -OVERLOADABLE short4 convert_short4_sat(double4 v); -OVERLOADABLE ushort4 convert_ushort4_sat(double4 v); -OVERLOADABLE char4 convert_char4_sat(double4 v); -OVERLOADABLE uchar4 convert_uchar4_sat(double4 v); -OVERLOADABLE long4 convert_long4_sat(float4 v); -OVERLOADABLE ulong4 convert_ulong4_sat(float4 v); -OVERLOADABLE int4 convert_int4_sat(float4 v); -OVERLOADABLE uint4 convert_uint4_sat(float4 v); -OVERLOADABLE short4 convert_short4_sat(float4 v); -OVERLOADABLE ushort4 convert_ushort4_sat(float4 v); -OVERLOADABLE char4 convert_char4_sat(float4 v); -OVERLOADABLE uchar4 convert_uchar4_sat(float4 v); -OVERLOADABLE long4 convert_long4_sat(half4 v); -OVERLOADABLE ulong4 convert_ulong4_sat(half4 v); -OVERLOADABLE int4 convert_int4_sat(half4 v); -OVERLOADABLE uint4 convert_uint4_sat(half4 v); -OVERLOADABLE short4 convert_short4_sat(half4 v); -OVERLOADABLE ushort4 convert_ushort4_sat(half4 v); -OVERLOADABLE char4 convert_char4_sat(half4 v); -OVERLOADABLE uchar4 convert_uchar4_sat(half4 v); -OVERLOADABLE long8 convert_long8_sat(long8 v); -OVERLOADABLE ulong8 convert_ulong8_sat(long8 v); -OVERLOADABLE int8 convert_int8_sat(long8 v); -OVERLOADABLE uint8 convert_uint8_sat(long8 v); -OVERLOADABLE short8 convert_short8_sat(long8 v); -OVERLOADABLE ushort8 convert_ushort8_sat(long8 v); -OVERLOADABLE char8 convert_char8_sat(long8 v); -OVERLOADABLE uchar8 convert_uchar8_sat(long8 v); -OVERLOADABLE long8 convert_long8_sat(ulong8 v); -OVERLOADABLE ulong8 convert_ulong8_sat(ulong8 v); -OVERLOADABLE int8 convert_int8_sat(ulong8 v); -OVERLOADABLE uint8 convert_uint8_sat(ulong8 v); -OVERLOADABLE short8 convert_short8_sat(ulong8 v); -OVERLOADABLE ushort8 convert_ushort8_sat(ulong8 v); -OVERLOADABLE char8 convert_char8_sat(ulong8 v); -OVERLOADABLE uchar8 convert_uchar8_sat(ulong8 v); -OVERLOADABLE long8 convert_long8_sat(int8 v); -OVERLOADABLE ulong8 convert_ulong8_sat(int8 v); -OVERLOADABLE int8 convert_int8_sat(int8 v); -OVERLOADABLE uint8 convert_uint8_sat(int8 v); -OVERLOADABLE short8 convert_short8_sat(int8 v); -OVERLOADABLE ushort8 convert_ushort8_sat(int8 v); -OVERLOADABLE char8 convert_char8_sat(int8 v); -OVERLOADABLE uchar8 convert_uchar8_sat(int8 v); -OVERLOADABLE long8 convert_long8_sat(uint8 v); -OVERLOADABLE ulong8 convert_ulong8_sat(uint8 v); -OVERLOADABLE int8 convert_int8_sat(uint8 v); -OVERLOADABLE uint8 convert_uint8_sat(uint8 v); -OVERLOADABLE short8 convert_short8_sat(uint8 v); -OVERLOADABLE ushort8 convert_ushort8_sat(uint8 v); -OVERLOADABLE char8 convert_char8_sat(uint8 v); -OVERLOADABLE uchar8 convert_uchar8_sat(uint8 v); -OVERLOADABLE long8 convert_long8_sat(short8 v); -OVERLOADABLE ulong8 convert_ulong8_sat(short8 v); -OVERLOADABLE int8 convert_int8_sat(short8 v); -OVERLOADABLE uint8 convert_uint8_sat(short8 v); -OVERLOADABLE short8 convert_short8_sat(short8 v); -OVERLOADABLE ushort8 convert_ushort8_sat(short8 v); -OVERLOADABLE char8 convert_char8_sat(short8 v); -OVERLOADABLE uchar8 convert_uchar8_sat(short8 v); -OVERLOADABLE long8 convert_long8_sat(ushort8 v); -OVERLOADABLE ulong8 convert_ulong8_sat(ushort8 v); -OVERLOADABLE int8 convert_int8_sat(ushort8 v); -OVERLOADABLE uint8 convert_uint8_sat(ushort8 v); -OVERLOADABLE short8 convert_short8_sat(ushort8 v); -OVERLOADABLE ushort8 convert_ushort8_sat(ushort8 v); -OVERLOADABLE char8 convert_char8_sat(ushort8 v); -OVERLOADABLE uchar8 convert_uchar8_sat(ushort8 v); -OVERLOADABLE long8 convert_long8_sat(char8 v); -OVERLOADABLE ulong8 convert_ulong8_sat(char8 v); -OVERLOADABLE int8 convert_int8_sat(char8 v); -OVERLOADABLE uint8 convert_uint8_sat(char8 v); -OVERLOADABLE short8 convert_short8_sat(char8 v); -OVERLOADABLE ushort8 convert_ushort8_sat(char8 v); -OVERLOADABLE char8 convert_char8_sat(char8 v); -OVERLOADABLE uchar8 convert_uchar8_sat(char8 v); -OVERLOADABLE long8 convert_long8_sat(uchar8 v); -OVERLOADABLE ulong8 convert_ulong8_sat(uchar8 v); -OVERLOADABLE int8 convert_int8_sat(uchar8 v); -OVERLOADABLE uint8 convert_uint8_sat(uchar8 v); -OVERLOADABLE short8 convert_short8_sat(uchar8 v); -OVERLOADABLE ushort8 convert_ushort8_sat(uchar8 v); -OVERLOADABLE char8 convert_char8_sat(uchar8 v); -OVERLOADABLE uchar8 convert_uchar8_sat(uchar8 v); -OVERLOADABLE long8 convert_long8_sat(double8 v); -OVERLOADABLE ulong8 convert_ulong8_sat(double8 v); -OVERLOADABLE int8 convert_int8_sat(double8 v); -OVERLOADABLE uint8 convert_uint8_sat(double8 v); -OVERLOADABLE short8 convert_short8_sat(double8 v); -OVERLOADABLE ushort8 convert_ushort8_sat(double8 v); -OVERLOADABLE char8 convert_char8_sat(double8 v); -OVERLOADABLE uchar8 convert_uchar8_sat(double8 v); -OVERLOADABLE long8 convert_long8_sat(float8 v); -OVERLOADABLE ulong8 convert_ulong8_sat(float8 v); -OVERLOADABLE int8 convert_int8_sat(float8 v); -OVERLOADABLE uint8 convert_uint8_sat(float8 v); -OVERLOADABLE short8 convert_short8_sat(float8 v); -OVERLOADABLE ushort8 convert_ushort8_sat(float8 v); -OVERLOADABLE char8 convert_char8_sat(float8 v); -OVERLOADABLE uchar8 convert_uchar8_sat(float8 v); -OVERLOADABLE long8 convert_long8_sat(half8 v); -OVERLOADABLE ulong8 convert_ulong8_sat(half8 v); -OVERLOADABLE int8 convert_int8_sat(half8 v); -OVERLOADABLE uint8 convert_uint8_sat(half8 v); -OVERLOADABLE short8 convert_short8_sat(half8 v); -OVERLOADABLE ushort8 convert_ushort8_sat(half8 v); -OVERLOADABLE char8 convert_char8_sat(half8 v); -OVERLOADABLE uchar8 convert_uchar8_sat(half8 v); -OVERLOADABLE long16 convert_long16_sat(long16 v); -OVERLOADABLE ulong16 convert_ulong16_sat(long16 v); -OVERLOADABLE int16 convert_int16_sat(long16 v); -OVERLOADABLE uint16 convert_uint16_sat(long16 v); -OVERLOADABLE short16 convert_short16_sat(long16 v); -OVERLOADABLE ushort16 convert_ushort16_sat(long16 v); -OVERLOADABLE char16 convert_char16_sat(long16 v); -OVERLOADABLE uchar16 convert_uchar16_sat(long16 v); -OVERLOADABLE long16 convert_long16_sat(ulong16 v); -OVERLOADABLE ulong16 convert_ulong16_sat(ulong16 v); -OVERLOADABLE int16 convert_int16_sat(ulong16 v); -OVERLOADABLE uint16 convert_uint16_sat(ulong16 v); -OVERLOADABLE short16 convert_short16_sat(ulong16 v); -OVERLOADABLE ushort16 convert_ushort16_sat(ulong16 v); -OVERLOADABLE char16 convert_char16_sat(ulong16 v); -OVERLOADABLE uchar16 convert_uchar16_sat(ulong16 v); -OVERLOADABLE long16 convert_long16_sat(int16 v); -OVERLOADABLE ulong16 convert_ulong16_sat(int16 v); -OVERLOADABLE int16 convert_int16_sat(int16 v); -OVERLOADABLE uint16 convert_uint16_sat(int16 v); -OVERLOADABLE short16 convert_short16_sat(int16 v); -OVERLOADABLE ushort16 convert_ushort16_sat(int16 v); -OVERLOADABLE char16 convert_char16_sat(int16 v); -OVERLOADABLE uchar16 convert_uchar16_sat(int16 v); -OVERLOADABLE long16 convert_long16_sat(uint16 v); -OVERLOADABLE ulong16 convert_ulong16_sat(uint16 v); -OVERLOADABLE int16 convert_int16_sat(uint16 v); -OVERLOADABLE uint16 convert_uint16_sat(uint16 v); -OVERLOADABLE short16 convert_short16_sat(uint16 v); -OVERLOADABLE ushort16 convert_ushort16_sat(uint16 v); -OVERLOADABLE char16 convert_char16_sat(uint16 v); -OVERLOADABLE uchar16 convert_uchar16_sat(uint16 v); -OVERLOADABLE long16 convert_long16_sat(short16 v); -OVERLOADABLE ulong16 convert_ulong16_sat(short16 v); -OVERLOADABLE int16 convert_int16_sat(short16 v); -OVERLOADABLE uint16 convert_uint16_sat(short16 v); -OVERLOADABLE short16 convert_short16_sat(short16 v); -OVERLOADABLE ushort16 convert_ushort16_sat(short16 v); -OVERLOADABLE char16 convert_char16_sat(short16 v); -OVERLOADABLE uchar16 convert_uchar16_sat(short16 v); -OVERLOADABLE long16 convert_long16_sat(ushort16 v); -OVERLOADABLE ulong16 convert_ulong16_sat(ushort16 v); -OVERLOADABLE int16 convert_int16_sat(ushort16 v); -OVERLOADABLE uint16 convert_uint16_sat(ushort16 v); -OVERLOADABLE short16 convert_short16_sat(ushort16 v); -OVERLOADABLE ushort16 convert_ushort16_sat(ushort16 v); -OVERLOADABLE char16 convert_char16_sat(ushort16 v); -OVERLOADABLE uchar16 convert_uchar16_sat(ushort16 v); -OVERLOADABLE long16 convert_long16_sat(char16 v); -OVERLOADABLE ulong16 convert_ulong16_sat(char16 v); -OVERLOADABLE int16 convert_int16_sat(char16 v); -OVERLOADABLE uint16 convert_uint16_sat(char16 v); -OVERLOADABLE short16 convert_short16_sat(char16 v); -OVERLOADABLE ushort16 convert_ushort16_sat(char16 v); -OVERLOADABLE char16 convert_char16_sat(char16 v); -OVERLOADABLE uchar16 convert_uchar16_sat(char16 v); -OVERLOADABLE long16 convert_long16_sat(uchar16 v); -OVERLOADABLE ulong16 convert_ulong16_sat(uchar16 v); -OVERLOADABLE int16 convert_int16_sat(uchar16 v); -OVERLOADABLE uint16 convert_uint16_sat(uchar16 v); -OVERLOADABLE short16 convert_short16_sat(uchar16 v); -OVERLOADABLE ushort16 convert_ushort16_sat(uchar16 v); -OVERLOADABLE char16 convert_char16_sat(uchar16 v); -OVERLOADABLE uchar16 convert_uchar16_sat(uchar16 v); -OVERLOADABLE long16 convert_long16_sat(double16 v); -OVERLOADABLE ulong16 convert_ulong16_sat(double16 v); -OVERLOADABLE int16 convert_int16_sat(double16 v); -OVERLOADABLE uint16 convert_uint16_sat(double16 v); -OVERLOADABLE short16 convert_short16_sat(double16 v); -OVERLOADABLE ushort16 convert_ushort16_sat(double16 v); -OVERLOADABLE char16 convert_char16_sat(double16 v); -OVERLOADABLE uchar16 convert_uchar16_sat(double16 v); -OVERLOADABLE long16 convert_long16_sat(float16 v); -OVERLOADABLE ulong16 convert_ulong16_sat(float16 v); -OVERLOADABLE int16 convert_int16_sat(float16 v); -OVERLOADABLE uint16 convert_uint16_sat(float16 v); -OVERLOADABLE short16 convert_short16_sat(float16 v); -OVERLOADABLE ushort16 convert_ushort16_sat(float16 v); -OVERLOADABLE char16 convert_char16_sat(float16 v); -OVERLOADABLE uchar16 convert_uchar16_sat(float16 v); -OVERLOADABLE long16 convert_long16_sat(half16 v); -OVERLOADABLE ulong16 convert_ulong16_sat(half16 v); -OVERLOADABLE int16 convert_int16_sat(half16 v); -OVERLOADABLE uint16 convert_uint16_sat(half16 v); -OVERLOADABLE short16 convert_short16_sat(half16 v); -OVERLOADABLE ushort16 convert_ushort16_sat(half16 v); -OVERLOADABLE char16 convert_char16_sat(half16 v); -OVERLOADABLE uchar16 convert_uchar16_sat(half16 v); -OVERLOADABLE long convert_long_rte(long x); -OVERLOADABLE long convert_long_rtz(long x); -OVERLOADABLE long convert_long_rtp(long x); -OVERLOADABLE long convert_long_rtn(long x); -OVERLOADABLE ulong convert_ulong_rte(long x); -OVERLOADABLE ulong convert_ulong_rtz(long x); -OVERLOADABLE ulong convert_ulong_rtp(long x); -OVERLOADABLE ulong convert_ulong_rtn(long x); -OVERLOADABLE int convert_int_rte(long x); -OVERLOADABLE int convert_int_rtz(long x); -OVERLOADABLE int convert_int_rtp(long x); -OVERLOADABLE int convert_int_rtn(long x); -OVERLOADABLE uint convert_uint_rte(long x); -OVERLOADABLE uint convert_uint_rtz(long x); -OVERLOADABLE uint convert_uint_rtp(long x); -OVERLOADABLE uint convert_uint_rtn(long x); -OVERLOADABLE short convert_short_rte(long x); -OVERLOADABLE short convert_short_rtz(long x); -OVERLOADABLE short convert_short_rtp(long x); -OVERLOADABLE short convert_short_rtn(long x); -OVERLOADABLE ushort convert_ushort_rte(long x); -OVERLOADABLE ushort convert_ushort_rtz(long x); -OVERLOADABLE ushort convert_ushort_rtp(long x); -OVERLOADABLE ushort convert_ushort_rtn(long x); -OVERLOADABLE char convert_char_rte(long x); -OVERLOADABLE char convert_char_rtz(long x); -OVERLOADABLE char convert_char_rtp(long x); -OVERLOADABLE char convert_char_rtn(long x); -OVERLOADABLE uchar convert_uchar_rte(long x); -OVERLOADABLE uchar convert_uchar_rtz(long x); -OVERLOADABLE uchar convert_uchar_rtp(long x); -OVERLOADABLE uchar convert_uchar_rtn(long x); -OVERLOADABLE float convert_float_rte(long x); -OVERLOADABLE float convert_float_rtz(long x); -OVERLOADABLE float convert_float_rtp(long x); -OVERLOADABLE float convert_float_rtn(long x); -OVERLOADABLE half convert_half_rte(long x); -OVERLOADABLE half convert_half_rtz(long x); -OVERLOADABLE half convert_half_rtp(long x); -OVERLOADABLE half convert_half_rtn(long x); -OVERLOADABLE long convert_long_rte(ulong x); -OVERLOADABLE long convert_long_rtz(ulong x); -OVERLOADABLE long convert_long_rtp(ulong x); -OVERLOADABLE long convert_long_rtn(ulong x); -OVERLOADABLE ulong convert_ulong_rte(ulong x); -OVERLOADABLE ulong convert_ulong_rtz(ulong x); -OVERLOADABLE ulong convert_ulong_rtp(ulong x); -OVERLOADABLE ulong convert_ulong_rtn(ulong x); -OVERLOADABLE int convert_int_rte(ulong x); -OVERLOADABLE int convert_int_rtz(ulong x); -OVERLOADABLE int convert_int_rtp(ulong x); -OVERLOADABLE int convert_int_rtn(ulong x); -OVERLOADABLE uint convert_uint_rte(ulong x); -OVERLOADABLE uint convert_uint_rtz(ulong x); -OVERLOADABLE uint convert_uint_rtp(ulong x); -OVERLOADABLE uint convert_uint_rtn(ulong x); -OVERLOADABLE short convert_short_rte(ulong x); -OVERLOADABLE short convert_short_rtz(ulong x); -OVERLOADABLE short convert_short_rtp(ulong x); -OVERLOADABLE short convert_short_rtn(ulong x); -OVERLOADABLE ushort convert_ushort_rte(ulong x); -OVERLOADABLE ushort convert_ushort_rtz(ulong x); -OVERLOADABLE ushort convert_ushort_rtp(ulong x); -OVERLOADABLE ushort convert_ushort_rtn(ulong x); -OVERLOADABLE char convert_char_rte(ulong x); -OVERLOADABLE char convert_char_rtz(ulong x); -OVERLOADABLE char convert_char_rtp(ulong x); -OVERLOADABLE char convert_char_rtn(ulong x); -OVERLOADABLE uchar convert_uchar_rte(ulong x); -OVERLOADABLE uchar convert_uchar_rtz(ulong x); -OVERLOADABLE uchar convert_uchar_rtp(ulong x); -OVERLOADABLE uchar convert_uchar_rtn(ulong x); -OVERLOADABLE float convert_float_rte(ulong x); -OVERLOADABLE float convert_float_rtz(ulong x); -OVERLOADABLE float convert_float_rtp(ulong x); -OVERLOADABLE float convert_float_rtn(ulong x); -OVERLOADABLE half convert_half_rte(ulong x); -OVERLOADABLE half convert_half_rtz(ulong x); -OVERLOADABLE half convert_half_rtp(ulong x); -OVERLOADABLE half convert_half_rtn(ulong x); -OVERLOADABLE long convert_long_rte(int x); -OVERLOADABLE long convert_long_rtz(int x); -OVERLOADABLE long convert_long_rtp(int x); -OVERLOADABLE long convert_long_rtn(int x); -OVERLOADABLE ulong convert_ulong_rte(int x); -OVERLOADABLE ulong convert_ulong_rtz(int x); -OVERLOADABLE ulong convert_ulong_rtp(int x); -OVERLOADABLE ulong convert_ulong_rtn(int x); -OVERLOADABLE int convert_int_rte(int x); -OVERLOADABLE int convert_int_rtz(int x); -OVERLOADABLE int convert_int_rtp(int x); -OVERLOADABLE int convert_int_rtn(int x); -OVERLOADABLE uint convert_uint_rte(int x); -OVERLOADABLE uint convert_uint_rtz(int x); -OVERLOADABLE uint convert_uint_rtp(int x); -OVERLOADABLE uint convert_uint_rtn(int x); -OVERLOADABLE short convert_short_rte(int x); -OVERLOADABLE short convert_short_rtz(int x); -OVERLOADABLE short convert_short_rtp(int x); -OVERLOADABLE short convert_short_rtn(int x); -OVERLOADABLE ushort convert_ushort_rte(int x); -OVERLOADABLE ushort convert_ushort_rtz(int x); -OVERLOADABLE ushort convert_ushort_rtp(int x); -OVERLOADABLE ushort convert_ushort_rtn(int x); -OVERLOADABLE char convert_char_rte(int x); -OVERLOADABLE char convert_char_rtz(int x); -OVERLOADABLE char convert_char_rtp(int x); -OVERLOADABLE char convert_char_rtn(int x); -OVERLOADABLE uchar convert_uchar_rte(int x); -OVERLOADABLE uchar convert_uchar_rtz(int x); -OVERLOADABLE uchar convert_uchar_rtp(int x); -OVERLOADABLE uchar convert_uchar_rtn(int x); -OVERLOADABLE float convert_float_rte(int x); -OVERLOADABLE float convert_float_rtz(int x); -OVERLOADABLE float convert_float_rtp(int x); -OVERLOADABLE float convert_float_rtn(int x); -OVERLOADABLE half convert_half_rte(int x); -OVERLOADABLE half convert_half_rtz(int x); -OVERLOADABLE half convert_half_rtp(int x); -OVERLOADABLE half convert_half_rtn(int x); -OVERLOADABLE long convert_long_rte(uint x); -OVERLOADABLE long convert_long_rtz(uint x); -OVERLOADABLE long convert_long_rtp(uint x); -OVERLOADABLE long convert_long_rtn(uint x); -OVERLOADABLE ulong convert_ulong_rte(uint x); -OVERLOADABLE ulong convert_ulong_rtz(uint x); -OVERLOADABLE ulong convert_ulong_rtp(uint x); -OVERLOADABLE ulong convert_ulong_rtn(uint x); -OVERLOADABLE int convert_int_rte(uint x); -OVERLOADABLE int convert_int_rtz(uint x); -OVERLOADABLE int convert_int_rtp(uint x); -OVERLOADABLE int convert_int_rtn(uint x); -OVERLOADABLE uint convert_uint_rte(uint x); -OVERLOADABLE uint convert_uint_rtz(uint x); -OVERLOADABLE uint convert_uint_rtp(uint x); -OVERLOADABLE uint convert_uint_rtn(uint x); -OVERLOADABLE short convert_short_rte(uint x); -OVERLOADABLE short convert_short_rtz(uint x); -OVERLOADABLE short convert_short_rtp(uint x); -OVERLOADABLE short convert_short_rtn(uint x); -OVERLOADABLE ushort convert_ushort_rte(uint x); -OVERLOADABLE ushort convert_ushort_rtz(uint x); -OVERLOADABLE ushort convert_ushort_rtp(uint x); -OVERLOADABLE ushort convert_ushort_rtn(uint x); -OVERLOADABLE char convert_char_rte(uint x); -OVERLOADABLE char convert_char_rtz(uint x); -OVERLOADABLE char convert_char_rtp(uint x); -OVERLOADABLE char convert_char_rtn(uint x); -OVERLOADABLE uchar convert_uchar_rte(uint x); -OVERLOADABLE uchar convert_uchar_rtz(uint x); -OVERLOADABLE uchar convert_uchar_rtp(uint x); -OVERLOADABLE uchar convert_uchar_rtn(uint x); -OVERLOADABLE float convert_float_rte(uint x); -OVERLOADABLE float convert_float_rtz(uint x); -OVERLOADABLE float convert_float_rtp(uint x); -OVERLOADABLE float convert_float_rtn(uint x); -OVERLOADABLE half convert_half_rte(uint x); -OVERLOADABLE half convert_half_rtz(uint x); -OVERLOADABLE half convert_half_rtp(uint x); -OVERLOADABLE half convert_half_rtn(uint x); -OVERLOADABLE long convert_long_rte(short x); -OVERLOADABLE long convert_long_rtz(short x); -OVERLOADABLE long convert_long_rtp(short x); -OVERLOADABLE long convert_long_rtn(short x); -OVERLOADABLE ulong convert_ulong_rte(short x); -OVERLOADABLE ulong convert_ulong_rtz(short x); -OVERLOADABLE ulong convert_ulong_rtp(short x); -OVERLOADABLE ulong convert_ulong_rtn(short x); -OVERLOADABLE int convert_int_rte(short x); -OVERLOADABLE int convert_int_rtz(short x); -OVERLOADABLE int convert_int_rtp(short x); -OVERLOADABLE int convert_int_rtn(short x); -OVERLOADABLE uint convert_uint_rte(short x); -OVERLOADABLE uint convert_uint_rtz(short x); -OVERLOADABLE uint convert_uint_rtp(short x); -OVERLOADABLE uint convert_uint_rtn(short x); -OVERLOADABLE short convert_short_rte(short x); -OVERLOADABLE short convert_short_rtz(short x); -OVERLOADABLE short convert_short_rtp(short x); -OVERLOADABLE short convert_short_rtn(short x); -OVERLOADABLE ushort convert_ushort_rte(short x); -OVERLOADABLE ushort convert_ushort_rtz(short x); -OVERLOADABLE ushort convert_ushort_rtp(short x); -OVERLOADABLE ushort convert_ushort_rtn(short x); -OVERLOADABLE char convert_char_rte(short x); -OVERLOADABLE char convert_char_rtz(short x); -OVERLOADABLE char convert_char_rtp(short x); -OVERLOADABLE char convert_char_rtn(short x); -OVERLOADABLE uchar convert_uchar_rte(short x); -OVERLOADABLE uchar convert_uchar_rtz(short x); -OVERLOADABLE uchar convert_uchar_rtp(short x); -OVERLOADABLE uchar convert_uchar_rtn(short x); -OVERLOADABLE float convert_float_rte(short x); -OVERLOADABLE float convert_float_rtz(short x); -OVERLOADABLE float convert_float_rtp(short x); -OVERLOADABLE float convert_float_rtn(short x); -OVERLOADABLE half convert_half_rte(short x); -OVERLOADABLE half convert_half_rtz(short x); -OVERLOADABLE half convert_half_rtp(short x); -OVERLOADABLE half convert_half_rtn(short x); -OVERLOADABLE long convert_long_rte(ushort x); -OVERLOADABLE long convert_long_rtz(ushort x); -OVERLOADABLE long convert_long_rtp(ushort x); -OVERLOADABLE long convert_long_rtn(ushort x); -OVERLOADABLE ulong convert_ulong_rte(ushort x); -OVERLOADABLE ulong convert_ulong_rtz(ushort x); -OVERLOADABLE ulong convert_ulong_rtp(ushort x); -OVERLOADABLE ulong convert_ulong_rtn(ushort x); -OVERLOADABLE int convert_int_rte(ushort x); -OVERLOADABLE int convert_int_rtz(ushort x); -OVERLOADABLE int convert_int_rtp(ushort x); -OVERLOADABLE int convert_int_rtn(ushort x); -OVERLOADABLE uint convert_uint_rte(ushort x); -OVERLOADABLE uint convert_uint_rtz(ushort x); -OVERLOADABLE uint convert_uint_rtp(ushort x); -OVERLOADABLE uint convert_uint_rtn(ushort x); -OVERLOADABLE short convert_short_rte(ushort x); -OVERLOADABLE short convert_short_rtz(ushort x); -OVERLOADABLE short convert_short_rtp(ushort x); -OVERLOADABLE short convert_short_rtn(ushort x); -OVERLOADABLE ushort convert_ushort_rte(ushort x); -OVERLOADABLE ushort convert_ushort_rtz(ushort x); -OVERLOADABLE ushort convert_ushort_rtp(ushort x); -OVERLOADABLE ushort convert_ushort_rtn(ushort x); -OVERLOADABLE char convert_char_rte(ushort x); -OVERLOADABLE char convert_char_rtz(ushort x); -OVERLOADABLE char convert_char_rtp(ushort x); -OVERLOADABLE char convert_char_rtn(ushort x); -OVERLOADABLE uchar convert_uchar_rte(ushort x); -OVERLOADABLE uchar convert_uchar_rtz(ushort x); -OVERLOADABLE uchar convert_uchar_rtp(ushort x); -OVERLOADABLE uchar convert_uchar_rtn(ushort x); -OVERLOADABLE float convert_float_rte(ushort x); -OVERLOADABLE float convert_float_rtz(ushort x); -OVERLOADABLE float convert_float_rtp(ushort x); -OVERLOADABLE float convert_float_rtn(ushort x); -OVERLOADABLE half convert_half_rte(ushort x); -OVERLOADABLE half convert_half_rtz(ushort x); -OVERLOADABLE half convert_half_rtp(ushort x); -OVERLOADABLE half convert_half_rtn(ushort x); -OVERLOADABLE long convert_long_rte(char x); -OVERLOADABLE long convert_long_rtz(char x); -OVERLOADABLE long convert_long_rtp(char x); -OVERLOADABLE long convert_long_rtn(char x); -OVERLOADABLE ulong convert_ulong_rte(char x); -OVERLOADABLE ulong convert_ulong_rtz(char x); -OVERLOADABLE ulong convert_ulong_rtp(char x); -OVERLOADABLE ulong convert_ulong_rtn(char x); -OVERLOADABLE int convert_int_rte(char x); -OVERLOADABLE int convert_int_rtz(char x); -OVERLOADABLE int convert_int_rtp(char x); -OVERLOADABLE int convert_int_rtn(char x); -OVERLOADABLE uint convert_uint_rte(char x); -OVERLOADABLE uint convert_uint_rtz(char x); -OVERLOADABLE uint convert_uint_rtp(char x); -OVERLOADABLE uint convert_uint_rtn(char x); -OVERLOADABLE short convert_short_rte(char x); -OVERLOADABLE short convert_short_rtz(char x); -OVERLOADABLE short convert_short_rtp(char x); -OVERLOADABLE short convert_short_rtn(char x); -OVERLOADABLE ushort convert_ushort_rte(char x); -OVERLOADABLE ushort convert_ushort_rtz(char x); -OVERLOADABLE ushort convert_ushort_rtp(char x); -OVERLOADABLE ushort convert_ushort_rtn(char x); -OVERLOADABLE char convert_char_rte(char x); -OVERLOADABLE char convert_char_rtz(char x); -OVERLOADABLE char convert_char_rtp(char x); -OVERLOADABLE char convert_char_rtn(char x); -OVERLOADABLE uchar convert_uchar_rte(char x); -OVERLOADABLE uchar convert_uchar_rtz(char x); -OVERLOADABLE uchar convert_uchar_rtp(char x); -OVERLOADABLE uchar convert_uchar_rtn(char x); -OVERLOADABLE float convert_float_rte(char x); -OVERLOADABLE float convert_float_rtz(char x); -OVERLOADABLE float convert_float_rtp(char x); -OVERLOADABLE float convert_float_rtn(char x); -OVERLOADABLE half convert_half_rte(char x); -OVERLOADABLE half convert_half_rtz(char x); -OVERLOADABLE half convert_half_rtp(char x); -OVERLOADABLE half convert_half_rtn(char x); -OVERLOADABLE long convert_long_rte(uchar x); -OVERLOADABLE long convert_long_rtz(uchar x); -OVERLOADABLE long convert_long_rtp(uchar x); -OVERLOADABLE long convert_long_rtn(uchar x); -OVERLOADABLE ulong convert_ulong_rte(uchar x); -OVERLOADABLE ulong convert_ulong_rtz(uchar x); -OVERLOADABLE ulong convert_ulong_rtp(uchar x); -OVERLOADABLE ulong convert_ulong_rtn(uchar x); -OVERLOADABLE int convert_int_rte(uchar x); -OVERLOADABLE int convert_int_rtz(uchar x); -OVERLOADABLE int convert_int_rtp(uchar x); -OVERLOADABLE int convert_int_rtn(uchar x); -OVERLOADABLE uint convert_uint_rte(uchar x); -OVERLOADABLE uint convert_uint_rtz(uchar x); -OVERLOADABLE uint convert_uint_rtp(uchar x); -OVERLOADABLE uint convert_uint_rtn(uchar x); -OVERLOADABLE short convert_short_rte(uchar x); -OVERLOADABLE short convert_short_rtz(uchar x); -OVERLOADABLE short convert_short_rtp(uchar x); -OVERLOADABLE short convert_short_rtn(uchar x); -OVERLOADABLE ushort convert_ushort_rte(uchar x); -OVERLOADABLE ushort convert_ushort_rtz(uchar x); -OVERLOADABLE ushort convert_ushort_rtp(uchar x); -OVERLOADABLE ushort convert_ushort_rtn(uchar x); -OVERLOADABLE char convert_char_rte(uchar x); -OVERLOADABLE char convert_char_rtz(uchar x); -OVERLOADABLE char convert_char_rtp(uchar x); -OVERLOADABLE char convert_char_rtn(uchar x); -OVERLOADABLE uchar convert_uchar_rte(uchar x); -OVERLOADABLE uchar convert_uchar_rtz(uchar x); -OVERLOADABLE uchar convert_uchar_rtp(uchar x); -OVERLOADABLE uchar convert_uchar_rtn(uchar x); -OVERLOADABLE float convert_float_rte(uchar x); -OVERLOADABLE float convert_float_rtz(uchar x); -OVERLOADABLE float convert_float_rtp(uchar x); -OVERLOADABLE float convert_float_rtn(uchar x); -OVERLOADABLE half convert_half_rte(uchar x); -OVERLOADABLE half convert_half_rtz(uchar x); -OVERLOADABLE half convert_half_rtp(uchar x); -OVERLOADABLE half convert_half_rtn(uchar x); -OVERLOADABLE long convert_long_rte(double x); -OVERLOADABLE long convert_long_rtz(double x); -OVERLOADABLE long convert_long_rtp(double x); -OVERLOADABLE long convert_long_rtn(double x); -OVERLOADABLE ulong convert_ulong_rte(double x); -OVERLOADABLE ulong convert_ulong_rtz(double x); -OVERLOADABLE ulong convert_ulong_rtp(double x); -OVERLOADABLE ulong convert_ulong_rtn(double x); -OVERLOADABLE int convert_int_rte(double x); -OVERLOADABLE int convert_int_rtz(double x); -OVERLOADABLE int convert_int_rtp(double x); -OVERLOADABLE int convert_int_rtn(double x); -OVERLOADABLE uint convert_uint_rte(double x); -OVERLOADABLE uint convert_uint_rtz(double x); -OVERLOADABLE uint convert_uint_rtp(double x); -OVERLOADABLE uint convert_uint_rtn(double x); -OVERLOADABLE short convert_short_rte(double x); -OVERLOADABLE short convert_short_rtz(double x); -OVERLOADABLE short convert_short_rtp(double x); -OVERLOADABLE short convert_short_rtn(double x); -OVERLOADABLE ushort convert_ushort_rte(double x); -OVERLOADABLE ushort convert_ushort_rtz(double x); -OVERLOADABLE ushort convert_ushort_rtp(double x); -OVERLOADABLE ushort convert_ushort_rtn(double x); -OVERLOADABLE char convert_char_rte(double x); -OVERLOADABLE char convert_char_rtz(double x); -OVERLOADABLE char convert_char_rtp(double x); -OVERLOADABLE char convert_char_rtn(double x); -OVERLOADABLE uchar convert_uchar_rte(double x); -OVERLOADABLE uchar convert_uchar_rtz(double x); -OVERLOADABLE uchar convert_uchar_rtp(double x); -OVERLOADABLE uchar convert_uchar_rtn(double x); -OVERLOADABLE float convert_float_rte(double x); -OVERLOADABLE float convert_float_rtz(double x); -OVERLOADABLE float convert_float_rtp(double x); -OVERLOADABLE float convert_float_rtn(double x); -OVERLOADABLE half convert_half_rte(double x); -OVERLOADABLE half convert_half_rtz(double x); -OVERLOADABLE half convert_half_rtp(double x); -OVERLOADABLE half convert_half_rtn(double x); -OVERLOADABLE long convert_long_rte(float x); -OVERLOADABLE long convert_long_rtz(float x); -OVERLOADABLE long convert_long_rtp(float x); -OVERLOADABLE long convert_long_rtn(float x); -OVERLOADABLE ulong convert_ulong_rte(float x); -OVERLOADABLE ulong convert_ulong_rtz(float x); -OVERLOADABLE ulong convert_ulong_rtp(float x); -OVERLOADABLE ulong convert_ulong_rtn(float x); -OVERLOADABLE int convert_int_rte(float x); -OVERLOADABLE int convert_int_rtz(float x); -OVERLOADABLE int convert_int_rtp(float x); -OVERLOADABLE int convert_int_rtn(float x); -OVERLOADABLE uint convert_uint_rte(float x); -OVERLOADABLE uint convert_uint_rtz(float x); -OVERLOADABLE uint convert_uint_rtp(float x); -OVERLOADABLE uint convert_uint_rtn(float x); -OVERLOADABLE short convert_short_rte(float x); -OVERLOADABLE short convert_short_rtz(float x); -OVERLOADABLE short convert_short_rtp(float x); -OVERLOADABLE short convert_short_rtn(float x); -OVERLOADABLE ushort convert_ushort_rte(float x); -OVERLOADABLE ushort convert_ushort_rtz(float x); -OVERLOADABLE ushort convert_ushort_rtp(float x); -OVERLOADABLE ushort convert_ushort_rtn(float x); -OVERLOADABLE char convert_char_rte(float x); -OVERLOADABLE char convert_char_rtz(float x); -OVERLOADABLE char convert_char_rtp(float x); -OVERLOADABLE char convert_char_rtn(float x); -OVERLOADABLE uchar convert_uchar_rte(float x); -OVERLOADABLE uchar convert_uchar_rtz(float x); -OVERLOADABLE uchar convert_uchar_rtp(float x); -OVERLOADABLE uchar convert_uchar_rtn(float x); -OVERLOADABLE float convert_float_rte(float x); -OVERLOADABLE float convert_float_rtz(float x); -OVERLOADABLE float convert_float_rtp(float x); -OVERLOADABLE float convert_float_rtn(float x); -OVERLOADABLE half convert_half_rte(float x); -OVERLOADABLE half convert_half_rtz(float x); -OVERLOADABLE half convert_half_rtp(float x); -OVERLOADABLE half convert_half_rtn(float x); -OVERLOADABLE long convert_long_rte(half x); -OVERLOADABLE long convert_long_rtz(half x); -OVERLOADABLE long convert_long_rtp(half x); -OVERLOADABLE long convert_long_rtn(half x); -OVERLOADABLE ulong convert_ulong_rte(half x); -OVERLOADABLE ulong convert_ulong_rtz(half x); -OVERLOADABLE ulong convert_ulong_rtp(half x); -OVERLOADABLE ulong convert_ulong_rtn(half x); -OVERLOADABLE int convert_int_rte(half x); -OVERLOADABLE int convert_int_rtz(half x); -OVERLOADABLE int convert_int_rtp(half x); -OVERLOADABLE int convert_int_rtn(half x); -OVERLOADABLE uint convert_uint_rte(half x); -OVERLOADABLE uint convert_uint_rtz(half x); -OVERLOADABLE uint convert_uint_rtp(half x); -OVERLOADABLE uint convert_uint_rtn(half x); -OVERLOADABLE short convert_short_rte(half x); -OVERLOADABLE short convert_short_rtz(half x); -OVERLOADABLE short convert_short_rtp(half x); -OVERLOADABLE short convert_short_rtn(half x); -OVERLOADABLE ushort convert_ushort_rte(half x); -OVERLOADABLE ushort convert_ushort_rtz(half x); -OVERLOADABLE ushort convert_ushort_rtp(half x); -OVERLOADABLE ushort convert_ushort_rtn(half x); -OVERLOADABLE char convert_char_rte(half x); -OVERLOADABLE char convert_char_rtz(half x); -OVERLOADABLE char convert_char_rtp(half x); -OVERLOADABLE char convert_char_rtn(half x); -OVERLOADABLE uchar convert_uchar_rte(half x); -OVERLOADABLE uchar convert_uchar_rtz(half x); -OVERLOADABLE uchar convert_uchar_rtp(half x); -OVERLOADABLE uchar convert_uchar_rtn(half x); -OVERLOADABLE float convert_float_rte(half x); -OVERLOADABLE float convert_float_rtz(half x); -OVERLOADABLE float convert_float_rtp(half x); -OVERLOADABLE float convert_float_rtn(half x); -OVERLOADABLE half convert_half_rte(half x); -OVERLOADABLE half convert_half_rtz(half x); -OVERLOADABLE half convert_half_rtp(half x); -OVERLOADABLE half convert_half_rtn(half x); -OVERLOADABLE long2 convert_long2_rte(long2 v); -OVERLOADABLE long2 convert_long2_rtz(long2 v); -OVERLOADABLE long2 convert_long2_rtp(long2 v); -OVERLOADABLE long2 convert_long2_rtn(long2 v); -OVERLOADABLE ulong2 convert_ulong2_rte(long2 v); -OVERLOADABLE ulong2 convert_ulong2_rtz(long2 v); -OVERLOADABLE ulong2 convert_ulong2_rtp(long2 v); -OVERLOADABLE ulong2 convert_ulong2_rtn(long2 v); -OVERLOADABLE int2 convert_int2_rte(long2 v); -OVERLOADABLE int2 convert_int2_rtz(long2 v); -OVERLOADABLE int2 convert_int2_rtp(long2 v); -OVERLOADABLE int2 convert_int2_rtn(long2 v); -OVERLOADABLE uint2 convert_uint2_rte(long2 v); -OVERLOADABLE uint2 convert_uint2_rtz(long2 v); -OVERLOADABLE uint2 convert_uint2_rtp(long2 v); -OVERLOADABLE uint2 convert_uint2_rtn(long2 v); -OVERLOADABLE short2 convert_short2_rte(long2 v); -OVERLOADABLE short2 convert_short2_rtz(long2 v); -OVERLOADABLE short2 convert_short2_rtp(long2 v); -OVERLOADABLE short2 convert_short2_rtn(long2 v); -OVERLOADABLE ushort2 convert_ushort2_rte(long2 v); -OVERLOADABLE ushort2 convert_ushort2_rtz(long2 v); -OVERLOADABLE ushort2 convert_ushort2_rtp(long2 v); -OVERLOADABLE ushort2 convert_ushort2_rtn(long2 v); -OVERLOADABLE char2 convert_char2_rte(long2 v); -OVERLOADABLE char2 convert_char2_rtz(long2 v); -OVERLOADABLE char2 convert_char2_rtp(long2 v); -OVERLOADABLE char2 convert_char2_rtn(long2 v); -OVERLOADABLE uchar2 convert_uchar2_rte(long2 v); -OVERLOADABLE uchar2 convert_uchar2_rtz(long2 v); -OVERLOADABLE uchar2 convert_uchar2_rtp(long2 v); -OVERLOADABLE uchar2 convert_uchar2_rtn(long2 v); -OVERLOADABLE float2 convert_float2_rte(long2 v); -OVERLOADABLE float2 convert_float2_rtz(long2 v); -OVERLOADABLE float2 convert_float2_rtp(long2 v); -OVERLOADABLE float2 convert_float2_rtn(long2 v); -OVERLOADABLE half2 convert_half2_rte(long2 v); -OVERLOADABLE half2 convert_half2_rtz(long2 v); -OVERLOADABLE half2 convert_half2_rtp(long2 v); -OVERLOADABLE half2 convert_half2_rtn(long2 v); -OVERLOADABLE long2 convert_long2_rte(ulong2 v); -OVERLOADABLE long2 convert_long2_rtz(ulong2 v); -OVERLOADABLE long2 convert_long2_rtp(ulong2 v); -OVERLOADABLE long2 convert_long2_rtn(ulong2 v); -OVERLOADABLE ulong2 convert_ulong2_rte(ulong2 v); -OVERLOADABLE ulong2 convert_ulong2_rtz(ulong2 v); -OVERLOADABLE ulong2 convert_ulong2_rtp(ulong2 v); -OVERLOADABLE ulong2 convert_ulong2_rtn(ulong2 v); -OVERLOADABLE int2 convert_int2_rte(ulong2 v); -OVERLOADABLE int2 convert_int2_rtz(ulong2 v); -OVERLOADABLE int2 convert_int2_rtp(ulong2 v); -OVERLOADABLE int2 convert_int2_rtn(ulong2 v); -OVERLOADABLE uint2 convert_uint2_rte(ulong2 v); -OVERLOADABLE uint2 convert_uint2_rtz(ulong2 v); -OVERLOADABLE uint2 convert_uint2_rtp(ulong2 v); -OVERLOADABLE uint2 convert_uint2_rtn(ulong2 v); -OVERLOADABLE short2 convert_short2_rte(ulong2 v); -OVERLOADABLE short2 convert_short2_rtz(ulong2 v); -OVERLOADABLE short2 convert_short2_rtp(ulong2 v); -OVERLOADABLE short2 convert_short2_rtn(ulong2 v); -OVERLOADABLE ushort2 convert_ushort2_rte(ulong2 v); -OVERLOADABLE ushort2 convert_ushort2_rtz(ulong2 v); -OVERLOADABLE ushort2 convert_ushort2_rtp(ulong2 v); -OVERLOADABLE ushort2 convert_ushort2_rtn(ulong2 v); -OVERLOADABLE char2 convert_char2_rte(ulong2 v); -OVERLOADABLE char2 convert_char2_rtz(ulong2 v); -OVERLOADABLE char2 convert_char2_rtp(ulong2 v); -OVERLOADABLE char2 convert_char2_rtn(ulong2 v); -OVERLOADABLE uchar2 convert_uchar2_rte(ulong2 v); -OVERLOADABLE uchar2 convert_uchar2_rtz(ulong2 v); -OVERLOADABLE uchar2 convert_uchar2_rtp(ulong2 v); -OVERLOADABLE uchar2 convert_uchar2_rtn(ulong2 v); -OVERLOADABLE float2 convert_float2_rte(ulong2 v); -OVERLOADABLE float2 convert_float2_rtz(ulong2 v); -OVERLOADABLE float2 convert_float2_rtp(ulong2 v); -OVERLOADABLE float2 convert_float2_rtn(ulong2 v); -OVERLOADABLE half2 convert_half2_rte(ulong2 v); -OVERLOADABLE half2 convert_half2_rtz(ulong2 v); -OVERLOADABLE half2 convert_half2_rtp(ulong2 v); -OVERLOADABLE half2 convert_half2_rtn(ulong2 v); -OVERLOADABLE long2 convert_long2_rte(int2 v); -OVERLOADABLE long2 convert_long2_rtz(int2 v); -OVERLOADABLE long2 convert_long2_rtp(int2 v); -OVERLOADABLE long2 convert_long2_rtn(int2 v); -OVERLOADABLE ulong2 convert_ulong2_rte(int2 v); -OVERLOADABLE ulong2 convert_ulong2_rtz(int2 v); -OVERLOADABLE ulong2 convert_ulong2_rtp(int2 v); -OVERLOADABLE ulong2 convert_ulong2_rtn(int2 v); -OVERLOADABLE int2 convert_int2_rte(int2 v); -OVERLOADABLE int2 convert_int2_rtz(int2 v); -OVERLOADABLE int2 convert_int2_rtp(int2 v); -OVERLOADABLE int2 convert_int2_rtn(int2 v); -OVERLOADABLE uint2 convert_uint2_rte(int2 v); -OVERLOADABLE uint2 convert_uint2_rtz(int2 v); -OVERLOADABLE uint2 convert_uint2_rtp(int2 v); -OVERLOADABLE uint2 convert_uint2_rtn(int2 v); -OVERLOADABLE short2 convert_short2_rte(int2 v); -OVERLOADABLE short2 convert_short2_rtz(int2 v); -OVERLOADABLE short2 convert_short2_rtp(int2 v); -OVERLOADABLE short2 convert_short2_rtn(int2 v); -OVERLOADABLE ushort2 convert_ushort2_rte(int2 v); -OVERLOADABLE ushort2 convert_ushort2_rtz(int2 v); -OVERLOADABLE ushort2 convert_ushort2_rtp(int2 v); -OVERLOADABLE ushort2 convert_ushort2_rtn(int2 v); -OVERLOADABLE char2 convert_char2_rte(int2 v); -OVERLOADABLE char2 convert_char2_rtz(int2 v); -OVERLOADABLE char2 convert_char2_rtp(int2 v); -OVERLOADABLE char2 convert_char2_rtn(int2 v); -OVERLOADABLE uchar2 convert_uchar2_rte(int2 v); -OVERLOADABLE uchar2 convert_uchar2_rtz(int2 v); -OVERLOADABLE uchar2 convert_uchar2_rtp(int2 v); -OVERLOADABLE uchar2 convert_uchar2_rtn(int2 v); -OVERLOADABLE float2 convert_float2_rte(int2 v); -OVERLOADABLE float2 convert_float2_rtz(int2 v); -OVERLOADABLE float2 convert_float2_rtp(int2 v); -OVERLOADABLE float2 convert_float2_rtn(int2 v); -OVERLOADABLE half2 convert_half2_rte(int2 v); -OVERLOADABLE half2 convert_half2_rtz(int2 v); -OVERLOADABLE half2 convert_half2_rtp(int2 v); -OVERLOADABLE half2 convert_half2_rtn(int2 v); -OVERLOADABLE long2 convert_long2_rte(uint2 v); -OVERLOADABLE long2 convert_long2_rtz(uint2 v); -OVERLOADABLE long2 convert_long2_rtp(uint2 v); -OVERLOADABLE long2 convert_long2_rtn(uint2 v); -OVERLOADABLE ulong2 convert_ulong2_rte(uint2 v); -OVERLOADABLE ulong2 convert_ulong2_rtz(uint2 v); -OVERLOADABLE ulong2 convert_ulong2_rtp(uint2 v); -OVERLOADABLE ulong2 convert_ulong2_rtn(uint2 v); -OVERLOADABLE int2 convert_int2_rte(uint2 v); -OVERLOADABLE int2 convert_int2_rtz(uint2 v); -OVERLOADABLE int2 convert_int2_rtp(uint2 v); -OVERLOADABLE int2 convert_int2_rtn(uint2 v); -OVERLOADABLE uint2 convert_uint2_rte(uint2 v); -OVERLOADABLE uint2 convert_uint2_rtz(uint2 v); -OVERLOADABLE uint2 convert_uint2_rtp(uint2 v); -OVERLOADABLE uint2 convert_uint2_rtn(uint2 v); -OVERLOADABLE short2 convert_short2_rte(uint2 v); -OVERLOADABLE short2 convert_short2_rtz(uint2 v); -OVERLOADABLE short2 convert_short2_rtp(uint2 v); -OVERLOADABLE short2 convert_short2_rtn(uint2 v); -OVERLOADABLE ushort2 convert_ushort2_rte(uint2 v); -OVERLOADABLE ushort2 convert_ushort2_rtz(uint2 v); -OVERLOADABLE ushort2 convert_ushort2_rtp(uint2 v); -OVERLOADABLE ushort2 convert_ushort2_rtn(uint2 v); -OVERLOADABLE char2 convert_char2_rte(uint2 v); -OVERLOADABLE char2 convert_char2_rtz(uint2 v); -OVERLOADABLE char2 convert_char2_rtp(uint2 v); -OVERLOADABLE char2 convert_char2_rtn(uint2 v); -OVERLOADABLE uchar2 convert_uchar2_rte(uint2 v); -OVERLOADABLE uchar2 convert_uchar2_rtz(uint2 v); -OVERLOADABLE uchar2 convert_uchar2_rtp(uint2 v); -OVERLOADABLE uchar2 convert_uchar2_rtn(uint2 v); -OVERLOADABLE float2 convert_float2_rte(uint2 v); -OVERLOADABLE float2 convert_float2_rtz(uint2 v); -OVERLOADABLE float2 convert_float2_rtp(uint2 v); -OVERLOADABLE float2 convert_float2_rtn(uint2 v); -OVERLOADABLE half2 convert_half2_rte(uint2 v); -OVERLOADABLE half2 convert_half2_rtz(uint2 v); -OVERLOADABLE half2 convert_half2_rtp(uint2 v); -OVERLOADABLE half2 convert_half2_rtn(uint2 v); -OVERLOADABLE long2 convert_long2_rte(short2 v); -OVERLOADABLE long2 convert_long2_rtz(short2 v); -OVERLOADABLE long2 convert_long2_rtp(short2 v); -OVERLOADABLE long2 convert_long2_rtn(short2 v); -OVERLOADABLE ulong2 convert_ulong2_rte(short2 v); -OVERLOADABLE ulong2 convert_ulong2_rtz(short2 v); -OVERLOADABLE ulong2 convert_ulong2_rtp(short2 v); -OVERLOADABLE ulong2 convert_ulong2_rtn(short2 v); -OVERLOADABLE int2 convert_int2_rte(short2 v); -OVERLOADABLE int2 convert_int2_rtz(short2 v); -OVERLOADABLE int2 convert_int2_rtp(short2 v); -OVERLOADABLE int2 convert_int2_rtn(short2 v); -OVERLOADABLE uint2 convert_uint2_rte(short2 v); -OVERLOADABLE uint2 convert_uint2_rtz(short2 v); -OVERLOADABLE uint2 convert_uint2_rtp(short2 v); -OVERLOADABLE uint2 convert_uint2_rtn(short2 v); -OVERLOADABLE short2 convert_short2_rte(short2 v); -OVERLOADABLE short2 convert_short2_rtz(short2 v); -OVERLOADABLE short2 convert_short2_rtp(short2 v); -OVERLOADABLE short2 convert_short2_rtn(short2 v); -OVERLOADABLE ushort2 convert_ushort2_rte(short2 v); -OVERLOADABLE ushort2 convert_ushort2_rtz(short2 v); -OVERLOADABLE ushort2 convert_ushort2_rtp(short2 v); -OVERLOADABLE ushort2 convert_ushort2_rtn(short2 v); -OVERLOADABLE char2 convert_char2_rte(short2 v); -OVERLOADABLE char2 convert_char2_rtz(short2 v); -OVERLOADABLE char2 convert_char2_rtp(short2 v); -OVERLOADABLE char2 convert_char2_rtn(short2 v); -OVERLOADABLE uchar2 convert_uchar2_rte(short2 v); -OVERLOADABLE uchar2 convert_uchar2_rtz(short2 v); -OVERLOADABLE uchar2 convert_uchar2_rtp(short2 v); -OVERLOADABLE uchar2 convert_uchar2_rtn(short2 v); -OVERLOADABLE float2 convert_float2_rte(short2 v); -OVERLOADABLE float2 convert_float2_rtz(short2 v); -OVERLOADABLE float2 convert_float2_rtp(short2 v); -OVERLOADABLE float2 convert_float2_rtn(short2 v); -OVERLOADABLE half2 convert_half2_rte(short2 v); -OVERLOADABLE half2 convert_half2_rtz(short2 v); -OVERLOADABLE half2 convert_half2_rtp(short2 v); -OVERLOADABLE half2 convert_half2_rtn(short2 v); -OVERLOADABLE long2 convert_long2_rte(ushort2 v); -OVERLOADABLE long2 convert_long2_rtz(ushort2 v); -OVERLOADABLE long2 convert_long2_rtp(ushort2 v); -OVERLOADABLE long2 convert_long2_rtn(ushort2 v); -OVERLOADABLE ulong2 convert_ulong2_rte(ushort2 v); -OVERLOADABLE ulong2 convert_ulong2_rtz(ushort2 v); -OVERLOADABLE ulong2 convert_ulong2_rtp(ushort2 v); -OVERLOADABLE ulong2 convert_ulong2_rtn(ushort2 v); -OVERLOADABLE int2 convert_int2_rte(ushort2 v); -OVERLOADABLE int2 convert_int2_rtz(ushort2 v); -OVERLOADABLE int2 convert_int2_rtp(ushort2 v); -OVERLOADABLE int2 convert_int2_rtn(ushort2 v); -OVERLOADABLE uint2 convert_uint2_rte(ushort2 v); -OVERLOADABLE uint2 convert_uint2_rtz(ushort2 v); -OVERLOADABLE uint2 convert_uint2_rtp(ushort2 v); -OVERLOADABLE uint2 convert_uint2_rtn(ushort2 v); -OVERLOADABLE short2 convert_short2_rte(ushort2 v); -OVERLOADABLE short2 convert_short2_rtz(ushort2 v); -OVERLOADABLE short2 convert_short2_rtp(ushort2 v); -OVERLOADABLE short2 convert_short2_rtn(ushort2 v); -OVERLOADABLE ushort2 convert_ushort2_rte(ushort2 v); -OVERLOADABLE ushort2 convert_ushort2_rtz(ushort2 v); -OVERLOADABLE ushort2 convert_ushort2_rtp(ushort2 v); -OVERLOADABLE ushort2 convert_ushort2_rtn(ushort2 v); -OVERLOADABLE char2 convert_char2_rte(ushort2 v); -OVERLOADABLE char2 convert_char2_rtz(ushort2 v); -OVERLOADABLE char2 convert_char2_rtp(ushort2 v); -OVERLOADABLE char2 convert_char2_rtn(ushort2 v); -OVERLOADABLE uchar2 convert_uchar2_rte(ushort2 v); -OVERLOADABLE uchar2 convert_uchar2_rtz(ushort2 v); -OVERLOADABLE uchar2 convert_uchar2_rtp(ushort2 v); -OVERLOADABLE uchar2 convert_uchar2_rtn(ushort2 v); -OVERLOADABLE float2 convert_float2_rte(ushort2 v); -OVERLOADABLE float2 convert_float2_rtz(ushort2 v); -OVERLOADABLE float2 convert_float2_rtp(ushort2 v); -OVERLOADABLE float2 convert_float2_rtn(ushort2 v); -OVERLOADABLE half2 convert_half2_rte(ushort2 v); -OVERLOADABLE half2 convert_half2_rtz(ushort2 v); -OVERLOADABLE half2 convert_half2_rtp(ushort2 v); -OVERLOADABLE half2 convert_half2_rtn(ushort2 v); -OVERLOADABLE long2 convert_long2_rte(char2 v); -OVERLOADABLE long2 convert_long2_rtz(char2 v); -OVERLOADABLE long2 convert_long2_rtp(char2 v); -OVERLOADABLE long2 convert_long2_rtn(char2 v); -OVERLOADABLE ulong2 convert_ulong2_rte(char2 v); -OVERLOADABLE ulong2 convert_ulong2_rtz(char2 v); -OVERLOADABLE ulong2 convert_ulong2_rtp(char2 v); -OVERLOADABLE ulong2 convert_ulong2_rtn(char2 v); -OVERLOADABLE int2 convert_int2_rte(char2 v); -OVERLOADABLE int2 convert_int2_rtz(char2 v); -OVERLOADABLE int2 convert_int2_rtp(char2 v); -OVERLOADABLE int2 convert_int2_rtn(char2 v); -OVERLOADABLE uint2 convert_uint2_rte(char2 v); -OVERLOADABLE uint2 convert_uint2_rtz(char2 v); -OVERLOADABLE uint2 convert_uint2_rtp(char2 v); -OVERLOADABLE uint2 convert_uint2_rtn(char2 v); -OVERLOADABLE short2 convert_short2_rte(char2 v); -OVERLOADABLE short2 convert_short2_rtz(char2 v); -OVERLOADABLE short2 convert_short2_rtp(char2 v); -OVERLOADABLE short2 convert_short2_rtn(char2 v); -OVERLOADABLE ushort2 convert_ushort2_rte(char2 v); -OVERLOADABLE ushort2 convert_ushort2_rtz(char2 v); -OVERLOADABLE ushort2 convert_ushort2_rtp(char2 v); -OVERLOADABLE ushort2 convert_ushort2_rtn(char2 v); -OVERLOADABLE char2 convert_char2_rte(char2 v); -OVERLOADABLE char2 convert_char2_rtz(char2 v); -OVERLOADABLE char2 convert_char2_rtp(char2 v); -OVERLOADABLE char2 convert_char2_rtn(char2 v); -OVERLOADABLE uchar2 convert_uchar2_rte(char2 v); -OVERLOADABLE uchar2 convert_uchar2_rtz(char2 v); -OVERLOADABLE uchar2 convert_uchar2_rtp(char2 v); -OVERLOADABLE uchar2 convert_uchar2_rtn(char2 v); -OVERLOADABLE float2 convert_float2_rte(char2 v); -OVERLOADABLE float2 convert_float2_rtz(char2 v); -OVERLOADABLE float2 convert_float2_rtp(char2 v); -OVERLOADABLE float2 convert_float2_rtn(char2 v); -OVERLOADABLE half2 convert_half2_rte(char2 v); -OVERLOADABLE half2 convert_half2_rtz(char2 v); -OVERLOADABLE half2 convert_half2_rtp(char2 v); -OVERLOADABLE half2 convert_half2_rtn(char2 v); -OVERLOADABLE long2 convert_long2_rte(uchar2 v); -OVERLOADABLE long2 convert_long2_rtz(uchar2 v); -OVERLOADABLE long2 convert_long2_rtp(uchar2 v); -OVERLOADABLE long2 convert_long2_rtn(uchar2 v); -OVERLOADABLE ulong2 convert_ulong2_rte(uchar2 v); -OVERLOADABLE ulong2 convert_ulong2_rtz(uchar2 v); -OVERLOADABLE ulong2 convert_ulong2_rtp(uchar2 v); -OVERLOADABLE ulong2 convert_ulong2_rtn(uchar2 v); -OVERLOADABLE int2 convert_int2_rte(uchar2 v); -OVERLOADABLE int2 convert_int2_rtz(uchar2 v); -OVERLOADABLE int2 convert_int2_rtp(uchar2 v); -OVERLOADABLE int2 convert_int2_rtn(uchar2 v); -OVERLOADABLE uint2 convert_uint2_rte(uchar2 v); -OVERLOADABLE uint2 convert_uint2_rtz(uchar2 v); -OVERLOADABLE uint2 convert_uint2_rtp(uchar2 v); -OVERLOADABLE uint2 convert_uint2_rtn(uchar2 v); -OVERLOADABLE short2 convert_short2_rte(uchar2 v); -OVERLOADABLE short2 convert_short2_rtz(uchar2 v); -OVERLOADABLE short2 convert_short2_rtp(uchar2 v); -OVERLOADABLE short2 convert_short2_rtn(uchar2 v); -OVERLOADABLE ushort2 convert_ushort2_rte(uchar2 v); -OVERLOADABLE ushort2 convert_ushort2_rtz(uchar2 v); -OVERLOADABLE ushort2 convert_ushort2_rtp(uchar2 v); -OVERLOADABLE ushort2 convert_ushort2_rtn(uchar2 v); -OVERLOADABLE char2 convert_char2_rte(uchar2 v); -OVERLOADABLE char2 convert_char2_rtz(uchar2 v); -OVERLOADABLE char2 convert_char2_rtp(uchar2 v); -OVERLOADABLE char2 convert_char2_rtn(uchar2 v); -OVERLOADABLE uchar2 convert_uchar2_rte(uchar2 v); -OVERLOADABLE uchar2 convert_uchar2_rtz(uchar2 v); -OVERLOADABLE uchar2 convert_uchar2_rtp(uchar2 v); -OVERLOADABLE uchar2 convert_uchar2_rtn(uchar2 v); -OVERLOADABLE float2 convert_float2_rte(uchar2 v); -OVERLOADABLE float2 convert_float2_rtz(uchar2 v); -OVERLOADABLE float2 convert_float2_rtp(uchar2 v); -OVERLOADABLE float2 convert_float2_rtn(uchar2 v); -OVERLOADABLE half2 convert_half2_rte(uchar2 v); -OVERLOADABLE half2 convert_half2_rtz(uchar2 v); -OVERLOADABLE half2 convert_half2_rtp(uchar2 v); -OVERLOADABLE half2 convert_half2_rtn(uchar2 v); -OVERLOADABLE long2 convert_long2_rte(double2 v); -OVERLOADABLE long2 convert_long2_rtz(double2 v); -OVERLOADABLE long2 convert_long2_rtp(double2 v); -OVERLOADABLE long2 convert_long2_rtn(double2 v); -OVERLOADABLE ulong2 convert_ulong2_rte(double2 v); -OVERLOADABLE ulong2 convert_ulong2_rtz(double2 v); -OVERLOADABLE ulong2 convert_ulong2_rtp(double2 v); -OVERLOADABLE ulong2 convert_ulong2_rtn(double2 v); -OVERLOADABLE int2 convert_int2_rte(double2 v); -OVERLOADABLE int2 convert_int2_rtz(double2 v); -OVERLOADABLE int2 convert_int2_rtp(double2 v); -OVERLOADABLE int2 convert_int2_rtn(double2 v); -OVERLOADABLE uint2 convert_uint2_rte(double2 v); -OVERLOADABLE uint2 convert_uint2_rtz(double2 v); -OVERLOADABLE uint2 convert_uint2_rtp(double2 v); -OVERLOADABLE uint2 convert_uint2_rtn(double2 v); -OVERLOADABLE short2 convert_short2_rte(double2 v); -OVERLOADABLE short2 convert_short2_rtz(double2 v); -OVERLOADABLE short2 convert_short2_rtp(double2 v); -OVERLOADABLE short2 convert_short2_rtn(double2 v); -OVERLOADABLE ushort2 convert_ushort2_rte(double2 v); -OVERLOADABLE ushort2 convert_ushort2_rtz(double2 v); -OVERLOADABLE ushort2 convert_ushort2_rtp(double2 v); -OVERLOADABLE ushort2 convert_ushort2_rtn(double2 v); -OVERLOADABLE char2 convert_char2_rte(double2 v); -OVERLOADABLE char2 convert_char2_rtz(double2 v); -OVERLOADABLE char2 convert_char2_rtp(double2 v); -OVERLOADABLE char2 convert_char2_rtn(double2 v); -OVERLOADABLE uchar2 convert_uchar2_rte(double2 v); -OVERLOADABLE uchar2 convert_uchar2_rtz(double2 v); -OVERLOADABLE uchar2 convert_uchar2_rtp(double2 v); -OVERLOADABLE uchar2 convert_uchar2_rtn(double2 v); -OVERLOADABLE float2 convert_float2_rte(double2 v); -OVERLOADABLE float2 convert_float2_rtz(double2 v); -OVERLOADABLE float2 convert_float2_rtp(double2 v); -OVERLOADABLE float2 convert_float2_rtn(double2 v); -OVERLOADABLE half2 convert_half2_rte(double2 v); -OVERLOADABLE half2 convert_half2_rtz(double2 v); -OVERLOADABLE half2 convert_half2_rtp(double2 v); -OVERLOADABLE half2 convert_half2_rtn(double2 v); -OVERLOADABLE long2 convert_long2_rte(float2 v); -OVERLOADABLE long2 convert_long2_rtz(float2 v); -OVERLOADABLE long2 convert_long2_rtp(float2 v); -OVERLOADABLE long2 convert_long2_rtn(float2 v); -OVERLOADABLE ulong2 convert_ulong2_rte(float2 v); -OVERLOADABLE ulong2 convert_ulong2_rtz(float2 v); -OVERLOADABLE ulong2 convert_ulong2_rtp(float2 v); -OVERLOADABLE ulong2 convert_ulong2_rtn(float2 v); -OVERLOADABLE int2 convert_int2_rte(float2 v); -OVERLOADABLE int2 convert_int2_rtz(float2 v); -OVERLOADABLE int2 convert_int2_rtp(float2 v); -OVERLOADABLE int2 convert_int2_rtn(float2 v); -OVERLOADABLE uint2 convert_uint2_rte(float2 v); -OVERLOADABLE uint2 convert_uint2_rtz(float2 v); -OVERLOADABLE uint2 convert_uint2_rtp(float2 v); -OVERLOADABLE uint2 convert_uint2_rtn(float2 v); -OVERLOADABLE short2 convert_short2_rte(float2 v); -OVERLOADABLE short2 convert_short2_rtz(float2 v); -OVERLOADABLE short2 convert_short2_rtp(float2 v); -OVERLOADABLE short2 convert_short2_rtn(float2 v); -OVERLOADABLE ushort2 convert_ushort2_rte(float2 v); -OVERLOADABLE ushort2 convert_ushort2_rtz(float2 v); -OVERLOADABLE ushort2 convert_ushort2_rtp(float2 v); -OVERLOADABLE ushort2 convert_ushort2_rtn(float2 v); -OVERLOADABLE char2 convert_char2_rte(float2 v); -OVERLOADABLE char2 convert_char2_rtz(float2 v); -OVERLOADABLE char2 convert_char2_rtp(float2 v); -OVERLOADABLE char2 convert_char2_rtn(float2 v); -OVERLOADABLE uchar2 convert_uchar2_rte(float2 v); -OVERLOADABLE uchar2 convert_uchar2_rtz(float2 v); -OVERLOADABLE uchar2 convert_uchar2_rtp(float2 v); -OVERLOADABLE uchar2 convert_uchar2_rtn(float2 v); -OVERLOADABLE float2 convert_float2_rte(float2 v); -OVERLOADABLE float2 convert_float2_rtz(float2 v); -OVERLOADABLE float2 convert_float2_rtp(float2 v); -OVERLOADABLE float2 convert_float2_rtn(float2 v); -OVERLOADABLE half2 convert_half2_rte(float2 v); -OVERLOADABLE half2 convert_half2_rtz(float2 v); -OVERLOADABLE half2 convert_half2_rtp(float2 v); -OVERLOADABLE half2 convert_half2_rtn(float2 v); -OVERLOADABLE long2 convert_long2_rte(half2 v); -OVERLOADABLE long2 convert_long2_rtz(half2 v); -OVERLOADABLE long2 convert_long2_rtp(half2 v); -OVERLOADABLE long2 convert_long2_rtn(half2 v); -OVERLOADABLE ulong2 convert_ulong2_rte(half2 v); -OVERLOADABLE ulong2 convert_ulong2_rtz(half2 v); -OVERLOADABLE ulong2 convert_ulong2_rtp(half2 v); -OVERLOADABLE ulong2 convert_ulong2_rtn(half2 v); -OVERLOADABLE int2 convert_int2_rte(half2 v); -OVERLOADABLE int2 convert_int2_rtz(half2 v); -OVERLOADABLE int2 convert_int2_rtp(half2 v); -OVERLOADABLE int2 convert_int2_rtn(half2 v); -OVERLOADABLE uint2 convert_uint2_rte(half2 v); -OVERLOADABLE uint2 convert_uint2_rtz(half2 v); -OVERLOADABLE uint2 convert_uint2_rtp(half2 v); -OVERLOADABLE uint2 convert_uint2_rtn(half2 v); -OVERLOADABLE short2 convert_short2_rte(half2 v); -OVERLOADABLE short2 convert_short2_rtz(half2 v); -OVERLOADABLE short2 convert_short2_rtp(half2 v); -OVERLOADABLE short2 convert_short2_rtn(half2 v); -OVERLOADABLE ushort2 convert_ushort2_rte(half2 v); -OVERLOADABLE ushort2 convert_ushort2_rtz(half2 v); -OVERLOADABLE ushort2 convert_ushort2_rtp(half2 v); -OVERLOADABLE ushort2 convert_ushort2_rtn(half2 v); -OVERLOADABLE char2 convert_char2_rte(half2 v); -OVERLOADABLE char2 convert_char2_rtz(half2 v); -OVERLOADABLE char2 convert_char2_rtp(half2 v); -OVERLOADABLE char2 convert_char2_rtn(half2 v); -OVERLOADABLE uchar2 convert_uchar2_rte(half2 v); -OVERLOADABLE uchar2 convert_uchar2_rtz(half2 v); -OVERLOADABLE uchar2 convert_uchar2_rtp(half2 v); -OVERLOADABLE uchar2 convert_uchar2_rtn(half2 v); -OVERLOADABLE float2 convert_float2_rte(half2 v); -OVERLOADABLE float2 convert_float2_rtz(half2 v); -OVERLOADABLE float2 convert_float2_rtp(half2 v); -OVERLOADABLE float2 convert_float2_rtn(half2 v); -OVERLOADABLE half2 convert_half2_rte(half2 v); -OVERLOADABLE half2 convert_half2_rtz(half2 v); -OVERLOADABLE half2 convert_half2_rtp(half2 v); -OVERLOADABLE half2 convert_half2_rtn(half2 v); -OVERLOADABLE long3 convert_long3_rte(long3 v); -OVERLOADABLE long3 convert_long3_rtz(long3 v); -OVERLOADABLE long3 convert_long3_rtp(long3 v); -OVERLOADABLE long3 convert_long3_rtn(long3 v); -OVERLOADABLE ulong3 convert_ulong3_rte(long3 v); -OVERLOADABLE ulong3 convert_ulong3_rtz(long3 v); -OVERLOADABLE ulong3 convert_ulong3_rtp(long3 v); -OVERLOADABLE ulong3 convert_ulong3_rtn(long3 v); -OVERLOADABLE int3 convert_int3_rte(long3 v); -OVERLOADABLE int3 convert_int3_rtz(long3 v); -OVERLOADABLE int3 convert_int3_rtp(long3 v); -OVERLOADABLE int3 convert_int3_rtn(long3 v); -OVERLOADABLE uint3 convert_uint3_rte(long3 v); -OVERLOADABLE uint3 convert_uint3_rtz(long3 v); -OVERLOADABLE uint3 convert_uint3_rtp(long3 v); -OVERLOADABLE uint3 convert_uint3_rtn(long3 v); -OVERLOADABLE short3 convert_short3_rte(long3 v); -OVERLOADABLE short3 convert_short3_rtz(long3 v); -OVERLOADABLE short3 convert_short3_rtp(long3 v); -OVERLOADABLE short3 convert_short3_rtn(long3 v); -OVERLOADABLE ushort3 convert_ushort3_rte(long3 v); -OVERLOADABLE ushort3 convert_ushort3_rtz(long3 v); -OVERLOADABLE ushort3 convert_ushort3_rtp(long3 v); -OVERLOADABLE ushort3 convert_ushort3_rtn(long3 v); -OVERLOADABLE char3 convert_char3_rte(long3 v); -OVERLOADABLE char3 convert_char3_rtz(long3 v); -OVERLOADABLE char3 convert_char3_rtp(long3 v); -OVERLOADABLE char3 convert_char3_rtn(long3 v); -OVERLOADABLE uchar3 convert_uchar3_rte(long3 v); -OVERLOADABLE uchar3 convert_uchar3_rtz(long3 v); -OVERLOADABLE uchar3 convert_uchar3_rtp(long3 v); -OVERLOADABLE uchar3 convert_uchar3_rtn(long3 v); -OVERLOADABLE float3 convert_float3_rte(long3 v); -OVERLOADABLE float3 convert_float3_rtz(long3 v); -OVERLOADABLE float3 convert_float3_rtp(long3 v); -OVERLOADABLE float3 convert_float3_rtn(long3 v); -OVERLOADABLE half3 convert_half3_rte(long3 v); -OVERLOADABLE half3 convert_half3_rtz(long3 v); -OVERLOADABLE half3 convert_half3_rtp(long3 v); -OVERLOADABLE half3 convert_half3_rtn(long3 v); -OVERLOADABLE long3 convert_long3_rte(ulong3 v); -OVERLOADABLE long3 convert_long3_rtz(ulong3 v); -OVERLOADABLE long3 convert_long3_rtp(ulong3 v); -OVERLOADABLE long3 convert_long3_rtn(ulong3 v); -OVERLOADABLE ulong3 convert_ulong3_rte(ulong3 v); -OVERLOADABLE ulong3 convert_ulong3_rtz(ulong3 v); -OVERLOADABLE ulong3 convert_ulong3_rtp(ulong3 v); -OVERLOADABLE ulong3 convert_ulong3_rtn(ulong3 v); -OVERLOADABLE int3 convert_int3_rte(ulong3 v); -OVERLOADABLE int3 convert_int3_rtz(ulong3 v); -OVERLOADABLE int3 convert_int3_rtp(ulong3 v); -OVERLOADABLE int3 convert_int3_rtn(ulong3 v); -OVERLOADABLE uint3 convert_uint3_rte(ulong3 v); -OVERLOADABLE uint3 convert_uint3_rtz(ulong3 v); -OVERLOADABLE uint3 convert_uint3_rtp(ulong3 v); -OVERLOADABLE uint3 convert_uint3_rtn(ulong3 v); -OVERLOADABLE short3 convert_short3_rte(ulong3 v); -OVERLOADABLE short3 convert_short3_rtz(ulong3 v); -OVERLOADABLE short3 convert_short3_rtp(ulong3 v); -OVERLOADABLE short3 convert_short3_rtn(ulong3 v); -OVERLOADABLE ushort3 convert_ushort3_rte(ulong3 v); -OVERLOADABLE ushort3 convert_ushort3_rtz(ulong3 v); -OVERLOADABLE ushort3 convert_ushort3_rtp(ulong3 v); -OVERLOADABLE ushort3 convert_ushort3_rtn(ulong3 v); -OVERLOADABLE char3 convert_char3_rte(ulong3 v); -OVERLOADABLE char3 convert_char3_rtz(ulong3 v); -OVERLOADABLE char3 convert_char3_rtp(ulong3 v); -OVERLOADABLE char3 convert_char3_rtn(ulong3 v); -OVERLOADABLE uchar3 convert_uchar3_rte(ulong3 v); -OVERLOADABLE uchar3 convert_uchar3_rtz(ulong3 v); -OVERLOADABLE uchar3 convert_uchar3_rtp(ulong3 v); -OVERLOADABLE uchar3 convert_uchar3_rtn(ulong3 v); -OVERLOADABLE float3 convert_float3_rte(ulong3 v); -OVERLOADABLE float3 convert_float3_rtz(ulong3 v); -OVERLOADABLE float3 convert_float3_rtp(ulong3 v); -OVERLOADABLE float3 convert_float3_rtn(ulong3 v); -OVERLOADABLE half3 convert_half3_rte(ulong3 v); -OVERLOADABLE half3 convert_half3_rtz(ulong3 v); -OVERLOADABLE half3 convert_half3_rtp(ulong3 v); -OVERLOADABLE half3 convert_half3_rtn(ulong3 v); -OVERLOADABLE long3 convert_long3_rte(int3 v); -OVERLOADABLE long3 convert_long3_rtz(int3 v); -OVERLOADABLE long3 convert_long3_rtp(int3 v); -OVERLOADABLE long3 convert_long3_rtn(int3 v); -OVERLOADABLE ulong3 convert_ulong3_rte(int3 v); -OVERLOADABLE ulong3 convert_ulong3_rtz(int3 v); -OVERLOADABLE ulong3 convert_ulong3_rtp(int3 v); -OVERLOADABLE ulong3 convert_ulong3_rtn(int3 v); -OVERLOADABLE int3 convert_int3_rte(int3 v); -OVERLOADABLE int3 convert_int3_rtz(int3 v); -OVERLOADABLE int3 convert_int3_rtp(int3 v); -OVERLOADABLE int3 convert_int3_rtn(int3 v); -OVERLOADABLE uint3 convert_uint3_rte(int3 v); -OVERLOADABLE uint3 convert_uint3_rtz(int3 v); -OVERLOADABLE uint3 convert_uint3_rtp(int3 v); -OVERLOADABLE uint3 convert_uint3_rtn(int3 v); -OVERLOADABLE short3 convert_short3_rte(int3 v); -OVERLOADABLE short3 convert_short3_rtz(int3 v); -OVERLOADABLE short3 convert_short3_rtp(int3 v); -OVERLOADABLE short3 convert_short3_rtn(int3 v); -OVERLOADABLE ushort3 convert_ushort3_rte(int3 v); -OVERLOADABLE ushort3 convert_ushort3_rtz(int3 v); -OVERLOADABLE ushort3 convert_ushort3_rtp(int3 v); -OVERLOADABLE ushort3 convert_ushort3_rtn(int3 v); -OVERLOADABLE char3 convert_char3_rte(int3 v); -OVERLOADABLE char3 convert_char3_rtz(int3 v); -OVERLOADABLE char3 convert_char3_rtp(int3 v); -OVERLOADABLE char3 convert_char3_rtn(int3 v); -OVERLOADABLE uchar3 convert_uchar3_rte(int3 v); -OVERLOADABLE uchar3 convert_uchar3_rtz(int3 v); -OVERLOADABLE uchar3 convert_uchar3_rtp(int3 v); -OVERLOADABLE uchar3 convert_uchar3_rtn(int3 v); -OVERLOADABLE float3 convert_float3_rte(int3 v); -OVERLOADABLE float3 convert_float3_rtz(int3 v); -OVERLOADABLE float3 convert_float3_rtp(int3 v); -OVERLOADABLE float3 convert_float3_rtn(int3 v); -OVERLOADABLE half3 convert_half3_rte(int3 v); -OVERLOADABLE half3 convert_half3_rtz(int3 v); -OVERLOADABLE half3 convert_half3_rtp(int3 v); -OVERLOADABLE half3 convert_half3_rtn(int3 v); -OVERLOADABLE long3 convert_long3_rte(uint3 v); -OVERLOADABLE long3 convert_long3_rtz(uint3 v); -OVERLOADABLE long3 convert_long3_rtp(uint3 v); -OVERLOADABLE long3 convert_long3_rtn(uint3 v); -OVERLOADABLE ulong3 convert_ulong3_rte(uint3 v); -OVERLOADABLE ulong3 convert_ulong3_rtz(uint3 v); -OVERLOADABLE ulong3 convert_ulong3_rtp(uint3 v); -OVERLOADABLE ulong3 convert_ulong3_rtn(uint3 v); -OVERLOADABLE int3 convert_int3_rte(uint3 v); -OVERLOADABLE int3 convert_int3_rtz(uint3 v); -OVERLOADABLE int3 convert_int3_rtp(uint3 v); -OVERLOADABLE int3 convert_int3_rtn(uint3 v); -OVERLOADABLE uint3 convert_uint3_rte(uint3 v); -OVERLOADABLE uint3 convert_uint3_rtz(uint3 v); -OVERLOADABLE uint3 convert_uint3_rtp(uint3 v); -OVERLOADABLE uint3 convert_uint3_rtn(uint3 v); -OVERLOADABLE short3 convert_short3_rte(uint3 v); -OVERLOADABLE short3 convert_short3_rtz(uint3 v); -OVERLOADABLE short3 convert_short3_rtp(uint3 v); -OVERLOADABLE short3 convert_short3_rtn(uint3 v); -OVERLOADABLE ushort3 convert_ushort3_rte(uint3 v); -OVERLOADABLE ushort3 convert_ushort3_rtz(uint3 v); -OVERLOADABLE ushort3 convert_ushort3_rtp(uint3 v); -OVERLOADABLE ushort3 convert_ushort3_rtn(uint3 v); -OVERLOADABLE char3 convert_char3_rte(uint3 v); -OVERLOADABLE char3 convert_char3_rtz(uint3 v); -OVERLOADABLE char3 convert_char3_rtp(uint3 v); -OVERLOADABLE char3 convert_char3_rtn(uint3 v); -OVERLOADABLE uchar3 convert_uchar3_rte(uint3 v); -OVERLOADABLE uchar3 convert_uchar3_rtz(uint3 v); -OVERLOADABLE uchar3 convert_uchar3_rtp(uint3 v); -OVERLOADABLE uchar3 convert_uchar3_rtn(uint3 v); -OVERLOADABLE float3 convert_float3_rte(uint3 v); -OVERLOADABLE float3 convert_float3_rtz(uint3 v); -OVERLOADABLE float3 convert_float3_rtp(uint3 v); -OVERLOADABLE float3 convert_float3_rtn(uint3 v); -OVERLOADABLE half3 convert_half3_rte(uint3 v); -OVERLOADABLE half3 convert_half3_rtz(uint3 v); -OVERLOADABLE half3 convert_half3_rtp(uint3 v); -OVERLOADABLE half3 convert_half3_rtn(uint3 v); -OVERLOADABLE long3 convert_long3_rte(short3 v); -OVERLOADABLE long3 convert_long3_rtz(short3 v); -OVERLOADABLE long3 convert_long3_rtp(short3 v); -OVERLOADABLE long3 convert_long3_rtn(short3 v); -OVERLOADABLE ulong3 convert_ulong3_rte(short3 v); -OVERLOADABLE ulong3 convert_ulong3_rtz(short3 v); -OVERLOADABLE ulong3 convert_ulong3_rtp(short3 v); -OVERLOADABLE ulong3 convert_ulong3_rtn(short3 v); -OVERLOADABLE int3 convert_int3_rte(short3 v); -OVERLOADABLE int3 convert_int3_rtz(short3 v); -OVERLOADABLE int3 convert_int3_rtp(short3 v); -OVERLOADABLE int3 convert_int3_rtn(short3 v); -OVERLOADABLE uint3 convert_uint3_rte(short3 v); -OVERLOADABLE uint3 convert_uint3_rtz(short3 v); -OVERLOADABLE uint3 convert_uint3_rtp(short3 v); -OVERLOADABLE uint3 convert_uint3_rtn(short3 v); -OVERLOADABLE short3 convert_short3_rte(short3 v); -OVERLOADABLE short3 convert_short3_rtz(short3 v); -OVERLOADABLE short3 convert_short3_rtp(short3 v); -OVERLOADABLE short3 convert_short3_rtn(short3 v); -OVERLOADABLE ushort3 convert_ushort3_rte(short3 v); -OVERLOADABLE ushort3 convert_ushort3_rtz(short3 v); -OVERLOADABLE ushort3 convert_ushort3_rtp(short3 v); -OVERLOADABLE ushort3 convert_ushort3_rtn(short3 v); -OVERLOADABLE char3 convert_char3_rte(short3 v); -OVERLOADABLE char3 convert_char3_rtz(short3 v); -OVERLOADABLE char3 convert_char3_rtp(short3 v); -OVERLOADABLE char3 convert_char3_rtn(short3 v); -OVERLOADABLE uchar3 convert_uchar3_rte(short3 v); -OVERLOADABLE uchar3 convert_uchar3_rtz(short3 v); -OVERLOADABLE uchar3 convert_uchar3_rtp(short3 v); -OVERLOADABLE uchar3 convert_uchar3_rtn(short3 v); -OVERLOADABLE float3 convert_float3_rte(short3 v); -OVERLOADABLE float3 convert_float3_rtz(short3 v); -OVERLOADABLE float3 convert_float3_rtp(short3 v); -OVERLOADABLE float3 convert_float3_rtn(short3 v); -OVERLOADABLE half3 convert_half3_rte(short3 v); -OVERLOADABLE half3 convert_half3_rtz(short3 v); -OVERLOADABLE half3 convert_half3_rtp(short3 v); -OVERLOADABLE half3 convert_half3_rtn(short3 v); -OVERLOADABLE long3 convert_long3_rte(ushort3 v); -OVERLOADABLE long3 convert_long3_rtz(ushort3 v); -OVERLOADABLE long3 convert_long3_rtp(ushort3 v); -OVERLOADABLE long3 convert_long3_rtn(ushort3 v); -OVERLOADABLE ulong3 convert_ulong3_rte(ushort3 v); -OVERLOADABLE ulong3 convert_ulong3_rtz(ushort3 v); -OVERLOADABLE ulong3 convert_ulong3_rtp(ushort3 v); -OVERLOADABLE ulong3 convert_ulong3_rtn(ushort3 v); -OVERLOADABLE int3 convert_int3_rte(ushort3 v); -OVERLOADABLE int3 convert_int3_rtz(ushort3 v); -OVERLOADABLE int3 convert_int3_rtp(ushort3 v); -OVERLOADABLE int3 convert_int3_rtn(ushort3 v); -OVERLOADABLE uint3 convert_uint3_rte(ushort3 v); -OVERLOADABLE uint3 convert_uint3_rtz(ushort3 v); -OVERLOADABLE uint3 convert_uint3_rtp(ushort3 v); -OVERLOADABLE uint3 convert_uint3_rtn(ushort3 v); -OVERLOADABLE short3 convert_short3_rte(ushort3 v); -OVERLOADABLE short3 convert_short3_rtz(ushort3 v); -OVERLOADABLE short3 convert_short3_rtp(ushort3 v); -OVERLOADABLE short3 convert_short3_rtn(ushort3 v); -OVERLOADABLE ushort3 convert_ushort3_rte(ushort3 v); -OVERLOADABLE ushort3 convert_ushort3_rtz(ushort3 v); -OVERLOADABLE ushort3 convert_ushort3_rtp(ushort3 v); -OVERLOADABLE ushort3 convert_ushort3_rtn(ushort3 v); -OVERLOADABLE char3 convert_char3_rte(ushort3 v); -OVERLOADABLE char3 convert_char3_rtz(ushort3 v); -OVERLOADABLE char3 convert_char3_rtp(ushort3 v); -OVERLOADABLE char3 convert_char3_rtn(ushort3 v); -OVERLOADABLE uchar3 convert_uchar3_rte(ushort3 v); -OVERLOADABLE uchar3 convert_uchar3_rtz(ushort3 v); -OVERLOADABLE uchar3 convert_uchar3_rtp(ushort3 v); -OVERLOADABLE uchar3 convert_uchar3_rtn(ushort3 v); -OVERLOADABLE float3 convert_float3_rte(ushort3 v); -OVERLOADABLE float3 convert_float3_rtz(ushort3 v); -OVERLOADABLE float3 convert_float3_rtp(ushort3 v); -OVERLOADABLE float3 convert_float3_rtn(ushort3 v); -OVERLOADABLE half3 convert_half3_rte(ushort3 v); -OVERLOADABLE half3 convert_half3_rtz(ushort3 v); -OVERLOADABLE half3 convert_half3_rtp(ushort3 v); -OVERLOADABLE half3 convert_half3_rtn(ushort3 v); -OVERLOADABLE long3 convert_long3_rte(char3 v); -OVERLOADABLE long3 convert_long3_rtz(char3 v); -OVERLOADABLE long3 convert_long3_rtp(char3 v); -OVERLOADABLE long3 convert_long3_rtn(char3 v); -OVERLOADABLE ulong3 convert_ulong3_rte(char3 v); -OVERLOADABLE ulong3 convert_ulong3_rtz(char3 v); -OVERLOADABLE ulong3 convert_ulong3_rtp(char3 v); -OVERLOADABLE ulong3 convert_ulong3_rtn(char3 v); -OVERLOADABLE int3 convert_int3_rte(char3 v); -OVERLOADABLE int3 convert_int3_rtz(char3 v); -OVERLOADABLE int3 convert_int3_rtp(char3 v); -OVERLOADABLE int3 convert_int3_rtn(char3 v); -OVERLOADABLE uint3 convert_uint3_rte(char3 v); -OVERLOADABLE uint3 convert_uint3_rtz(char3 v); -OVERLOADABLE uint3 convert_uint3_rtp(char3 v); -OVERLOADABLE uint3 convert_uint3_rtn(char3 v); -OVERLOADABLE short3 convert_short3_rte(char3 v); -OVERLOADABLE short3 convert_short3_rtz(char3 v); -OVERLOADABLE short3 convert_short3_rtp(char3 v); -OVERLOADABLE short3 convert_short3_rtn(char3 v); -OVERLOADABLE ushort3 convert_ushort3_rte(char3 v); -OVERLOADABLE ushort3 convert_ushort3_rtz(char3 v); -OVERLOADABLE ushort3 convert_ushort3_rtp(char3 v); -OVERLOADABLE ushort3 convert_ushort3_rtn(char3 v); -OVERLOADABLE char3 convert_char3_rte(char3 v); -OVERLOADABLE char3 convert_char3_rtz(char3 v); -OVERLOADABLE char3 convert_char3_rtp(char3 v); -OVERLOADABLE char3 convert_char3_rtn(char3 v); -OVERLOADABLE uchar3 convert_uchar3_rte(char3 v); -OVERLOADABLE uchar3 convert_uchar3_rtz(char3 v); -OVERLOADABLE uchar3 convert_uchar3_rtp(char3 v); -OVERLOADABLE uchar3 convert_uchar3_rtn(char3 v); -OVERLOADABLE float3 convert_float3_rte(char3 v); -OVERLOADABLE float3 convert_float3_rtz(char3 v); -OVERLOADABLE float3 convert_float3_rtp(char3 v); -OVERLOADABLE float3 convert_float3_rtn(char3 v); -OVERLOADABLE half3 convert_half3_rte(char3 v); -OVERLOADABLE half3 convert_half3_rtz(char3 v); -OVERLOADABLE half3 convert_half3_rtp(char3 v); -OVERLOADABLE half3 convert_half3_rtn(char3 v); -OVERLOADABLE long3 convert_long3_rte(uchar3 v); -OVERLOADABLE long3 convert_long3_rtz(uchar3 v); -OVERLOADABLE long3 convert_long3_rtp(uchar3 v); -OVERLOADABLE long3 convert_long3_rtn(uchar3 v); -OVERLOADABLE ulong3 convert_ulong3_rte(uchar3 v); -OVERLOADABLE ulong3 convert_ulong3_rtz(uchar3 v); -OVERLOADABLE ulong3 convert_ulong3_rtp(uchar3 v); -OVERLOADABLE ulong3 convert_ulong3_rtn(uchar3 v); -OVERLOADABLE int3 convert_int3_rte(uchar3 v); -OVERLOADABLE int3 convert_int3_rtz(uchar3 v); -OVERLOADABLE int3 convert_int3_rtp(uchar3 v); -OVERLOADABLE int3 convert_int3_rtn(uchar3 v); -OVERLOADABLE uint3 convert_uint3_rte(uchar3 v); -OVERLOADABLE uint3 convert_uint3_rtz(uchar3 v); -OVERLOADABLE uint3 convert_uint3_rtp(uchar3 v); -OVERLOADABLE uint3 convert_uint3_rtn(uchar3 v); -OVERLOADABLE short3 convert_short3_rte(uchar3 v); -OVERLOADABLE short3 convert_short3_rtz(uchar3 v); -OVERLOADABLE short3 convert_short3_rtp(uchar3 v); -OVERLOADABLE short3 convert_short3_rtn(uchar3 v); -OVERLOADABLE ushort3 convert_ushort3_rte(uchar3 v); -OVERLOADABLE ushort3 convert_ushort3_rtz(uchar3 v); -OVERLOADABLE ushort3 convert_ushort3_rtp(uchar3 v); -OVERLOADABLE ushort3 convert_ushort3_rtn(uchar3 v); -OVERLOADABLE char3 convert_char3_rte(uchar3 v); -OVERLOADABLE char3 convert_char3_rtz(uchar3 v); -OVERLOADABLE char3 convert_char3_rtp(uchar3 v); -OVERLOADABLE char3 convert_char3_rtn(uchar3 v); -OVERLOADABLE uchar3 convert_uchar3_rte(uchar3 v); -OVERLOADABLE uchar3 convert_uchar3_rtz(uchar3 v); -OVERLOADABLE uchar3 convert_uchar3_rtp(uchar3 v); -OVERLOADABLE uchar3 convert_uchar3_rtn(uchar3 v); -OVERLOADABLE float3 convert_float3_rte(uchar3 v); -OVERLOADABLE float3 convert_float3_rtz(uchar3 v); -OVERLOADABLE float3 convert_float3_rtp(uchar3 v); -OVERLOADABLE float3 convert_float3_rtn(uchar3 v); -OVERLOADABLE half3 convert_half3_rte(uchar3 v); -OVERLOADABLE half3 convert_half3_rtz(uchar3 v); -OVERLOADABLE half3 convert_half3_rtp(uchar3 v); -OVERLOADABLE half3 convert_half3_rtn(uchar3 v); -OVERLOADABLE long3 convert_long3_rte(double3 v); -OVERLOADABLE long3 convert_long3_rtz(double3 v); -OVERLOADABLE long3 convert_long3_rtp(double3 v); -OVERLOADABLE long3 convert_long3_rtn(double3 v); -OVERLOADABLE ulong3 convert_ulong3_rte(double3 v); -OVERLOADABLE ulong3 convert_ulong3_rtz(double3 v); -OVERLOADABLE ulong3 convert_ulong3_rtp(double3 v); -OVERLOADABLE ulong3 convert_ulong3_rtn(double3 v); -OVERLOADABLE int3 convert_int3_rte(double3 v); -OVERLOADABLE int3 convert_int3_rtz(double3 v); -OVERLOADABLE int3 convert_int3_rtp(double3 v); -OVERLOADABLE int3 convert_int3_rtn(double3 v); -OVERLOADABLE uint3 convert_uint3_rte(double3 v); -OVERLOADABLE uint3 convert_uint3_rtz(double3 v); -OVERLOADABLE uint3 convert_uint3_rtp(double3 v); -OVERLOADABLE uint3 convert_uint3_rtn(double3 v); -OVERLOADABLE short3 convert_short3_rte(double3 v); -OVERLOADABLE short3 convert_short3_rtz(double3 v); -OVERLOADABLE short3 convert_short3_rtp(double3 v); -OVERLOADABLE short3 convert_short3_rtn(double3 v); -OVERLOADABLE ushort3 convert_ushort3_rte(double3 v); -OVERLOADABLE ushort3 convert_ushort3_rtz(double3 v); -OVERLOADABLE ushort3 convert_ushort3_rtp(double3 v); -OVERLOADABLE ushort3 convert_ushort3_rtn(double3 v); -OVERLOADABLE char3 convert_char3_rte(double3 v); -OVERLOADABLE char3 convert_char3_rtz(double3 v); -OVERLOADABLE char3 convert_char3_rtp(double3 v); -OVERLOADABLE char3 convert_char3_rtn(double3 v); -OVERLOADABLE uchar3 convert_uchar3_rte(double3 v); -OVERLOADABLE uchar3 convert_uchar3_rtz(double3 v); -OVERLOADABLE uchar3 convert_uchar3_rtp(double3 v); -OVERLOADABLE uchar3 convert_uchar3_rtn(double3 v); -OVERLOADABLE float3 convert_float3_rte(double3 v); -OVERLOADABLE float3 convert_float3_rtz(double3 v); -OVERLOADABLE float3 convert_float3_rtp(double3 v); -OVERLOADABLE float3 convert_float3_rtn(double3 v); -OVERLOADABLE half3 convert_half3_rte(double3 v); -OVERLOADABLE half3 convert_half3_rtz(double3 v); -OVERLOADABLE half3 convert_half3_rtp(double3 v); -OVERLOADABLE half3 convert_half3_rtn(double3 v); -OVERLOADABLE long3 convert_long3_rte(float3 v); -OVERLOADABLE long3 convert_long3_rtz(float3 v); -OVERLOADABLE long3 convert_long3_rtp(float3 v); -OVERLOADABLE long3 convert_long3_rtn(float3 v); -OVERLOADABLE ulong3 convert_ulong3_rte(float3 v); -OVERLOADABLE ulong3 convert_ulong3_rtz(float3 v); -OVERLOADABLE ulong3 convert_ulong3_rtp(float3 v); -OVERLOADABLE ulong3 convert_ulong3_rtn(float3 v); -OVERLOADABLE int3 convert_int3_rte(float3 v); -OVERLOADABLE int3 convert_int3_rtz(float3 v); -OVERLOADABLE int3 convert_int3_rtp(float3 v); -OVERLOADABLE int3 convert_int3_rtn(float3 v); -OVERLOADABLE uint3 convert_uint3_rte(float3 v); -OVERLOADABLE uint3 convert_uint3_rtz(float3 v); -OVERLOADABLE uint3 convert_uint3_rtp(float3 v); -OVERLOADABLE uint3 convert_uint3_rtn(float3 v); -OVERLOADABLE short3 convert_short3_rte(float3 v); -OVERLOADABLE short3 convert_short3_rtz(float3 v); -OVERLOADABLE short3 convert_short3_rtp(float3 v); -OVERLOADABLE short3 convert_short3_rtn(float3 v); -OVERLOADABLE ushort3 convert_ushort3_rte(float3 v); -OVERLOADABLE ushort3 convert_ushort3_rtz(float3 v); -OVERLOADABLE ushort3 convert_ushort3_rtp(float3 v); -OVERLOADABLE ushort3 convert_ushort3_rtn(float3 v); -OVERLOADABLE char3 convert_char3_rte(float3 v); -OVERLOADABLE char3 convert_char3_rtz(float3 v); -OVERLOADABLE char3 convert_char3_rtp(float3 v); -OVERLOADABLE char3 convert_char3_rtn(float3 v); -OVERLOADABLE uchar3 convert_uchar3_rte(float3 v); -OVERLOADABLE uchar3 convert_uchar3_rtz(float3 v); -OVERLOADABLE uchar3 convert_uchar3_rtp(float3 v); -OVERLOADABLE uchar3 convert_uchar3_rtn(float3 v); -OVERLOADABLE float3 convert_float3_rte(float3 v); -OVERLOADABLE float3 convert_float3_rtz(float3 v); -OVERLOADABLE float3 convert_float3_rtp(float3 v); -OVERLOADABLE float3 convert_float3_rtn(float3 v); -OVERLOADABLE half3 convert_half3_rte(float3 v); -OVERLOADABLE half3 convert_half3_rtz(float3 v); -OVERLOADABLE half3 convert_half3_rtp(float3 v); -OVERLOADABLE half3 convert_half3_rtn(float3 v); -OVERLOADABLE long3 convert_long3_rte(half3 v); -OVERLOADABLE long3 convert_long3_rtz(half3 v); -OVERLOADABLE long3 convert_long3_rtp(half3 v); -OVERLOADABLE long3 convert_long3_rtn(half3 v); -OVERLOADABLE ulong3 convert_ulong3_rte(half3 v); -OVERLOADABLE ulong3 convert_ulong3_rtz(half3 v); -OVERLOADABLE ulong3 convert_ulong3_rtp(half3 v); -OVERLOADABLE ulong3 convert_ulong3_rtn(half3 v); -OVERLOADABLE int3 convert_int3_rte(half3 v); -OVERLOADABLE int3 convert_int3_rtz(half3 v); -OVERLOADABLE int3 convert_int3_rtp(half3 v); -OVERLOADABLE int3 convert_int3_rtn(half3 v); -OVERLOADABLE uint3 convert_uint3_rte(half3 v); -OVERLOADABLE uint3 convert_uint3_rtz(half3 v); -OVERLOADABLE uint3 convert_uint3_rtp(half3 v); -OVERLOADABLE uint3 convert_uint3_rtn(half3 v); -OVERLOADABLE short3 convert_short3_rte(half3 v); -OVERLOADABLE short3 convert_short3_rtz(half3 v); -OVERLOADABLE short3 convert_short3_rtp(half3 v); -OVERLOADABLE short3 convert_short3_rtn(half3 v); -OVERLOADABLE ushort3 convert_ushort3_rte(half3 v); -OVERLOADABLE ushort3 convert_ushort3_rtz(half3 v); -OVERLOADABLE ushort3 convert_ushort3_rtp(half3 v); -OVERLOADABLE ushort3 convert_ushort3_rtn(half3 v); -OVERLOADABLE char3 convert_char3_rte(half3 v); -OVERLOADABLE char3 convert_char3_rtz(half3 v); -OVERLOADABLE char3 convert_char3_rtp(half3 v); -OVERLOADABLE char3 convert_char3_rtn(half3 v); -OVERLOADABLE uchar3 convert_uchar3_rte(half3 v); -OVERLOADABLE uchar3 convert_uchar3_rtz(half3 v); -OVERLOADABLE uchar3 convert_uchar3_rtp(half3 v); -OVERLOADABLE uchar3 convert_uchar3_rtn(half3 v); -OVERLOADABLE float3 convert_float3_rte(half3 v); -OVERLOADABLE float3 convert_float3_rtz(half3 v); -OVERLOADABLE float3 convert_float3_rtp(half3 v); -OVERLOADABLE float3 convert_float3_rtn(half3 v); -OVERLOADABLE half3 convert_half3_rte(half3 v); -OVERLOADABLE half3 convert_half3_rtz(half3 v); -OVERLOADABLE half3 convert_half3_rtp(half3 v); -OVERLOADABLE half3 convert_half3_rtn(half3 v); -OVERLOADABLE long4 convert_long4_rte(long4 v); -OVERLOADABLE long4 convert_long4_rtz(long4 v); -OVERLOADABLE long4 convert_long4_rtp(long4 v); -OVERLOADABLE long4 convert_long4_rtn(long4 v); -OVERLOADABLE ulong4 convert_ulong4_rte(long4 v); -OVERLOADABLE ulong4 convert_ulong4_rtz(long4 v); -OVERLOADABLE ulong4 convert_ulong4_rtp(long4 v); -OVERLOADABLE ulong4 convert_ulong4_rtn(long4 v); -OVERLOADABLE int4 convert_int4_rte(long4 v); -OVERLOADABLE int4 convert_int4_rtz(long4 v); -OVERLOADABLE int4 convert_int4_rtp(long4 v); -OVERLOADABLE int4 convert_int4_rtn(long4 v); -OVERLOADABLE uint4 convert_uint4_rte(long4 v); -OVERLOADABLE uint4 convert_uint4_rtz(long4 v); -OVERLOADABLE uint4 convert_uint4_rtp(long4 v); -OVERLOADABLE uint4 convert_uint4_rtn(long4 v); -OVERLOADABLE short4 convert_short4_rte(long4 v); -OVERLOADABLE short4 convert_short4_rtz(long4 v); -OVERLOADABLE short4 convert_short4_rtp(long4 v); -OVERLOADABLE short4 convert_short4_rtn(long4 v); -OVERLOADABLE ushort4 convert_ushort4_rte(long4 v); -OVERLOADABLE ushort4 convert_ushort4_rtz(long4 v); -OVERLOADABLE ushort4 convert_ushort4_rtp(long4 v); -OVERLOADABLE ushort4 convert_ushort4_rtn(long4 v); -OVERLOADABLE char4 convert_char4_rte(long4 v); -OVERLOADABLE char4 convert_char4_rtz(long4 v); -OVERLOADABLE char4 convert_char4_rtp(long4 v); -OVERLOADABLE char4 convert_char4_rtn(long4 v); -OVERLOADABLE uchar4 convert_uchar4_rte(long4 v); -OVERLOADABLE uchar4 convert_uchar4_rtz(long4 v); -OVERLOADABLE uchar4 convert_uchar4_rtp(long4 v); -OVERLOADABLE uchar4 convert_uchar4_rtn(long4 v); -OVERLOADABLE float4 convert_float4_rte(long4 v); -OVERLOADABLE float4 convert_float4_rtz(long4 v); -OVERLOADABLE float4 convert_float4_rtp(long4 v); -OVERLOADABLE float4 convert_float4_rtn(long4 v); -OVERLOADABLE half4 convert_half4_rte(long4 v); -OVERLOADABLE half4 convert_half4_rtz(long4 v); -OVERLOADABLE half4 convert_half4_rtp(long4 v); -OVERLOADABLE half4 convert_half4_rtn(long4 v); -OVERLOADABLE long4 convert_long4_rte(ulong4 v); -OVERLOADABLE long4 convert_long4_rtz(ulong4 v); -OVERLOADABLE long4 convert_long4_rtp(ulong4 v); -OVERLOADABLE long4 convert_long4_rtn(ulong4 v); -OVERLOADABLE ulong4 convert_ulong4_rte(ulong4 v); -OVERLOADABLE ulong4 convert_ulong4_rtz(ulong4 v); -OVERLOADABLE ulong4 convert_ulong4_rtp(ulong4 v); -OVERLOADABLE ulong4 convert_ulong4_rtn(ulong4 v); -OVERLOADABLE int4 convert_int4_rte(ulong4 v); -OVERLOADABLE int4 convert_int4_rtz(ulong4 v); -OVERLOADABLE int4 convert_int4_rtp(ulong4 v); -OVERLOADABLE int4 convert_int4_rtn(ulong4 v); -OVERLOADABLE uint4 convert_uint4_rte(ulong4 v); -OVERLOADABLE uint4 convert_uint4_rtz(ulong4 v); -OVERLOADABLE uint4 convert_uint4_rtp(ulong4 v); -OVERLOADABLE uint4 convert_uint4_rtn(ulong4 v); -OVERLOADABLE short4 convert_short4_rte(ulong4 v); -OVERLOADABLE short4 convert_short4_rtz(ulong4 v); -OVERLOADABLE short4 convert_short4_rtp(ulong4 v); -OVERLOADABLE short4 convert_short4_rtn(ulong4 v); -OVERLOADABLE ushort4 convert_ushort4_rte(ulong4 v); -OVERLOADABLE ushort4 convert_ushort4_rtz(ulong4 v); -OVERLOADABLE ushort4 convert_ushort4_rtp(ulong4 v); -OVERLOADABLE ushort4 convert_ushort4_rtn(ulong4 v); -OVERLOADABLE char4 convert_char4_rte(ulong4 v); -OVERLOADABLE char4 convert_char4_rtz(ulong4 v); -OVERLOADABLE char4 convert_char4_rtp(ulong4 v); -OVERLOADABLE char4 convert_char4_rtn(ulong4 v); -OVERLOADABLE uchar4 convert_uchar4_rte(ulong4 v); -OVERLOADABLE uchar4 convert_uchar4_rtz(ulong4 v); -OVERLOADABLE uchar4 convert_uchar4_rtp(ulong4 v); -OVERLOADABLE uchar4 convert_uchar4_rtn(ulong4 v); -OVERLOADABLE float4 convert_float4_rte(ulong4 v); -OVERLOADABLE float4 convert_float4_rtz(ulong4 v); -OVERLOADABLE float4 convert_float4_rtp(ulong4 v); -OVERLOADABLE float4 convert_float4_rtn(ulong4 v); -OVERLOADABLE half4 convert_half4_rte(ulong4 v); -OVERLOADABLE half4 convert_half4_rtz(ulong4 v); -OVERLOADABLE half4 convert_half4_rtp(ulong4 v); -OVERLOADABLE half4 convert_half4_rtn(ulong4 v); -OVERLOADABLE long4 convert_long4_rte(int4 v); -OVERLOADABLE long4 convert_long4_rtz(int4 v); -OVERLOADABLE long4 convert_long4_rtp(int4 v); -OVERLOADABLE long4 convert_long4_rtn(int4 v); -OVERLOADABLE ulong4 convert_ulong4_rte(int4 v); -OVERLOADABLE ulong4 convert_ulong4_rtz(int4 v); -OVERLOADABLE ulong4 convert_ulong4_rtp(int4 v); -OVERLOADABLE ulong4 convert_ulong4_rtn(int4 v); -OVERLOADABLE int4 convert_int4_rte(int4 v); -OVERLOADABLE int4 convert_int4_rtz(int4 v); -OVERLOADABLE int4 convert_int4_rtp(int4 v); -OVERLOADABLE int4 convert_int4_rtn(int4 v); -OVERLOADABLE uint4 convert_uint4_rte(int4 v); -OVERLOADABLE uint4 convert_uint4_rtz(int4 v); -OVERLOADABLE uint4 convert_uint4_rtp(int4 v); -OVERLOADABLE uint4 convert_uint4_rtn(int4 v); -OVERLOADABLE short4 convert_short4_rte(int4 v); -OVERLOADABLE short4 convert_short4_rtz(int4 v); -OVERLOADABLE short4 convert_short4_rtp(int4 v); -OVERLOADABLE short4 convert_short4_rtn(int4 v); -OVERLOADABLE ushort4 convert_ushort4_rte(int4 v); -OVERLOADABLE ushort4 convert_ushort4_rtz(int4 v); -OVERLOADABLE ushort4 convert_ushort4_rtp(int4 v); -OVERLOADABLE ushort4 convert_ushort4_rtn(int4 v); -OVERLOADABLE char4 convert_char4_rte(int4 v); -OVERLOADABLE char4 convert_char4_rtz(int4 v); -OVERLOADABLE char4 convert_char4_rtp(int4 v); -OVERLOADABLE char4 convert_char4_rtn(int4 v); -OVERLOADABLE uchar4 convert_uchar4_rte(int4 v); -OVERLOADABLE uchar4 convert_uchar4_rtz(int4 v); -OVERLOADABLE uchar4 convert_uchar4_rtp(int4 v); -OVERLOADABLE uchar4 convert_uchar4_rtn(int4 v); -OVERLOADABLE float4 convert_float4_rte(int4 v); -OVERLOADABLE float4 convert_float4_rtz(int4 v); -OVERLOADABLE float4 convert_float4_rtp(int4 v); -OVERLOADABLE float4 convert_float4_rtn(int4 v); -OVERLOADABLE half4 convert_half4_rte(int4 v); -OVERLOADABLE half4 convert_half4_rtz(int4 v); -OVERLOADABLE half4 convert_half4_rtp(int4 v); -OVERLOADABLE half4 convert_half4_rtn(int4 v); -OVERLOADABLE long4 convert_long4_rte(uint4 v); -OVERLOADABLE long4 convert_long4_rtz(uint4 v); -OVERLOADABLE long4 convert_long4_rtp(uint4 v); -OVERLOADABLE long4 convert_long4_rtn(uint4 v); -OVERLOADABLE ulong4 convert_ulong4_rte(uint4 v); -OVERLOADABLE ulong4 convert_ulong4_rtz(uint4 v); -OVERLOADABLE ulong4 convert_ulong4_rtp(uint4 v); -OVERLOADABLE ulong4 convert_ulong4_rtn(uint4 v); -OVERLOADABLE int4 convert_int4_rte(uint4 v); -OVERLOADABLE int4 convert_int4_rtz(uint4 v); -OVERLOADABLE int4 convert_int4_rtp(uint4 v); -OVERLOADABLE int4 convert_int4_rtn(uint4 v); -OVERLOADABLE uint4 convert_uint4_rte(uint4 v); -OVERLOADABLE uint4 convert_uint4_rtz(uint4 v); -OVERLOADABLE uint4 convert_uint4_rtp(uint4 v); -OVERLOADABLE uint4 convert_uint4_rtn(uint4 v); -OVERLOADABLE short4 convert_short4_rte(uint4 v); -OVERLOADABLE short4 convert_short4_rtz(uint4 v); -OVERLOADABLE short4 convert_short4_rtp(uint4 v); -OVERLOADABLE short4 convert_short4_rtn(uint4 v); -OVERLOADABLE ushort4 convert_ushort4_rte(uint4 v); -OVERLOADABLE ushort4 convert_ushort4_rtz(uint4 v); -OVERLOADABLE ushort4 convert_ushort4_rtp(uint4 v); -OVERLOADABLE ushort4 convert_ushort4_rtn(uint4 v); -OVERLOADABLE char4 convert_char4_rte(uint4 v); -OVERLOADABLE char4 convert_char4_rtz(uint4 v); -OVERLOADABLE char4 convert_char4_rtp(uint4 v); -OVERLOADABLE char4 convert_char4_rtn(uint4 v); -OVERLOADABLE uchar4 convert_uchar4_rte(uint4 v); -OVERLOADABLE uchar4 convert_uchar4_rtz(uint4 v); -OVERLOADABLE uchar4 convert_uchar4_rtp(uint4 v); -OVERLOADABLE uchar4 convert_uchar4_rtn(uint4 v); -OVERLOADABLE float4 convert_float4_rte(uint4 v); -OVERLOADABLE float4 convert_float4_rtz(uint4 v); -OVERLOADABLE float4 convert_float4_rtp(uint4 v); -OVERLOADABLE float4 convert_float4_rtn(uint4 v); -OVERLOADABLE half4 convert_half4_rte(uint4 v); -OVERLOADABLE half4 convert_half4_rtz(uint4 v); -OVERLOADABLE half4 convert_half4_rtp(uint4 v); -OVERLOADABLE half4 convert_half4_rtn(uint4 v); -OVERLOADABLE long4 convert_long4_rte(short4 v); -OVERLOADABLE long4 convert_long4_rtz(short4 v); -OVERLOADABLE long4 convert_long4_rtp(short4 v); -OVERLOADABLE long4 convert_long4_rtn(short4 v); -OVERLOADABLE ulong4 convert_ulong4_rte(short4 v); -OVERLOADABLE ulong4 convert_ulong4_rtz(short4 v); -OVERLOADABLE ulong4 convert_ulong4_rtp(short4 v); -OVERLOADABLE ulong4 convert_ulong4_rtn(short4 v); -OVERLOADABLE int4 convert_int4_rte(short4 v); -OVERLOADABLE int4 convert_int4_rtz(short4 v); -OVERLOADABLE int4 convert_int4_rtp(short4 v); -OVERLOADABLE int4 convert_int4_rtn(short4 v); -OVERLOADABLE uint4 convert_uint4_rte(short4 v); -OVERLOADABLE uint4 convert_uint4_rtz(short4 v); -OVERLOADABLE uint4 convert_uint4_rtp(short4 v); -OVERLOADABLE uint4 convert_uint4_rtn(short4 v); -OVERLOADABLE short4 convert_short4_rte(short4 v); -OVERLOADABLE short4 convert_short4_rtz(short4 v); -OVERLOADABLE short4 convert_short4_rtp(short4 v); -OVERLOADABLE short4 convert_short4_rtn(short4 v); -OVERLOADABLE ushort4 convert_ushort4_rte(short4 v); -OVERLOADABLE ushort4 convert_ushort4_rtz(short4 v); -OVERLOADABLE ushort4 convert_ushort4_rtp(short4 v); -OVERLOADABLE ushort4 convert_ushort4_rtn(short4 v); -OVERLOADABLE char4 convert_char4_rte(short4 v); -OVERLOADABLE char4 convert_char4_rtz(short4 v); -OVERLOADABLE char4 convert_char4_rtp(short4 v); -OVERLOADABLE char4 convert_char4_rtn(short4 v); -OVERLOADABLE uchar4 convert_uchar4_rte(short4 v); -OVERLOADABLE uchar4 convert_uchar4_rtz(short4 v); -OVERLOADABLE uchar4 convert_uchar4_rtp(short4 v); -OVERLOADABLE uchar4 convert_uchar4_rtn(short4 v); -OVERLOADABLE float4 convert_float4_rte(short4 v); -OVERLOADABLE float4 convert_float4_rtz(short4 v); -OVERLOADABLE float4 convert_float4_rtp(short4 v); -OVERLOADABLE float4 convert_float4_rtn(short4 v); -OVERLOADABLE half4 convert_half4_rte(short4 v); -OVERLOADABLE half4 convert_half4_rtz(short4 v); -OVERLOADABLE half4 convert_half4_rtp(short4 v); -OVERLOADABLE half4 convert_half4_rtn(short4 v); -OVERLOADABLE long4 convert_long4_rte(ushort4 v); -OVERLOADABLE long4 convert_long4_rtz(ushort4 v); -OVERLOADABLE long4 convert_long4_rtp(ushort4 v); -OVERLOADABLE long4 convert_long4_rtn(ushort4 v); -OVERLOADABLE ulong4 convert_ulong4_rte(ushort4 v); -OVERLOADABLE ulong4 convert_ulong4_rtz(ushort4 v); -OVERLOADABLE ulong4 convert_ulong4_rtp(ushort4 v); -OVERLOADABLE ulong4 convert_ulong4_rtn(ushort4 v); -OVERLOADABLE int4 convert_int4_rte(ushort4 v); -OVERLOADABLE int4 convert_int4_rtz(ushort4 v); -OVERLOADABLE int4 convert_int4_rtp(ushort4 v); -OVERLOADABLE int4 convert_int4_rtn(ushort4 v); -OVERLOADABLE uint4 convert_uint4_rte(ushort4 v); -OVERLOADABLE uint4 convert_uint4_rtz(ushort4 v); -OVERLOADABLE uint4 convert_uint4_rtp(ushort4 v); -OVERLOADABLE uint4 convert_uint4_rtn(ushort4 v); -OVERLOADABLE short4 convert_short4_rte(ushort4 v); -OVERLOADABLE short4 convert_short4_rtz(ushort4 v); -OVERLOADABLE short4 convert_short4_rtp(ushort4 v); -OVERLOADABLE short4 convert_short4_rtn(ushort4 v); -OVERLOADABLE ushort4 convert_ushort4_rte(ushort4 v); -OVERLOADABLE ushort4 convert_ushort4_rtz(ushort4 v); -OVERLOADABLE ushort4 convert_ushort4_rtp(ushort4 v); -OVERLOADABLE ushort4 convert_ushort4_rtn(ushort4 v); -OVERLOADABLE char4 convert_char4_rte(ushort4 v); -OVERLOADABLE char4 convert_char4_rtz(ushort4 v); -OVERLOADABLE char4 convert_char4_rtp(ushort4 v); -OVERLOADABLE char4 convert_char4_rtn(ushort4 v); -OVERLOADABLE uchar4 convert_uchar4_rte(ushort4 v); -OVERLOADABLE uchar4 convert_uchar4_rtz(ushort4 v); -OVERLOADABLE uchar4 convert_uchar4_rtp(ushort4 v); -OVERLOADABLE uchar4 convert_uchar4_rtn(ushort4 v); -OVERLOADABLE float4 convert_float4_rte(ushort4 v); -OVERLOADABLE float4 convert_float4_rtz(ushort4 v); -OVERLOADABLE float4 convert_float4_rtp(ushort4 v); -OVERLOADABLE float4 convert_float4_rtn(ushort4 v); -OVERLOADABLE half4 convert_half4_rte(ushort4 v); -OVERLOADABLE half4 convert_half4_rtz(ushort4 v); -OVERLOADABLE half4 convert_half4_rtp(ushort4 v); -OVERLOADABLE half4 convert_half4_rtn(ushort4 v); -OVERLOADABLE long4 convert_long4_rte(char4 v); -OVERLOADABLE long4 convert_long4_rtz(char4 v); -OVERLOADABLE long4 convert_long4_rtp(char4 v); -OVERLOADABLE long4 convert_long4_rtn(char4 v); -OVERLOADABLE ulong4 convert_ulong4_rte(char4 v); -OVERLOADABLE ulong4 convert_ulong4_rtz(char4 v); -OVERLOADABLE ulong4 convert_ulong4_rtp(char4 v); -OVERLOADABLE ulong4 convert_ulong4_rtn(char4 v); -OVERLOADABLE int4 convert_int4_rte(char4 v); -OVERLOADABLE int4 convert_int4_rtz(char4 v); -OVERLOADABLE int4 convert_int4_rtp(char4 v); -OVERLOADABLE int4 convert_int4_rtn(char4 v); -OVERLOADABLE uint4 convert_uint4_rte(char4 v); -OVERLOADABLE uint4 convert_uint4_rtz(char4 v); -OVERLOADABLE uint4 convert_uint4_rtp(char4 v); -OVERLOADABLE uint4 convert_uint4_rtn(char4 v); -OVERLOADABLE short4 convert_short4_rte(char4 v); -OVERLOADABLE short4 convert_short4_rtz(char4 v); -OVERLOADABLE short4 convert_short4_rtp(char4 v); -OVERLOADABLE short4 convert_short4_rtn(char4 v); -OVERLOADABLE ushort4 convert_ushort4_rte(char4 v); -OVERLOADABLE ushort4 convert_ushort4_rtz(char4 v); -OVERLOADABLE ushort4 convert_ushort4_rtp(char4 v); -OVERLOADABLE ushort4 convert_ushort4_rtn(char4 v); -OVERLOADABLE char4 convert_char4_rte(char4 v); -OVERLOADABLE char4 convert_char4_rtz(char4 v); -OVERLOADABLE char4 convert_char4_rtp(char4 v); -OVERLOADABLE char4 convert_char4_rtn(char4 v); -OVERLOADABLE uchar4 convert_uchar4_rte(char4 v); -OVERLOADABLE uchar4 convert_uchar4_rtz(char4 v); -OVERLOADABLE uchar4 convert_uchar4_rtp(char4 v); -OVERLOADABLE uchar4 convert_uchar4_rtn(char4 v); -OVERLOADABLE float4 convert_float4_rte(char4 v); -OVERLOADABLE float4 convert_float4_rtz(char4 v); -OVERLOADABLE float4 convert_float4_rtp(char4 v); -OVERLOADABLE float4 convert_float4_rtn(char4 v); -OVERLOADABLE half4 convert_half4_rte(char4 v); -OVERLOADABLE half4 convert_half4_rtz(char4 v); -OVERLOADABLE half4 convert_half4_rtp(char4 v); -OVERLOADABLE half4 convert_half4_rtn(char4 v); -OVERLOADABLE long4 convert_long4_rte(uchar4 v); -OVERLOADABLE long4 convert_long4_rtz(uchar4 v); -OVERLOADABLE long4 convert_long4_rtp(uchar4 v); -OVERLOADABLE long4 convert_long4_rtn(uchar4 v); -OVERLOADABLE ulong4 convert_ulong4_rte(uchar4 v); -OVERLOADABLE ulong4 convert_ulong4_rtz(uchar4 v); -OVERLOADABLE ulong4 convert_ulong4_rtp(uchar4 v); -OVERLOADABLE ulong4 convert_ulong4_rtn(uchar4 v); -OVERLOADABLE int4 convert_int4_rte(uchar4 v); -OVERLOADABLE int4 convert_int4_rtz(uchar4 v); -OVERLOADABLE int4 convert_int4_rtp(uchar4 v); -OVERLOADABLE int4 convert_int4_rtn(uchar4 v); -OVERLOADABLE uint4 convert_uint4_rte(uchar4 v); -OVERLOADABLE uint4 convert_uint4_rtz(uchar4 v); -OVERLOADABLE uint4 convert_uint4_rtp(uchar4 v); -OVERLOADABLE uint4 convert_uint4_rtn(uchar4 v); -OVERLOADABLE short4 convert_short4_rte(uchar4 v); -OVERLOADABLE short4 convert_short4_rtz(uchar4 v); -OVERLOADABLE short4 convert_short4_rtp(uchar4 v); -OVERLOADABLE short4 convert_short4_rtn(uchar4 v); -OVERLOADABLE ushort4 convert_ushort4_rte(uchar4 v); -OVERLOADABLE ushort4 convert_ushort4_rtz(uchar4 v); -OVERLOADABLE ushort4 convert_ushort4_rtp(uchar4 v); -OVERLOADABLE ushort4 convert_ushort4_rtn(uchar4 v); -OVERLOADABLE char4 convert_char4_rte(uchar4 v); -OVERLOADABLE char4 convert_char4_rtz(uchar4 v); -OVERLOADABLE char4 convert_char4_rtp(uchar4 v); -OVERLOADABLE char4 convert_char4_rtn(uchar4 v); -OVERLOADABLE uchar4 convert_uchar4_rte(uchar4 v); -OVERLOADABLE uchar4 convert_uchar4_rtz(uchar4 v); -OVERLOADABLE uchar4 convert_uchar4_rtp(uchar4 v); -OVERLOADABLE uchar4 convert_uchar4_rtn(uchar4 v); -OVERLOADABLE float4 convert_float4_rte(uchar4 v); -OVERLOADABLE float4 convert_float4_rtz(uchar4 v); -OVERLOADABLE float4 convert_float4_rtp(uchar4 v); -OVERLOADABLE float4 convert_float4_rtn(uchar4 v); -OVERLOADABLE half4 convert_half4_rte(uchar4 v); -OVERLOADABLE half4 convert_half4_rtz(uchar4 v); -OVERLOADABLE half4 convert_half4_rtp(uchar4 v); -OVERLOADABLE half4 convert_half4_rtn(uchar4 v); -OVERLOADABLE long4 convert_long4_rte(double4 v); -OVERLOADABLE long4 convert_long4_rtz(double4 v); -OVERLOADABLE long4 convert_long4_rtp(double4 v); -OVERLOADABLE long4 convert_long4_rtn(double4 v); -OVERLOADABLE ulong4 convert_ulong4_rte(double4 v); -OVERLOADABLE ulong4 convert_ulong4_rtz(double4 v); -OVERLOADABLE ulong4 convert_ulong4_rtp(double4 v); -OVERLOADABLE ulong4 convert_ulong4_rtn(double4 v); -OVERLOADABLE int4 convert_int4_rte(double4 v); -OVERLOADABLE int4 convert_int4_rtz(double4 v); -OVERLOADABLE int4 convert_int4_rtp(double4 v); -OVERLOADABLE int4 convert_int4_rtn(double4 v); -OVERLOADABLE uint4 convert_uint4_rte(double4 v); -OVERLOADABLE uint4 convert_uint4_rtz(double4 v); -OVERLOADABLE uint4 convert_uint4_rtp(double4 v); -OVERLOADABLE uint4 convert_uint4_rtn(double4 v); -OVERLOADABLE short4 convert_short4_rte(double4 v); -OVERLOADABLE short4 convert_short4_rtz(double4 v); -OVERLOADABLE short4 convert_short4_rtp(double4 v); -OVERLOADABLE short4 convert_short4_rtn(double4 v); -OVERLOADABLE ushort4 convert_ushort4_rte(double4 v); -OVERLOADABLE ushort4 convert_ushort4_rtz(double4 v); -OVERLOADABLE ushort4 convert_ushort4_rtp(double4 v); -OVERLOADABLE ushort4 convert_ushort4_rtn(double4 v); -OVERLOADABLE char4 convert_char4_rte(double4 v); -OVERLOADABLE char4 convert_char4_rtz(double4 v); -OVERLOADABLE char4 convert_char4_rtp(double4 v); -OVERLOADABLE char4 convert_char4_rtn(double4 v); -OVERLOADABLE uchar4 convert_uchar4_rte(double4 v); -OVERLOADABLE uchar4 convert_uchar4_rtz(double4 v); -OVERLOADABLE uchar4 convert_uchar4_rtp(double4 v); -OVERLOADABLE uchar4 convert_uchar4_rtn(double4 v); -OVERLOADABLE float4 convert_float4_rte(double4 v); -OVERLOADABLE float4 convert_float4_rtz(double4 v); -OVERLOADABLE float4 convert_float4_rtp(double4 v); -OVERLOADABLE float4 convert_float4_rtn(double4 v); -OVERLOADABLE half4 convert_half4_rte(double4 v); -OVERLOADABLE half4 convert_half4_rtz(double4 v); -OVERLOADABLE half4 convert_half4_rtp(double4 v); -OVERLOADABLE half4 convert_half4_rtn(double4 v); -OVERLOADABLE long4 convert_long4_rte(float4 v); -OVERLOADABLE long4 convert_long4_rtz(float4 v); -OVERLOADABLE long4 convert_long4_rtp(float4 v); -OVERLOADABLE long4 convert_long4_rtn(float4 v); -OVERLOADABLE ulong4 convert_ulong4_rte(float4 v); -OVERLOADABLE ulong4 convert_ulong4_rtz(float4 v); -OVERLOADABLE ulong4 convert_ulong4_rtp(float4 v); -OVERLOADABLE ulong4 convert_ulong4_rtn(float4 v); -OVERLOADABLE int4 convert_int4_rte(float4 v); -OVERLOADABLE int4 convert_int4_rtz(float4 v); -OVERLOADABLE int4 convert_int4_rtp(float4 v); -OVERLOADABLE int4 convert_int4_rtn(float4 v); -OVERLOADABLE uint4 convert_uint4_rte(float4 v); -OVERLOADABLE uint4 convert_uint4_rtz(float4 v); -OVERLOADABLE uint4 convert_uint4_rtp(float4 v); -OVERLOADABLE uint4 convert_uint4_rtn(float4 v); -OVERLOADABLE short4 convert_short4_rte(float4 v); -OVERLOADABLE short4 convert_short4_rtz(float4 v); -OVERLOADABLE short4 convert_short4_rtp(float4 v); -OVERLOADABLE short4 convert_short4_rtn(float4 v); -OVERLOADABLE ushort4 convert_ushort4_rte(float4 v); -OVERLOADABLE ushort4 convert_ushort4_rtz(float4 v); -OVERLOADABLE ushort4 convert_ushort4_rtp(float4 v); -OVERLOADABLE ushort4 convert_ushort4_rtn(float4 v); -OVERLOADABLE char4 convert_char4_rte(float4 v); -OVERLOADABLE char4 convert_char4_rtz(float4 v); -OVERLOADABLE char4 convert_char4_rtp(float4 v); -OVERLOADABLE char4 convert_char4_rtn(float4 v); -OVERLOADABLE uchar4 convert_uchar4_rte(float4 v); -OVERLOADABLE uchar4 convert_uchar4_rtz(float4 v); -OVERLOADABLE uchar4 convert_uchar4_rtp(float4 v); -OVERLOADABLE uchar4 convert_uchar4_rtn(float4 v); -OVERLOADABLE float4 convert_float4_rte(float4 v); -OVERLOADABLE float4 convert_float4_rtz(float4 v); -OVERLOADABLE float4 convert_float4_rtp(float4 v); -OVERLOADABLE float4 convert_float4_rtn(float4 v); -OVERLOADABLE half4 convert_half4_rte(float4 v); -OVERLOADABLE half4 convert_half4_rtz(float4 v); -OVERLOADABLE half4 convert_half4_rtp(float4 v); -OVERLOADABLE half4 convert_half4_rtn(float4 v); -OVERLOADABLE long4 convert_long4_rte(half4 v); -OVERLOADABLE long4 convert_long4_rtz(half4 v); -OVERLOADABLE long4 convert_long4_rtp(half4 v); -OVERLOADABLE long4 convert_long4_rtn(half4 v); -OVERLOADABLE ulong4 convert_ulong4_rte(half4 v); -OVERLOADABLE ulong4 convert_ulong4_rtz(half4 v); -OVERLOADABLE ulong4 convert_ulong4_rtp(half4 v); -OVERLOADABLE ulong4 convert_ulong4_rtn(half4 v); -OVERLOADABLE int4 convert_int4_rte(half4 v); -OVERLOADABLE int4 convert_int4_rtz(half4 v); -OVERLOADABLE int4 convert_int4_rtp(half4 v); -OVERLOADABLE int4 convert_int4_rtn(half4 v); -OVERLOADABLE uint4 convert_uint4_rte(half4 v); -OVERLOADABLE uint4 convert_uint4_rtz(half4 v); -OVERLOADABLE uint4 convert_uint4_rtp(half4 v); -OVERLOADABLE uint4 convert_uint4_rtn(half4 v); -OVERLOADABLE short4 convert_short4_rte(half4 v); -OVERLOADABLE short4 convert_short4_rtz(half4 v); -OVERLOADABLE short4 convert_short4_rtp(half4 v); -OVERLOADABLE short4 convert_short4_rtn(half4 v); -OVERLOADABLE ushort4 convert_ushort4_rte(half4 v); -OVERLOADABLE ushort4 convert_ushort4_rtz(half4 v); -OVERLOADABLE ushort4 convert_ushort4_rtp(half4 v); -OVERLOADABLE ushort4 convert_ushort4_rtn(half4 v); -OVERLOADABLE char4 convert_char4_rte(half4 v); -OVERLOADABLE char4 convert_char4_rtz(half4 v); -OVERLOADABLE char4 convert_char4_rtp(half4 v); -OVERLOADABLE char4 convert_char4_rtn(half4 v); -OVERLOADABLE uchar4 convert_uchar4_rte(half4 v); -OVERLOADABLE uchar4 convert_uchar4_rtz(half4 v); -OVERLOADABLE uchar4 convert_uchar4_rtp(half4 v); -OVERLOADABLE uchar4 convert_uchar4_rtn(half4 v); -OVERLOADABLE float4 convert_float4_rte(half4 v); -OVERLOADABLE float4 convert_float4_rtz(half4 v); -OVERLOADABLE float4 convert_float4_rtp(half4 v); -OVERLOADABLE float4 convert_float4_rtn(half4 v); -OVERLOADABLE half4 convert_half4_rte(half4 v); -OVERLOADABLE half4 convert_half4_rtz(half4 v); -OVERLOADABLE half4 convert_half4_rtp(half4 v); -OVERLOADABLE half4 convert_half4_rtn(half4 v); -OVERLOADABLE long8 convert_long8_rte(long8 v); -OVERLOADABLE long8 convert_long8_rtz(long8 v); -OVERLOADABLE long8 convert_long8_rtp(long8 v); -OVERLOADABLE long8 convert_long8_rtn(long8 v); -OVERLOADABLE ulong8 convert_ulong8_rte(long8 v); -OVERLOADABLE ulong8 convert_ulong8_rtz(long8 v); -OVERLOADABLE ulong8 convert_ulong8_rtp(long8 v); -OVERLOADABLE ulong8 convert_ulong8_rtn(long8 v); -OVERLOADABLE int8 convert_int8_rte(long8 v); -OVERLOADABLE int8 convert_int8_rtz(long8 v); -OVERLOADABLE int8 convert_int8_rtp(long8 v); -OVERLOADABLE int8 convert_int8_rtn(long8 v); -OVERLOADABLE uint8 convert_uint8_rte(long8 v); -OVERLOADABLE uint8 convert_uint8_rtz(long8 v); -OVERLOADABLE uint8 convert_uint8_rtp(long8 v); -OVERLOADABLE uint8 convert_uint8_rtn(long8 v); -OVERLOADABLE short8 convert_short8_rte(long8 v); -OVERLOADABLE short8 convert_short8_rtz(long8 v); -OVERLOADABLE short8 convert_short8_rtp(long8 v); -OVERLOADABLE short8 convert_short8_rtn(long8 v); -OVERLOADABLE ushort8 convert_ushort8_rte(long8 v); -OVERLOADABLE ushort8 convert_ushort8_rtz(long8 v); -OVERLOADABLE ushort8 convert_ushort8_rtp(long8 v); -OVERLOADABLE ushort8 convert_ushort8_rtn(long8 v); -OVERLOADABLE char8 convert_char8_rte(long8 v); -OVERLOADABLE char8 convert_char8_rtz(long8 v); -OVERLOADABLE char8 convert_char8_rtp(long8 v); -OVERLOADABLE char8 convert_char8_rtn(long8 v); -OVERLOADABLE uchar8 convert_uchar8_rte(long8 v); -OVERLOADABLE uchar8 convert_uchar8_rtz(long8 v); -OVERLOADABLE uchar8 convert_uchar8_rtp(long8 v); -OVERLOADABLE uchar8 convert_uchar8_rtn(long8 v); -OVERLOADABLE float8 convert_float8_rte(long8 v); -OVERLOADABLE float8 convert_float8_rtz(long8 v); -OVERLOADABLE float8 convert_float8_rtp(long8 v); -OVERLOADABLE float8 convert_float8_rtn(long8 v); -OVERLOADABLE half8 convert_half8_rte(long8 v); -OVERLOADABLE half8 convert_half8_rtz(long8 v); -OVERLOADABLE half8 convert_half8_rtp(long8 v); -OVERLOADABLE half8 convert_half8_rtn(long8 v); -OVERLOADABLE long8 convert_long8_rte(ulong8 v); -OVERLOADABLE long8 convert_long8_rtz(ulong8 v); -OVERLOADABLE long8 convert_long8_rtp(ulong8 v); -OVERLOADABLE long8 convert_long8_rtn(ulong8 v); -OVERLOADABLE ulong8 convert_ulong8_rte(ulong8 v); -OVERLOADABLE ulong8 convert_ulong8_rtz(ulong8 v); -OVERLOADABLE ulong8 convert_ulong8_rtp(ulong8 v); -OVERLOADABLE ulong8 convert_ulong8_rtn(ulong8 v); -OVERLOADABLE int8 convert_int8_rte(ulong8 v); -OVERLOADABLE int8 convert_int8_rtz(ulong8 v); -OVERLOADABLE int8 convert_int8_rtp(ulong8 v); -OVERLOADABLE int8 convert_int8_rtn(ulong8 v); -OVERLOADABLE uint8 convert_uint8_rte(ulong8 v); -OVERLOADABLE uint8 convert_uint8_rtz(ulong8 v); -OVERLOADABLE uint8 convert_uint8_rtp(ulong8 v); -OVERLOADABLE uint8 convert_uint8_rtn(ulong8 v); -OVERLOADABLE short8 convert_short8_rte(ulong8 v); -OVERLOADABLE short8 convert_short8_rtz(ulong8 v); -OVERLOADABLE short8 convert_short8_rtp(ulong8 v); -OVERLOADABLE short8 convert_short8_rtn(ulong8 v); -OVERLOADABLE ushort8 convert_ushort8_rte(ulong8 v); -OVERLOADABLE ushort8 convert_ushort8_rtz(ulong8 v); -OVERLOADABLE ushort8 convert_ushort8_rtp(ulong8 v); -OVERLOADABLE ushort8 convert_ushort8_rtn(ulong8 v); -OVERLOADABLE char8 convert_char8_rte(ulong8 v); -OVERLOADABLE char8 convert_char8_rtz(ulong8 v); -OVERLOADABLE char8 convert_char8_rtp(ulong8 v); -OVERLOADABLE char8 convert_char8_rtn(ulong8 v); -OVERLOADABLE uchar8 convert_uchar8_rte(ulong8 v); -OVERLOADABLE uchar8 convert_uchar8_rtz(ulong8 v); -OVERLOADABLE uchar8 convert_uchar8_rtp(ulong8 v); -OVERLOADABLE uchar8 convert_uchar8_rtn(ulong8 v); -OVERLOADABLE float8 convert_float8_rte(ulong8 v); -OVERLOADABLE float8 convert_float8_rtz(ulong8 v); -OVERLOADABLE float8 convert_float8_rtp(ulong8 v); -OVERLOADABLE float8 convert_float8_rtn(ulong8 v); -OVERLOADABLE half8 convert_half8_rte(ulong8 v); -OVERLOADABLE half8 convert_half8_rtz(ulong8 v); -OVERLOADABLE half8 convert_half8_rtp(ulong8 v); -OVERLOADABLE half8 convert_half8_rtn(ulong8 v); -OVERLOADABLE long8 convert_long8_rte(int8 v); -OVERLOADABLE long8 convert_long8_rtz(int8 v); -OVERLOADABLE long8 convert_long8_rtp(int8 v); -OVERLOADABLE long8 convert_long8_rtn(int8 v); -OVERLOADABLE ulong8 convert_ulong8_rte(int8 v); -OVERLOADABLE ulong8 convert_ulong8_rtz(int8 v); -OVERLOADABLE ulong8 convert_ulong8_rtp(int8 v); -OVERLOADABLE ulong8 convert_ulong8_rtn(int8 v); -OVERLOADABLE int8 convert_int8_rte(int8 v); -OVERLOADABLE int8 convert_int8_rtz(int8 v); -OVERLOADABLE int8 convert_int8_rtp(int8 v); -OVERLOADABLE int8 convert_int8_rtn(int8 v); -OVERLOADABLE uint8 convert_uint8_rte(int8 v); -OVERLOADABLE uint8 convert_uint8_rtz(int8 v); -OVERLOADABLE uint8 convert_uint8_rtp(int8 v); -OVERLOADABLE uint8 convert_uint8_rtn(int8 v); -OVERLOADABLE short8 convert_short8_rte(int8 v); -OVERLOADABLE short8 convert_short8_rtz(int8 v); -OVERLOADABLE short8 convert_short8_rtp(int8 v); -OVERLOADABLE short8 convert_short8_rtn(int8 v); -OVERLOADABLE ushort8 convert_ushort8_rte(int8 v); -OVERLOADABLE ushort8 convert_ushort8_rtz(int8 v); -OVERLOADABLE ushort8 convert_ushort8_rtp(int8 v); -OVERLOADABLE ushort8 convert_ushort8_rtn(int8 v); -OVERLOADABLE char8 convert_char8_rte(int8 v); -OVERLOADABLE char8 convert_char8_rtz(int8 v); -OVERLOADABLE char8 convert_char8_rtp(int8 v); -OVERLOADABLE char8 convert_char8_rtn(int8 v); -OVERLOADABLE uchar8 convert_uchar8_rte(int8 v); -OVERLOADABLE uchar8 convert_uchar8_rtz(int8 v); -OVERLOADABLE uchar8 convert_uchar8_rtp(int8 v); -OVERLOADABLE uchar8 convert_uchar8_rtn(int8 v); -OVERLOADABLE float8 convert_float8_rte(int8 v); -OVERLOADABLE float8 convert_float8_rtz(int8 v); -OVERLOADABLE float8 convert_float8_rtp(int8 v); -OVERLOADABLE float8 convert_float8_rtn(int8 v); -OVERLOADABLE half8 convert_half8_rte(int8 v); -OVERLOADABLE half8 convert_half8_rtz(int8 v); -OVERLOADABLE half8 convert_half8_rtp(int8 v); -OVERLOADABLE half8 convert_half8_rtn(int8 v); -OVERLOADABLE long8 convert_long8_rte(uint8 v); -OVERLOADABLE long8 convert_long8_rtz(uint8 v); -OVERLOADABLE long8 convert_long8_rtp(uint8 v); -OVERLOADABLE long8 convert_long8_rtn(uint8 v); -OVERLOADABLE ulong8 convert_ulong8_rte(uint8 v); -OVERLOADABLE ulong8 convert_ulong8_rtz(uint8 v); -OVERLOADABLE ulong8 convert_ulong8_rtp(uint8 v); -OVERLOADABLE ulong8 convert_ulong8_rtn(uint8 v); -OVERLOADABLE int8 convert_int8_rte(uint8 v); -OVERLOADABLE int8 convert_int8_rtz(uint8 v); -OVERLOADABLE int8 convert_int8_rtp(uint8 v); -OVERLOADABLE int8 convert_int8_rtn(uint8 v); -OVERLOADABLE uint8 convert_uint8_rte(uint8 v); -OVERLOADABLE uint8 convert_uint8_rtz(uint8 v); -OVERLOADABLE uint8 convert_uint8_rtp(uint8 v); -OVERLOADABLE uint8 convert_uint8_rtn(uint8 v); -OVERLOADABLE short8 convert_short8_rte(uint8 v); -OVERLOADABLE short8 convert_short8_rtz(uint8 v); -OVERLOADABLE short8 convert_short8_rtp(uint8 v); -OVERLOADABLE short8 convert_short8_rtn(uint8 v); -OVERLOADABLE ushort8 convert_ushort8_rte(uint8 v); -OVERLOADABLE ushort8 convert_ushort8_rtz(uint8 v); -OVERLOADABLE ushort8 convert_ushort8_rtp(uint8 v); -OVERLOADABLE ushort8 convert_ushort8_rtn(uint8 v); -OVERLOADABLE char8 convert_char8_rte(uint8 v); -OVERLOADABLE char8 convert_char8_rtz(uint8 v); -OVERLOADABLE char8 convert_char8_rtp(uint8 v); -OVERLOADABLE char8 convert_char8_rtn(uint8 v); -OVERLOADABLE uchar8 convert_uchar8_rte(uint8 v); -OVERLOADABLE uchar8 convert_uchar8_rtz(uint8 v); -OVERLOADABLE uchar8 convert_uchar8_rtp(uint8 v); -OVERLOADABLE uchar8 convert_uchar8_rtn(uint8 v); -OVERLOADABLE float8 convert_float8_rte(uint8 v); -OVERLOADABLE float8 convert_float8_rtz(uint8 v); -OVERLOADABLE float8 convert_float8_rtp(uint8 v); -OVERLOADABLE float8 convert_float8_rtn(uint8 v); -OVERLOADABLE half8 convert_half8_rte(uint8 v); -OVERLOADABLE half8 convert_half8_rtz(uint8 v); -OVERLOADABLE half8 convert_half8_rtp(uint8 v); -OVERLOADABLE half8 convert_half8_rtn(uint8 v); -OVERLOADABLE long8 convert_long8_rte(short8 v); -OVERLOADABLE long8 convert_long8_rtz(short8 v); -OVERLOADABLE long8 convert_long8_rtp(short8 v); -OVERLOADABLE long8 convert_long8_rtn(short8 v); -OVERLOADABLE ulong8 convert_ulong8_rte(short8 v); -OVERLOADABLE ulong8 convert_ulong8_rtz(short8 v); -OVERLOADABLE ulong8 convert_ulong8_rtp(short8 v); -OVERLOADABLE ulong8 convert_ulong8_rtn(short8 v); -OVERLOADABLE int8 convert_int8_rte(short8 v); -OVERLOADABLE int8 convert_int8_rtz(short8 v); -OVERLOADABLE int8 convert_int8_rtp(short8 v); -OVERLOADABLE int8 convert_int8_rtn(short8 v); -OVERLOADABLE uint8 convert_uint8_rte(short8 v); -OVERLOADABLE uint8 convert_uint8_rtz(short8 v); -OVERLOADABLE uint8 convert_uint8_rtp(short8 v); -OVERLOADABLE uint8 convert_uint8_rtn(short8 v); -OVERLOADABLE short8 convert_short8_rte(short8 v); -OVERLOADABLE short8 convert_short8_rtz(short8 v); -OVERLOADABLE short8 convert_short8_rtp(short8 v); -OVERLOADABLE short8 convert_short8_rtn(short8 v); -OVERLOADABLE ushort8 convert_ushort8_rte(short8 v); -OVERLOADABLE ushort8 convert_ushort8_rtz(short8 v); -OVERLOADABLE ushort8 convert_ushort8_rtp(short8 v); -OVERLOADABLE ushort8 convert_ushort8_rtn(short8 v); -OVERLOADABLE char8 convert_char8_rte(short8 v); -OVERLOADABLE char8 convert_char8_rtz(short8 v); -OVERLOADABLE char8 convert_char8_rtp(short8 v); -OVERLOADABLE char8 convert_char8_rtn(short8 v); -OVERLOADABLE uchar8 convert_uchar8_rte(short8 v); -OVERLOADABLE uchar8 convert_uchar8_rtz(short8 v); -OVERLOADABLE uchar8 convert_uchar8_rtp(short8 v); -OVERLOADABLE uchar8 convert_uchar8_rtn(short8 v); -OVERLOADABLE float8 convert_float8_rte(short8 v); -OVERLOADABLE float8 convert_float8_rtz(short8 v); -OVERLOADABLE float8 convert_float8_rtp(short8 v); -OVERLOADABLE float8 convert_float8_rtn(short8 v); -OVERLOADABLE half8 convert_half8_rte(short8 v); -OVERLOADABLE half8 convert_half8_rtz(short8 v); -OVERLOADABLE half8 convert_half8_rtp(short8 v); -OVERLOADABLE half8 convert_half8_rtn(short8 v); -OVERLOADABLE long8 convert_long8_rte(ushort8 v); -OVERLOADABLE long8 convert_long8_rtz(ushort8 v); -OVERLOADABLE long8 convert_long8_rtp(ushort8 v); -OVERLOADABLE long8 convert_long8_rtn(ushort8 v); -OVERLOADABLE ulong8 convert_ulong8_rte(ushort8 v); -OVERLOADABLE ulong8 convert_ulong8_rtz(ushort8 v); -OVERLOADABLE ulong8 convert_ulong8_rtp(ushort8 v); -OVERLOADABLE ulong8 convert_ulong8_rtn(ushort8 v); -OVERLOADABLE int8 convert_int8_rte(ushort8 v); -OVERLOADABLE int8 convert_int8_rtz(ushort8 v); -OVERLOADABLE int8 convert_int8_rtp(ushort8 v); -OVERLOADABLE int8 convert_int8_rtn(ushort8 v); -OVERLOADABLE uint8 convert_uint8_rte(ushort8 v); -OVERLOADABLE uint8 convert_uint8_rtz(ushort8 v); -OVERLOADABLE uint8 convert_uint8_rtp(ushort8 v); -OVERLOADABLE uint8 convert_uint8_rtn(ushort8 v); -OVERLOADABLE short8 convert_short8_rte(ushort8 v); -OVERLOADABLE short8 convert_short8_rtz(ushort8 v); -OVERLOADABLE short8 convert_short8_rtp(ushort8 v); -OVERLOADABLE short8 convert_short8_rtn(ushort8 v); -OVERLOADABLE ushort8 convert_ushort8_rte(ushort8 v); -OVERLOADABLE ushort8 convert_ushort8_rtz(ushort8 v); -OVERLOADABLE ushort8 convert_ushort8_rtp(ushort8 v); -OVERLOADABLE ushort8 convert_ushort8_rtn(ushort8 v); -OVERLOADABLE char8 convert_char8_rte(ushort8 v); -OVERLOADABLE char8 convert_char8_rtz(ushort8 v); -OVERLOADABLE char8 convert_char8_rtp(ushort8 v); -OVERLOADABLE char8 convert_char8_rtn(ushort8 v); -OVERLOADABLE uchar8 convert_uchar8_rte(ushort8 v); -OVERLOADABLE uchar8 convert_uchar8_rtz(ushort8 v); -OVERLOADABLE uchar8 convert_uchar8_rtp(ushort8 v); -OVERLOADABLE uchar8 convert_uchar8_rtn(ushort8 v); -OVERLOADABLE float8 convert_float8_rte(ushort8 v); -OVERLOADABLE float8 convert_float8_rtz(ushort8 v); -OVERLOADABLE float8 convert_float8_rtp(ushort8 v); -OVERLOADABLE float8 convert_float8_rtn(ushort8 v); -OVERLOADABLE half8 convert_half8_rte(ushort8 v); -OVERLOADABLE half8 convert_half8_rtz(ushort8 v); -OVERLOADABLE half8 convert_half8_rtp(ushort8 v); -OVERLOADABLE half8 convert_half8_rtn(ushort8 v); -OVERLOADABLE long8 convert_long8_rte(char8 v); -OVERLOADABLE long8 convert_long8_rtz(char8 v); -OVERLOADABLE long8 convert_long8_rtp(char8 v); -OVERLOADABLE long8 convert_long8_rtn(char8 v); -OVERLOADABLE ulong8 convert_ulong8_rte(char8 v); -OVERLOADABLE ulong8 convert_ulong8_rtz(char8 v); -OVERLOADABLE ulong8 convert_ulong8_rtp(char8 v); -OVERLOADABLE ulong8 convert_ulong8_rtn(char8 v); -OVERLOADABLE int8 convert_int8_rte(char8 v); -OVERLOADABLE int8 convert_int8_rtz(char8 v); -OVERLOADABLE int8 convert_int8_rtp(char8 v); -OVERLOADABLE int8 convert_int8_rtn(char8 v); -OVERLOADABLE uint8 convert_uint8_rte(char8 v); -OVERLOADABLE uint8 convert_uint8_rtz(char8 v); -OVERLOADABLE uint8 convert_uint8_rtp(char8 v); -OVERLOADABLE uint8 convert_uint8_rtn(char8 v); -OVERLOADABLE short8 convert_short8_rte(char8 v); -OVERLOADABLE short8 convert_short8_rtz(char8 v); -OVERLOADABLE short8 convert_short8_rtp(char8 v); -OVERLOADABLE short8 convert_short8_rtn(char8 v); -OVERLOADABLE ushort8 convert_ushort8_rte(char8 v); -OVERLOADABLE ushort8 convert_ushort8_rtz(char8 v); -OVERLOADABLE ushort8 convert_ushort8_rtp(char8 v); -OVERLOADABLE ushort8 convert_ushort8_rtn(char8 v); -OVERLOADABLE char8 convert_char8_rte(char8 v); -OVERLOADABLE char8 convert_char8_rtz(char8 v); -OVERLOADABLE char8 convert_char8_rtp(char8 v); -OVERLOADABLE char8 convert_char8_rtn(char8 v); -OVERLOADABLE uchar8 convert_uchar8_rte(char8 v); -OVERLOADABLE uchar8 convert_uchar8_rtz(char8 v); -OVERLOADABLE uchar8 convert_uchar8_rtp(char8 v); -OVERLOADABLE uchar8 convert_uchar8_rtn(char8 v); -OVERLOADABLE float8 convert_float8_rte(char8 v); -OVERLOADABLE float8 convert_float8_rtz(char8 v); -OVERLOADABLE float8 convert_float8_rtp(char8 v); -OVERLOADABLE float8 convert_float8_rtn(char8 v); -OVERLOADABLE half8 convert_half8_rte(char8 v); -OVERLOADABLE half8 convert_half8_rtz(char8 v); -OVERLOADABLE half8 convert_half8_rtp(char8 v); -OVERLOADABLE half8 convert_half8_rtn(char8 v); -OVERLOADABLE long8 convert_long8_rte(uchar8 v); -OVERLOADABLE long8 convert_long8_rtz(uchar8 v); -OVERLOADABLE long8 convert_long8_rtp(uchar8 v); -OVERLOADABLE long8 convert_long8_rtn(uchar8 v); -OVERLOADABLE ulong8 convert_ulong8_rte(uchar8 v); -OVERLOADABLE ulong8 convert_ulong8_rtz(uchar8 v); -OVERLOADABLE ulong8 convert_ulong8_rtp(uchar8 v); -OVERLOADABLE ulong8 convert_ulong8_rtn(uchar8 v); -OVERLOADABLE int8 convert_int8_rte(uchar8 v); -OVERLOADABLE int8 convert_int8_rtz(uchar8 v); -OVERLOADABLE int8 convert_int8_rtp(uchar8 v); -OVERLOADABLE int8 convert_int8_rtn(uchar8 v); -OVERLOADABLE uint8 convert_uint8_rte(uchar8 v); -OVERLOADABLE uint8 convert_uint8_rtz(uchar8 v); -OVERLOADABLE uint8 convert_uint8_rtp(uchar8 v); -OVERLOADABLE uint8 convert_uint8_rtn(uchar8 v); -OVERLOADABLE short8 convert_short8_rte(uchar8 v); -OVERLOADABLE short8 convert_short8_rtz(uchar8 v); -OVERLOADABLE short8 convert_short8_rtp(uchar8 v); -OVERLOADABLE short8 convert_short8_rtn(uchar8 v); -OVERLOADABLE ushort8 convert_ushort8_rte(uchar8 v); -OVERLOADABLE ushort8 convert_ushort8_rtz(uchar8 v); -OVERLOADABLE ushort8 convert_ushort8_rtp(uchar8 v); -OVERLOADABLE ushort8 convert_ushort8_rtn(uchar8 v); -OVERLOADABLE char8 convert_char8_rte(uchar8 v); -OVERLOADABLE char8 convert_char8_rtz(uchar8 v); -OVERLOADABLE char8 convert_char8_rtp(uchar8 v); -OVERLOADABLE char8 convert_char8_rtn(uchar8 v); -OVERLOADABLE uchar8 convert_uchar8_rte(uchar8 v); -OVERLOADABLE uchar8 convert_uchar8_rtz(uchar8 v); -OVERLOADABLE uchar8 convert_uchar8_rtp(uchar8 v); -OVERLOADABLE uchar8 convert_uchar8_rtn(uchar8 v); -OVERLOADABLE float8 convert_float8_rte(uchar8 v); -OVERLOADABLE float8 convert_float8_rtz(uchar8 v); -OVERLOADABLE float8 convert_float8_rtp(uchar8 v); -OVERLOADABLE float8 convert_float8_rtn(uchar8 v); -OVERLOADABLE half8 convert_half8_rte(uchar8 v); -OVERLOADABLE half8 convert_half8_rtz(uchar8 v); -OVERLOADABLE half8 convert_half8_rtp(uchar8 v); -OVERLOADABLE half8 convert_half8_rtn(uchar8 v); -OVERLOADABLE long8 convert_long8_rte(double8 v); -OVERLOADABLE long8 convert_long8_rtz(double8 v); -OVERLOADABLE long8 convert_long8_rtp(double8 v); -OVERLOADABLE long8 convert_long8_rtn(double8 v); -OVERLOADABLE ulong8 convert_ulong8_rte(double8 v); -OVERLOADABLE ulong8 convert_ulong8_rtz(double8 v); -OVERLOADABLE ulong8 convert_ulong8_rtp(double8 v); -OVERLOADABLE ulong8 convert_ulong8_rtn(double8 v); -OVERLOADABLE int8 convert_int8_rte(double8 v); -OVERLOADABLE int8 convert_int8_rtz(double8 v); -OVERLOADABLE int8 convert_int8_rtp(double8 v); -OVERLOADABLE int8 convert_int8_rtn(double8 v); -OVERLOADABLE uint8 convert_uint8_rte(double8 v); -OVERLOADABLE uint8 convert_uint8_rtz(double8 v); -OVERLOADABLE uint8 convert_uint8_rtp(double8 v); -OVERLOADABLE uint8 convert_uint8_rtn(double8 v); -OVERLOADABLE short8 convert_short8_rte(double8 v); -OVERLOADABLE short8 convert_short8_rtz(double8 v); -OVERLOADABLE short8 convert_short8_rtp(double8 v); -OVERLOADABLE short8 convert_short8_rtn(double8 v); -OVERLOADABLE ushort8 convert_ushort8_rte(double8 v); -OVERLOADABLE ushort8 convert_ushort8_rtz(double8 v); -OVERLOADABLE ushort8 convert_ushort8_rtp(double8 v); -OVERLOADABLE ushort8 convert_ushort8_rtn(double8 v); -OVERLOADABLE char8 convert_char8_rte(double8 v); -OVERLOADABLE char8 convert_char8_rtz(double8 v); -OVERLOADABLE char8 convert_char8_rtp(double8 v); -OVERLOADABLE char8 convert_char8_rtn(double8 v); -OVERLOADABLE uchar8 convert_uchar8_rte(double8 v); -OVERLOADABLE uchar8 convert_uchar8_rtz(double8 v); -OVERLOADABLE uchar8 convert_uchar8_rtp(double8 v); -OVERLOADABLE uchar8 convert_uchar8_rtn(double8 v); -OVERLOADABLE float8 convert_float8_rte(double8 v); -OVERLOADABLE float8 convert_float8_rtz(double8 v); -OVERLOADABLE float8 convert_float8_rtp(double8 v); -OVERLOADABLE float8 convert_float8_rtn(double8 v); -OVERLOADABLE half8 convert_half8_rte(double8 v); -OVERLOADABLE half8 convert_half8_rtz(double8 v); -OVERLOADABLE half8 convert_half8_rtp(double8 v); -OVERLOADABLE half8 convert_half8_rtn(double8 v); -OVERLOADABLE long8 convert_long8_rte(float8 v); -OVERLOADABLE long8 convert_long8_rtz(float8 v); -OVERLOADABLE long8 convert_long8_rtp(float8 v); -OVERLOADABLE long8 convert_long8_rtn(float8 v); -OVERLOADABLE ulong8 convert_ulong8_rte(float8 v); -OVERLOADABLE ulong8 convert_ulong8_rtz(float8 v); -OVERLOADABLE ulong8 convert_ulong8_rtp(float8 v); -OVERLOADABLE ulong8 convert_ulong8_rtn(float8 v); -OVERLOADABLE int8 convert_int8_rte(float8 v); -OVERLOADABLE int8 convert_int8_rtz(float8 v); -OVERLOADABLE int8 convert_int8_rtp(float8 v); -OVERLOADABLE int8 convert_int8_rtn(float8 v); -OVERLOADABLE uint8 convert_uint8_rte(float8 v); -OVERLOADABLE uint8 convert_uint8_rtz(float8 v); -OVERLOADABLE uint8 convert_uint8_rtp(float8 v); -OVERLOADABLE uint8 convert_uint8_rtn(float8 v); -OVERLOADABLE short8 convert_short8_rte(float8 v); -OVERLOADABLE short8 convert_short8_rtz(float8 v); -OVERLOADABLE short8 convert_short8_rtp(float8 v); -OVERLOADABLE short8 convert_short8_rtn(float8 v); -OVERLOADABLE ushort8 convert_ushort8_rte(float8 v); -OVERLOADABLE ushort8 convert_ushort8_rtz(float8 v); -OVERLOADABLE ushort8 convert_ushort8_rtp(float8 v); -OVERLOADABLE ushort8 convert_ushort8_rtn(float8 v); -OVERLOADABLE char8 convert_char8_rte(float8 v); -OVERLOADABLE char8 convert_char8_rtz(float8 v); -OVERLOADABLE char8 convert_char8_rtp(float8 v); -OVERLOADABLE char8 convert_char8_rtn(float8 v); -OVERLOADABLE uchar8 convert_uchar8_rte(float8 v); -OVERLOADABLE uchar8 convert_uchar8_rtz(float8 v); -OVERLOADABLE uchar8 convert_uchar8_rtp(float8 v); -OVERLOADABLE uchar8 convert_uchar8_rtn(float8 v); -OVERLOADABLE float8 convert_float8_rte(float8 v); -OVERLOADABLE float8 convert_float8_rtz(float8 v); -OVERLOADABLE float8 convert_float8_rtp(float8 v); -OVERLOADABLE float8 convert_float8_rtn(float8 v); -OVERLOADABLE half8 convert_half8_rte(float8 v); -OVERLOADABLE half8 convert_half8_rtz(float8 v); -OVERLOADABLE half8 convert_half8_rtp(float8 v); -OVERLOADABLE half8 convert_half8_rtn(float8 v); -OVERLOADABLE long8 convert_long8_rte(half8 v); -OVERLOADABLE long8 convert_long8_rtz(half8 v); -OVERLOADABLE long8 convert_long8_rtp(half8 v); -OVERLOADABLE long8 convert_long8_rtn(half8 v); -OVERLOADABLE ulong8 convert_ulong8_rte(half8 v); -OVERLOADABLE ulong8 convert_ulong8_rtz(half8 v); -OVERLOADABLE ulong8 convert_ulong8_rtp(half8 v); -OVERLOADABLE ulong8 convert_ulong8_rtn(half8 v); -OVERLOADABLE int8 convert_int8_rte(half8 v); -OVERLOADABLE int8 convert_int8_rtz(half8 v); -OVERLOADABLE int8 convert_int8_rtp(half8 v); -OVERLOADABLE int8 convert_int8_rtn(half8 v); -OVERLOADABLE uint8 convert_uint8_rte(half8 v); -OVERLOADABLE uint8 convert_uint8_rtz(half8 v); -OVERLOADABLE uint8 convert_uint8_rtp(half8 v); -OVERLOADABLE uint8 convert_uint8_rtn(half8 v); -OVERLOADABLE short8 convert_short8_rte(half8 v); -OVERLOADABLE short8 convert_short8_rtz(half8 v); -OVERLOADABLE short8 convert_short8_rtp(half8 v); -OVERLOADABLE short8 convert_short8_rtn(half8 v); -OVERLOADABLE ushort8 convert_ushort8_rte(half8 v); -OVERLOADABLE ushort8 convert_ushort8_rtz(half8 v); -OVERLOADABLE ushort8 convert_ushort8_rtp(half8 v); -OVERLOADABLE ushort8 convert_ushort8_rtn(half8 v); -OVERLOADABLE char8 convert_char8_rte(half8 v); -OVERLOADABLE char8 convert_char8_rtz(half8 v); -OVERLOADABLE char8 convert_char8_rtp(half8 v); -OVERLOADABLE char8 convert_char8_rtn(half8 v); -OVERLOADABLE uchar8 convert_uchar8_rte(half8 v); -OVERLOADABLE uchar8 convert_uchar8_rtz(half8 v); -OVERLOADABLE uchar8 convert_uchar8_rtp(half8 v); -OVERLOADABLE uchar8 convert_uchar8_rtn(half8 v); -OVERLOADABLE float8 convert_float8_rte(half8 v); -OVERLOADABLE float8 convert_float8_rtz(half8 v); -OVERLOADABLE float8 convert_float8_rtp(half8 v); -OVERLOADABLE float8 convert_float8_rtn(half8 v); -OVERLOADABLE half8 convert_half8_rte(half8 v); -OVERLOADABLE half8 convert_half8_rtz(half8 v); -OVERLOADABLE half8 convert_half8_rtp(half8 v); -OVERLOADABLE half8 convert_half8_rtn(half8 v); -OVERLOADABLE long16 convert_long16_rte(long16 v); -OVERLOADABLE long16 convert_long16_rtz(long16 v); -OVERLOADABLE long16 convert_long16_rtp(long16 v); -OVERLOADABLE long16 convert_long16_rtn(long16 v); -OVERLOADABLE ulong16 convert_ulong16_rte(long16 v); -OVERLOADABLE ulong16 convert_ulong16_rtz(long16 v); -OVERLOADABLE ulong16 convert_ulong16_rtp(long16 v); -OVERLOADABLE ulong16 convert_ulong16_rtn(long16 v); -OVERLOADABLE int16 convert_int16_rte(long16 v); -OVERLOADABLE int16 convert_int16_rtz(long16 v); -OVERLOADABLE int16 convert_int16_rtp(long16 v); -OVERLOADABLE int16 convert_int16_rtn(long16 v); -OVERLOADABLE uint16 convert_uint16_rte(long16 v); -OVERLOADABLE uint16 convert_uint16_rtz(long16 v); -OVERLOADABLE uint16 convert_uint16_rtp(long16 v); -OVERLOADABLE uint16 convert_uint16_rtn(long16 v); -OVERLOADABLE short16 convert_short16_rte(long16 v); -OVERLOADABLE short16 convert_short16_rtz(long16 v); -OVERLOADABLE short16 convert_short16_rtp(long16 v); -OVERLOADABLE short16 convert_short16_rtn(long16 v); -OVERLOADABLE ushort16 convert_ushort16_rte(long16 v); -OVERLOADABLE ushort16 convert_ushort16_rtz(long16 v); -OVERLOADABLE ushort16 convert_ushort16_rtp(long16 v); -OVERLOADABLE ushort16 convert_ushort16_rtn(long16 v); -OVERLOADABLE char16 convert_char16_rte(long16 v); -OVERLOADABLE char16 convert_char16_rtz(long16 v); -OVERLOADABLE char16 convert_char16_rtp(long16 v); -OVERLOADABLE char16 convert_char16_rtn(long16 v); -OVERLOADABLE uchar16 convert_uchar16_rte(long16 v); -OVERLOADABLE uchar16 convert_uchar16_rtz(long16 v); -OVERLOADABLE uchar16 convert_uchar16_rtp(long16 v); -OVERLOADABLE uchar16 convert_uchar16_rtn(long16 v); -OVERLOADABLE float16 convert_float16_rte(long16 v); -OVERLOADABLE float16 convert_float16_rtz(long16 v); -OVERLOADABLE float16 convert_float16_rtp(long16 v); -OVERLOADABLE float16 convert_float16_rtn(long16 v); -OVERLOADABLE half16 convert_half16_rte(long16 v); -OVERLOADABLE half16 convert_half16_rtz(long16 v); -OVERLOADABLE half16 convert_half16_rtp(long16 v); -OVERLOADABLE half16 convert_half16_rtn(long16 v); -OVERLOADABLE long16 convert_long16_rte(ulong16 v); -OVERLOADABLE long16 convert_long16_rtz(ulong16 v); -OVERLOADABLE long16 convert_long16_rtp(ulong16 v); -OVERLOADABLE long16 convert_long16_rtn(ulong16 v); -OVERLOADABLE ulong16 convert_ulong16_rte(ulong16 v); -OVERLOADABLE ulong16 convert_ulong16_rtz(ulong16 v); -OVERLOADABLE ulong16 convert_ulong16_rtp(ulong16 v); -OVERLOADABLE ulong16 convert_ulong16_rtn(ulong16 v); -OVERLOADABLE int16 convert_int16_rte(ulong16 v); -OVERLOADABLE int16 convert_int16_rtz(ulong16 v); -OVERLOADABLE int16 convert_int16_rtp(ulong16 v); -OVERLOADABLE int16 convert_int16_rtn(ulong16 v); -OVERLOADABLE uint16 convert_uint16_rte(ulong16 v); -OVERLOADABLE uint16 convert_uint16_rtz(ulong16 v); -OVERLOADABLE uint16 convert_uint16_rtp(ulong16 v); -OVERLOADABLE uint16 convert_uint16_rtn(ulong16 v); -OVERLOADABLE short16 convert_short16_rte(ulong16 v); -OVERLOADABLE short16 convert_short16_rtz(ulong16 v); -OVERLOADABLE short16 convert_short16_rtp(ulong16 v); -OVERLOADABLE short16 convert_short16_rtn(ulong16 v); -OVERLOADABLE ushort16 convert_ushort16_rte(ulong16 v); -OVERLOADABLE ushort16 convert_ushort16_rtz(ulong16 v); -OVERLOADABLE ushort16 convert_ushort16_rtp(ulong16 v); -OVERLOADABLE ushort16 convert_ushort16_rtn(ulong16 v); -OVERLOADABLE char16 convert_char16_rte(ulong16 v); -OVERLOADABLE char16 convert_char16_rtz(ulong16 v); -OVERLOADABLE char16 convert_char16_rtp(ulong16 v); -OVERLOADABLE char16 convert_char16_rtn(ulong16 v); -OVERLOADABLE uchar16 convert_uchar16_rte(ulong16 v); -OVERLOADABLE uchar16 convert_uchar16_rtz(ulong16 v); -OVERLOADABLE uchar16 convert_uchar16_rtp(ulong16 v); -OVERLOADABLE uchar16 convert_uchar16_rtn(ulong16 v); -OVERLOADABLE float16 convert_float16_rte(ulong16 v); -OVERLOADABLE float16 convert_float16_rtz(ulong16 v); -OVERLOADABLE float16 convert_float16_rtp(ulong16 v); -OVERLOADABLE float16 convert_float16_rtn(ulong16 v); -OVERLOADABLE half16 convert_half16_rte(ulong16 v); -OVERLOADABLE half16 convert_half16_rtz(ulong16 v); -OVERLOADABLE half16 convert_half16_rtp(ulong16 v); -OVERLOADABLE half16 convert_half16_rtn(ulong16 v); -OVERLOADABLE long16 convert_long16_rte(int16 v); -OVERLOADABLE long16 convert_long16_rtz(int16 v); -OVERLOADABLE long16 convert_long16_rtp(int16 v); -OVERLOADABLE long16 convert_long16_rtn(int16 v); -OVERLOADABLE ulong16 convert_ulong16_rte(int16 v); -OVERLOADABLE ulong16 convert_ulong16_rtz(int16 v); -OVERLOADABLE ulong16 convert_ulong16_rtp(int16 v); -OVERLOADABLE ulong16 convert_ulong16_rtn(int16 v); -OVERLOADABLE int16 convert_int16_rte(int16 v); -OVERLOADABLE int16 convert_int16_rtz(int16 v); -OVERLOADABLE int16 convert_int16_rtp(int16 v); -OVERLOADABLE int16 convert_int16_rtn(int16 v); -OVERLOADABLE uint16 convert_uint16_rte(int16 v); -OVERLOADABLE uint16 convert_uint16_rtz(int16 v); -OVERLOADABLE uint16 convert_uint16_rtp(int16 v); -OVERLOADABLE uint16 convert_uint16_rtn(int16 v); -OVERLOADABLE short16 convert_short16_rte(int16 v); -OVERLOADABLE short16 convert_short16_rtz(int16 v); -OVERLOADABLE short16 convert_short16_rtp(int16 v); -OVERLOADABLE short16 convert_short16_rtn(int16 v); -OVERLOADABLE ushort16 convert_ushort16_rte(int16 v); -OVERLOADABLE ushort16 convert_ushort16_rtz(int16 v); -OVERLOADABLE ushort16 convert_ushort16_rtp(int16 v); -OVERLOADABLE ushort16 convert_ushort16_rtn(int16 v); -OVERLOADABLE char16 convert_char16_rte(int16 v); -OVERLOADABLE char16 convert_char16_rtz(int16 v); -OVERLOADABLE char16 convert_char16_rtp(int16 v); -OVERLOADABLE char16 convert_char16_rtn(int16 v); -OVERLOADABLE uchar16 convert_uchar16_rte(int16 v); -OVERLOADABLE uchar16 convert_uchar16_rtz(int16 v); -OVERLOADABLE uchar16 convert_uchar16_rtp(int16 v); -OVERLOADABLE uchar16 convert_uchar16_rtn(int16 v); -OVERLOADABLE float16 convert_float16_rte(int16 v); -OVERLOADABLE float16 convert_float16_rtz(int16 v); -OVERLOADABLE float16 convert_float16_rtp(int16 v); -OVERLOADABLE float16 convert_float16_rtn(int16 v); -OVERLOADABLE half16 convert_half16_rte(int16 v); -OVERLOADABLE half16 convert_half16_rtz(int16 v); -OVERLOADABLE half16 convert_half16_rtp(int16 v); -OVERLOADABLE half16 convert_half16_rtn(int16 v); -OVERLOADABLE long16 convert_long16_rte(uint16 v); -OVERLOADABLE long16 convert_long16_rtz(uint16 v); -OVERLOADABLE long16 convert_long16_rtp(uint16 v); -OVERLOADABLE long16 convert_long16_rtn(uint16 v); -OVERLOADABLE ulong16 convert_ulong16_rte(uint16 v); -OVERLOADABLE ulong16 convert_ulong16_rtz(uint16 v); -OVERLOADABLE ulong16 convert_ulong16_rtp(uint16 v); -OVERLOADABLE ulong16 convert_ulong16_rtn(uint16 v); -OVERLOADABLE int16 convert_int16_rte(uint16 v); -OVERLOADABLE int16 convert_int16_rtz(uint16 v); -OVERLOADABLE int16 convert_int16_rtp(uint16 v); -OVERLOADABLE int16 convert_int16_rtn(uint16 v); -OVERLOADABLE uint16 convert_uint16_rte(uint16 v); -OVERLOADABLE uint16 convert_uint16_rtz(uint16 v); -OVERLOADABLE uint16 convert_uint16_rtp(uint16 v); -OVERLOADABLE uint16 convert_uint16_rtn(uint16 v); -OVERLOADABLE short16 convert_short16_rte(uint16 v); -OVERLOADABLE short16 convert_short16_rtz(uint16 v); -OVERLOADABLE short16 convert_short16_rtp(uint16 v); -OVERLOADABLE short16 convert_short16_rtn(uint16 v); -OVERLOADABLE ushort16 convert_ushort16_rte(uint16 v); -OVERLOADABLE ushort16 convert_ushort16_rtz(uint16 v); -OVERLOADABLE ushort16 convert_ushort16_rtp(uint16 v); -OVERLOADABLE ushort16 convert_ushort16_rtn(uint16 v); -OVERLOADABLE char16 convert_char16_rte(uint16 v); -OVERLOADABLE char16 convert_char16_rtz(uint16 v); -OVERLOADABLE char16 convert_char16_rtp(uint16 v); -OVERLOADABLE char16 convert_char16_rtn(uint16 v); -OVERLOADABLE uchar16 convert_uchar16_rte(uint16 v); -OVERLOADABLE uchar16 convert_uchar16_rtz(uint16 v); -OVERLOADABLE uchar16 convert_uchar16_rtp(uint16 v); -OVERLOADABLE uchar16 convert_uchar16_rtn(uint16 v); -OVERLOADABLE float16 convert_float16_rte(uint16 v); -OVERLOADABLE float16 convert_float16_rtz(uint16 v); -OVERLOADABLE float16 convert_float16_rtp(uint16 v); -OVERLOADABLE float16 convert_float16_rtn(uint16 v); -OVERLOADABLE half16 convert_half16_rte(uint16 v); -OVERLOADABLE half16 convert_half16_rtz(uint16 v); -OVERLOADABLE half16 convert_half16_rtp(uint16 v); -OVERLOADABLE half16 convert_half16_rtn(uint16 v); -OVERLOADABLE long16 convert_long16_rte(short16 v); -OVERLOADABLE long16 convert_long16_rtz(short16 v); -OVERLOADABLE long16 convert_long16_rtp(short16 v); -OVERLOADABLE long16 convert_long16_rtn(short16 v); -OVERLOADABLE ulong16 convert_ulong16_rte(short16 v); -OVERLOADABLE ulong16 convert_ulong16_rtz(short16 v); -OVERLOADABLE ulong16 convert_ulong16_rtp(short16 v); -OVERLOADABLE ulong16 convert_ulong16_rtn(short16 v); -OVERLOADABLE int16 convert_int16_rte(short16 v); -OVERLOADABLE int16 convert_int16_rtz(short16 v); -OVERLOADABLE int16 convert_int16_rtp(short16 v); -OVERLOADABLE int16 convert_int16_rtn(short16 v); -OVERLOADABLE uint16 convert_uint16_rte(short16 v); -OVERLOADABLE uint16 convert_uint16_rtz(short16 v); -OVERLOADABLE uint16 convert_uint16_rtp(short16 v); -OVERLOADABLE uint16 convert_uint16_rtn(short16 v); -OVERLOADABLE short16 convert_short16_rte(short16 v); -OVERLOADABLE short16 convert_short16_rtz(short16 v); -OVERLOADABLE short16 convert_short16_rtp(short16 v); -OVERLOADABLE short16 convert_short16_rtn(short16 v); -OVERLOADABLE ushort16 convert_ushort16_rte(short16 v); -OVERLOADABLE ushort16 convert_ushort16_rtz(short16 v); -OVERLOADABLE ushort16 convert_ushort16_rtp(short16 v); -OVERLOADABLE ushort16 convert_ushort16_rtn(short16 v); -OVERLOADABLE char16 convert_char16_rte(short16 v); -OVERLOADABLE char16 convert_char16_rtz(short16 v); -OVERLOADABLE char16 convert_char16_rtp(short16 v); -OVERLOADABLE char16 convert_char16_rtn(short16 v); -OVERLOADABLE uchar16 convert_uchar16_rte(short16 v); -OVERLOADABLE uchar16 convert_uchar16_rtz(short16 v); -OVERLOADABLE uchar16 convert_uchar16_rtp(short16 v); -OVERLOADABLE uchar16 convert_uchar16_rtn(short16 v); -OVERLOADABLE float16 convert_float16_rte(short16 v); -OVERLOADABLE float16 convert_float16_rtz(short16 v); -OVERLOADABLE float16 convert_float16_rtp(short16 v); -OVERLOADABLE float16 convert_float16_rtn(short16 v); -OVERLOADABLE half16 convert_half16_rte(short16 v); -OVERLOADABLE half16 convert_half16_rtz(short16 v); -OVERLOADABLE half16 convert_half16_rtp(short16 v); -OVERLOADABLE half16 convert_half16_rtn(short16 v); -OVERLOADABLE long16 convert_long16_rte(ushort16 v); -OVERLOADABLE long16 convert_long16_rtz(ushort16 v); -OVERLOADABLE long16 convert_long16_rtp(ushort16 v); -OVERLOADABLE long16 convert_long16_rtn(ushort16 v); -OVERLOADABLE ulong16 convert_ulong16_rte(ushort16 v); -OVERLOADABLE ulong16 convert_ulong16_rtz(ushort16 v); -OVERLOADABLE ulong16 convert_ulong16_rtp(ushort16 v); -OVERLOADABLE ulong16 convert_ulong16_rtn(ushort16 v); -OVERLOADABLE int16 convert_int16_rte(ushort16 v); -OVERLOADABLE int16 convert_int16_rtz(ushort16 v); -OVERLOADABLE int16 convert_int16_rtp(ushort16 v); -OVERLOADABLE int16 convert_int16_rtn(ushort16 v); -OVERLOADABLE uint16 convert_uint16_rte(ushort16 v); -OVERLOADABLE uint16 convert_uint16_rtz(ushort16 v); -OVERLOADABLE uint16 convert_uint16_rtp(ushort16 v); -OVERLOADABLE uint16 convert_uint16_rtn(ushort16 v); -OVERLOADABLE short16 convert_short16_rte(ushort16 v); -OVERLOADABLE short16 convert_short16_rtz(ushort16 v); -OVERLOADABLE short16 convert_short16_rtp(ushort16 v); -OVERLOADABLE short16 convert_short16_rtn(ushort16 v); -OVERLOADABLE ushort16 convert_ushort16_rte(ushort16 v); -OVERLOADABLE ushort16 convert_ushort16_rtz(ushort16 v); -OVERLOADABLE ushort16 convert_ushort16_rtp(ushort16 v); -OVERLOADABLE ushort16 convert_ushort16_rtn(ushort16 v); -OVERLOADABLE char16 convert_char16_rte(ushort16 v); -OVERLOADABLE char16 convert_char16_rtz(ushort16 v); -OVERLOADABLE char16 convert_char16_rtp(ushort16 v); -OVERLOADABLE char16 convert_char16_rtn(ushort16 v); -OVERLOADABLE uchar16 convert_uchar16_rte(ushort16 v); -OVERLOADABLE uchar16 convert_uchar16_rtz(ushort16 v); -OVERLOADABLE uchar16 convert_uchar16_rtp(ushort16 v); -OVERLOADABLE uchar16 convert_uchar16_rtn(ushort16 v); -OVERLOADABLE float16 convert_float16_rte(ushort16 v); -OVERLOADABLE float16 convert_float16_rtz(ushort16 v); -OVERLOADABLE float16 convert_float16_rtp(ushort16 v); -OVERLOADABLE float16 convert_float16_rtn(ushort16 v); -OVERLOADABLE half16 convert_half16_rte(ushort16 v); -OVERLOADABLE half16 convert_half16_rtz(ushort16 v); -OVERLOADABLE half16 convert_half16_rtp(ushort16 v); -OVERLOADABLE half16 convert_half16_rtn(ushort16 v); -OVERLOADABLE long16 convert_long16_rte(char16 v); -OVERLOADABLE long16 convert_long16_rtz(char16 v); -OVERLOADABLE long16 convert_long16_rtp(char16 v); -OVERLOADABLE long16 convert_long16_rtn(char16 v); -OVERLOADABLE ulong16 convert_ulong16_rte(char16 v); -OVERLOADABLE ulong16 convert_ulong16_rtz(char16 v); -OVERLOADABLE ulong16 convert_ulong16_rtp(char16 v); -OVERLOADABLE ulong16 convert_ulong16_rtn(char16 v); -OVERLOADABLE int16 convert_int16_rte(char16 v); -OVERLOADABLE int16 convert_int16_rtz(char16 v); -OVERLOADABLE int16 convert_int16_rtp(char16 v); -OVERLOADABLE int16 convert_int16_rtn(char16 v); -OVERLOADABLE uint16 convert_uint16_rte(char16 v); -OVERLOADABLE uint16 convert_uint16_rtz(char16 v); -OVERLOADABLE uint16 convert_uint16_rtp(char16 v); -OVERLOADABLE uint16 convert_uint16_rtn(char16 v); -OVERLOADABLE short16 convert_short16_rte(char16 v); -OVERLOADABLE short16 convert_short16_rtz(char16 v); -OVERLOADABLE short16 convert_short16_rtp(char16 v); -OVERLOADABLE short16 convert_short16_rtn(char16 v); -OVERLOADABLE ushort16 convert_ushort16_rte(char16 v); -OVERLOADABLE ushort16 convert_ushort16_rtz(char16 v); -OVERLOADABLE ushort16 convert_ushort16_rtp(char16 v); -OVERLOADABLE ushort16 convert_ushort16_rtn(char16 v); -OVERLOADABLE char16 convert_char16_rte(char16 v); -OVERLOADABLE char16 convert_char16_rtz(char16 v); -OVERLOADABLE char16 convert_char16_rtp(char16 v); -OVERLOADABLE char16 convert_char16_rtn(char16 v); -OVERLOADABLE uchar16 convert_uchar16_rte(char16 v); -OVERLOADABLE uchar16 convert_uchar16_rtz(char16 v); -OVERLOADABLE uchar16 convert_uchar16_rtp(char16 v); -OVERLOADABLE uchar16 convert_uchar16_rtn(char16 v); -OVERLOADABLE float16 convert_float16_rte(char16 v); -OVERLOADABLE float16 convert_float16_rtz(char16 v); -OVERLOADABLE float16 convert_float16_rtp(char16 v); -OVERLOADABLE float16 convert_float16_rtn(char16 v); -OVERLOADABLE half16 convert_half16_rte(char16 v); -OVERLOADABLE half16 convert_half16_rtz(char16 v); -OVERLOADABLE half16 convert_half16_rtp(char16 v); -OVERLOADABLE half16 convert_half16_rtn(char16 v); -OVERLOADABLE long16 convert_long16_rte(uchar16 v); -OVERLOADABLE long16 convert_long16_rtz(uchar16 v); -OVERLOADABLE long16 convert_long16_rtp(uchar16 v); -OVERLOADABLE long16 convert_long16_rtn(uchar16 v); -OVERLOADABLE ulong16 convert_ulong16_rte(uchar16 v); -OVERLOADABLE ulong16 convert_ulong16_rtz(uchar16 v); -OVERLOADABLE ulong16 convert_ulong16_rtp(uchar16 v); -OVERLOADABLE ulong16 convert_ulong16_rtn(uchar16 v); -OVERLOADABLE int16 convert_int16_rte(uchar16 v); -OVERLOADABLE int16 convert_int16_rtz(uchar16 v); -OVERLOADABLE int16 convert_int16_rtp(uchar16 v); -OVERLOADABLE int16 convert_int16_rtn(uchar16 v); -OVERLOADABLE uint16 convert_uint16_rte(uchar16 v); -OVERLOADABLE uint16 convert_uint16_rtz(uchar16 v); -OVERLOADABLE uint16 convert_uint16_rtp(uchar16 v); -OVERLOADABLE uint16 convert_uint16_rtn(uchar16 v); -OVERLOADABLE short16 convert_short16_rte(uchar16 v); -OVERLOADABLE short16 convert_short16_rtz(uchar16 v); -OVERLOADABLE short16 convert_short16_rtp(uchar16 v); -OVERLOADABLE short16 convert_short16_rtn(uchar16 v); -OVERLOADABLE ushort16 convert_ushort16_rte(uchar16 v); -OVERLOADABLE ushort16 convert_ushort16_rtz(uchar16 v); -OVERLOADABLE ushort16 convert_ushort16_rtp(uchar16 v); -OVERLOADABLE ushort16 convert_ushort16_rtn(uchar16 v); -OVERLOADABLE char16 convert_char16_rte(uchar16 v); -OVERLOADABLE char16 convert_char16_rtz(uchar16 v); -OVERLOADABLE char16 convert_char16_rtp(uchar16 v); -OVERLOADABLE char16 convert_char16_rtn(uchar16 v); -OVERLOADABLE uchar16 convert_uchar16_rte(uchar16 v); -OVERLOADABLE uchar16 convert_uchar16_rtz(uchar16 v); -OVERLOADABLE uchar16 convert_uchar16_rtp(uchar16 v); -OVERLOADABLE uchar16 convert_uchar16_rtn(uchar16 v); -OVERLOADABLE float16 convert_float16_rte(uchar16 v); -OVERLOADABLE float16 convert_float16_rtz(uchar16 v); -OVERLOADABLE float16 convert_float16_rtp(uchar16 v); -OVERLOADABLE float16 convert_float16_rtn(uchar16 v); -OVERLOADABLE half16 convert_half16_rte(uchar16 v); -OVERLOADABLE half16 convert_half16_rtz(uchar16 v); -OVERLOADABLE half16 convert_half16_rtp(uchar16 v); -OVERLOADABLE half16 convert_half16_rtn(uchar16 v); -OVERLOADABLE long16 convert_long16_rte(double16 v); -OVERLOADABLE long16 convert_long16_rtz(double16 v); -OVERLOADABLE long16 convert_long16_rtp(double16 v); -OVERLOADABLE long16 convert_long16_rtn(double16 v); -OVERLOADABLE ulong16 convert_ulong16_rte(double16 v); -OVERLOADABLE ulong16 convert_ulong16_rtz(double16 v); -OVERLOADABLE ulong16 convert_ulong16_rtp(double16 v); -OVERLOADABLE ulong16 convert_ulong16_rtn(double16 v); -OVERLOADABLE int16 convert_int16_rte(double16 v); -OVERLOADABLE int16 convert_int16_rtz(double16 v); -OVERLOADABLE int16 convert_int16_rtp(double16 v); -OVERLOADABLE int16 convert_int16_rtn(double16 v); -OVERLOADABLE uint16 convert_uint16_rte(double16 v); -OVERLOADABLE uint16 convert_uint16_rtz(double16 v); -OVERLOADABLE uint16 convert_uint16_rtp(double16 v); -OVERLOADABLE uint16 convert_uint16_rtn(double16 v); -OVERLOADABLE short16 convert_short16_rte(double16 v); -OVERLOADABLE short16 convert_short16_rtz(double16 v); -OVERLOADABLE short16 convert_short16_rtp(double16 v); -OVERLOADABLE short16 convert_short16_rtn(double16 v); -OVERLOADABLE ushort16 convert_ushort16_rte(double16 v); -OVERLOADABLE ushort16 convert_ushort16_rtz(double16 v); -OVERLOADABLE ushort16 convert_ushort16_rtp(double16 v); -OVERLOADABLE ushort16 convert_ushort16_rtn(double16 v); -OVERLOADABLE char16 convert_char16_rte(double16 v); -OVERLOADABLE char16 convert_char16_rtz(double16 v); -OVERLOADABLE char16 convert_char16_rtp(double16 v); -OVERLOADABLE char16 convert_char16_rtn(double16 v); -OVERLOADABLE uchar16 convert_uchar16_rte(double16 v); -OVERLOADABLE uchar16 convert_uchar16_rtz(double16 v); -OVERLOADABLE uchar16 convert_uchar16_rtp(double16 v); -OVERLOADABLE uchar16 convert_uchar16_rtn(double16 v); -OVERLOADABLE float16 convert_float16_rte(double16 v); -OVERLOADABLE float16 convert_float16_rtz(double16 v); -OVERLOADABLE float16 convert_float16_rtp(double16 v); -OVERLOADABLE float16 convert_float16_rtn(double16 v); -OVERLOADABLE half16 convert_half16_rte(double16 v); -OVERLOADABLE half16 convert_half16_rtz(double16 v); -OVERLOADABLE half16 convert_half16_rtp(double16 v); -OVERLOADABLE half16 convert_half16_rtn(double16 v); -OVERLOADABLE long16 convert_long16_rte(float16 v); -OVERLOADABLE long16 convert_long16_rtz(float16 v); -OVERLOADABLE long16 convert_long16_rtp(float16 v); -OVERLOADABLE long16 convert_long16_rtn(float16 v); -OVERLOADABLE ulong16 convert_ulong16_rte(float16 v); -OVERLOADABLE ulong16 convert_ulong16_rtz(float16 v); -OVERLOADABLE ulong16 convert_ulong16_rtp(float16 v); -OVERLOADABLE ulong16 convert_ulong16_rtn(float16 v); -OVERLOADABLE int16 convert_int16_rte(float16 v); -OVERLOADABLE int16 convert_int16_rtz(float16 v); -OVERLOADABLE int16 convert_int16_rtp(float16 v); -OVERLOADABLE int16 convert_int16_rtn(float16 v); -OVERLOADABLE uint16 convert_uint16_rte(float16 v); -OVERLOADABLE uint16 convert_uint16_rtz(float16 v); -OVERLOADABLE uint16 convert_uint16_rtp(float16 v); -OVERLOADABLE uint16 convert_uint16_rtn(float16 v); -OVERLOADABLE short16 convert_short16_rte(float16 v); -OVERLOADABLE short16 convert_short16_rtz(float16 v); -OVERLOADABLE short16 convert_short16_rtp(float16 v); -OVERLOADABLE short16 convert_short16_rtn(float16 v); -OVERLOADABLE ushort16 convert_ushort16_rte(float16 v); -OVERLOADABLE ushort16 convert_ushort16_rtz(float16 v); -OVERLOADABLE ushort16 convert_ushort16_rtp(float16 v); -OVERLOADABLE ushort16 convert_ushort16_rtn(float16 v); -OVERLOADABLE char16 convert_char16_rte(float16 v); -OVERLOADABLE char16 convert_char16_rtz(float16 v); -OVERLOADABLE char16 convert_char16_rtp(float16 v); -OVERLOADABLE char16 convert_char16_rtn(float16 v); -OVERLOADABLE uchar16 convert_uchar16_rte(float16 v); -OVERLOADABLE uchar16 convert_uchar16_rtz(float16 v); -OVERLOADABLE uchar16 convert_uchar16_rtp(float16 v); -OVERLOADABLE uchar16 convert_uchar16_rtn(float16 v); -OVERLOADABLE float16 convert_float16_rte(float16 v); -OVERLOADABLE float16 convert_float16_rtz(float16 v); -OVERLOADABLE float16 convert_float16_rtp(float16 v); -OVERLOADABLE float16 convert_float16_rtn(float16 v); -OVERLOADABLE half16 convert_half16_rte(float16 v); -OVERLOADABLE half16 convert_half16_rtz(float16 v); -OVERLOADABLE half16 convert_half16_rtp(float16 v); -OVERLOADABLE half16 convert_half16_rtn(float16 v); -OVERLOADABLE long16 convert_long16_rte(half16 v); -OVERLOADABLE long16 convert_long16_rtz(half16 v); -OVERLOADABLE long16 convert_long16_rtp(half16 v); -OVERLOADABLE long16 convert_long16_rtn(half16 v); -OVERLOADABLE ulong16 convert_ulong16_rte(half16 v); -OVERLOADABLE ulong16 convert_ulong16_rtz(half16 v); -OVERLOADABLE ulong16 convert_ulong16_rtp(half16 v); -OVERLOADABLE ulong16 convert_ulong16_rtn(half16 v); -OVERLOADABLE int16 convert_int16_rte(half16 v); -OVERLOADABLE int16 convert_int16_rtz(half16 v); -OVERLOADABLE int16 convert_int16_rtp(half16 v); -OVERLOADABLE int16 convert_int16_rtn(half16 v); -OVERLOADABLE uint16 convert_uint16_rte(half16 v); -OVERLOADABLE uint16 convert_uint16_rtz(half16 v); -OVERLOADABLE uint16 convert_uint16_rtp(half16 v); -OVERLOADABLE uint16 convert_uint16_rtn(half16 v); -OVERLOADABLE short16 convert_short16_rte(half16 v); -OVERLOADABLE short16 convert_short16_rtz(half16 v); -OVERLOADABLE short16 convert_short16_rtp(half16 v); -OVERLOADABLE short16 convert_short16_rtn(half16 v); -OVERLOADABLE ushort16 convert_ushort16_rte(half16 v); -OVERLOADABLE ushort16 convert_ushort16_rtz(half16 v); -OVERLOADABLE ushort16 convert_ushort16_rtp(half16 v); -OVERLOADABLE ushort16 convert_ushort16_rtn(half16 v); -OVERLOADABLE char16 convert_char16_rte(half16 v); -OVERLOADABLE char16 convert_char16_rtz(half16 v); -OVERLOADABLE char16 convert_char16_rtp(half16 v); -OVERLOADABLE char16 convert_char16_rtn(half16 v); -OVERLOADABLE uchar16 convert_uchar16_rte(half16 v); -OVERLOADABLE uchar16 convert_uchar16_rtz(half16 v); -OVERLOADABLE uchar16 convert_uchar16_rtp(half16 v); -OVERLOADABLE uchar16 convert_uchar16_rtn(half16 v); -OVERLOADABLE float16 convert_float16_rte(half16 v); -OVERLOADABLE float16 convert_float16_rtz(half16 v); -OVERLOADABLE float16 convert_float16_rtp(half16 v); -OVERLOADABLE float16 convert_float16_rtn(half16 v); -OVERLOADABLE half16 convert_half16_rte(half16 v); -OVERLOADABLE half16 convert_half16_rtz(half16 v); -OVERLOADABLE half16 convert_half16_rtp(half16 v); -OVERLOADABLE half16 convert_half16_rtn(half16 v); -#define DEF(DSTTYPE, SRCTYPE, SRC_MIN, SRC_MAX, DST_MIN, DST_MAX) OVERLOADABLE DSTTYPE convert_ ## DSTTYPE ## _sat_rte(SRCTYPE x); OVERLOADABLE DSTTYPE convert_ ## DSTTYPE ## _sat_rtz(SRCTYPE x); OVERLOADABLE DSTTYPE convert_ ## DSTTYPE ## _sat_rtn(SRCTYPE x); OVERLOADABLE DSTTYPE convert_ ## DSTTYPE ## _sat_rtp(SRCTYPE x); - - DEF(char, double, -0x1.0p7, 0x1.0p7-1, 0x80, 0x7F); - DEF(uchar, double, 0, 0x1.0p8-1, 0, 0xFF); - DEF(short, double, -0x1.0p15, 0x1.0p15-1, 0x8000, 0x7FFF); - DEF(ushort, double, 0, 0x1.0p16-1, 0, 0xFFFF); - DEF(int, double, -0x1.0p31, 0x1.0p31-1, 0x80000000, 0x7FFFFFFF); - DEF(uint, double, 0, 0x1.0p32-1, 0, 0xFFFFFFFF); - DEF(long, double, -0x1.0p63, 0x1.0p63, 0x8000000000000000, 0x7FFFFFFFFFFFFFFF); - DEF(ulong, double, 0, 0x1.0p64, 0, 0xFFFFFFFFFFFFFFFF); - #undef DEF - -OVERLOADABLE long convert_long_sat_rte(long x); -OVERLOADABLE long convert_long_sat_rtz(long x); -OVERLOADABLE long convert_long_sat_rtp(long x); -OVERLOADABLE long convert_long_sat_rtn(long x); -OVERLOADABLE ulong convert_ulong_sat_rte(long x); -OVERLOADABLE ulong convert_ulong_sat_rtz(long x); -OVERLOADABLE ulong convert_ulong_sat_rtp(long x); -OVERLOADABLE ulong convert_ulong_sat_rtn(long x); -OVERLOADABLE int convert_int_sat_rte(long x); -OVERLOADABLE int convert_int_sat_rtz(long x); -OVERLOADABLE int convert_int_sat_rtp(long x); -OVERLOADABLE int convert_int_sat_rtn(long x); -OVERLOADABLE uint convert_uint_sat_rte(long x); -OVERLOADABLE uint convert_uint_sat_rtz(long x); -OVERLOADABLE uint convert_uint_sat_rtp(long x); -OVERLOADABLE uint convert_uint_sat_rtn(long x); -OVERLOADABLE short convert_short_sat_rte(long x); -OVERLOADABLE short convert_short_sat_rtz(long x); -OVERLOADABLE short convert_short_sat_rtp(long x); -OVERLOADABLE short convert_short_sat_rtn(long x); -OVERLOADABLE ushort convert_ushort_sat_rte(long x); -OVERLOADABLE ushort convert_ushort_sat_rtz(long x); -OVERLOADABLE ushort convert_ushort_sat_rtp(long x); -OVERLOADABLE ushort convert_ushort_sat_rtn(long x); -OVERLOADABLE char convert_char_sat_rte(long x); -OVERLOADABLE char convert_char_sat_rtz(long x); -OVERLOADABLE char convert_char_sat_rtp(long x); -OVERLOADABLE char convert_char_sat_rtn(long x); -OVERLOADABLE uchar convert_uchar_sat_rte(long x); -OVERLOADABLE uchar convert_uchar_sat_rtz(long x); -OVERLOADABLE uchar convert_uchar_sat_rtp(long x); -OVERLOADABLE uchar convert_uchar_sat_rtn(long x); -OVERLOADABLE long convert_long_sat_rte(ulong x); -OVERLOADABLE long convert_long_sat_rtz(ulong x); -OVERLOADABLE long convert_long_sat_rtp(ulong x); -OVERLOADABLE long convert_long_sat_rtn(ulong x); -OVERLOADABLE ulong convert_ulong_sat_rte(ulong x); -OVERLOADABLE ulong convert_ulong_sat_rtz(ulong x); -OVERLOADABLE ulong convert_ulong_sat_rtp(ulong x); -OVERLOADABLE ulong convert_ulong_sat_rtn(ulong x); -OVERLOADABLE int convert_int_sat_rte(ulong x); -OVERLOADABLE int convert_int_sat_rtz(ulong x); -OVERLOADABLE int convert_int_sat_rtp(ulong x); -OVERLOADABLE int convert_int_sat_rtn(ulong x); -OVERLOADABLE uint convert_uint_sat_rte(ulong x); -OVERLOADABLE uint convert_uint_sat_rtz(ulong x); -OVERLOADABLE uint convert_uint_sat_rtp(ulong x); -OVERLOADABLE uint convert_uint_sat_rtn(ulong x); -OVERLOADABLE short convert_short_sat_rte(ulong x); -OVERLOADABLE short convert_short_sat_rtz(ulong x); -OVERLOADABLE short convert_short_sat_rtp(ulong x); -OVERLOADABLE short convert_short_sat_rtn(ulong x); -OVERLOADABLE ushort convert_ushort_sat_rte(ulong x); -OVERLOADABLE ushort convert_ushort_sat_rtz(ulong x); -OVERLOADABLE ushort convert_ushort_sat_rtp(ulong x); -OVERLOADABLE ushort convert_ushort_sat_rtn(ulong x); -OVERLOADABLE char convert_char_sat_rte(ulong x); -OVERLOADABLE char convert_char_sat_rtz(ulong x); -OVERLOADABLE char convert_char_sat_rtp(ulong x); -OVERLOADABLE char convert_char_sat_rtn(ulong x); -OVERLOADABLE uchar convert_uchar_sat_rte(ulong x); -OVERLOADABLE uchar convert_uchar_sat_rtz(ulong x); -OVERLOADABLE uchar convert_uchar_sat_rtp(ulong x); -OVERLOADABLE uchar convert_uchar_sat_rtn(ulong x); -OVERLOADABLE long convert_long_sat_rte(int x); -OVERLOADABLE long convert_long_sat_rtz(int x); -OVERLOADABLE long convert_long_sat_rtp(int x); -OVERLOADABLE long convert_long_sat_rtn(int x); -OVERLOADABLE ulong convert_ulong_sat_rte(int x); -OVERLOADABLE ulong convert_ulong_sat_rtz(int x); -OVERLOADABLE ulong convert_ulong_sat_rtp(int x); -OVERLOADABLE ulong convert_ulong_sat_rtn(int x); -OVERLOADABLE int convert_int_sat_rte(int x); -OVERLOADABLE int convert_int_sat_rtz(int x); -OVERLOADABLE int convert_int_sat_rtp(int x); -OVERLOADABLE int convert_int_sat_rtn(int x); -OVERLOADABLE uint convert_uint_sat_rte(int x); -OVERLOADABLE uint convert_uint_sat_rtz(int x); -OVERLOADABLE uint convert_uint_sat_rtp(int x); -OVERLOADABLE uint convert_uint_sat_rtn(int x); -OVERLOADABLE short convert_short_sat_rte(int x); -OVERLOADABLE short convert_short_sat_rtz(int x); -OVERLOADABLE short convert_short_sat_rtp(int x); -OVERLOADABLE short convert_short_sat_rtn(int x); -OVERLOADABLE ushort convert_ushort_sat_rte(int x); -OVERLOADABLE ushort convert_ushort_sat_rtz(int x); -OVERLOADABLE ushort convert_ushort_sat_rtp(int x); -OVERLOADABLE ushort convert_ushort_sat_rtn(int x); -OVERLOADABLE char convert_char_sat_rte(int x); -OVERLOADABLE char convert_char_sat_rtz(int x); -OVERLOADABLE char convert_char_sat_rtp(int x); -OVERLOADABLE char convert_char_sat_rtn(int x); -OVERLOADABLE uchar convert_uchar_sat_rte(int x); -OVERLOADABLE uchar convert_uchar_sat_rtz(int x); -OVERLOADABLE uchar convert_uchar_sat_rtp(int x); -OVERLOADABLE uchar convert_uchar_sat_rtn(int x); -OVERLOADABLE long convert_long_sat_rte(uint x); -OVERLOADABLE long convert_long_sat_rtz(uint x); -OVERLOADABLE long convert_long_sat_rtp(uint x); -OVERLOADABLE long convert_long_sat_rtn(uint x); -OVERLOADABLE ulong convert_ulong_sat_rte(uint x); -OVERLOADABLE ulong convert_ulong_sat_rtz(uint x); -OVERLOADABLE ulong convert_ulong_sat_rtp(uint x); -OVERLOADABLE ulong convert_ulong_sat_rtn(uint x); -OVERLOADABLE int convert_int_sat_rte(uint x); -OVERLOADABLE int convert_int_sat_rtz(uint x); -OVERLOADABLE int convert_int_sat_rtp(uint x); -OVERLOADABLE int convert_int_sat_rtn(uint x); -OVERLOADABLE uint convert_uint_sat_rte(uint x); -OVERLOADABLE uint convert_uint_sat_rtz(uint x); -OVERLOADABLE uint convert_uint_sat_rtp(uint x); -OVERLOADABLE uint convert_uint_sat_rtn(uint x); -OVERLOADABLE short convert_short_sat_rte(uint x); -OVERLOADABLE short convert_short_sat_rtz(uint x); -OVERLOADABLE short convert_short_sat_rtp(uint x); -OVERLOADABLE short convert_short_sat_rtn(uint x); -OVERLOADABLE ushort convert_ushort_sat_rte(uint x); -OVERLOADABLE ushort convert_ushort_sat_rtz(uint x); -OVERLOADABLE ushort convert_ushort_sat_rtp(uint x); -OVERLOADABLE ushort convert_ushort_sat_rtn(uint x); -OVERLOADABLE char convert_char_sat_rte(uint x); -OVERLOADABLE char convert_char_sat_rtz(uint x); -OVERLOADABLE char convert_char_sat_rtp(uint x); -OVERLOADABLE char convert_char_sat_rtn(uint x); -OVERLOADABLE uchar convert_uchar_sat_rte(uint x); -OVERLOADABLE uchar convert_uchar_sat_rtz(uint x); -OVERLOADABLE uchar convert_uchar_sat_rtp(uint x); -OVERLOADABLE uchar convert_uchar_sat_rtn(uint x); -OVERLOADABLE long convert_long_sat_rte(short x); -OVERLOADABLE long convert_long_sat_rtz(short x); -OVERLOADABLE long convert_long_sat_rtp(short x); -OVERLOADABLE long convert_long_sat_rtn(short x); -OVERLOADABLE ulong convert_ulong_sat_rte(short x); -OVERLOADABLE ulong convert_ulong_sat_rtz(short x); -OVERLOADABLE ulong convert_ulong_sat_rtp(short x); -OVERLOADABLE ulong convert_ulong_sat_rtn(short x); -OVERLOADABLE int convert_int_sat_rte(short x); -OVERLOADABLE int convert_int_sat_rtz(short x); -OVERLOADABLE int convert_int_sat_rtp(short x); -OVERLOADABLE int convert_int_sat_rtn(short x); -OVERLOADABLE uint convert_uint_sat_rte(short x); -OVERLOADABLE uint convert_uint_sat_rtz(short x); -OVERLOADABLE uint convert_uint_sat_rtp(short x); -OVERLOADABLE uint convert_uint_sat_rtn(short x); -OVERLOADABLE short convert_short_sat_rte(short x); -OVERLOADABLE short convert_short_sat_rtz(short x); -OVERLOADABLE short convert_short_sat_rtp(short x); -OVERLOADABLE short convert_short_sat_rtn(short x); -OVERLOADABLE ushort convert_ushort_sat_rte(short x); -OVERLOADABLE ushort convert_ushort_sat_rtz(short x); -OVERLOADABLE ushort convert_ushort_sat_rtp(short x); -OVERLOADABLE ushort convert_ushort_sat_rtn(short x); -OVERLOADABLE char convert_char_sat_rte(short x); -OVERLOADABLE char convert_char_sat_rtz(short x); -OVERLOADABLE char convert_char_sat_rtp(short x); -OVERLOADABLE char convert_char_sat_rtn(short x); -OVERLOADABLE uchar convert_uchar_sat_rte(short x); -OVERLOADABLE uchar convert_uchar_sat_rtz(short x); -OVERLOADABLE uchar convert_uchar_sat_rtp(short x); -OVERLOADABLE uchar convert_uchar_sat_rtn(short x); -OVERLOADABLE long convert_long_sat_rte(ushort x); -OVERLOADABLE long convert_long_sat_rtz(ushort x); -OVERLOADABLE long convert_long_sat_rtp(ushort x); -OVERLOADABLE long convert_long_sat_rtn(ushort x); -OVERLOADABLE ulong convert_ulong_sat_rte(ushort x); -OVERLOADABLE ulong convert_ulong_sat_rtz(ushort x); -OVERLOADABLE ulong convert_ulong_sat_rtp(ushort x); -OVERLOADABLE ulong convert_ulong_sat_rtn(ushort x); -OVERLOADABLE int convert_int_sat_rte(ushort x); -OVERLOADABLE int convert_int_sat_rtz(ushort x); -OVERLOADABLE int convert_int_sat_rtp(ushort x); -OVERLOADABLE int convert_int_sat_rtn(ushort x); -OVERLOADABLE uint convert_uint_sat_rte(ushort x); -OVERLOADABLE uint convert_uint_sat_rtz(ushort x); -OVERLOADABLE uint convert_uint_sat_rtp(ushort x); -OVERLOADABLE uint convert_uint_sat_rtn(ushort x); -OVERLOADABLE short convert_short_sat_rte(ushort x); -OVERLOADABLE short convert_short_sat_rtz(ushort x); -OVERLOADABLE short convert_short_sat_rtp(ushort x); -OVERLOADABLE short convert_short_sat_rtn(ushort x); -OVERLOADABLE ushort convert_ushort_sat_rte(ushort x); -OVERLOADABLE ushort convert_ushort_sat_rtz(ushort x); -OVERLOADABLE ushort convert_ushort_sat_rtp(ushort x); -OVERLOADABLE ushort convert_ushort_sat_rtn(ushort x); -OVERLOADABLE char convert_char_sat_rte(ushort x); -OVERLOADABLE char convert_char_sat_rtz(ushort x); -OVERLOADABLE char convert_char_sat_rtp(ushort x); -OVERLOADABLE char convert_char_sat_rtn(ushort x); -OVERLOADABLE uchar convert_uchar_sat_rte(ushort x); -OVERLOADABLE uchar convert_uchar_sat_rtz(ushort x); -OVERLOADABLE uchar convert_uchar_sat_rtp(ushort x); -OVERLOADABLE uchar convert_uchar_sat_rtn(ushort x); -OVERLOADABLE long convert_long_sat_rte(char x); -OVERLOADABLE long convert_long_sat_rtz(char x); -OVERLOADABLE long convert_long_sat_rtp(char x); -OVERLOADABLE long convert_long_sat_rtn(char x); -OVERLOADABLE ulong convert_ulong_sat_rte(char x); -OVERLOADABLE ulong convert_ulong_sat_rtz(char x); -OVERLOADABLE ulong convert_ulong_sat_rtp(char x); -OVERLOADABLE ulong convert_ulong_sat_rtn(char x); -OVERLOADABLE int convert_int_sat_rte(char x); -OVERLOADABLE int convert_int_sat_rtz(char x); -OVERLOADABLE int convert_int_sat_rtp(char x); -OVERLOADABLE int convert_int_sat_rtn(char x); -OVERLOADABLE uint convert_uint_sat_rte(char x); -OVERLOADABLE uint convert_uint_sat_rtz(char x); -OVERLOADABLE uint convert_uint_sat_rtp(char x); -OVERLOADABLE uint convert_uint_sat_rtn(char x); -OVERLOADABLE short convert_short_sat_rte(char x); -OVERLOADABLE short convert_short_sat_rtz(char x); -OVERLOADABLE short convert_short_sat_rtp(char x); -OVERLOADABLE short convert_short_sat_rtn(char x); -OVERLOADABLE ushort convert_ushort_sat_rte(char x); -OVERLOADABLE ushort convert_ushort_sat_rtz(char x); -OVERLOADABLE ushort convert_ushort_sat_rtp(char x); -OVERLOADABLE ushort convert_ushort_sat_rtn(char x); -OVERLOADABLE char convert_char_sat_rte(char x); -OVERLOADABLE char convert_char_sat_rtz(char x); -OVERLOADABLE char convert_char_sat_rtp(char x); -OVERLOADABLE char convert_char_sat_rtn(char x); -OVERLOADABLE uchar convert_uchar_sat_rte(char x); -OVERLOADABLE uchar convert_uchar_sat_rtz(char x); -OVERLOADABLE uchar convert_uchar_sat_rtp(char x); -OVERLOADABLE uchar convert_uchar_sat_rtn(char x); -OVERLOADABLE long convert_long_sat_rte(uchar x); -OVERLOADABLE long convert_long_sat_rtz(uchar x); -OVERLOADABLE long convert_long_sat_rtp(uchar x); -OVERLOADABLE long convert_long_sat_rtn(uchar x); -OVERLOADABLE ulong convert_ulong_sat_rte(uchar x); -OVERLOADABLE ulong convert_ulong_sat_rtz(uchar x); -OVERLOADABLE ulong convert_ulong_sat_rtp(uchar x); -OVERLOADABLE ulong convert_ulong_sat_rtn(uchar x); -OVERLOADABLE int convert_int_sat_rte(uchar x); -OVERLOADABLE int convert_int_sat_rtz(uchar x); -OVERLOADABLE int convert_int_sat_rtp(uchar x); -OVERLOADABLE int convert_int_sat_rtn(uchar x); -OVERLOADABLE uint convert_uint_sat_rte(uchar x); -OVERLOADABLE uint convert_uint_sat_rtz(uchar x); -OVERLOADABLE uint convert_uint_sat_rtp(uchar x); -OVERLOADABLE uint convert_uint_sat_rtn(uchar x); -OVERLOADABLE short convert_short_sat_rte(uchar x); -OVERLOADABLE short convert_short_sat_rtz(uchar x); -OVERLOADABLE short convert_short_sat_rtp(uchar x); -OVERLOADABLE short convert_short_sat_rtn(uchar x); -OVERLOADABLE ushort convert_ushort_sat_rte(uchar x); -OVERLOADABLE ushort convert_ushort_sat_rtz(uchar x); -OVERLOADABLE ushort convert_ushort_sat_rtp(uchar x); -OVERLOADABLE ushort convert_ushort_sat_rtn(uchar x); -OVERLOADABLE char convert_char_sat_rte(uchar x); -OVERLOADABLE char convert_char_sat_rtz(uchar x); -OVERLOADABLE char convert_char_sat_rtp(uchar x); -OVERLOADABLE char convert_char_sat_rtn(uchar x); -OVERLOADABLE uchar convert_uchar_sat_rte(uchar x); -OVERLOADABLE uchar convert_uchar_sat_rtz(uchar x); -OVERLOADABLE uchar convert_uchar_sat_rtp(uchar x); -OVERLOADABLE uchar convert_uchar_sat_rtn(uchar x); -OVERLOADABLE long convert_long_sat_rte(float x); -OVERLOADABLE long convert_long_sat_rtz(float x); -OVERLOADABLE long convert_long_sat_rtp(float x); -OVERLOADABLE long convert_long_sat_rtn(float x); -OVERLOADABLE ulong convert_ulong_sat_rte(float x); -OVERLOADABLE ulong convert_ulong_sat_rtz(float x); -OVERLOADABLE ulong convert_ulong_sat_rtp(float x); -OVERLOADABLE ulong convert_ulong_sat_rtn(float x); -OVERLOADABLE int convert_int_sat_rte(float x); -OVERLOADABLE int convert_int_sat_rtz(float x); -OVERLOADABLE int convert_int_sat_rtp(float x); -OVERLOADABLE int convert_int_sat_rtn(float x); -OVERLOADABLE uint convert_uint_sat_rte(float x); -OVERLOADABLE uint convert_uint_sat_rtz(float x); -OVERLOADABLE uint convert_uint_sat_rtp(float x); -OVERLOADABLE uint convert_uint_sat_rtn(float x); -OVERLOADABLE short convert_short_sat_rte(float x); -OVERLOADABLE short convert_short_sat_rtz(float x); -OVERLOADABLE short convert_short_sat_rtp(float x); -OVERLOADABLE short convert_short_sat_rtn(float x); -OVERLOADABLE ushort convert_ushort_sat_rte(float x); -OVERLOADABLE ushort convert_ushort_sat_rtz(float x); -OVERLOADABLE ushort convert_ushort_sat_rtp(float x); -OVERLOADABLE ushort convert_ushort_sat_rtn(float x); -OVERLOADABLE char convert_char_sat_rte(float x); -OVERLOADABLE char convert_char_sat_rtz(float x); -OVERLOADABLE char convert_char_sat_rtp(float x); -OVERLOADABLE char convert_char_sat_rtn(float x); -OVERLOADABLE uchar convert_uchar_sat_rte(float x); -OVERLOADABLE uchar convert_uchar_sat_rtz(float x); -OVERLOADABLE uchar convert_uchar_sat_rtp(float x); -OVERLOADABLE uchar convert_uchar_sat_rtn(float x); -OVERLOADABLE long convert_long_sat_rte(half x); -OVERLOADABLE long convert_long_sat_rtz(half x); -OVERLOADABLE long convert_long_sat_rtp(half x); -OVERLOADABLE long convert_long_sat_rtn(half x); -OVERLOADABLE ulong convert_ulong_sat_rte(half x); -OVERLOADABLE ulong convert_ulong_sat_rtz(half x); -OVERLOADABLE ulong convert_ulong_sat_rtp(half x); -OVERLOADABLE ulong convert_ulong_sat_rtn(half x); -OVERLOADABLE int convert_int_sat_rte(half x); -OVERLOADABLE int convert_int_sat_rtz(half x); -OVERLOADABLE int convert_int_sat_rtp(half x); -OVERLOADABLE int convert_int_sat_rtn(half x); -OVERLOADABLE uint convert_uint_sat_rte(half x); -OVERLOADABLE uint convert_uint_sat_rtz(half x); -OVERLOADABLE uint convert_uint_sat_rtp(half x); -OVERLOADABLE uint convert_uint_sat_rtn(half x); -OVERLOADABLE short convert_short_sat_rte(half x); -OVERLOADABLE short convert_short_sat_rtz(half x); -OVERLOADABLE short convert_short_sat_rtp(half x); -OVERLOADABLE short convert_short_sat_rtn(half x); -OVERLOADABLE ushort convert_ushort_sat_rte(half x); -OVERLOADABLE ushort convert_ushort_sat_rtz(half x); -OVERLOADABLE ushort convert_ushort_sat_rtp(half x); -OVERLOADABLE ushort convert_ushort_sat_rtn(half x); -OVERLOADABLE char convert_char_sat_rte(half x); -OVERLOADABLE char convert_char_sat_rtz(half x); -OVERLOADABLE char convert_char_sat_rtp(half x); -OVERLOADABLE char convert_char_sat_rtn(half x); -OVERLOADABLE uchar convert_uchar_sat_rte(half x); -OVERLOADABLE uchar convert_uchar_sat_rtz(half x); -OVERLOADABLE uchar convert_uchar_sat_rtp(half x); -OVERLOADABLE uchar convert_uchar_sat_rtn(half x); -OVERLOADABLE long2 convert_long2_sat_rte(long2 v); -OVERLOADABLE long2 convert_long2_sat_rtz(long2 v); -OVERLOADABLE long2 convert_long2_sat_rtp(long2 v); -OVERLOADABLE long2 convert_long2_sat_rtn(long2 v); -OVERLOADABLE ulong2 convert_ulong2_sat_rte(long2 v); -OVERLOADABLE ulong2 convert_ulong2_sat_rtz(long2 v); -OVERLOADABLE ulong2 convert_ulong2_sat_rtp(long2 v); -OVERLOADABLE ulong2 convert_ulong2_sat_rtn(long2 v); -OVERLOADABLE int2 convert_int2_sat_rte(long2 v); -OVERLOADABLE int2 convert_int2_sat_rtz(long2 v); -OVERLOADABLE int2 convert_int2_sat_rtp(long2 v); -OVERLOADABLE int2 convert_int2_sat_rtn(long2 v); -OVERLOADABLE uint2 convert_uint2_sat_rte(long2 v); -OVERLOADABLE uint2 convert_uint2_sat_rtz(long2 v); -OVERLOADABLE uint2 convert_uint2_sat_rtp(long2 v); -OVERLOADABLE uint2 convert_uint2_sat_rtn(long2 v); -OVERLOADABLE short2 convert_short2_sat_rte(long2 v); -OVERLOADABLE short2 convert_short2_sat_rtz(long2 v); -OVERLOADABLE short2 convert_short2_sat_rtp(long2 v); -OVERLOADABLE short2 convert_short2_sat_rtn(long2 v); -OVERLOADABLE ushort2 convert_ushort2_sat_rte(long2 v); -OVERLOADABLE ushort2 convert_ushort2_sat_rtz(long2 v); -OVERLOADABLE ushort2 convert_ushort2_sat_rtp(long2 v); -OVERLOADABLE ushort2 convert_ushort2_sat_rtn(long2 v); -OVERLOADABLE char2 convert_char2_sat_rte(long2 v); -OVERLOADABLE char2 convert_char2_sat_rtz(long2 v); -OVERLOADABLE char2 convert_char2_sat_rtp(long2 v); -OVERLOADABLE char2 convert_char2_sat_rtn(long2 v); -OVERLOADABLE uchar2 convert_uchar2_sat_rte(long2 v); -OVERLOADABLE uchar2 convert_uchar2_sat_rtz(long2 v); -OVERLOADABLE uchar2 convert_uchar2_sat_rtp(long2 v); -OVERLOADABLE uchar2 convert_uchar2_sat_rtn(long2 v); -OVERLOADABLE long2 convert_long2_sat_rte(ulong2 v); -OVERLOADABLE long2 convert_long2_sat_rtz(ulong2 v); -OVERLOADABLE long2 convert_long2_sat_rtp(ulong2 v); -OVERLOADABLE long2 convert_long2_sat_rtn(ulong2 v); -OVERLOADABLE ulong2 convert_ulong2_sat_rte(ulong2 v); -OVERLOADABLE ulong2 convert_ulong2_sat_rtz(ulong2 v); -OVERLOADABLE ulong2 convert_ulong2_sat_rtp(ulong2 v); -OVERLOADABLE ulong2 convert_ulong2_sat_rtn(ulong2 v); -OVERLOADABLE int2 convert_int2_sat_rte(ulong2 v); -OVERLOADABLE int2 convert_int2_sat_rtz(ulong2 v); -OVERLOADABLE int2 convert_int2_sat_rtp(ulong2 v); -OVERLOADABLE int2 convert_int2_sat_rtn(ulong2 v); -OVERLOADABLE uint2 convert_uint2_sat_rte(ulong2 v); -OVERLOADABLE uint2 convert_uint2_sat_rtz(ulong2 v); -OVERLOADABLE uint2 convert_uint2_sat_rtp(ulong2 v); -OVERLOADABLE uint2 convert_uint2_sat_rtn(ulong2 v); -OVERLOADABLE short2 convert_short2_sat_rte(ulong2 v); -OVERLOADABLE short2 convert_short2_sat_rtz(ulong2 v); -OVERLOADABLE short2 convert_short2_sat_rtp(ulong2 v); -OVERLOADABLE short2 convert_short2_sat_rtn(ulong2 v); -OVERLOADABLE ushort2 convert_ushort2_sat_rte(ulong2 v); -OVERLOADABLE ushort2 convert_ushort2_sat_rtz(ulong2 v); -OVERLOADABLE ushort2 convert_ushort2_sat_rtp(ulong2 v); -OVERLOADABLE ushort2 convert_ushort2_sat_rtn(ulong2 v); -OVERLOADABLE char2 convert_char2_sat_rte(ulong2 v); -OVERLOADABLE char2 convert_char2_sat_rtz(ulong2 v); -OVERLOADABLE char2 convert_char2_sat_rtp(ulong2 v); -OVERLOADABLE char2 convert_char2_sat_rtn(ulong2 v); -OVERLOADABLE uchar2 convert_uchar2_sat_rte(ulong2 v); -OVERLOADABLE uchar2 convert_uchar2_sat_rtz(ulong2 v); -OVERLOADABLE uchar2 convert_uchar2_sat_rtp(ulong2 v); -OVERLOADABLE uchar2 convert_uchar2_sat_rtn(ulong2 v); -OVERLOADABLE long2 convert_long2_sat_rte(int2 v); -OVERLOADABLE long2 convert_long2_sat_rtz(int2 v); -OVERLOADABLE long2 convert_long2_sat_rtp(int2 v); -OVERLOADABLE long2 convert_long2_sat_rtn(int2 v); -OVERLOADABLE ulong2 convert_ulong2_sat_rte(int2 v); -OVERLOADABLE ulong2 convert_ulong2_sat_rtz(int2 v); -OVERLOADABLE ulong2 convert_ulong2_sat_rtp(int2 v); -OVERLOADABLE ulong2 convert_ulong2_sat_rtn(int2 v); -OVERLOADABLE int2 convert_int2_sat_rte(int2 v); -OVERLOADABLE int2 convert_int2_sat_rtz(int2 v); -OVERLOADABLE int2 convert_int2_sat_rtp(int2 v); -OVERLOADABLE int2 convert_int2_sat_rtn(int2 v); -OVERLOADABLE uint2 convert_uint2_sat_rte(int2 v); -OVERLOADABLE uint2 convert_uint2_sat_rtz(int2 v); -OVERLOADABLE uint2 convert_uint2_sat_rtp(int2 v); -OVERLOADABLE uint2 convert_uint2_sat_rtn(int2 v); -OVERLOADABLE short2 convert_short2_sat_rte(int2 v); -OVERLOADABLE short2 convert_short2_sat_rtz(int2 v); -OVERLOADABLE short2 convert_short2_sat_rtp(int2 v); -OVERLOADABLE short2 convert_short2_sat_rtn(int2 v); -OVERLOADABLE ushort2 convert_ushort2_sat_rte(int2 v); -OVERLOADABLE ushort2 convert_ushort2_sat_rtz(int2 v); -OVERLOADABLE ushort2 convert_ushort2_sat_rtp(int2 v); -OVERLOADABLE ushort2 convert_ushort2_sat_rtn(int2 v); -OVERLOADABLE char2 convert_char2_sat_rte(int2 v); -OVERLOADABLE char2 convert_char2_sat_rtz(int2 v); -OVERLOADABLE char2 convert_char2_sat_rtp(int2 v); -OVERLOADABLE char2 convert_char2_sat_rtn(int2 v); -OVERLOADABLE uchar2 convert_uchar2_sat_rte(int2 v); -OVERLOADABLE uchar2 convert_uchar2_sat_rtz(int2 v); -OVERLOADABLE uchar2 convert_uchar2_sat_rtp(int2 v); -OVERLOADABLE uchar2 convert_uchar2_sat_rtn(int2 v); -OVERLOADABLE long2 convert_long2_sat_rte(uint2 v); -OVERLOADABLE long2 convert_long2_sat_rtz(uint2 v); -OVERLOADABLE long2 convert_long2_sat_rtp(uint2 v); -OVERLOADABLE long2 convert_long2_sat_rtn(uint2 v); -OVERLOADABLE ulong2 convert_ulong2_sat_rte(uint2 v); -OVERLOADABLE ulong2 convert_ulong2_sat_rtz(uint2 v); -OVERLOADABLE ulong2 convert_ulong2_sat_rtp(uint2 v); -OVERLOADABLE ulong2 convert_ulong2_sat_rtn(uint2 v); -OVERLOADABLE int2 convert_int2_sat_rte(uint2 v); -OVERLOADABLE int2 convert_int2_sat_rtz(uint2 v); -OVERLOADABLE int2 convert_int2_sat_rtp(uint2 v); -OVERLOADABLE int2 convert_int2_sat_rtn(uint2 v); -OVERLOADABLE uint2 convert_uint2_sat_rte(uint2 v); -OVERLOADABLE uint2 convert_uint2_sat_rtz(uint2 v); -OVERLOADABLE uint2 convert_uint2_sat_rtp(uint2 v); -OVERLOADABLE uint2 convert_uint2_sat_rtn(uint2 v); -OVERLOADABLE short2 convert_short2_sat_rte(uint2 v); -OVERLOADABLE short2 convert_short2_sat_rtz(uint2 v); -OVERLOADABLE short2 convert_short2_sat_rtp(uint2 v); -OVERLOADABLE short2 convert_short2_sat_rtn(uint2 v); -OVERLOADABLE ushort2 convert_ushort2_sat_rte(uint2 v); -OVERLOADABLE ushort2 convert_ushort2_sat_rtz(uint2 v); -OVERLOADABLE ushort2 convert_ushort2_sat_rtp(uint2 v); -OVERLOADABLE ushort2 convert_ushort2_sat_rtn(uint2 v); -OVERLOADABLE char2 convert_char2_sat_rte(uint2 v); -OVERLOADABLE char2 convert_char2_sat_rtz(uint2 v); -OVERLOADABLE char2 convert_char2_sat_rtp(uint2 v); -OVERLOADABLE char2 convert_char2_sat_rtn(uint2 v); -OVERLOADABLE uchar2 convert_uchar2_sat_rte(uint2 v); -OVERLOADABLE uchar2 convert_uchar2_sat_rtz(uint2 v); -OVERLOADABLE uchar2 convert_uchar2_sat_rtp(uint2 v); -OVERLOADABLE uchar2 convert_uchar2_sat_rtn(uint2 v); -OVERLOADABLE long2 convert_long2_sat_rte(short2 v); -OVERLOADABLE long2 convert_long2_sat_rtz(short2 v); -OVERLOADABLE long2 convert_long2_sat_rtp(short2 v); -OVERLOADABLE long2 convert_long2_sat_rtn(short2 v); -OVERLOADABLE ulong2 convert_ulong2_sat_rte(short2 v); -OVERLOADABLE ulong2 convert_ulong2_sat_rtz(short2 v); -OVERLOADABLE ulong2 convert_ulong2_sat_rtp(short2 v); -OVERLOADABLE ulong2 convert_ulong2_sat_rtn(short2 v); -OVERLOADABLE int2 convert_int2_sat_rte(short2 v); -OVERLOADABLE int2 convert_int2_sat_rtz(short2 v); -OVERLOADABLE int2 convert_int2_sat_rtp(short2 v); -OVERLOADABLE int2 convert_int2_sat_rtn(short2 v); -OVERLOADABLE uint2 convert_uint2_sat_rte(short2 v); -OVERLOADABLE uint2 convert_uint2_sat_rtz(short2 v); -OVERLOADABLE uint2 convert_uint2_sat_rtp(short2 v); -OVERLOADABLE uint2 convert_uint2_sat_rtn(short2 v); -OVERLOADABLE short2 convert_short2_sat_rte(short2 v); -OVERLOADABLE short2 convert_short2_sat_rtz(short2 v); -OVERLOADABLE short2 convert_short2_sat_rtp(short2 v); -OVERLOADABLE short2 convert_short2_sat_rtn(short2 v); -OVERLOADABLE ushort2 convert_ushort2_sat_rte(short2 v); -OVERLOADABLE ushort2 convert_ushort2_sat_rtz(short2 v); -OVERLOADABLE ushort2 convert_ushort2_sat_rtp(short2 v); -OVERLOADABLE ushort2 convert_ushort2_sat_rtn(short2 v); -OVERLOADABLE char2 convert_char2_sat_rte(short2 v); -OVERLOADABLE char2 convert_char2_sat_rtz(short2 v); -OVERLOADABLE char2 convert_char2_sat_rtp(short2 v); -OVERLOADABLE char2 convert_char2_sat_rtn(short2 v); -OVERLOADABLE uchar2 convert_uchar2_sat_rte(short2 v); -OVERLOADABLE uchar2 convert_uchar2_sat_rtz(short2 v); -OVERLOADABLE uchar2 convert_uchar2_sat_rtp(short2 v); -OVERLOADABLE uchar2 convert_uchar2_sat_rtn(short2 v); -OVERLOADABLE long2 convert_long2_sat_rte(ushort2 v); -OVERLOADABLE long2 convert_long2_sat_rtz(ushort2 v); -OVERLOADABLE long2 convert_long2_sat_rtp(ushort2 v); -OVERLOADABLE long2 convert_long2_sat_rtn(ushort2 v); -OVERLOADABLE ulong2 convert_ulong2_sat_rte(ushort2 v); -OVERLOADABLE ulong2 convert_ulong2_sat_rtz(ushort2 v); -OVERLOADABLE ulong2 convert_ulong2_sat_rtp(ushort2 v); -OVERLOADABLE ulong2 convert_ulong2_sat_rtn(ushort2 v); -OVERLOADABLE int2 convert_int2_sat_rte(ushort2 v); -OVERLOADABLE int2 convert_int2_sat_rtz(ushort2 v); -OVERLOADABLE int2 convert_int2_sat_rtp(ushort2 v); -OVERLOADABLE int2 convert_int2_sat_rtn(ushort2 v); -OVERLOADABLE uint2 convert_uint2_sat_rte(ushort2 v); -OVERLOADABLE uint2 convert_uint2_sat_rtz(ushort2 v); -OVERLOADABLE uint2 convert_uint2_sat_rtp(ushort2 v); -OVERLOADABLE uint2 convert_uint2_sat_rtn(ushort2 v); -OVERLOADABLE short2 convert_short2_sat_rte(ushort2 v); -OVERLOADABLE short2 convert_short2_sat_rtz(ushort2 v); -OVERLOADABLE short2 convert_short2_sat_rtp(ushort2 v); -OVERLOADABLE short2 convert_short2_sat_rtn(ushort2 v); -OVERLOADABLE ushort2 convert_ushort2_sat_rte(ushort2 v); -OVERLOADABLE ushort2 convert_ushort2_sat_rtz(ushort2 v); -OVERLOADABLE ushort2 convert_ushort2_sat_rtp(ushort2 v); -OVERLOADABLE ushort2 convert_ushort2_sat_rtn(ushort2 v); -OVERLOADABLE char2 convert_char2_sat_rte(ushort2 v); -OVERLOADABLE char2 convert_char2_sat_rtz(ushort2 v); -OVERLOADABLE char2 convert_char2_sat_rtp(ushort2 v); -OVERLOADABLE char2 convert_char2_sat_rtn(ushort2 v); -OVERLOADABLE uchar2 convert_uchar2_sat_rte(ushort2 v); -OVERLOADABLE uchar2 convert_uchar2_sat_rtz(ushort2 v); -OVERLOADABLE uchar2 convert_uchar2_sat_rtp(ushort2 v); -OVERLOADABLE uchar2 convert_uchar2_sat_rtn(ushort2 v); -OVERLOADABLE long2 convert_long2_sat_rte(char2 v); -OVERLOADABLE long2 convert_long2_sat_rtz(char2 v); -OVERLOADABLE long2 convert_long2_sat_rtp(char2 v); -OVERLOADABLE long2 convert_long2_sat_rtn(char2 v); -OVERLOADABLE ulong2 convert_ulong2_sat_rte(char2 v); -OVERLOADABLE ulong2 convert_ulong2_sat_rtz(char2 v); -OVERLOADABLE ulong2 convert_ulong2_sat_rtp(char2 v); -OVERLOADABLE ulong2 convert_ulong2_sat_rtn(char2 v); -OVERLOADABLE int2 convert_int2_sat_rte(char2 v); -OVERLOADABLE int2 convert_int2_sat_rtz(char2 v); -OVERLOADABLE int2 convert_int2_sat_rtp(char2 v); -OVERLOADABLE int2 convert_int2_sat_rtn(char2 v); -OVERLOADABLE uint2 convert_uint2_sat_rte(char2 v); -OVERLOADABLE uint2 convert_uint2_sat_rtz(char2 v); -OVERLOADABLE uint2 convert_uint2_sat_rtp(char2 v); -OVERLOADABLE uint2 convert_uint2_sat_rtn(char2 v); -OVERLOADABLE short2 convert_short2_sat_rte(char2 v); -OVERLOADABLE short2 convert_short2_sat_rtz(char2 v); -OVERLOADABLE short2 convert_short2_sat_rtp(char2 v); -OVERLOADABLE short2 convert_short2_sat_rtn(char2 v); -OVERLOADABLE ushort2 convert_ushort2_sat_rte(char2 v); -OVERLOADABLE ushort2 convert_ushort2_sat_rtz(char2 v); -OVERLOADABLE ushort2 convert_ushort2_sat_rtp(char2 v); -OVERLOADABLE ushort2 convert_ushort2_sat_rtn(char2 v); -OVERLOADABLE char2 convert_char2_sat_rte(char2 v); -OVERLOADABLE char2 convert_char2_sat_rtz(char2 v); -OVERLOADABLE char2 convert_char2_sat_rtp(char2 v); -OVERLOADABLE char2 convert_char2_sat_rtn(char2 v); -OVERLOADABLE uchar2 convert_uchar2_sat_rte(char2 v); -OVERLOADABLE uchar2 convert_uchar2_sat_rtz(char2 v); -OVERLOADABLE uchar2 convert_uchar2_sat_rtp(char2 v); -OVERLOADABLE uchar2 convert_uchar2_sat_rtn(char2 v); -OVERLOADABLE long2 convert_long2_sat_rte(uchar2 v); -OVERLOADABLE long2 convert_long2_sat_rtz(uchar2 v); -OVERLOADABLE long2 convert_long2_sat_rtp(uchar2 v); -OVERLOADABLE long2 convert_long2_sat_rtn(uchar2 v); -OVERLOADABLE ulong2 convert_ulong2_sat_rte(uchar2 v); -OVERLOADABLE ulong2 convert_ulong2_sat_rtz(uchar2 v); -OVERLOADABLE ulong2 convert_ulong2_sat_rtp(uchar2 v); -OVERLOADABLE ulong2 convert_ulong2_sat_rtn(uchar2 v); -OVERLOADABLE int2 convert_int2_sat_rte(uchar2 v); -OVERLOADABLE int2 convert_int2_sat_rtz(uchar2 v); -OVERLOADABLE int2 convert_int2_sat_rtp(uchar2 v); -OVERLOADABLE int2 convert_int2_sat_rtn(uchar2 v); -OVERLOADABLE uint2 convert_uint2_sat_rte(uchar2 v); -OVERLOADABLE uint2 convert_uint2_sat_rtz(uchar2 v); -OVERLOADABLE uint2 convert_uint2_sat_rtp(uchar2 v); -OVERLOADABLE uint2 convert_uint2_sat_rtn(uchar2 v); -OVERLOADABLE short2 convert_short2_sat_rte(uchar2 v); -OVERLOADABLE short2 convert_short2_sat_rtz(uchar2 v); -OVERLOADABLE short2 convert_short2_sat_rtp(uchar2 v); -OVERLOADABLE short2 convert_short2_sat_rtn(uchar2 v); -OVERLOADABLE ushort2 convert_ushort2_sat_rte(uchar2 v); -OVERLOADABLE ushort2 convert_ushort2_sat_rtz(uchar2 v); -OVERLOADABLE ushort2 convert_ushort2_sat_rtp(uchar2 v); -OVERLOADABLE ushort2 convert_ushort2_sat_rtn(uchar2 v); -OVERLOADABLE char2 convert_char2_sat_rte(uchar2 v); -OVERLOADABLE char2 convert_char2_sat_rtz(uchar2 v); -OVERLOADABLE char2 convert_char2_sat_rtp(uchar2 v); -OVERLOADABLE char2 convert_char2_sat_rtn(uchar2 v); -OVERLOADABLE uchar2 convert_uchar2_sat_rte(uchar2 v); -OVERLOADABLE uchar2 convert_uchar2_sat_rtz(uchar2 v); -OVERLOADABLE uchar2 convert_uchar2_sat_rtp(uchar2 v); -OVERLOADABLE uchar2 convert_uchar2_sat_rtn(uchar2 v); -OVERLOADABLE long2 convert_long2_sat_rte(double2 v); -OVERLOADABLE long2 convert_long2_sat_rtz(double2 v); -OVERLOADABLE long2 convert_long2_sat_rtp(double2 v); -OVERLOADABLE long2 convert_long2_sat_rtn(double2 v); -OVERLOADABLE ulong2 convert_ulong2_sat_rte(double2 v); -OVERLOADABLE ulong2 convert_ulong2_sat_rtz(double2 v); -OVERLOADABLE ulong2 convert_ulong2_sat_rtp(double2 v); -OVERLOADABLE ulong2 convert_ulong2_sat_rtn(double2 v); -OVERLOADABLE int2 convert_int2_sat_rte(double2 v); -OVERLOADABLE int2 convert_int2_sat_rtz(double2 v); -OVERLOADABLE int2 convert_int2_sat_rtp(double2 v); -OVERLOADABLE int2 convert_int2_sat_rtn(double2 v); -OVERLOADABLE uint2 convert_uint2_sat_rte(double2 v); -OVERLOADABLE uint2 convert_uint2_sat_rtz(double2 v); -OVERLOADABLE uint2 convert_uint2_sat_rtp(double2 v); -OVERLOADABLE uint2 convert_uint2_sat_rtn(double2 v); -OVERLOADABLE short2 convert_short2_sat_rte(double2 v); -OVERLOADABLE short2 convert_short2_sat_rtz(double2 v); -OVERLOADABLE short2 convert_short2_sat_rtp(double2 v); -OVERLOADABLE short2 convert_short2_sat_rtn(double2 v); -OVERLOADABLE ushort2 convert_ushort2_sat_rte(double2 v); -OVERLOADABLE ushort2 convert_ushort2_sat_rtz(double2 v); -OVERLOADABLE ushort2 convert_ushort2_sat_rtp(double2 v); -OVERLOADABLE ushort2 convert_ushort2_sat_rtn(double2 v); -OVERLOADABLE char2 convert_char2_sat_rte(double2 v); -OVERLOADABLE char2 convert_char2_sat_rtz(double2 v); -OVERLOADABLE char2 convert_char2_sat_rtp(double2 v); -OVERLOADABLE char2 convert_char2_sat_rtn(double2 v); -OVERLOADABLE uchar2 convert_uchar2_sat_rte(double2 v); -OVERLOADABLE uchar2 convert_uchar2_sat_rtz(double2 v); -OVERLOADABLE uchar2 convert_uchar2_sat_rtp(double2 v); -OVERLOADABLE uchar2 convert_uchar2_sat_rtn(double2 v); -OVERLOADABLE long2 convert_long2_sat_rte(float2 v); -OVERLOADABLE long2 convert_long2_sat_rtz(float2 v); -OVERLOADABLE long2 convert_long2_sat_rtp(float2 v); -OVERLOADABLE long2 convert_long2_sat_rtn(float2 v); -OVERLOADABLE ulong2 convert_ulong2_sat_rte(float2 v); -OVERLOADABLE ulong2 convert_ulong2_sat_rtz(float2 v); -OVERLOADABLE ulong2 convert_ulong2_sat_rtp(float2 v); -OVERLOADABLE ulong2 convert_ulong2_sat_rtn(float2 v); -OVERLOADABLE int2 convert_int2_sat_rte(float2 v); -OVERLOADABLE int2 convert_int2_sat_rtz(float2 v); -OVERLOADABLE int2 convert_int2_sat_rtp(float2 v); -OVERLOADABLE int2 convert_int2_sat_rtn(float2 v); -OVERLOADABLE uint2 convert_uint2_sat_rte(float2 v); -OVERLOADABLE uint2 convert_uint2_sat_rtz(float2 v); -OVERLOADABLE uint2 convert_uint2_sat_rtp(float2 v); -OVERLOADABLE uint2 convert_uint2_sat_rtn(float2 v); -OVERLOADABLE short2 convert_short2_sat_rte(float2 v); -OVERLOADABLE short2 convert_short2_sat_rtz(float2 v); -OVERLOADABLE short2 convert_short2_sat_rtp(float2 v); -OVERLOADABLE short2 convert_short2_sat_rtn(float2 v); -OVERLOADABLE ushort2 convert_ushort2_sat_rte(float2 v); -OVERLOADABLE ushort2 convert_ushort2_sat_rtz(float2 v); -OVERLOADABLE ushort2 convert_ushort2_sat_rtp(float2 v); -OVERLOADABLE ushort2 convert_ushort2_sat_rtn(float2 v); -OVERLOADABLE char2 convert_char2_sat_rte(float2 v); -OVERLOADABLE char2 convert_char2_sat_rtz(float2 v); -OVERLOADABLE char2 convert_char2_sat_rtp(float2 v); -OVERLOADABLE char2 convert_char2_sat_rtn(float2 v); -OVERLOADABLE uchar2 convert_uchar2_sat_rte(float2 v); -OVERLOADABLE uchar2 convert_uchar2_sat_rtz(float2 v); -OVERLOADABLE uchar2 convert_uchar2_sat_rtp(float2 v); -OVERLOADABLE uchar2 convert_uchar2_sat_rtn(float2 v); -OVERLOADABLE long2 convert_long2_sat_rte(half2 v); -OVERLOADABLE long2 convert_long2_sat_rtz(half2 v); -OVERLOADABLE long2 convert_long2_sat_rtp(half2 v); -OVERLOADABLE long2 convert_long2_sat_rtn(half2 v); -OVERLOADABLE ulong2 convert_ulong2_sat_rte(half2 v); -OVERLOADABLE ulong2 convert_ulong2_sat_rtz(half2 v); -OVERLOADABLE ulong2 convert_ulong2_sat_rtp(half2 v); -OVERLOADABLE ulong2 convert_ulong2_sat_rtn(half2 v); -OVERLOADABLE int2 convert_int2_sat_rte(half2 v); -OVERLOADABLE int2 convert_int2_sat_rtz(half2 v); -OVERLOADABLE int2 convert_int2_sat_rtp(half2 v); -OVERLOADABLE int2 convert_int2_sat_rtn(half2 v); -OVERLOADABLE uint2 convert_uint2_sat_rte(half2 v); -OVERLOADABLE uint2 convert_uint2_sat_rtz(half2 v); -OVERLOADABLE uint2 convert_uint2_sat_rtp(half2 v); -OVERLOADABLE uint2 convert_uint2_sat_rtn(half2 v); -OVERLOADABLE short2 convert_short2_sat_rte(half2 v); -OVERLOADABLE short2 convert_short2_sat_rtz(half2 v); -OVERLOADABLE short2 convert_short2_sat_rtp(half2 v); -OVERLOADABLE short2 convert_short2_sat_rtn(half2 v); -OVERLOADABLE ushort2 convert_ushort2_sat_rte(half2 v); -OVERLOADABLE ushort2 convert_ushort2_sat_rtz(half2 v); -OVERLOADABLE ushort2 convert_ushort2_sat_rtp(half2 v); -OVERLOADABLE ushort2 convert_ushort2_sat_rtn(half2 v); -OVERLOADABLE char2 convert_char2_sat_rte(half2 v); -OVERLOADABLE char2 convert_char2_sat_rtz(half2 v); -OVERLOADABLE char2 convert_char2_sat_rtp(half2 v); -OVERLOADABLE char2 convert_char2_sat_rtn(half2 v); -OVERLOADABLE uchar2 convert_uchar2_sat_rte(half2 v); -OVERLOADABLE uchar2 convert_uchar2_sat_rtz(half2 v); -OVERLOADABLE uchar2 convert_uchar2_sat_rtp(half2 v); -OVERLOADABLE uchar2 convert_uchar2_sat_rtn(half2 v); -OVERLOADABLE long3 convert_long3_sat_rte(long3 v); -OVERLOADABLE long3 convert_long3_sat_rtz(long3 v); -OVERLOADABLE long3 convert_long3_sat_rtp(long3 v); -OVERLOADABLE long3 convert_long3_sat_rtn(long3 v); -OVERLOADABLE ulong3 convert_ulong3_sat_rte(long3 v); -OVERLOADABLE ulong3 convert_ulong3_sat_rtz(long3 v); -OVERLOADABLE ulong3 convert_ulong3_sat_rtp(long3 v); -OVERLOADABLE ulong3 convert_ulong3_sat_rtn(long3 v); -OVERLOADABLE int3 convert_int3_sat_rte(long3 v); -OVERLOADABLE int3 convert_int3_sat_rtz(long3 v); -OVERLOADABLE int3 convert_int3_sat_rtp(long3 v); -OVERLOADABLE int3 convert_int3_sat_rtn(long3 v); -OVERLOADABLE uint3 convert_uint3_sat_rte(long3 v); -OVERLOADABLE uint3 convert_uint3_sat_rtz(long3 v); -OVERLOADABLE uint3 convert_uint3_sat_rtp(long3 v); -OVERLOADABLE uint3 convert_uint3_sat_rtn(long3 v); -OVERLOADABLE short3 convert_short3_sat_rte(long3 v); -OVERLOADABLE short3 convert_short3_sat_rtz(long3 v); -OVERLOADABLE short3 convert_short3_sat_rtp(long3 v); -OVERLOADABLE short3 convert_short3_sat_rtn(long3 v); -OVERLOADABLE ushort3 convert_ushort3_sat_rte(long3 v); -OVERLOADABLE ushort3 convert_ushort3_sat_rtz(long3 v); -OVERLOADABLE ushort3 convert_ushort3_sat_rtp(long3 v); -OVERLOADABLE ushort3 convert_ushort3_sat_rtn(long3 v); -OVERLOADABLE char3 convert_char3_sat_rte(long3 v); -OVERLOADABLE char3 convert_char3_sat_rtz(long3 v); -OVERLOADABLE char3 convert_char3_sat_rtp(long3 v); -OVERLOADABLE char3 convert_char3_sat_rtn(long3 v); -OVERLOADABLE uchar3 convert_uchar3_sat_rte(long3 v); -OVERLOADABLE uchar3 convert_uchar3_sat_rtz(long3 v); -OVERLOADABLE uchar3 convert_uchar3_sat_rtp(long3 v); -OVERLOADABLE uchar3 convert_uchar3_sat_rtn(long3 v); -OVERLOADABLE long3 convert_long3_sat_rte(ulong3 v); -OVERLOADABLE long3 convert_long3_sat_rtz(ulong3 v); -OVERLOADABLE long3 convert_long3_sat_rtp(ulong3 v); -OVERLOADABLE long3 convert_long3_sat_rtn(ulong3 v); -OVERLOADABLE ulong3 convert_ulong3_sat_rte(ulong3 v); -OVERLOADABLE ulong3 convert_ulong3_sat_rtz(ulong3 v); -OVERLOADABLE ulong3 convert_ulong3_sat_rtp(ulong3 v); -OVERLOADABLE ulong3 convert_ulong3_sat_rtn(ulong3 v); -OVERLOADABLE int3 convert_int3_sat_rte(ulong3 v); -OVERLOADABLE int3 convert_int3_sat_rtz(ulong3 v); -OVERLOADABLE int3 convert_int3_sat_rtp(ulong3 v); -OVERLOADABLE int3 convert_int3_sat_rtn(ulong3 v); -OVERLOADABLE uint3 convert_uint3_sat_rte(ulong3 v); -OVERLOADABLE uint3 convert_uint3_sat_rtz(ulong3 v); -OVERLOADABLE uint3 convert_uint3_sat_rtp(ulong3 v); -OVERLOADABLE uint3 convert_uint3_sat_rtn(ulong3 v); -OVERLOADABLE short3 convert_short3_sat_rte(ulong3 v); -OVERLOADABLE short3 convert_short3_sat_rtz(ulong3 v); -OVERLOADABLE short3 convert_short3_sat_rtp(ulong3 v); -OVERLOADABLE short3 convert_short3_sat_rtn(ulong3 v); -OVERLOADABLE ushort3 convert_ushort3_sat_rte(ulong3 v); -OVERLOADABLE ushort3 convert_ushort3_sat_rtz(ulong3 v); -OVERLOADABLE ushort3 convert_ushort3_sat_rtp(ulong3 v); -OVERLOADABLE ushort3 convert_ushort3_sat_rtn(ulong3 v); -OVERLOADABLE char3 convert_char3_sat_rte(ulong3 v); -OVERLOADABLE char3 convert_char3_sat_rtz(ulong3 v); -OVERLOADABLE char3 convert_char3_sat_rtp(ulong3 v); -OVERLOADABLE char3 convert_char3_sat_rtn(ulong3 v); -OVERLOADABLE uchar3 convert_uchar3_sat_rte(ulong3 v); -OVERLOADABLE uchar3 convert_uchar3_sat_rtz(ulong3 v); -OVERLOADABLE uchar3 convert_uchar3_sat_rtp(ulong3 v); -OVERLOADABLE uchar3 convert_uchar3_sat_rtn(ulong3 v); -OVERLOADABLE long3 convert_long3_sat_rte(int3 v); -OVERLOADABLE long3 convert_long3_sat_rtz(int3 v); -OVERLOADABLE long3 convert_long3_sat_rtp(int3 v); -OVERLOADABLE long3 convert_long3_sat_rtn(int3 v); -OVERLOADABLE ulong3 convert_ulong3_sat_rte(int3 v); -OVERLOADABLE ulong3 convert_ulong3_sat_rtz(int3 v); -OVERLOADABLE ulong3 convert_ulong3_sat_rtp(int3 v); -OVERLOADABLE ulong3 convert_ulong3_sat_rtn(int3 v); -OVERLOADABLE int3 convert_int3_sat_rte(int3 v); -OVERLOADABLE int3 convert_int3_sat_rtz(int3 v); -OVERLOADABLE int3 convert_int3_sat_rtp(int3 v); -OVERLOADABLE int3 convert_int3_sat_rtn(int3 v); -OVERLOADABLE uint3 convert_uint3_sat_rte(int3 v); -OVERLOADABLE uint3 convert_uint3_sat_rtz(int3 v); -OVERLOADABLE uint3 convert_uint3_sat_rtp(int3 v); -OVERLOADABLE uint3 convert_uint3_sat_rtn(int3 v); -OVERLOADABLE short3 convert_short3_sat_rte(int3 v); -OVERLOADABLE short3 convert_short3_sat_rtz(int3 v); -OVERLOADABLE short3 convert_short3_sat_rtp(int3 v); -OVERLOADABLE short3 convert_short3_sat_rtn(int3 v); -OVERLOADABLE ushort3 convert_ushort3_sat_rte(int3 v); -OVERLOADABLE ushort3 convert_ushort3_sat_rtz(int3 v); -OVERLOADABLE ushort3 convert_ushort3_sat_rtp(int3 v); -OVERLOADABLE ushort3 convert_ushort3_sat_rtn(int3 v); -OVERLOADABLE char3 convert_char3_sat_rte(int3 v); -OVERLOADABLE char3 convert_char3_sat_rtz(int3 v); -OVERLOADABLE char3 convert_char3_sat_rtp(int3 v); -OVERLOADABLE char3 convert_char3_sat_rtn(int3 v); -OVERLOADABLE uchar3 convert_uchar3_sat_rte(int3 v); -OVERLOADABLE uchar3 convert_uchar3_sat_rtz(int3 v); -OVERLOADABLE uchar3 convert_uchar3_sat_rtp(int3 v); -OVERLOADABLE uchar3 convert_uchar3_sat_rtn(int3 v); -OVERLOADABLE long3 convert_long3_sat_rte(uint3 v); -OVERLOADABLE long3 convert_long3_sat_rtz(uint3 v); -OVERLOADABLE long3 convert_long3_sat_rtp(uint3 v); -OVERLOADABLE long3 convert_long3_sat_rtn(uint3 v); -OVERLOADABLE ulong3 convert_ulong3_sat_rte(uint3 v); -OVERLOADABLE ulong3 convert_ulong3_sat_rtz(uint3 v); -OVERLOADABLE ulong3 convert_ulong3_sat_rtp(uint3 v); -OVERLOADABLE ulong3 convert_ulong3_sat_rtn(uint3 v); -OVERLOADABLE int3 convert_int3_sat_rte(uint3 v); -OVERLOADABLE int3 convert_int3_sat_rtz(uint3 v); -OVERLOADABLE int3 convert_int3_sat_rtp(uint3 v); -OVERLOADABLE int3 convert_int3_sat_rtn(uint3 v); -OVERLOADABLE uint3 convert_uint3_sat_rte(uint3 v); -OVERLOADABLE uint3 convert_uint3_sat_rtz(uint3 v); -OVERLOADABLE uint3 convert_uint3_sat_rtp(uint3 v); -OVERLOADABLE uint3 convert_uint3_sat_rtn(uint3 v); -OVERLOADABLE short3 convert_short3_sat_rte(uint3 v); -OVERLOADABLE short3 convert_short3_sat_rtz(uint3 v); -OVERLOADABLE short3 convert_short3_sat_rtp(uint3 v); -OVERLOADABLE short3 convert_short3_sat_rtn(uint3 v); -OVERLOADABLE ushort3 convert_ushort3_sat_rte(uint3 v); -OVERLOADABLE ushort3 convert_ushort3_sat_rtz(uint3 v); -OVERLOADABLE ushort3 convert_ushort3_sat_rtp(uint3 v); -OVERLOADABLE ushort3 convert_ushort3_sat_rtn(uint3 v); -OVERLOADABLE char3 convert_char3_sat_rte(uint3 v); -OVERLOADABLE char3 convert_char3_sat_rtz(uint3 v); -OVERLOADABLE char3 convert_char3_sat_rtp(uint3 v); -OVERLOADABLE char3 convert_char3_sat_rtn(uint3 v); -OVERLOADABLE uchar3 convert_uchar3_sat_rte(uint3 v); -OVERLOADABLE uchar3 convert_uchar3_sat_rtz(uint3 v); -OVERLOADABLE uchar3 convert_uchar3_sat_rtp(uint3 v); -OVERLOADABLE uchar3 convert_uchar3_sat_rtn(uint3 v); -OVERLOADABLE long3 convert_long3_sat_rte(short3 v); -OVERLOADABLE long3 convert_long3_sat_rtz(short3 v); -OVERLOADABLE long3 convert_long3_sat_rtp(short3 v); -OVERLOADABLE long3 convert_long3_sat_rtn(short3 v); -OVERLOADABLE ulong3 convert_ulong3_sat_rte(short3 v); -OVERLOADABLE ulong3 convert_ulong3_sat_rtz(short3 v); -OVERLOADABLE ulong3 convert_ulong3_sat_rtp(short3 v); -OVERLOADABLE ulong3 convert_ulong3_sat_rtn(short3 v); -OVERLOADABLE int3 convert_int3_sat_rte(short3 v); -OVERLOADABLE int3 convert_int3_sat_rtz(short3 v); -OVERLOADABLE int3 convert_int3_sat_rtp(short3 v); -OVERLOADABLE int3 convert_int3_sat_rtn(short3 v); -OVERLOADABLE uint3 convert_uint3_sat_rte(short3 v); -OVERLOADABLE uint3 convert_uint3_sat_rtz(short3 v); -OVERLOADABLE uint3 convert_uint3_sat_rtp(short3 v); -OVERLOADABLE uint3 convert_uint3_sat_rtn(short3 v); -OVERLOADABLE short3 convert_short3_sat_rte(short3 v); -OVERLOADABLE short3 convert_short3_sat_rtz(short3 v); -OVERLOADABLE short3 convert_short3_sat_rtp(short3 v); -OVERLOADABLE short3 convert_short3_sat_rtn(short3 v); -OVERLOADABLE ushort3 convert_ushort3_sat_rte(short3 v); -OVERLOADABLE ushort3 convert_ushort3_sat_rtz(short3 v); -OVERLOADABLE ushort3 convert_ushort3_sat_rtp(short3 v); -OVERLOADABLE ushort3 convert_ushort3_sat_rtn(short3 v); -OVERLOADABLE char3 convert_char3_sat_rte(short3 v); -OVERLOADABLE char3 convert_char3_sat_rtz(short3 v); -OVERLOADABLE char3 convert_char3_sat_rtp(short3 v); -OVERLOADABLE char3 convert_char3_sat_rtn(short3 v); -OVERLOADABLE uchar3 convert_uchar3_sat_rte(short3 v); -OVERLOADABLE uchar3 convert_uchar3_sat_rtz(short3 v); -OVERLOADABLE uchar3 convert_uchar3_sat_rtp(short3 v); -OVERLOADABLE uchar3 convert_uchar3_sat_rtn(short3 v); -OVERLOADABLE long3 convert_long3_sat_rte(ushort3 v); -OVERLOADABLE long3 convert_long3_sat_rtz(ushort3 v); -OVERLOADABLE long3 convert_long3_sat_rtp(ushort3 v); -OVERLOADABLE long3 convert_long3_sat_rtn(ushort3 v); -OVERLOADABLE ulong3 convert_ulong3_sat_rte(ushort3 v); -OVERLOADABLE ulong3 convert_ulong3_sat_rtz(ushort3 v); -OVERLOADABLE ulong3 convert_ulong3_sat_rtp(ushort3 v); -OVERLOADABLE ulong3 convert_ulong3_sat_rtn(ushort3 v); -OVERLOADABLE int3 convert_int3_sat_rte(ushort3 v); -OVERLOADABLE int3 convert_int3_sat_rtz(ushort3 v); -OVERLOADABLE int3 convert_int3_sat_rtp(ushort3 v); -OVERLOADABLE int3 convert_int3_sat_rtn(ushort3 v); -OVERLOADABLE uint3 convert_uint3_sat_rte(ushort3 v); -OVERLOADABLE uint3 convert_uint3_sat_rtz(ushort3 v); -OVERLOADABLE uint3 convert_uint3_sat_rtp(ushort3 v); -OVERLOADABLE uint3 convert_uint3_sat_rtn(ushort3 v); -OVERLOADABLE short3 convert_short3_sat_rte(ushort3 v); -OVERLOADABLE short3 convert_short3_sat_rtz(ushort3 v); -OVERLOADABLE short3 convert_short3_sat_rtp(ushort3 v); -OVERLOADABLE short3 convert_short3_sat_rtn(ushort3 v); -OVERLOADABLE ushort3 convert_ushort3_sat_rte(ushort3 v); -OVERLOADABLE ushort3 convert_ushort3_sat_rtz(ushort3 v); -OVERLOADABLE ushort3 convert_ushort3_sat_rtp(ushort3 v); -OVERLOADABLE ushort3 convert_ushort3_sat_rtn(ushort3 v); -OVERLOADABLE char3 convert_char3_sat_rte(ushort3 v); -OVERLOADABLE char3 convert_char3_sat_rtz(ushort3 v); -OVERLOADABLE char3 convert_char3_sat_rtp(ushort3 v); -OVERLOADABLE char3 convert_char3_sat_rtn(ushort3 v); -OVERLOADABLE uchar3 convert_uchar3_sat_rte(ushort3 v); -OVERLOADABLE uchar3 convert_uchar3_sat_rtz(ushort3 v); -OVERLOADABLE uchar3 convert_uchar3_sat_rtp(ushort3 v); -OVERLOADABLE uchar3 convert_uchar3_sat_rtn(ushort3 v); -OVERLOADABLE long3 convert_long3_sat_rte(char3 v); -OVERLOADABLE long3 convert_long3_sat_rtz(char3 v); -OVERLOADABLE long3 convert_long3_sat_rtp(char3 v); -OVERLOADABLE long3 convert_long3_sat_rtn(char3 v); -OVERLOADABLE ulong3 convert_ulong3_sat_rte(char3 v); -OVERLOADABLE ulong3 convert_ulong3_sat_rtz(char3 v); -OVERLOADABLE ulong3 convert_ulong3_sat_rtp(char3 v); -OVERLOADABLE ulong3 convert_ulong3_sat_rtn(char3 v); -OVERLOADABLE int3 convert_int3_sat_rte(char3 v); -OVERLOADABLE int3 convert_int3_sat_rtz(char3 v); -OVERLOADABLE int3 convert_int3_sat_rtp(char3 v); -OVERLOADABLE int3 convert_int3_sat_rtn(char3 v); -OVERLOADABLE uint3 convert_uint3_sat_rte(char3 v); -OVERLOADABLE uint3 convert_uint3_sat_rtz(char3 v); -OVERLOADABLE uint3 convert_uint3_sat_rtp(char3 v); -OVERLOADABLE uint3 convert_uint3_sat_rtn(char3 v); -OVERLOADABLE short3 convert_short3_sat_rte(char3 v); -OVERLOADABLE short3 convert_short3_sat_rtz(char3 v); -OVERLOADABLE short3 convert_short3_sat_rtp(char3 v); -OVERLOADABLE short3 convert_short3_sat_rtn(char3 v); -OVERLOADABLE ushort3 convert_ushort3_sat_rte(char3 v); -OVERLOADABLE ushort3 convert_ushort3_sat_rtz(char3 v); -OVERLOADABLE ushort3 convert_ushort3_sat_rtp(char3 v); -OVERLOADABLE ushort3 convert_ushort3_sat_rtn(char3 v); -OVERLOADABLE char3 convert_char3_sat_rte(char3 v); -OVERLOADABLE char3 convert_char3_sat_rtz(char3 v); -OVERLOADABLE char3 convert_char3_sat_rtp(char3 v); -OVERLOADABLE char3 convert_char3_sat_rtn(char3 v); -OVERLOADABLE uchar3 convert_uchar3_sat_rte(char3 v); -OVERLOADABLE uchar3 convert_uchar3_sat_rtz(char3 v); -OVERLOADABLE uchar3 convert_uchar3_sat_rtp(char3 v); -OVERLOADABLE uchar3 convert_uchar3_sat_rtn(char3 v); -OVERLOADABLE long3 convert_long3_sat_rte(uchar3 v); -OVERLOADABLE long3 convert_long3_sat_rtz(uchar3 v); -OVERLOADABLE long3 convert_long3_sat_rtp(uchar3 v); -OVERLOADABLE long3 convert_long3_sat_rtn(uchar3 v); -OVERLOADABLE ulong3 convert_ulong3_sat_rte(uchar3 v); -OVERLOADABLE ulong3 convert_ulong3_sat_rtz(uchar3 v); -OVERLOADABLE ulong3 convert_ulong3_sat_rtp(uchar3 v); -OVERLOADABLE ulong3 convert_ulong3_sat_rtn(uchar3 v); -OVERLOADABLE int3 convert_int3_sat_rte(uchar3 v); -OVERLOADABLE int3 convert_int3_sat_rtz(uchar3 v); -OVERLOADABLE int3 convert_int3_sat_rtp(uchar3 v); -OVERLOADABLE int3 convert_int3_sat_rtn(uchar3 v); -OVERLOADABLE uint3 convert_uint3_sat_rte(uchar3 v); -OVERLOADABLE uint3 convert_uint3_sat_rtz(uchar3 v); -OVERLOADABLE uint3 convert_uint3_sat_rtp(uchar3 v); -OVERLOADABLE uint3 convert_uint3_sat_rtn(uchar3 v); -OVERLOADABLE short3 convert_short3_sat_rte(uchar3 v); -OVERLOADABLE short3 convert_short3_sat_rtz(uchar3 v); -OVERLOADABLE short3 convert_short3_sat_rtp(uchar3 v); -OVERLOADABLE short3 convert_short3_sat_rtn(uchar3 v); -OVERLOADABLE ushort3 convert_ushort3_sat_rte(uchar3 v); -OVERLOADABLE ushort3 convert_ushort3_sat_rtz(uchar3 v); -OVERLOADABLE ushort3 convert_ushort3_sat_rtp(uchar3 v); -OVERLOADABLE ushort3 convert_ushort3_sat_rtn(uchar3 v); -OVERLOADABLE char3 convert_char3_sat_rte(uchar3 v); -OVERLOADABLE char3 convert_char3_sat_rtz(uchar3 v); -OVERLOADABLE char3 convert_char3_sat_rtp(uchar3 v); -OVERLOADABLE char3 convert_char3_sat_rtn(uchar3 v); -OVERLOADABLE uchar3 convert_uchar3_sat_rte(uchar3 v); -OVERLOADABLE uchar3 convert_uchar3_sat_rtz(uchar3 v); -OVERLOADABLE uchar3 convert_uchar3_sat_rtp(uchar3 v); -OVERLOADABLE uchar3 convert_uchar3_sat_rtn(uchar3 v); -OVERLOADABLE long3 convert_long3_sat_rte(double3 v); -OVERLOADABLE long3 convert_long3_sat_rtz(double3 v); -OVERLOADABLE long3 convert_long3_sat_rtp(double3 v); -OVERLOADABLE long3 convert_long3_sat_rtn(double3 v); -OVERLOADABLE ulong3 convert_ulong3_sat_rte(double3 v); -OVERLOADABLE ulong3 convert_ulong3_sat_rtz(double3 v); -OVERLOADABLE ulong3 convert_ulong3_sat_rtp(double3 v); -OVERLOADABLE ulong3 convert_ulong3_sat_rtn(double3 v); -OVERLOADABLE int3 convert_int3_sat_rte(double3 v); -OVERLOADABLE int3 convert_int3_sat_rtz(double3 v); -OVERLOADABLE int3 convert_int3_sat_rtp(double3 v); -OVERLOADABLE int3 convert_int3_sat_rtn(double3 v); -OVERLOADABLE uint3 convert_uint3_sat_rte(double3 v); -OVERLOADABLE uint3 convert_uint3_sat_rtz(double3 v); -OVERLOADABLE uint3 convert_uint3_sat_rtp(double3 v); -OVERLOADABLE uint3 convert_uint3_sat_rtn(double3 v); -OVERLOADABLE short3 convert_short3_sat_rte(double3 v); -OVERLOADABLE short3 convert_short3_sat_rtz(double3 v); -OVERLOADABLE short3 convert_short3_sat_rtp(double3 v); -OVERLOADABLE short3 convert_short3_sat_rtn(double3 v); -OVERLOADABLE ushort3 convert_ushort3_sat_rte(double3 v); -OVERLOADABLE ushort3 convert_ushort3_sat_rtz(double3 v); -OVERLOADABLE ushort3 convert_ushort3_sat_rtp(double3 v); -OVERLOADABLE ushort3 convert_ushort3_sat_rtn(double3 v); -OVERLOADABLE char3 convert_char3_sat_rte(double3 v); -OVERLOADABLE char3 convert_char3_sat_rtz(double3 v); -OVERLOADABLE char3 convert_char3_sat_rtp(double3 v); -OVERLOADABLE char3 convert_char3_sat_rtn(double3 v); -OVERLOADABLE uchar3 convert_uchar3_sat_rte(double3 v); -OVERLOADABLE uchar3 convert_uchar3_sat_rtz(double3 v); -OVERLOADABLE uchar3 convert_uchar3_sat_rtp(double3 v); -OVERLOADABLE uchar3 convert_uchar3_sat_rtn(double3 v); -OVERLOADABLE long3 convert_long3_sat_rte(float3 v); -OVERLOADABLE long3 convert_long3_sat_rtz(float3 v); -OVERLOADABLE long3 convert_long3_sat_rtp(float3 v); -OVERLOADABLE long3 convert_long3_sat_rtn(float3 v); -OVERLOADABLE ulong3 convert_ulong3_sat_rte(float3 v); -OVERLOADABLE ulong3 convert_ulong3_sat_rtz(float3 v); -OVERLOADABLE ulong3 convert_ulong3_sat_rtp(float3 v); -OVERLOADABLE ulong3 convert_ulong3_sat_rtn(float3 v); -OVERLOADABLE int3 convert_int3_sat_rte(float3 v); -OVERLOADABLE int3 convert_int3_sat_rtz(float3 v); -OVERLOADABLE int3 convert_int3_sat_rtp(float3 v); -OVERLOADABLE int3 convert_int3_sat_rtn(float3 v); -OVERLOADABLE uint3 convert_uint3_sat_rte(float3 v); -OVERLOADABLE uint3 convert_uint3_sat_rtz(float3 v); -OVERLOADABLE uint3 convert_uint3_sat_rtp(float3 v); -OVERLOADABLE uint3 convert_uint3_sat_rtn(float3 v); -OVERLOADABLE short3 convert_short3_sat_rte(float3 v); -OVERLOADABLE short3 convert_short3_sat_rtz(float3 v); -OVERLOADABLE short3 convert_short3_sat_rtp(float3 v); -OVERLOADABLE short3 convert_short3_sat_rtn(float3 v); -OVERLOADABLE ushort3 convert_ushort3_sat_rte(float3 v); -OVERLOADABLE ushort3 convert_ushort3_sat_rtz(float3 v); -OVERLOADABLE ushort3 convert_ushort3_sat_rtp(float3 v); -OVERLOADABLE ushort3 convert_ushort3_sat_rtn(float3 v); -OVERLOADABLE char3 convert_char3_sat_rte(float3 v); -OVERLOADABLE char3 convert_char3_sat_rtz(float3 v); -OVERLOADABLE char3 convert_char3_sat_rtp(float3 v); -OVERLOADABLE char3 convert_char3_sat_rtn(float3 v); -OVERLOADABLE uchar3 convert_uchar3_sat_rte(float3 v); -OVERLOADABLE uchar3 convert_uchar3_sat_rtz(float3 v); -OVERLOADABLE uchar3 convert_uchar3_sat_rtp(float3 v); -OVERLOADABLE uchar3 convert_uchar3_sat_rtn(float3 v); -OVERLOADABLE long3 convert_long3_sat_rte(half3 v); -OVERLOADABLE long3 convert_long3_sat_rtz(half3 v); -OVERLOADABLE long3 convert_long3_sat_rtp(half3 v); -OVERLOADABLE long3 convert_long3_sat_rtn(half3 v); -OVERLOADABLE ulong3 convert_ulong3_sat_rte(half3 v); -OVERLOADABLE ulong3 convert_ulong3_sat_rtz(half3 v); -OVERLOADABLE ulong3 convert_ulong3_sat_rtp(half3 v); -OVERLOADABLE ulong3 convert_ulong3_sat_rtn(half3 v); -OVERLOADABLE int3 convert_int3_sat_rte(half3 v); -OVERLOADABLE int3 convert_int3_sat_rtz(half3 v); -OVERLOADABLE int3 convert_int3_sat_rtp(half3 v); -OVERLOADABLE int3 convert_int3_sat_rtn(half3 v); -OVERLOADABLE uint3 convert_uint3_sat_rte(half3 v); -OVERLOADABLE uint3 convert_uint3_sat_rtz(half3 v); -OVERLOADABLE uint3 convert_uint3_sat_rtp(half3 v); -OVERLOADABLE uint3 convert_uint3_sat_rtn(half3 v); -OVERLOADABLE short3 convert_short3_sat_rte(half3 v); -OVERLOADABLE short3 convert_short3_sat_rtz(half3 v); -OVERLOADABLE short3 convert_short3_sat_rtp(half3 v); -OVERLOADABLE short3 convert_short3_sat_rtn(half3 v); -OVERLOADABLE ushort3 convert_ushort3_sat_rte(half3 v); -OVERLOADABLE ushort3 convert_ushort3_sat_rtz(half3 v); -OVERLOADABLE ushort3 convert_ushort3_sat_rtp(half3 v); -OVERLOADABLE ushort3 convert_ushort3_sat_rtn(half3 v); -OVERLOADABLE char3 convert_char3_sat_rte(half3 v); -OVERLOADABLE char3 convert_char3_sat_rtz(half3 v); -OVERLOADABLE char3 convert_char3_sat_rtp(half3 v); -OVERLOADABLE char3 convert_char3_sat_rtn(half3 v); -OVERLOADABLE uchar3 convert_uchar3_sat_rte(half3 v); -OVERLOADABLE uchar3 convert_uchar3_sat_rtz(half3 v); -OVERLOADABLE uchar3 convert_uchar3_sat_rtp(half3 v); -OVERLOADABLE uchar3 convert_uchar3_sat_rtn(half3 v); -OVERLOADABLE long4 convert_long4_sat_rte(long4 v); -OVERLOADABLE long4 convert_long4_sat_rtz(long4 v); -OVERLOADABLE long4 convert_long4_sat_rtp(long4 v); -OVERLOADABLE long4 convert_long4_sat_rtn(long4 v); -OVERLOADABLE ulong4 convert_ulong4_sat_rte(long4 v); -OVERLOADABLE ulong4 convert_ulong4_sat_rtz(long4 v); -OVERLOADABLE ulong4 convert_ulong4_sat_rtp(long4 v); -OVERLOADABLE ulong4 convert_ulong4_sat_rtn(long4 v); -OVERLOADABLE int4 convert_int4_sat_rte(long4 v); -OVERLOADABLE int4 convert_int4_sat_rtz(long4 v); -OVERLOADABLE int4 convert_int4_sat_rtp(long4 v); -OVERLOADABLE int4 convert_int4_sat_rtn(long4 v); -OVERLOADABLE uint4 convert_uint4_sat_rte(long4 v); -OVERLOADABLE uint4 convert_uint4_sat_rtz(long4 v); -OVERLOADABLE uint4 convert_uint4_sat_rtp(long4 v); -OVERLOADABLE uint4 convert_uint4_sat_rtn(long4 v); -OVERLOADABLE short4 convert_short4_sat_rte(long4 v); -OVERLOADABLE short4 convert_short4_sat_rtz(long4 v); -OVERLOADABLE short4 convert_short4_sat_rtp(long4 v); -OVERLOADABLE short4 convert_short4_sat_rtn(long4 v); -OVERLOADABLE ushort4 convert_ushort4_sat_rte(long4 v); -OVERLOADABLE ushort4 convert_ushort4_sat_rtz(long4 v); -OVERLOADABLE ushort4 convert_ushort4_sat_rtp(long4 v); -OVERLOADABLE ushort4 convert_ushort4_sat_rtn(long4 v); -OVERLOADABLE char4 convert_char4_sat_rte(long4 v); -OVERLOADABLE char4 convert_char4_sat_rtz(long4 v); -OVERLOADABLE char4 convert_char4_sat_rtp(long4 v); -OVERLOADABLE char4 convert_char4_sat_rtn(long4 v); -OVERLOADABLE uchar4 convert_uchar4_sat_rte(long4 v); -OVERLOADABLE uchar4 convert_uchar4_sat_rtz(long4 v); -OVERLOADABLE uchar4 convert_uchar4_sat_rtp(long4 v); -OVERLOADABLE uchar4 convert_uchar4_sat_rtn(long4 v); -OVERLOADABLE long4 convert_long4_sat_rte(ulong4 v); -OVERLOADABLE long4 convert_long4_sat_rtz(ulong4 v); -OVERLOADABLE long4 convert_long4_sat_rtp(ulong4 v); -OVERLOADABLE long4 convert_long4_sat_rtn(ulong4 v); -OVERLOADABLE ulong4 convert_ulong4_sat_rte(ulong4 v); -OVERLOADABLE ulong4 convert_ulong4_sat_rtz(ulong4 v); -OVERLOADABLE ulong4 convert_ulong4_sat_rtp(ulong4 v); -OVERLOADABLE ulong4 convert_ulong4_sat_rtn(ulong4 v); -OVERLOADABLE int4 convert_int4_sat_rte(ulong4 v); -OVERLOADABLE int4 convert_int4_sat_rtz(ulong4 v); -OVERLOADABLE int4 convert_int4_sat_rtp(ulong4 v); -OVERLOADABLE int4 convert_int4_sat_rtn(ulong4 v); -OVERLOADABLE uint4 convert_uint4_sat_rte(ulong4 v); -OVERLOADABLE uint4 convert_uint4_sat_rtz(ulong4 v); -OVERLOADABLE uint4 convert_uint4_sat_rtp(ulong4 v); -OVERLOADABLE uint4 convert_uint4_sat_rtn(ulong4 v); -OVERLOADABLE short4 convert_short4_sat_rte(ulong4 v); -OVERLOADABLE short4 convert_short4_sat_rtz(ulong4 v); -OVERLOADABLE short4 convert_short4_sat_rtp(ulong4 v); -OVERLOADABLE short4 convert_short4_sat_rtn(ulong4 v); -OVERLOADABLE ushort4 convert_ushort4_sat_rte(ulong4 v); -OVERLOADABLE ushort4 convert_ushort4_sat_rtz(ulong4 v); -OVERLOADABLE ushort4 convert_ushort4_sat_rtp(ulong4 v); -OVERLOADABLE ushort4 convert_ushort4_sat_rtn(ulong4 v); -OVERLOADABLE char4 convert_char4_sat_rte(ulong4 v); -OVERLOADABLE char4 convert_char4_sat_rtz(ulong4 v); -OVERLOADABLE char4 convert_char4_sat_rtp(ulong4 v); -OVERLOADABLE char4 convert_char4_sat_rtn(ulong4 v); -OVERLOADABLE uchar4 convert_uchar4_sat_rte(ulong4 v); -OVERLOADABLE uchar4 convert_uchar4_sat_rtz(ulong4 v); -OVERLOADABLE uchar4 convert_uchar4_sat_rtp(ulong4 v); -OVERLOADABLE uchar4 convert_uchar4_sat_rtn(ulong4 v); -OVERLOADABLE long4 convert_long4_sat_rte(int4 v); -OVERLOADABLE long4 convert_long4_sat_rtz(int4 v); -OVERLOADABLE long4 convert_long4_sat_rtp(int4 v); -OVERLOADABLE long4 convert_long4_sat_rtn(int4 v); -OVERLOADABLE ulong4 convert_ulong4_sat_rte(int4 v); -OVERLOADABLE ulong4 convert_ulong4_sat_rtz(int4 v); -OVERLOADABLE ulong4 convert_ulong4_sat_rtp(int4 v); -OVERLOADABLE ulong4 convert_ulong4_sat_rtn(int4 v); -OVERLOADABLE int4 convert_int4_sat_rte(int4 v); -OVERLOADABLE int4 convert_int4_sat_rtz(int4 v); -OVERLOADABLE int4 convert_int4_sat_rtp(int4 v); -OVERLOADABLE int4 convert_int4_sat_rtn(int4 v); -OVERLOADABLE uint4 convert_uint4_sat_rte(int4 v); -OVERLOADABLE uint4 convert_uint4_sat_rtz(int4 v); -OVERLOADABLE uint4 convert_uint4_sat_rtp(int4 v); -OVERLOADABLE uint4 convert_uint4_sat_rtn(int4 v); -OVERLOADABLE short4 convert_short4_sat_rte(int4 v); -OVERLOADABLE short4 convert_short4_sat_rtz(int4 v); -OVERLOADABLE short4 convert_short4_sat_rtp(int4 v); -OVERLOADABLE short4 convert_short4_sat_rtn(int4 v); -OVERLOADABLE ushort4 convert_ushort4_sat_rte(int4 v); -OVERLOADABLE ushort4 convert_ushort4_sat_rtz(int4 v); -OVERLOADABLE ushort4 convert_ushort4_sat_rtp(int4 v); -OVERLOADABLE ushort4 convert_ushort4_sat_rtn(int4 v); -OVERLOADABLE char4 convert_char4_sat_rte(int4 v); -OVERLOADABLE char4 convert_char4_sat_rtz(int4 v); -OVERLOADABLE char4 convert_char4_sat_rtp(int4 v); -OVERLOADABLE char4 convert_char4_sat_rtn(int4 v); -OVERLOADABLE uchar4 convert_uchar4_sat_rte(int4 v); -OVERLOADABLE uchar4 convert_uchar4_sat_rtz(int4 v); -OVERLOADABLE uchar4 convert_uchar4_sat_rtp(int4 v); -OVERLOADABLE uchar4 convert_uchar4_sat_rtn(int4 v); -OVERLOADABLE long4 convert_long4_sat_rte(uint4 v); -OVERLOADABLE long4 convert_long4_sat_rtz(uint4 v); -OVERLOADABLE long4 convert_long4_sat_rtp(uint4 v); -OVERLOADABLE long4 convert_long4_sat_rtn(uint4 v); -OVERLOADABLE ulong4 convert_ulong4_sat_rte(uint4 v); -OVERLOADABLE ulong4 convert_ulong4_sat_rtz(uint4 v); -OVERLOADABLE ulong4 convert_ulong4_sat_rtp(uint4 v); -OVERLOADABLE ulong4 convert_ulong4_sat_rtn(uint4 v); -OVERLOADABLE int4 convert_int4_sat_rte(uint4 v); -OVERLOADABLE int4 convert_int4_sat_rtz(uint4 v); -OVERLOADABLE int4 convert_int4_sat_rtp(uint4 v); -OVERLOADABLE int4 convert_int4_sat_rtn(uint4 v); -OVERLOADABLE uint4 convert_uint4_sat_rte(uint4 v); -OVERLOADABLE uint4 convert_uint4_sat_rtz(uint4 v); -OVERLOADABLE uint4 convert_uint4_sat_rtp(uint4 v); -OVERLOADABLE uint4 convert_uint4_sat_rtn(uint4 v); -OVERLOADABLE short4 convert_short4_sat_rte(uint4 v); -OVERLOADABLE short4 convert_short4_sat_rtz(uint4 v); -OVERLOADABLE short4 convert_short4_sat_rtp(uint4 v); -OVERLOADABLE short4 convert_short4_sat_rtn(uint4 v); -OVERLOADABLE ushort4 convert_ushort4_sat_rte(uint4 v); -OVERLOADABLE ushort4 convert_ushort4_sat_rtz(uint4 v); -OVERLOADABLE ushort4 convert_ushort4_sat_rtp(uint4 v); -OVERLOADABLE ushort4 convert_ushort4_sat_rtn(uint4 v); -OVERLOADABLE char4 convert_char4_sat_rte(uint4 v); -OVERLOADABLE char4 convert_char4_sat_rtz(uint4 v); -OVERLOADABLE char4 convert_char4_sat_rtp(uint4 v); -OVERLOADABLE char4 convert_char4_sat_rtn(uint4 v); -OVERLOADABLE uchar4 convert_uchar4_sat_rte(uint4 v); -OVERLOADABLE uchar4 convert_uchar4_sat_rtz(uint4 v); -OVERLOADABLE uchar4 convert_uchar4_sat_rtp(uint4 v); -OVERLOADABLE uchar4 convert_uchar4_sat_rtn(uint4 v); -OVERLOADABLE long4 convert_long4_sat_rte(short4 v); -OVERLOADABLE long4 convert_long4_sat_rtz(short4 v); -OVERLOADABLE long4 convert_long4_sat_rtp(short4 v); -OVERLOADABLE long4 convert_long4_sat_rtn(short4 v); -OVERLOADABLE ulong4 convert_ulong4_sat_rte(short4 v); -OVERLOADABLE ulong4 convert_ulong4_sat_rtz(short4 v); -OVERLOADABLE ulong4 convert_ulong4_sat_rtp(short4 v); -OVERLOADABLE ulong4 convert_ulong4_sat_rtn(short4 v); -OVERLOADABLE int4 convert_int4_sat_rte(short4 v); -OVERLOADABLE int4 convert_int4_sat_rtz(short4 v); -OVERLOADABLE int4 convert_int4_sat_rtp(short4 v); -OVERLOADABLE int4 convert_int4_sat_rtn(short4 v); -OVERLOADABLE uint4 convert_uint4_sat_rte(short4 v); -OVERLOADABLE uint4 convert_uint4_sat_rtz(short4 v); -OVERLOADABLE uint4 convert_uint4_sat_rtp(short4 v); -OVERLOADABLE uint4 convert_uint4_sat_rtn(short4 v); -OVERLOADABLE short4 convert_short4_sat_rte(short4 v); -OVERLOADABLE short4 convert_short4_sat_rtz(short4 v); -OVERLOADABLE short4 convert_short4_sat_rtp(short4 v); -OVERLOADABLE short4 convert_short4_sat_rtn(short4 v); -OVERLOADABLE ushort4 convert_ushort4_sat_rte(short4 v); -OVERLOADABLE ushort4 convert_ushort4_sat_rtz(short4 v); -OVERLOADABLE ushort4 convert_ushort4_sat_rtp(short4 v); -OVERLOADABLE ushort4 convert_ushort4_sat_rtn(short4 v); -OVERLOADABLE char4 convert_char4_sat_rte(short4 v); -OVERLOADABLE char4 convert_char4_sat_rtz(short4 v); -OVERLOADABLE char4 convert_char4_sat_rtp(short4 v); -OVERLOADABLE char4 convert_char4_sat_rtn(short4 v); -OVERLOADABLE uchar4 convert_uchar4_sat_rte(short4 v); -OVERLOADABLE uchar4 convert_uchar4_sat_rtz(short4 v); -OVERLOADABLE uchar4 convert_uchar4_sat_rtp(short4 v); -OVERLOADABLE uchar4 convert_uchar4_sat_rtn(short4 v); -OVERLOADABLE long4 convert_long4_sat_rte(ushort4 v); -OVERLOADABLE long4 convert_long4_sat_rtz(ushort4 v); -OVERLOADABLE long4 convert_long4_sat_rtp(ushort4 v); -OVERLOADABLE long4 convert_long4_sat_rtn(ushort4 v); -OVERLOADABLE ulong4 convert_ulong4_sat_rte(ushort4 v); -OVERLOADABLE ulong4 convert_ulong4_sat_rtz(ushort4 v); -OVERLOADABLE ulong4 convert_ulong4_sat_rtp(ushort4 v); -OVERLOADABLE ulong4 convert_ulong4_sat_rtn(ushort4 v); -OVERLOADABLE int4 convert_int4_sat_rte(ushort4 v); -OVERLOADABLE int4 convert_int4_sat_rtz(ushort4 v); -OVERLOADABLE int4 convert_int4_sat_rtp(ushort4 v); -OVERLOADABLE int4 convert_int4_sat_rtn(ushort4 v); -OVERLOADABLE uint4 convert_uint4_sat_rte(ushort4 v); -OVERLOADABLE uint4 convert_uint4_sat_rtz(ushort4 v); -OVERLOADABLE uint4 convert_uint4_sat_rtp(ushort4 v); -OVERLOADABLE uint4 convert_uint4_sat_rtn(ushort4 v); -OVERLOADABLE short4 convert_short4_sat_rte(ushort4 v); -OVERLOADABLE short4 convert_short4_sat_rtz(ushort4 v); -OVERLOADABLE short4 convert_short4_sat_rtp(ushort4 v); -OVERLOADABLE short4 convert_short4_sat_rtn(ushort4 v); -OVERLOADABLE ushort4 convert_ushort4_sat_rte(ushort4 v); -OVERLOADABLE ushort4 convert_ushort4_sat_rtz(ushort4 v); -OVERLOADABLE ushort4 convert_ushort4_sat_rtp(ushort4 v); -OVERLOADABLE ushort4 convert_ushort4_sat_rtn(ushort4 v); -OVERLOADABLE char4 convert_char4_sat_rte(ushort4 v); -OVERLOADABLE char4 convert_char4_sat_rtz(ushort4 v); -OVERLOADABLE char4 convert_char4_sat_rtp(ushort4 v); -OVERLOADABLE char4 convert_char4_sat_rtn(ushort4 v); -OVERLOADABLE uchar4 convert_uchar4_sat_rte(ushort4 v); -OVERLOADABLE uchar4 convert_uchar4_sat_rtz(ushort4 v); -OVERLOADABLE uchar4 convert_uchar4_sat_rtp(ushort4 v); -OVERLOADABLE uchar4 convert_uchar4_sat_rtn(ushort4 v); -OVERLOADABLE long4 convert_long4_sat_rte(char4 v); -OVERLOADABLE long4 convert_long4_sat_rtz(char4 v); -OVERLOADABLE long4 convert_long4_sat_rtp(char4 v); -OVERLOADABLE long4 convert_long4_sat_rtn(char4 v); -OVERLOADABLE ulong4 convert_ulong4_sat_rte(char4 v); -OVERLOADABLE ulong4 convert_ulong4_sat_rtz(char4 v); -OVERLOADABLE ulong4 convert_ulong4_sat_rtp(char4 v); -OVERLOADABLE ulong4 convert_ulong4_sat_rtn(char4 v); -OVERLOADABLE int4 convert_int4_sat_rte(char4 v); -OVERLOADABLE int4 convert_int4_sat_rtz(char4 v); -OVERLOADABLE int4 convert_int4_sat_rtp(char4 v); -OVERLOADABLE int4 convert_int4_sat_rtn(char4 v); -OVERLOADABLE uint4 convert_uint4_sat_rte(char4 v); -OVERLOADABLE uint4 convert_uint4_sat_rtz(char4 v); -OVERLOADABLE uint4 convert_uint4_sat_rtp(char4 v); -OVERLOADABLE uint4 convert_uint4_sat_rtn(char4 v); -OVERLOADABLE short4 convert_short4_sat_rte(char4 v); -OVERLOADABLE short4 convert_short4_sat_rtz(char4 v); -OVERLOADABLE short4 convert_short4_sat_rtp(char4 v); -OVERLOADABLE short4 convert_short4_sat_rtn(char4 v); -OVERLOADABLE ushort4 convert_ushort4_sat_rte(char4 v); -OVERLOADABLE ushort4 convert_ushort4_sat_rtz(char4 v); -OVERLOADABLE ushort4 convert_ushort4_sat_rtp(char4 v); -OVERLOADABLE ushort4 convert_ushort4_sat_rtn(char4 v); -OVERLOADABLE char4 convert_char4_sat_rte(char4 v); -OVERLOADABLE char4 convert_char4_sat_rtz(char4 v); -OVERLOADABLE char4 convert_char4_sat_rtp(char4 v); -OVERLOADABLE char4 convert_char4_sat_rtn(char4 v); -OVERLOADABLE uchar4 convert_uchar4_sat_rte(char4 v); -OVERLOADABLE uchar4 convert_uchar4_sat_rtz(char4 v); -OVERLOADABLE uchar4 convert_uchar4_sat_rtp(char4 v); -OVERLOADABLE uchar4 convert_uchar4_sat_rtn(char4 v); -OVERLOADABLE long4 convert_long4_sat_rte(uchar4 v); -OVERLOADABLE long4 convert_long4_sat_rtz(uchar4 v); -OVERLOADABLE long4 convert_long4_sat_rtp(uchar4 v); -OVERLOADABLE long4 convert_long4_sat_rtn(uchar4 v); -OVERLOADABLE ulong4 convert_ulong4_sat_rte(uchar4 v); -OVERLOADABLE ulong4 convert_ulong4_sat_rtz(uchar4 v); -OVERLOADABLE ulong4 convert_ulong4_sat_rtp(uchar4 v); -OVERLOADABLE ulong4 convert_ulong4_sat_rtn(uchar4 v); -OVERLOADABLE int4 convert_int4_sat_rte(uchar4 v); -OVERLOADABLE int4 convert_int4_sat_rtz(uchar4 v); -OVERLOADABLE int4 convert_int4_sat_rtp(uchar4 v); -OVERLOADABLE int4 convert_int4_sat_rtn(uchar4 v); -OVERLOADABLE uint4 convert_uint4_sat_rte(uchar4 v); -OVERLOADABLE uint4 convert_uint4_sat_rtz(uchar4 v); -OVERLOADABLE uint4 convert_uint4_sat_rtp(uchar4 v); -OVERLOADABLE uint4 convert_uint4_sat_rtn(uchar4 v); -OVERLOADABLE short4 convert_short4_sat_rte(uchar4 v); -OVERLOADABLE short4 convert_short4_sat_rtz(uchar4 v); -OVERLOADABLE short4 convert_short4_sat_rtp(uchar4 v); -OVERLOADABLE short4 convert_short4_sat_rtn(uchar4 v); -OVERLOADABLE ushort4 convert_ushort4_sat_rte(uchar4 v); -OVERLOADABLE ushort4 convert_ushort4_sat_rtz(uchar4 v); -OVERLOADABLE ushort4 convert_ushort4_sat_rtp(uchar4 v); -OVERLOADABLE ushort4 convert_ushort4_sat_rtn(uchar4 v); -OVERLOADABLE char4 convert_char4_sat_rte(uchar4 v); -OVERLOADABLE char4 convert_char4_sat_rtz(uchar4 v); -OVERLOADABLE char4 convert_char4_sat_rtp(uchar4 v); -OVERLOADABLE char4 convert_char4_sat_rtn(uchar4 v); -OVERLOADABLE uchar4 convert_uchar4_sat_rte(uchar4 v); -OVERLOADABLE uchar4 convert_uchar4_sat_rtz(uchar4 v); -OVERLOADABLE uchar4 convert_uchar4_sat_rtp(uchar4 v); -OVERLOADABLE uchar4 convert_uchar4_sat_rtn(uchar4 v); -OVERLOADABLE long4 convert_long4_sat_rte(double4 v); -OVERLOADABLE long4 convert_long4_sat_rtz(double4 v); -OVERLOADABLE long4 convert_long4_sat_rtp(double4 v); -OVERLOADABLE long4 convert_long4_sat_rtn(double4 v); -OVERLOADABLE ulong4 convert_ulong4_sat_rte(double4 v); -OVERLOADABLE ulong4 convert_ulong4_sat_rtz(double4 v); -OVERLOADABLE ulong4 convert_ulong4_sat_rtp(double4 v); -OVERLOADABLE ulong4 convert_ulong4_sat_rtn(double4 v); -OVERLOADABLE int4 convert_int4_sat_rte(double4 v); -OVERLOADABLE int4 convert_int4_sat_rtz(double4 v); -OVERLOADABLE int4 convert_int4_sat_rtp(double4 v); -OVERLOADABLE int4 convert_int4_sat_rtn(double4 v); -OVERLOADABLE uint4 convert_uint4_sat_rte(double4 v); -OVERLOADABLE uint4 convert_uint4_sat_rtz(double4 v); -OVERLOADABLE uint4 convert_uint4_sat_rtp(double4 v); -OVERLOADABLE uint4 convert_uint4_sat_rtn(double4 v); -OVERLOADABLE short4 convert_short4_sat_rte(double4 v); -OVERLOADABLE short4 convert_short4_sat_rtz(double4 v); -OVERLOADABLE short4 convert_short4_sat_rtp(double4 v); -OVERLOADABLE short4 convert_short4_sat_rtn(double4 v); -OVERLOADABLE ushort4 convert_ushort4_sat_rte(double4 v); -OVERLOADABLE ushort4 convert_ushort4_sat_rtz(double4 v); -OVERLOADABLE ushort4 convert_ushort4_sat_rtp(double4 v); -OVERLOADABLE ushort4 convert_ushort4_sat_rtn(double4 v); -OVERLOADABLE char4 convert_char4_sat_rte(double4 v); -OVERLOADABLE char4 convert_char4_sat_rtz(double4 v); -OVERLOADABLE char4 convert_char4_sat_rtp(double4 v); -OVERLOADABLE char4 convert_char4_sat_rtn(double4 v); -OVERLOADABLE uchar4 convert_uchar4_sat_rte(double4 v); -OVERLOADABLE uchar4 convert_uchar4_sat_rtz(double4 v); -OVERLOADABLE uchar4 convert_uchar4_sat_rtp(double4 v); -OVERLOADABLE uchar4 convert_uchar4_sat_rtn(double4 v); -OVERLOADABLE long4 convert_long4_sat_rte(float4 v); -OVERLOADABLE long4 convert_long4_sat_rtz(float4 v); -OVERLOADABLE long4 convert_long4_sat_rtp(float4 v); -OVERLOADABLE long4 convert_long4_sat_rtn(float4 v); -OVERLOADABLE ulong4 convert_ulong4_sat_rte(float4 v); -OVERLOADABLE ulong4 convert_ulong4_sat_rtz(float4 v); -OVERLOADABLE ulong4 convert_ulong4_sat_rtp(float4 v); -OVERLOADABLE ulong4 convert_ulong4_sat_rtn(float4 v); -OVERLOADABLE int4 convert_int4_sat_rte(float4 v); -OVERLOADABLE int4 convert_int4_sat_rtz(float4 v); -OVERLOADABLE int4 convert_int4_sat_rtp(float4 v); -OVERLOADABLE int4 convert_int4_sat_rtn(float4 v); -OVERLOADABLE uint4 convert_uint4_sat_rte(float4 v); -OVERLOADABLE uint4 convert_uint4_sat_rtz(float4 v); -OVERLOADABLE uint4 convert_uint4_sat_rtp(float4 v); -OVERLOADABLE uint4 convert_uint4_sat_rtn(float4 v); -OVERLOADABLE short4 convert_short4_sat_rte(float4 v); -OVERLOADABLE short4 convert_short4_sat_rtz(float4 v); -OVERLOADABLE short4 convert_short4_sat_rtp(float4 v); -OVERLOADABLE short4 convert_short4_sat_rtn(float4 v); -OVERLOADABLE ushort4 convert_ushort4_sat_rte(float4 v); -OVERLOADABLE ushort4 convert_ushort4_sat_rtz(float4 v); -OVERLOADABLE ushort4 convert_ushort4_sat_rtp(float4 v); -OVERLOADABLE ushort4 convert_ushort4_sat_rtn(float4 v); -OVERLOADABLE char4 convert_char4_sat_rte(float4 v); -OVERLOADABLE char4 convert_char4_sat_rtz(float4 v); -OVERLOADABLE char4 convert_char4_sat_rtp(float4 v); -OVERLOADABLE char4 convert_char4_sat_rtn(float4 v); -OVERLOADABLE uchar4 convert_uchar4_sat_rte(float4 v); -OVERLOADABLE uchar4 convert_uchar4_sat_rtz(float4 v); -OVERLOADABLE uchar4 convert_uchar4_sat_rtp(float4 v); -OVERLOADABLE uchar4 convert_uchar4_sat_rtn(float4 v); -OVERLOADABLE long4 convert_long4_sat_rte(half4 v); -OVERLOADABLE long4 convert_long4_sat_rtz(half4 v); -OVERLOADABLE long4 convert_long4_sat_rtp(half4 v); -OVERLOADABLE long4 convert_long4_sat_rtn(half4 v); -OVERLOADABLE ulong4 convert_ulong4_sat_rte(half4 v); -OVERLOADABLE ulong4 convert_ulong4_sat_rtz(half4 v); -OVERLOADABLE ulong4 convert_ulong4_sat_rtp(half4 v); -OVERLOADABLE ulong4 convert_ulong4_sat_rtn(half4 v); -OVERLOADABLE int4 convert_int4_sat_rte(half4 v); -OVERLOADABLE int4 convert_int4_sat_rtz(half4 v); -OVERLOADABLE int4 convert_int4_sat_rtp(half4 v); -OVERLOADABLE int4 convert_int4_sat_rtn(half4 v); -OVERLOADABLE uint4 convert_uint4_sat_rte(half4 v); -OVERLOADABLE uint4 convert_uint4_sat_rtz(half4 v); -OVERLOADABLE uint4 convert_uint4_sat_rtp(half4 v); -OVERLOADABLE uint4 convert_uint4_sat_rtn(half4 v); -OVERLOADABLE short4 convert_short4_sat_rte(half4 v); -OVERLOADABLE short4 convert_short4_sat_rtz(half4 v); -OVERLOADABLE short4 convert_short4_sat_rtp(half4 v); -OVERLOADABLE short4 convert_short4_sat_rtn(half4 v); -OVERLOADABLE ushort4 convert_ushort4_sat_rte(half4 v); -OVERLOADABLE ushort4 convert_ushort4_sat_rtz(half4 v); -OVERLOADABLE ushort4 convert_ushort4_sat_rtp(half4 v); -OVERLOADABLE ushort4 convert_ushort4_sat_rtn(half4 v); -OVERLOADABLE char4 convert_char4_sat_rte(half4 v); -OVERLOADABLE char4 convert_char4_sat_rtz(half4 v); -OVERLOADABLE char4 convert_char4_sat_rtp(half4 v); -OVERLOADABLE char4 convert_char4_sat_rtn(half4 v); -OVERLOADABLE uchar4 convert_uchar4_sat_rte(half4 v); -OVERLOADABLE uchar4 convert_uchar4_sat_rtz(half4 v); -OVERLOADABLE uchar4 convert_uchar4_sat_rtp(half4 v); -OVERLOADABLE uchar4 convert_uchar4_sat_rtn(half4 v); -OVERLOADABLE long8 convert_long8_sat_rte(long8 v); -OVERLOADABLE long8 convert_long8_sat_rtz(long8 v); -OVERLOADABLE long8 convert_long8_sat_rtp(long8 v); -OVERLOADABLE long8 convert_long8_sat_rtn(long8 v); -OVERLOADABLE ulong8 convert_ulong8_sat_rte(long8 v); -OVERLOADABLE ulong8 convert_ulong8_sat_rtz(long8 v); -OVERLOADABLE ulong8 convert_ulong8_sat_rtp(long8 v); -OVERLOADABLE ulong8 convert_ulong8_sat_rtn(long8 v); -OVERLOADABLE int8 convert_int8_sat_rte(long8 v); -OVERLOADABLE int8 convert_int8_sat_rtz(long8 v); -OVERLOADABLE int8 convert_int8_sat_rtp(long8 v); -OVERLOADABLE int8 convert_int8_sat_rtn(long8 v); -OVERLOADABLE uint8 convert_uint8_sat_rte(long8 v); -OVERLOADABLE uint8 convert_uint8_sat_rtz(long8 v); -OVERLOADABLE uint8 convert_uint8_sat_rtp(long8 v); -OVERLOADABLE uint8 convert_uint8_sat_rtn(long8 v); -OVERLOADABLE short8 convert_short8_sat_rte(long8 v); -OVERLOADABLE short8 convert_short8_sat_rtz(long8 v); -OVERLOADABLE short8 convert_short8_sat_rtp(long8 v); -OVERLOADABLE short8 convert_short8_sat_rtn(long8 v); -OVERLOADABLE ushort8 convert_ushort8_sat_rte(long8 v); -OVERLOADABLE ushort8 convert_ushort8_sat_rtz(long8 v); -OVERLOADABLE ushort8 convert_ushort8_sat_rtp(long8 v); -OVERLOADABLE ushort8 convert_ushort8_sat_rtn(long8 v); -OVERLOADABLE char8 convert_char8_sat_rte(long8 v); -OVERLOADABLE char8 convert_char8_sat_rtz(long8 v); -OVERLOADABLE char8 convert_char8_sat_rtp(long8 v); -OVERLOADABLE char8 convert_char8_sat_rtn(long8 v); -OVERLOADABLE uchar8 convert_uchar8_sat_rte(long8 v); -OVERLOADABLE uchar8 convert_uchar8_sat_rtz(long8 v); -OVERLOADABLE uchar8 convert_uchar8_sat_rtp(long8 v); -OVERLOADABLE uchar8 convert_uchar8_sat_rtn(long8 v); -OVERLOADABLE long8 convert_long8_sat_rte(ulong8 v); -OVERLOADABLE long8 convert_long8_sat_rtz(ulong8 v); -OVERLOADABLE long8 convert_long8_sat_rtp(ulong8 v); -OVERLOADABLE long8 convert_long8_sat_rtn(ulong8 v); -OVERLOADABLE ulong8 convert_ulong8_sat_rte(ulong8 v); -OVERLOADABLE ulong8 convert_ulong8_sat_rtz(ulong8 v); -OVERLOADABLE ulong8 convert_ulong8_sat_rtp(ulong8 v); -OVERLOADABLE ulong8 convert_ulong8_sat_rtn(ulong8 v); -OVERLOADABLE int8 convert_int8_sat_rte(ulong8 v); -OVERLOADABLE int8 convert_int8_sat_rtz(ulong8 v); -OVERLOADABLE int8 convert_int8_sat_rtp(ulong8 v); -OVERLOADABLE int8 convert_int8_sat_rtn(ulong8 v); -OVERLOADABLE uint8 convert_uint8_sat_rte(ulong8 v); -OVERLOADABLE uint8 convert_uint8_sat_rtz(ulong8 v); -OVERLOADABLE uint8 convert_uint8_sat_rtp(ulong8 v); -OVERLOADABLE uint8 convert_uint8_sat_rtn(ulong8 v); -OVERLOADABLE short8 convert_short8_sat_rte(ulong8 v); -OVERLOADABLE short8 convert_short8_sat_rtz(ulong8 v); -OVERLOADABLE short8 convert_short8_sat_rtp(ulong8 v); -OVERLOADABLE short8 convert_short8_sat_rtn(ulong8 v); -OVERLOADABLE ushort8 convert_ushort8_sat_rte(ulong8 v); -OVERLOADABLE ushort8 convert_ushort8_sat_rtz(ulong8 v); -OVERLOADABLE ushort8 convert_ushort8_sat_rtp(ulong8 v); -OVERLOADABLE ushort8 convert_ushort8_sat_rtn(ulong8 v); -OVERLOADABLE char8 convert_char8_sat_rte(ulong8 v); -OVERLOADABLE char8 convert_char8_sat_rtz(ulong8 v); -OVERLOADABLE char8 convert_char8_sat_rtp(ulong8 v); -OVERLOADABLE char8 convert_char8_sat_rtn(ulong8 v); -OVERLOADABLE uchar8 convert_uchar8_sat_rte(ulong8 v); -OVERLOADABLE uchar8 convert_uchar8_sat_rtz(ulong8 v); -OVERLOADABLE uchar8 convert_uchar8_sat_rtp(ulong8 v); -OVERLOADABLE uchar8 convert_uchar8_sat_rtn(ulong8 v); -OVERLOADABLE long8 convert_long8_sat_rte(int8 v); -OVERLOADABLE long8 convert_long8_sat_rtz(int8 v); -OVERLOADABLE long8 convert_long8_sat_rtp(int8 v); -OVERLOADABLE long8 convert_long8_sat_rtn(int8 v); -OVERLOADABLE ulong8 convert_ulong8_sat_rte(int8 v); -OVERLOADABLE ulong8 convert_ulong8_sat_rtz(int8 v); -OVERLOADABLE ulong8 convert_ulong8_sat_rtp(int8 v); -OVERLOADABLE ulong8 convert_ulong8_sat_rtn(int8 v); -OVERLOADABLE int8 convert_int8_sat_rte(int8 v); -OVERLOADABLE int8 convert_int8_sat_rtz(int8 v); -OVERLOADABLE int8 convert_int8_sat_rtp(int8 v); -OVERLOADABLE int8 convert_int8_sat_rtn(int8 v); -OVERLOADABLE uint8 convert_uint8_sat_rte(int8 v); -OVERLOADABLE uint8 convert_uint8_sat_rtz(int8 v); -OVERLOADABLE uint8 convert_uint8_sat_rtp(int8 v); -OVERLOADABLE uint8 convert_uint8_sat_rtn(int8 v); -OVERLOADABLE short8 convert_short8_sat_rte(int8 v); -OVERLOADABLE short8 convert_short8_sat_rtz(int8 v); -OVERLOADABLE short8 convert_short8_sat_rtp(int8 v); -OVERLOADABLE short8 convert_short8_sat_rtn(int8 v); -OVERLOADABLE ushort8 convert_ushort8_sat_rte(int8 v); -OVERLOADABLE ushort8 convert_ushort8_sat_rtz(int8 v); -OVERLOADABLE ushort8 convert_ushort8_sat_rtp(int8 v); -OVERLOADABLE ushort8 convert_ushort8_sat_rtn(int8 v); -OVERLOADABLE char8 convert_char8_sat_rte(int8 v); -OVERLOADABLE char8 convert_char8_sat_rtz(int8 v); -OVERLOADABLE char8 convert_char8_sat_rtp(int8 v); -OVERLOADABLE char8 convert_char8_sat_rtn(int8 v); -OVERLOADABLE uchar8 convert_uchar8_sat_rte(int8 v); -OVERLOADABLE uchar8 convert_uchar8_sat_rtz(int8 v); -OVERLOADABLE uchar8 convert_uchar8_sat_rtp(int8 v); -OVERLOADABLE uchar8 convert_uchar8_sat_rtn(int8 v); -OVERLOADABLE long8 convert_long8_sat_rte(uint8 v); -OVERLOADABLE long8 convert_long8_sat_rtz(uint8 v); -OVERLOADABLE long8 convert_long8_sat_rtp(uint8 v); -OVERLOADABLE long8 convert_long8_sat_rtn(uint8 v); -OVERLOADABLE ulong8 convert_ulong8_sat_rte(uint8 v); -OVERLOADABLE ulong8 convert_ulong8_sat_rtz(uint8 v); -OVERLOADABLE ulong8 convert_ulong8_sat_rtp(uint8 v); -OVERLOADABLE ulong8 convert_ulong8_sat_rtn(uint8 v); -OVERLOADABLE int8 convert_int8_sat_rte(uint8 v); -OVERLOADABLE int8 convert_int8_sat_rtz(uint8 v); -OVERLOADABLE int8 convert_int8_sat_rtp(uint8 v); -OVERLOADABLE int8 convert_int8_sat_rtn(uint8 v); -OVERLOADABLE uint8 convert_uint8_sat_rte(uint8 v); -OVERLOADABLE uint8 convert_uint8_sat_rtz(uint8 v); -OVERLOADABLE uint8 convert_uint8_sat_rtp(uint8 v); -OVERLOADABLE uint8 convert_uint8_sat_rtn(uint8 v); -OVERLOADABLE short8 convert_short8_sat_rte(uint8 v); -OVERLOADABLE short8 convert_short8_sat_rtz(uint8 v); -OVERLOADABLE short8 convert_short8_sat_rtp(uint8 v); -OVERLOADABLE short8 convert_short8_sat_rtn(uint8 v); -OVERLOADABLE ushort8 convert_ushort8_sat_rte(uint8 v); -OVERLOADABLE ushort8 convert_ushort8_sat_rtz(uint8 v); -OVERLOADABLE ushort8 convert_ushort8_sat_rtp(uint8 v); -OVERLOADABLE ushort8 convert_ushort8_sat_rtn(uint8 v); -OVERLOADABLE char8 convert_char8_sat_rte(uint8 v); -OVERLOADABLE char8 convert_char8_sat_rtz(uint8 v); -OVERLOADABLE char8 convert_char8_sat_rtp(uint8 v); -OVERLOADABLE char8 convert_char8_sat_rtn(uint8 v); -OVERLOADABLE uchar8 convert_uchar8_sat_rte(uint8 v); -OVERLOADABLE uchar8 convert_uchar8_sat_rtz(uint8 v); -OVERLOADABLE uchar8 convert_uchar8_sat_rtp(uint8 v); -OVERLOADABLE uchar8 convert_uchar8_sat_rtn(uint8 v); -OVERLOADABLE long8 convert_long8_sat_rte(short8 v); -OVERLOADABLE long8 convert_long8_sat_rtz(short8 v); -OVERLOADABLE long8 convert_long8_sat_rtp(short8 v); -OVERLOADABLE long8 convert_long8_sat_rtn(short8 v); -OVERLOADABLE ulong8 convert_ulong8_sat_rte(short8 v); -OVERLOADABLE ulong8 convert_ulong8_sat_rtz(short8 v); -OVERLOADABLE ulong8 convert_ulong8_sat_rtp(short8 v); -OVERLOADABLE ulong8 convert_ulong8_sat_rtn(short8 v); -OVERLOADABLE int8 convert_int8_sat_rte(short8 v); -OVERLOADABLE int8 convert_int8_sat_rtz(short8 v); -OVERLOADABLE int8 convert_int8_sat_rtp(short8 v); -OVERLOADABLE int8 convert_int8_sat_rtn(short8 v); -OVERLOADABLE uint8 convert_uint8_sat_rte(short8 v); -OVERLOADABLE uint8 convert_uint8_sat_rtz(short8 v); -OVERLOADABLE uint8 convert_uint8_sat_rtp(short8 v); -OVERLOADABLE uint8 convert_uint8_sat_rtn(short8 v); -OVERLOADABLE short8 convert_short8_sat_rte(short8 v); -OVERLOADABLE short8 convert_short8_sat_rtz(short8 v); -OVERLOADABLE short8 convert_short8_sat_rtp(short8 v); -OVERLOADABLE short8 convert_short8_sat_rtn(short8 v); -OVERLOADABLE ushort8 convert_ushort8_sat_rte(short8 v); -OVERLOADABLE ushort8 convert_ushort8_sat_rtz(short8 v); -OVERLOADABLE ushort8 convert_ushort8_sat_rtp(short8 v); -OVERLOADABLE ushort8 convert_ushort8_sat_rtn(short8 v); -OVERLOADABLE char8 convert_char8_sat_rte(short8 v); -OVERLOADABLE char8 convert_char8_sat_rtz(short8 v); -OVERLOADABLE char8 convert_char8_sat_rtp(short8 v); -OVERLOADABLE char8 convert_char8_sat_rtn(short8 v); -OVERLOADABLE uchar8 convert_uchar8_sat_rte(short8 v); -OVERLOADABLE uchar8 convert_uchar8_sat_rtz(short8 v); -OVERLOADABLE uchar8 convert_uchar8_sat_rtp(short8 v); -OVERLOADABLE uchar8 convert_uchar8_sat_rtn(short8 v); -OVERLOADABLE long8 convert_long8_sat_rte(ushort8 v); -OVERLOADABLE long8 convert_long8_sat_rtz(ushort8 v); -OVERLOADABLE long8 convert_long8_sat_rtp(ushort8 v); -OVERLOADABLE long8 convert_long8_sat_rtn(ushort8 v); -OVERLOADABLE ulong8 convert_ulong8_sat_rte(ushort8 v); -OVERLOADABLE ulong8 convert_ulong8_sat_rtz(ushort8 v); -OVERLOADABLE ulong8 convert_ulong8_sat_rtp(ushort8 v); -OVERLOADABLE ulong8 convert_ulong8_sat_rtn(ushort8 v); -OVERLOADABLE int8 convert_int8_sat_rte(ushort8 v); -OVERLOADABLE int8 convert_int8_sat_rtz(ushort8 v); -OVERLOADABLE int8 convert_int8_sat_rtp(ushort8 v); -OVERLOADABLE int8 convert_int8_sat_rtn(ushort8 v); -OVERLOADABLE uint8 convert_uint8_sat_rte(ushort8 v); -OVERLOADABLE uint8 convert_uint8_sat_rtz(ushort8 v); -OVERLOADABLE uint8 convert_uint8_sat_rtp(ushort8 v); -OVERLOADABLE uint8 convert_uint8_sat_rtn(ushort8 v); -OVERLOADABLE short8 convert_short8_sat_rte(ushort8 v); -OVERLOADABLE short8 convert_short8_sat_rtz(ushort8 v); -OVERLOADABLE short8 convert_short8_sat_rtp(ushort8 v); -OVERLOADABLE short8 convert_short8_sat_rtn(ushort8 v); -OVERLOADABLE ushort8 convert_ushort8_sat_rte(ushort8 v); -OVERLOADABLE ushort8 convert_ushort8_sat_rtz(ushort8 v); -OVERLOADABLE ushort8 convert_ushort8_sat_rtp(ushort8 v); -OVERLOADABLE ushort8 convert_ushort8_sat_rtn(ushort8 v); -OVERLOADABLE char8 convert_char8_sat_rte(ushort8 v); -OVERLOADABLE char8 convert_char8_sat_rtz(ushort8 v); -OVERLOADABLE char8 convert_char8_sat_rtp(ushort8 v); -OVERLOADABLE char8 convert_char8_sat_rtn(ushort8 v); -OVERLOADABLE uchar8 convert_uchar8_sat_rte(ushort8 v); -OVERLOADABLE uchar8 convert_uchar8_sat_rtz(ushort8 v); -OVERLOADABLE uchar8 convert_uchar8_sat_rtp(ushort8 v); -OVERLOADABLE uchar8 convert_uchar8_sat_rtn(ushort8 v); -OVERLOADABLE long8 convert_long8_sat_rte(char8 v); -OVERLOADABLE long8 convert_long8_sat_rtz(char8 v); -OVERLOADABLE long8 convert_long8_sat_rtp(char8 v); -OVERLOADABLE long8 convert_long8_sat_rtn(char8 v); -OVERLOADABLE ulong8 convert_ulong8_sat_rte(char8 v); -OVERLOADABLE ulong8 convert_ulong8_sat_rtz(char8 v); -OVERLOADABLE ulong8 convert_ulong8_sat_rtp(char8 v); -OVERLOADABLE ulong8 convert_ulong8_sat_rtn(char8 v); -OVERLOADABLE int8 convert_int8_sat_rte(char8 v); -OVERLOADABLE int8 convert_int8_sat_rtz(char8 v); -OVERLOADABLE int8 convert_int8_sat_rtp(char8 v); -OVERLOADABLE int8 convert_int8_sat_rtn(char8 v); -OVERLOADABLE uint8 convert_uint8_sat_rte(char8 v); -OVERLOADABLE uint8 convert_uint8_sat_rtz(char8 v); -OVERLOADABLE uint8 convert_uint8_sat_rtp(char8 v); -OVERLOADABLE uint8 convert_uint8_sat_rtn(char8 v); -OVERLOADABLE short8 convert_short8_sat_rte(char8 v); -OVERLOADABLE short8 convert_short8_sat_rtz(char8 v); -OVERLOADABLE short8 convert_short8_sat_rtp(char8 v); -OVERLOADABLE short8 convert_short8_sat_rtn(char8 v); -OVERLOADABLE ushort8 convert_ushort8_sat_rte(char8 v); -OVERLOADABLE ushort8 convert_ushort8_sat_rtz(char8 v); -OVERLOADABLE ushort8 convert_ushort8_sat_rtp(char8 v); -OVERLOADABLE ushort8 convert_ushort8_sat_rtn(char8 v); -OVERLOADABLE char8 convert_char8_sat_rte(char8 v); -OVERLOADABLE char8 convert_char8_sat_rtz(char8 v); -OVERLOADABLE char8 convert_char8_sat_rtp(char8 v); -OVERLOADABLE char8 convert_char8_sat_rtn(char8 v); -OVERLOADABLE uchar8 convert_uchar8_sat_rte(char8 v); -OVERLOADABLE uchar8 convert_uchar8_sat_rtz(char8 v); -OVERLOADABLE uchar8 convert_uchar8_sat_rtp(char8 v); -OVERLOADABLE uchar8 convert_uchar8_sat_rtn(char8 v); -OVERLOADABLE long8 convert_long8_sat_rte(uchar8 v); -OVERLOADABLE long8 convert_long8_sat_rtz(uchar8 v); -OVERLOADABLE long8 convert_long8_sat_rtp(uchar8 v); -OVERLOADABLE long8 convert_long8_sat_rtn(uchar8 v); -OVERLOADABLE ulong8 convert_ulong8_sat_rte(uchar8 v); -OVERLOADABLE ulong8 convert_ulong8_sat_rtz(uchar8 v); -OVERLOADABLE ulong8 convert_ulong8_sat_rtp(uchar8 v); -OVERLOADABLE ulong8 convert_ulong8_sat_rtn(uchar8 v); -OVERLOADABLE int8 convert_int8_sat_rte(uchar8 v); -OVERLOADABLE int8 convert_int8_sat_rtz(uchar8 v); -OVERLOADABLE int8 convert_int8_sat_rtp(uchar8 v); -OVERLOADABLE int8 convert_int8_sat_rtn(uchar8 v); -OVERLOADABLE uint8 convert_uint8_sat_rte(uchar8 v); -OVERLOADABLE uint8 convert_uint8_sat_rtz(uchar8 v); -OVERLOADABLE uint8 convert_uint8_sat_rtp(uchar8 v); -OVERLOADABLE uint8 convert_uint8_sat_rtn(uchar8 v); -OVERLOADABLE short8 convert_short8_sat_rte(uchar8 v); -OVERLOADABLE short8 convert_short8_sat_rtz(uchar8 v); -OVERLOADABLE short8 convert_short8_sat_rtp(uchar8 v); -OVERLOADABLE short8 convert_short8_sat_rtn(uchar8 v); -OVERLOADABLE ushort8 convert_ushort8_sat_rte(uchar8 v); -OVERLOADABLE ushort8 convert_ushort8_sat_rtz(uchar8 v); -OVERLOADABLE ushort8 convert_ushort8_sat_rtp(uchar8 v); -OVERLOADABLE ushort8 convert_ushort8_sat_rtn(uchar8 v); -OVERLOADABLE char8 convert_char8_sat_rte(uchar8 v); -OVERLOADABLE char8 convert_char8_sat_rtz(uchar8 v); -OVERLOADABLE char8 convert_char8_sat_rtp(uchar8 v); -OVERLOADABLE char8 convert_char8_sat_rtn(uchar8 v); -OVERLOADABLE uchar8 convert_uchar8_sat_rte(uchar8 v); -OVERLOADABLE uchar8 convert_uchar8_sat_rtz(uchar8 v); -OVERLOADABLE uchar8 convert_uchar8_sat_rtp(uchar8 v); -OVERLOADABLE uchar8 convert_uchar8_sat_rtn(uchar8 v); -OVERLOADABLE long8 convert_long8_sat_rte(double8 v); -OVERLOADABLE long8 convert_long8_sat_rtz(double8 v); -OVERLOADABLE long8 convert_long8_sat_rtp(double8 v); -OVERLOADABLE long8 convert_long8_sat_rtn(double8 v); -OVERLOADABLE ulong8 convert_ulong8_sat_rte(double8 v); -OVERLOADABLE ulong8 convert_ulong8_sat_rtz(double8 v); -OVERLOADABLE ulong8 convert_ulong8_sat_rtp(double8 v); -OVERLOADABLE ulong8 convert_ulong8_sat_rtn(double8 v); -OVERLOADABLE int8 convert_int8_sat_rte(double8 v); -OVERLOADABLE int8 convert_int8_sat_rtz(double8 v); -OVERLOADABLE int8 convert_int8_sat_rtp(double8 v); -OVERLOADABLE int8 convert_int8_sat_rtn(double8 v); -OVERLOADABLE uint8 convert_uint8_sat_rte(double8 v); -OVERLOADABLE uint8 convert_uint8_sat_rtz(double8 v); -OVERLOADABLE uint8 convert_uint8_sat_rtp(double8 v); -OVERLOADABLE uint8 convert_uint8_sat_rtn(double8 v); -OVERLOADABLE short8 convert_short8_sat_rte(double8 v); -OVERLOADABLE short8 convert_short8_sat_rtz(double8 v); -OVERLOADABLE short8 convert_short8_sat_rtp(double8 v); -OVERLOADABLE short8 convert_short8_sat_rtn(double8 v); -OVERLOADABLE ushort8 convert_ushort8_sat_rte(double8 v); -OVERLOADABLE ushort8 convert_ushort8_sat_rtz(double8 v); -OVERLOADABLE ushort8 convert_ushort8_sat_rtp(double8 v); -OVERLOADABLE ushort8 convert_ushort8_sat_rtn(double8 v); -OVERLOADABLE char8 convert_char8_sat_rte(double8 v); -OVERLOADABLE char8 convert_char8_sat_rtz(double8 v); -OVERLOADABLE char8 convert_char8_sat_rtp(double8 v); -OVERLOADABLE char8 convert_char8_sat_rtn(double8 v); -OVERLOADABLE uchar8 convert_uchar8_sat_rte(double8 v); -OVERLOADABLE uchar8 convert_uchar8_sat_rtz(double8 v); -OVERLOADABLE uchar8 convert_uchar8_sat_rtp(double8 v); -OVERLOADABLE uchar8 convert_uchar8_sat_rtn(double8 v); -OVERLOADABLE long8 convert_long8_sat_rte(float8 v); -OVERLOADABLE long8 convert_long8_sat_rtz(float8 v); -OVERLOADABLE long8 convert_long8_sat_rtp(float8 v); -OVERLOADABLE long8 convert_long8_sat_rtn(float8 v); -OVERLOADABLE ulong8 convert_ulong8_sat_rte(float8 v); -OVERLOADABLE ulong8 convert_ulong8_sat_rtz(float8 v); -OVERLOADABLE ulong8 convert_ulong8_sat_rtp(float8 v); -OVERLOADABLE ulong8 convert_ulong8_sat_rtn(float8 v); -OVERLOADABLE int8 convert_int8_sat_rte(float8 v); -OVERLOADABLE int8 convert_int8_sat_rtz(float8 v); -OVERLOADABLE int8 convert_int8_sat_rtp(float8 v); -OVERLOADABLE int8 convert_int8_sat_rtn(float8 v); -OVERLOADABLE uint8 convert_uint8_sat_rte(float8 v); -OVERLOADABLE uint8 convert_uint8_sat_rtz(float8 v); -OVERLOADABLE uint8 convert_uint8_sat_rtp(float8 v); -OVERLOADABLE uint8 convert_uint8_sat_rtn(float8 v); -OVERLOADABLE short8 convert_short8_sat_rte(float8 v); -OVERLOADABLE short8 convert_short8_sat_rtz(float8 v); -OVERLOADABLE short8 convert_short8_sat_rtp(float8 v); -OVERLOADABLE short8 convert_short8_sat_rtn(float8 v); -OVERLOADABLE ushort8 convert_ushort8_sat_rte(float8 v); -OVERLOADABLE ushort8 convert_ushort8_sat_rtz(float8 v); -OVERLOADABLE ushort8 convert_ushort8_sat_rtp(float8 v); -OVERLOADABLE ushort8 convert_ushort8_sat_rtn(float8 v); -OVERLOADABLE char8 convert_char8_sat_rte(float8 v); -OVERLOADABLE char8 convert_char8_sat_rtz(float8 v); -OVERLOADABLE char8 convert_char8_sat_rtp(float8 v); -OVERLOADABLE char8 convert_char8_sat_rtn(float8 v); -OVERLOADABLE uchar8 convert_uchar8_sat_rte(float8 v); -OVERLOADABLE uchar8 convert_uchar8_sat_rtz(float8 v); -OVERLOADABLE uchar8 convert_uchar8_sat_rtp(float8 v); -OVERLOADABLE uchar8 convert_uchar8_sat_rtn(float8 v); -OVERLOADABLE long8 convert_long8_sat_rte(half8 v); -OVERLOADABLE long8 convert_long8_sat_rtz(half8 v); -OVERLOADABLE long8 convert_long8_sat_rtp(half8 v); -OVERLOADABLE long8 convert_long8_sat_rtn(half8 v); -OVERLOADABLE ulong8 convert_ulong8_sat_rte(half8 v); -OVERLOADABLE ulong8 convert_ulong8_sat_rtz(half8 v); -OVERLOADABLE ulong8 convert_ulong8_sat_rtp(half8 v); -OVERLOADABLE ulong8 convert_ulong8_sat_rtn(half8 v); -OVERLOADABLE int8 convert_int8_sat_rte(half8 v); -OVERLOADABLE int8 convert_int8_sat_rtz(half8 v); -OVERLOADABLE int8 convert_int8_sat_rtp(half8 v); -OVERLOADABLE int8 convert_int8_sat_rtn(half8 v); -OVERLOADABLE uint8 convert_uint8_sat_rte(half8 v); -OVERLOADABLE uint8 convert_uint8_sat_rtz(half8 v); -OVERLOADABLE uint8 convert_uint8_sat_rtp(half8 v); -OVERLOADABLE uint8 convert_uint8_sat_rtn(half8 v); -OVERLOADABLE short8 convert_short8_sat_rte(half8 v); -OVERLOADABLE short8 convert_short8_sat_rtz(half8 v); -OVERLOADABLE short8 convert_short8_sat_rtp(half8 v); -OVERLOADABLE short8 convert_short8_sat_rtn(half8 v); -OVERLOADABLE ushort8 convert_ushort8_sat_rte(half8 v); -OVERLOADABLE ushort8 convert_ushort8_sat_rtz(half8 v); -OVERLOADABLE ushort8 convert_ushort8_sat_rtp(half8 v); -OVERLOADABLE ushort8 convert_ushort8_sat_rtn(half8 v); -OVERLOADABLE char8 convert_char8_sat_rte(half8 v); -OVERLOADABLE char8 convert_char8_sat_rtz(half8 v); -OVERLOADABLE char8 convert_char8_sat_rtp(half8 v); -OVERLOADABLE char8 convert_char8_sat_rtn(half8 v); -OVERLOADABLE uchar8 convert_uchar8_sat_rte(half8 v); -OVERLOADABLE uchar8 convert_uchar8_sat_rtz(half8 v); -OVERLOADABLE uchar8 convert_uchar8_sat_rtp(half8 v); -OVERLOADABLE uchar8 convert_uchar8_sat_rtn(half8 v); -OVERLOADABLE long16 convert_long16_sat_rte(long16 v); -OVERLOADABLE long16 convert_long16_sat_rtz(long16 v); -OVERLOADABLE long16 convert_long16_sat_rtp(long16 v); -OVERLOADABLE long16 convert_long16_sat_rtn(long16 v); -OVERLOADABLE ulong16 convert_ulong16_sat_rte(long16 v); -OVERLOADABLE ulong16 convert_ulong16_sat_rtz(long16 v); -OVERLOADABLE ulong16 convert_ulong16_sat_rtp(long16 v); -OVERLOADABLE ulong16 convert_ulong16_sat_rtn(long16 v); -OVERLOADABLE int16 convert_int16_sat_rte(long16 v); -OVERLOADABLE int16 convert_int16_sat_rtz(long16 v); -OVERLOADABLE int16 convert_int16_sat_rtp(long16 v); -OVERLOADABLE int16 convert_int16_sat_rtn(long16 v); -OVERLOADABLE uint16 convert_uint16_sat_rte(long16 v); -OVERLOADABLE uint16 convert_uint16_sat_rtz(long16 v); -OVERLOADABLE uint16 convert_uint16_sat_rtp(long16 v); -OVERLOADABLE uint16 convert_uint16_sat_rtn(long16 v); -OVERLOADABLE short16 convert_short16_sat_rte(long16 v); -OVERLOADABLE short16 convert_short16_sat_rtz(long16 v); -OVERLOADABLE short16 convert_short16_sat_rtp(long16 v); -OVERLOADABLE short16 convert_short16_sat_rtn(long16 v); -OVERLOADABLE ushort16 convert_ushort16_sat_rte(long16 v); -OVERLOADABLE ushort16 convert_ushort16_sat_rtz(long16 v); -OVERLOADABLE ushort16 convert_ushort16_sat_rtp(long16 v); -OVERLOADABLE ushort16 convert_ushort16_sat_rtn(long16 v); -OVERLOADABLE char16 convert_char16_sat_rte(long16 v); -OVERLOADABLE char16 convert_char16_sat_rtz(long16 v); -OVERLOADABLE char16 convert_char16_sat_rtp(long16 v); -OVERLOADABLE char16 convert_char16_sat_rtn(long16 v); -OVERLOADABLE uchar16 convert_uchar16_sat_rte(long16 v); -OVERLOADABLE uchar16 convert_uchar16_sat_rtz(long16 v); -OVERLOADABLE uchar16 convert_uchar16_sat_rtp(long16 v); -OVERLOADABLE uchar16 convert_uchar16_sat_rtn(long16 v); -OVERLOADABLE long16 convert_long16_sat_rte(ulong16 v); -OVERLOADABLE long16 convert_long16_sat_rtz(ulong16 v); -OVERLOADABLE long16 convert_long16_sat_rtp(ulong16 v); -OVERLOADABLE long16 convert_long16_sat_rtn(ulong16 v); -OVERLOADABLE ulong16 convert_ulong16_sat_rte(ulong16 v); -OVERLOADABLE ulong16 convert_ulong16_sat_rtz(ulong16 v); -OVERLOADABLE ulong16 convert_ulong16_sat_rtp(ulong16 v); -OVERLOADABLE ulong16 convert_ulong16_sat_rtn(ulong16 v); -OVERLOADABLE int16 convert_int16_sat_rte(ulong16 v); -OVERLOADABLE int16 convert_int16_sat_rtz(ulong16 v); -OVERLOADABLE int16 convert_int16_sat_rtp(ulong16 v); -OVERLOADABLE int16 convert_int16_sat_rtn(ulong16 v); -OVERLOADABLE uint16 convert_uint16_sat_rte(ulong16 v); -OVERLOADABLE uint16 convert_uint16_sat_rtz(ulong16 v); -OVERLOADABLE uint16 convert_uint16_sat_rtp(ulong16 v); -OVERLOADABLE uint16 convert_uint16_sat_rtn(ulong16 v); -OVERLOADABLE short16 convert_short16_sat_rte(ulong16 v); -OVERLOADABLE short16 convert_short16_sat_rtz(ulong16 v); -OVERLOADABLE short16 convert_short16_sat_rtp(ulong16 v); -OVERLOADABLE short16 convert_short16_sat_rtn(ulong16 v); -OVERLOADABLE ushort16 convert_ushort16_sat_rte(ulong16 v); -OVERLOADABLE ushort16 convert_ushort16_sat_rtz(ulong16 v); -OVERLOADABLE ushort16 convert_ushort16_sat_rtp(ulong16 v); -OVERLOADABLE ushort16 convert_ushort16_sat_rtn(ulong16 v); -OVERLOADABLE char16 convert_char16_sat_rte(ulong16 v); -OVERLOADABLE char16 convert_char16_sat_rtz(ulong16 v); -OVERLOADABLE char16 convert_char16_sat_rtp(ulong16 v); -OVERLOADABLE char16 convert_char16_sat_rtn(ulong16 v); -OVERLOADABLE uchar16 convert_uchar16_sat_rte(ulong16 v); -OVERLOADABLE uchar16 convert_uchar16_sat_rtz(ulong16 v); -OVERLOADABLE uchar16 convert_uchar16_sat_rtp(ulong16 v); -OVERLOADABLE uchar16 convert_uchar16_sat_rtn(ulong16 v); -OVERLOADABLE long16 convert_long16_sat_rte(int16 v); -OVERLOADABLE long16 convert_long16_sat_rtz(int16 v); -OVERLOADABLE long16 convert_long16_sat_rtp(int16 v); -OVERLOADABLE long16 convert_long16_sat_rtn(int16 v); -OVERLOADABLE ulong16 convert_ulong16_sat_rte(int16 v); -OVERLOADABLE ulong16 convert_ulong16_sat_rtz(int16 v); -OVERLOADABLE ulong16 convert_ulong16_sat_rtp(int16 v); -OVERLOADABLE ulong16 convert_ulong16_sat_rtn(int16 v); -OVERLOADABLE int16 convert_int16_sat_rte(int16 v); -OVERLOADABLE int16 convert_int16_sat_rtz(int16 v); -OVERLOADABLE int16 convert_int16_sat_rtp(int16 v); -OVERLOADABLE int16 convert_int16_sat_rtn(int16 v); -OVERLOADABLE uint16 convert_uint16_sat_rte(int16 v); -OVERLOADABLE uint16 convert_uint16_sat_rtz(int16 v); -OVERLOADABLE uint16 convert_uint16_sat_rtp(int16 v); -OVERLOADABLE uint16 convert_uint16_sat_rtn(int16 v); -OVERLOADABLE short16 convert_short16_sat_rte(int16 v); -OVERLOADABLE short16 convert_short16_sat_rtz(int16 v); -OVERLOADABLE short16 convert_short16_sat_rtp(int16 v); -OVERLOADABLE short16 convert_short16_sat_rtn(int16 v); -OVERLOADABLE ushort16 convert_ushort16_sat_rte(int16 v); -OVERLOADABLE ushort16 convert_ushort16_sat_rtz(int16 v); -OVERLOADABLE ushort16 convert_ushort16_sat_rtp(int16 v); -OVERLOADABLE ushort16 convert_ushort16_sat_rtn(int16 v); -OVERLOADABLE char16 convert_char16_sat_rte(int16 v); -OVERLOADABLE char16 convert_char16_sat_rtz(int16 v); -OVERLOADABLE char16 convert_char16_sat_rtp(int16 v); -OVERLOADABLE char16 convert_char16_sat_rtn(int16 v); -OVERLOADABLE uchar16 convert_uchar16_sat_rte(int16 v); -OVERLOADABLE uchar16 convert_uchar16_sat_rtz(int16 v); -OVERLOADABLE uchar16 convert_uchar16_sat_rtp(int16 v); -OVERLOADABLE uchar16 convert_uchar16_sat_rtn(int16 v); -OVERLOADABLE long16 convert_long16_sat_rte(uint16 v); -OVERLOADABLE long16 convert_long16_sat_rtz(uint16 v); -OVERLOADABLE long16 convert_long16_sat_rtp(uint16 v); -OVERLOADABLE long16 convert_long16_sat_rtn(uint16 v); -OVERLOADABLE ulong16 convert_ulong16_sat_rte(uint16 v); -OVERLOADABLE ulong16 convert_ulong16_sat_rtz(uint16 v); -OVERLOADABLE ulong16 convert_ulong16_sat_rtp(uint16 v); -OVERLOADABLE ulong16 convert_ulong16_sat_rtn(uint16 v); -OVERLOADABLE int16 convert_int16_sat_rte(uint16 v); -OVERLOADABLE int16 convert_int16_sat_rtz(uint16 v); -OVERLOADABLE int16 convert_int16_sat_rtp(uint16 v); -OVERLOADABLE int16 convert_int16_sat_rtn(uint16 v); -OVERLOADABLE uint16 convert_uint16_sat_rte(uint16 v); -OVERLOADABLE uint16 convert_uint16_sat_rtz(uint16 v); -OVERLOADABLE uint16 convert_uint16_sat_rtp(uint16 v); -OVERLOADABLE uint16 convert_uint16_sat_rtn(uint16 v); -OVERLOADABLE short16 convert_short16_sat_rte(uint16 v); -OVERLOADABLE short16 convert_short16_sat_rtz(uint16 v); -OVERLOADABLE short16 convert_short16_sat_rtp(uint16 v); -OVERLOADABLE short16 convert_short16_sat_rtn(uint16 v); -OVERLOADABLE ushort16 convert_ushort16_sat_rte(uint16 v); -OVERLOADABLE ushort16 convert_ushort16_sat_rtz(uint16 v); -OVERLOADABLE ushort16 convert_ushort16_sat_rtp(uint16 v); -OVERLOADABLE ushort16 convert_ushort16_sat_rtn(uint16 v); -OVERLOADABLE char16 convert_char16_sat_rte(uint16 v); -OVERLOADABLE char16 convert_char16_sat_rtz(uint16 v); -OVERLOADABLE char16 convert_char16_sat_rtp(uint16 v); -OVERLOADABLE char16 convert_char16_sat_rtn(uint16 v); -OVERLOADABLE uchar16 convert_uchar16_sat_rte(uint16 v); -OVERLOADABLE uchar16 convert_uchar16_sat_rtz(uint16 v); -OVERLOADABLE uchar16 convert_uchar16_sat_rtp(uint16 v); -OVERLOADABLE uchar16 convert_uchar16_sat_rtn(uint16 v); -OVERLOADABLE long16 convert_long16_sat_rte(short16 v); -OVERLOADABLE long16 convert_long16_sat_rtz(short16 v); -OVERLOADABLE long16 convert_long16_sat_rtp(short16 v); -OVERLOADABLE long16 convert_long16_sat_rtn(short16 v); -OVERLOADABLE ulong16 convert_ulong16_sat_rte(short16 v); -OVERLOADABLE ulong16 convert_ulong16_sat_rtz(short16 v); -OVERLOADABLE ulong16 convert_ulong16_sat_rtp(short16 v); -OVERLOADABLE ulong16 convert_ulong16_sat_rtn(short16 v); -OVERLOADABLE int16 convert_int16_sat_rte(short16 v); -OVERLOADABLE int16 convert_int16_sat_rtz(short16 v); -OVERLOADABLE int16 convert_int16_sat_rtp(short16 v); -OVERLOADABLE int16 convert_int16_sat_rtn(short16 v); -OVERLOADABLE uint16 convert_uint16_sat_rte(short16 v); -OVERLOADABLE uint16 convert_uint16_sat_rtz(short16 v); -OVERLOADABLE uint16 convert_uint16_sat_rtp(short16 v); -OVERLOADABLE uint16 convert_uint16_sat_rtn(short16 v); -OVERLOADABLE short16 convert_short16_sat_rte(short16 v); -OVERLOADABLE short16 convert_short16_sat_rtz(short16 v); -OVERLOADABLE short16 convert_short16_sat_rtp(short16 v); -OVERLOADABLE short16 convert_short16_sat_rtn(short16 v); -OVERLOADABLE ushort16 convert_ushort16_sat_rte(short16 v); -OVERLOADABLE ushort16 convert_ushort16_sat_rtz(short16 v); -OVERLOADABLE ushort16 convert_ushort16_sat_rtp(short16 v); -OVERLOADABLE ushort16 convert_ushort16_sat_rtn(short16 v); -OVERLOADABLE char16 convert_char16_sat_rte(short16 v); -OVERLOADABLE char16 convert_char16_sat_rtz(short16 v); -OVERLOADABLE char16 convert_char16_sat_rtp(short16 v); -OVERLOADABLE char16 convert_char16_sat_rtn(short16 v); -OVERLOADABLE uchar16 convert_uchar16_sat_rte(short16 v); -OVERLOADABLE uchar16 convert_uchar16_sat_rtz(short16 v); -OVERLOADABLE uchar16 convert_uchar16_sat_rtp(short16 v); -OVERLOADABLE uchar16 convert_uchar16_sat_rtn(short16 v); -OVERLOADABLE long16 convert_long16_sat_rte(ushort16 v); -OVERLOADABLE long16 convert_long16_sat_rtz(ushort16 v); -OVERLOADABLE long16 convert_long16_sat_rtp(ushort16 v); -OVERLOADABLE long16 convert_long16_sat_rtn(ushort16 v); -OVERLOADABLE ulong16 convert_ulong16_sat_rte(ushort16 v); -OVERLOADABLE ulong16 convert_ulong16_sat_rtz(ushort16 v); -OVERLOADABLE ulong16 convert_ulong16_sat_rtp(ushort16 v); -OVERLOADABLE ulong16 convert_ulong16_sat_rtn(ushort16 v); -OVERLOADABLE int16 convert_int16_sat_rte(ushort16 v); -OVERLOADABLE int16 convert_int16_sat_rtz(ushort16 v); -OVERLOADABLE int16 convert_int16_sat_rtp(ushort16 v); -OVERLOADABLE int16 convert_int16_sat_rtn(ushort16 v); -OVERLOADABLE uint16 convert_uint16_sat_rte(ushort16 v); -OVERLOADABLE uint16 convert_uint16_sat_rtz(ushort16 v); -OVERLOADABLE uint16 convert_uint16_sat_rtp(ushort16 v); -OVERLOADABLE uint16 convert_uint16_sat_rtn(ushort16 v); -OVERLOADABLE short16 convert_short16_sat_rte(ushort16 v); -OVERLOADABLE short16 convert_short16_sat_rtz(ushort16 v); -OVERLOADABLE short16 convert_short16_sat_rtp(ushort16 v); -OVERLOADABLE short16 convert_short16_sat_rtn(ushort16 v); -OVERLOADABLE ushort16 convert_ushort16_sat_rte(ushort16 v); -OVERLOADABLE ushort16 convert_ushort16_sat_rtz(ushort16 v); -OVERLOADABLE ushort16 convert_ushort16_sat_rtp(ushort16 v); -OVERLOADABLE ushort16 convert_ushort16_sat_rtn(ushort16 v); -OVERLOADABLE char16 convert_char16_sat_rte(ushort16 v); -OVERLOADABLE char16 convert_char16_sat_rtz(ushort16 v); -OVERLOADABLE char16 convert_char16_sat_rtp(ushort16 v); -OVERLOADABLE char16 convert_char16_sat_rtn(ushort16 v); -OVERLOADABLE uchar16 convert_uchar16_sat_rte(ushort16 v); -OVERLOADABLE uchar16 convert_uchar16_sat_rtz(ushort16 v); -OVERLOADABLE uchar16 convert_uchar16_sat_rtp(ushort16 v); -OVERLOADABLE uchar16 convert_uchar16_sat_rtn(ushort16 v); -OVERLOADABLE long16 convert_long16_sat_rte(char16 v); -OVERLOADABLE long16 convert_long16_sat_rtz(char16 v); -OVERLOADABLE long16 convert_long16_sat_rtp(char16 v); -OVERLOADABLE long16 convert_long16_sat_rtn(char16 v); -OVERLOADABLE ulong16 convert_ulong16_sat_rte(char16 v); -OVERLOADABLE ulong16 convert_ulong16_sat_rtz(char16 v); -OVERLOADABLE ulong16 convert_ulong16_sat_rtp(char16 v); -OVERLOADABLE ulong16 convert_ulong16_sat_rtn(char16 v); -OVERLOADABLE int16 convert_int16_sat_rte(char16 v); -OVERLOADABLE int16 convert_int16_sat_rtz(char16 v); -OVERLOADABLE int16 convert_int16_sat_rtp(char16 v); -OVERLOADABLE int16 convert_int16_sat_rtn(char16 v); -OVERLOADABLE uint16 convert_uint16_sat_rte(char16 v); -OVERLOADABLE uint16 convert_uint16_sat_rtz(char16 v); -OVERLOADABLE uint16 convert_uint16_sat_rtp(char16 v); -OVERLOADABLE uint16 convert_uint16_sat_rtn(char16 v); -OVERLOADABLE short16 convert_short16_sat_rte(char16 v); -OVERLOADABLE short16 convert_short16_sat_rtz(char16 v); -OVERLOADABLE short16 convert_short16_sat_rtp(char16 v); -OVERLOADABLE short16 convert_short16_sat_rtn(char16 v); -OVERLOADABLE ushort16 convert_ushort16_sat_rte(char16 v); -OVERLOADABLE ushort16 convert_ushort16_sat_rtz(char16 v); -OVERLOADABLE ushort16 convert_ushort16_sat_rtp(char16 v); -OVERLOADABLE ushort16 convert_ushort16_sat_rtn(char16 v); -OVERLOADABLE char16 convert_char16_sat_rte(char16 v); -OVERLOADABLE char16 convert_char16_sat_rtz(char16 v); -OVERLOADABLE char16 convert_char16_sat_rtp(char16 v); -OVERLOADABLE char16 convert_char16_sat_rtn(char16 v); -OVERLOADABLE uchar16 convert_uchar16_sat_rte(char16 v); -OVERLOADABLE uchar16 convert_uchar16_sat_rtz(char16 v); -OVERLOADABLE uchar16 convert_uchar16_sat_rtp(char16 v); -OVERLOADABLE uchar16 convert_uchar16_sat_rtn(char16 v); -OVERLOADABLE long16 convert_long16_sat_rte(uchar16 v); -OVERLOADABLE long16 convert_long16_sat_rtz(uchar16 v); -OVERLOADABLE long16 convert_long16_sat_rtp(uchar16 v); -OVERLOADABLE long16 convert_long16_sat_rtn(uchar16 v); -OVERLOADABLE ulong16 convert_ulong16_sat_rte(uchar16 v); -OVERLOADABLE ulong16 convert_ulong16_sat_rtz(uchar16 v); -OVERLOADABLE ulong16 convert_ulong16_sat_rtp(uchar16 v); -OVERLOADABLE ulong16 convert_ulong16_sat_rtn(uchar16 v); -OVERLOADABLE int16 convert_int16_sat_rte(uchar16 v); -OVERLOADABLE int16 convert_int16_sat_rtz(uchar16 v); -OVERLOADABLE int16 convert_int16_sat_rtp(uchar16 v); -OVERLOADABLE int16 convert_int16_sat_rtn(uchar16 v); -OVERLOADABLE uint16 convert_uint16_sat_rte(uchar16 v); -OVERLOADABLE uint16 convert_uint16_sat_rtz(uchar16 v); -OVERLOADABLE uint16 convert_uint16_sat_rtp(uchar16 v); -OVERLOADABLE uint16 convert_uint16_sat_rtn(uchar16 v); -OVERLOADABLE short16 convert_short16_sat_rte(uchar16 v); -OVERLOADABLE short16 convert_short16_sat_rtz(uchar16 v); -OVERLOADABLE short16 convert_short16_sat_rtp(uchar16 v); -OVERLOADABLE short16 convert_short16_sat_rtn(uchar16 v); -OVERLOADABLE ushort16 convert_ushort16_sat_rte(uchar16 v); -OVERLOADABLE ushort16 convert_ushort16_sat_rtz(uchar16 v); -OVERLOADABLE ushort16 convert_ushort16_sat_rtp(uchar16 v); -OVERLOADABLE ushort16 convert_ushort16_sat_rtn(uchar16 v); -OVERLOADABLE char16 convert_char16_sat_rte(uchar16 v); -OVERLOADABLE char16 convert_char16_sat_rtz(uchar16 v); -OVERLOADABLE char16 convert_char16_sat_rtp(uchar16 v); -OVERLOADABLE char16 convert_char16_sat_rtn(uchar16 v); -OVERLOADABLE uchar16 convert_uchar16_sat_rte(uchar16 v); -OVERLOADABLE uchar16 convert_uchar16_sat_rtz(uchar16 v); -OVERLOADABLE uchar16 convert_uchar16_sat_rtp(uchar16 v); -OVERLOADABLE uchar16 convert_uchar16_sat_rtn(uchar16 v); -OVERLOADABLE long16 convert_long16_sat_rte(double16 v); -OVERLOADABLE long16 convert_long16_sat_rtz(double16 v); -OVERLOADABLE long16 convert_long16_sat_rtp(double16 v); -OVERLOADABLE long16 convert_long16_sat_rtn(double16 v); -OVERLOADABLE ulong16 convert_ulong16_sat_rte(double16 v); -OVERLOADABLE ulong16 convert_ulong16_sat_rtz(double16 v); -OVERLOADABLE ulong16 convert_ulong16_sat_rtp(double16 v); -OVERLOADABLE ulong16 convert_ulong16_sat_rtn(double16 v); -OVERLOADABLE int16 convert_int16_sat_rte(double16 v); -OVERLOADABLE int16 convert_int16_sat_rtz(double16 v); -OVERLOADABLE int16 convert_int16_sat_rtp(double16 v); -OVERLOADABLE int16 convert_int16_sat_rtn(double16 v); -OVERLOADABLE uint16 convert_uint16_sat_rte(double16 v); -OVERLOADABLE uint16 convert_uint16_sat_rtz(double16 v); -OVERLOADABLE uint16 convert_uint16_sat_rtp(double16 v); -OVERLOADABLE uint16 convert_uint16_sat_rtn(double16 v); -OVERLOADABLE short16 convert_short16_sat_rte(double16 v); -OVERLOADABLE short16 convert_short16_sat_rtz(double16 v); -OVERLOADABLE short16 convert_short16_sat_rtp(double16 v); -OVERLOADABLE short16 convert_short16_sat_rtn(double16 v); -OVERLOADABLE ushort16 convert_ushort16_sat_rte(double16 v); -OVERLOADABLE ushort16 convert_ushort16_sat_rtz(double16 v); -OVERLOADABLE ushort16 convert_ushort16_sat_rtp(double16 v); -OVERLOADABLE ushort16 convert_ushort16_sat_rtn(double16 v); -OVERLOADABLE char16 convert_char16_sat_rte(double16 v); -OVERLOADABLE char16 convert_char16_sat_rtz(double16 v); -OVERLOADABLE char16 convert_char16_sat_rtp(double16 v); -OVERLOADABLE char16 convert_char16_sat_rtn(double16 v); -OVERLOADABLE uchar16 convert_uchar16_sat_rte(double16 v); -OVERLOADABLE uchar16 convert_uchar16_sat_rtz(double16 v); -OVERLOADABLE uchar16 convert_uchar16_sat_rtp(double16 v); -OVERLOADABLE uchar16 convert_uchar16_sat_rtn(double16 v); -OVERLOADABLE long16 convert_long16_sat_rte(float16 v); -OVERLOADABLE long16 convert_long16_sat_rtz(float16 v); -OVERLOADABLE long16 convert_long16_sat_rtp(float16 v); -OVERLOADABLE long16 convert_long16_sat_rtn(float16 v); -OVERLOADABLE ulong16 convert_ulong16_sat_rte(float16 v); -OVERLOADABLE ulong16 convert_ulong16_sat_rtz(float16 v); -OVERLOADABLE ulong16 convert_ulong16_sat_rtp(float16 v); -OVERLOADABLE ulong16 convert_ulong16_sat_rtn(float16 v); -OVERLOADABLE int16 convert_int16_sat_rte(float16 v); -OVERLOADABLE int16 convert_int16_sat_rtz(float16 v); -OVERLOADABLE int16 convert_int16_sat_rtp(float16 v); -OVERLOADABLE int16 convert_int16_sat_rtn(float16 v); -OVERLOADABLE uint16 convert_uint16_sat_rte(float16 v); -OVERLOADABLE uint16 convert_uint16_sat_rtz(float16 v); -OVERLOADABLE uint16 convert_uint16_sat_rtp(float16 v); -OVERLOADABLE uint16 convert_uint16_sat_rtn(float16 v); -OVERLOADABLE short16 convert_short16_sat_rte(float16 v); -OVERLOADABLE short16 convert_short16_sat_rtz(float16 v); -OVERLOADABLE short16 convert_short16_sat_rtp(float16 v); -OVERLOADABLE short16 convert_short16_sat_rtn(float16 v); -OVERLOADABLE ushort16 convert_ushort16_sat_rte(float16 v); -OVERLOADABLE ushort16 convert_ushort16_sat_rtz(float16 v); -OVERLOADABLE ushort16 convert_ushort16_sat_rtp(float16 v); -OVERLOADABLE ushort16 convert_ushort16_sat_rtn(float16 v); -OVERLOADABLE char16 convert_char16_sat_rte(float16 v); -OVERLOADABLE char16 convert_char16_sat_rtz(float16 v); -OVERLOADABLE char16 convert_char16_sat_rtp(float16 v); -OVERLOADABLE char16 convert_char16_sat_rtn(float16 v); -OVERLOADABLE uchar16 convert_uchar16_sat_rte(float16 v); -OVERLOADABLE uchar16 convert_uchar16_sat_rtz(float16 v); -OVERLOADABLE uchar16 convert_uchar16_sat_rtp(float16 v); -OVERLOADABLE uchar16 convert_uchar16_sat_rtn(float16 v); -OVERLOADABLE long16 convert_long16_sat_rte(half16 v); -OVERLOADABLE long16 convert_long16_sat_rtz(half16 v); -OVERLOADABLE long16 convert_long16_sat_rtp(half16 v); -OVERLOADABLE long16 convert_long16_sat_rtn(half16 v); -OVERLOADABLE ulong16 convert_ulong16_sat_rte(half16 v); -OVERLOADABLE ulong16 convert_ulong16_sat_rtz(half16 v); -OVERLOADABLE ulong16 convert_ulong16_sat_rtp(half16 v); -OVERLOADABLE ulong16 convert_ulong16_sat_rtn(half16 v); -OVERLOADABLE int16 convert_int16_sat_rte(half16 v); -OVERLOADABLE int16 convert_int16_sat_rtz(half16 v); -OVERLOADABLE int16 convert_int16_sat_rtp(half16 v); -OVERLOADABLE int16 convert_int16_sat_rtn(half16 v); -OVERLOADABLE uint16 convert_uint16_sat_rte(half16 v); -OVERLOADABLE uint16 convert_uint16_sat_rtz(half16 v); -OVERLOADABLE uint16 convert_uint16_sat_rtp(half16 v); -OVERLOADABLE uint16 convert_uint16_sat_rtn(half16 v); -OVERLOADABLE short16 convert_short16_sat_rte(half16 v); -OVERLOADABLE short16 convert_short16_sat_rtz(half16 v); -OVERLOADABLE short16 convert_short16_sat_rtp(half16 v); -OVERLOADABLE short16 convert_short16_sat_rtn(half16 v); -OVERLOADABLE ushort16 convert_ushort16_sat_rte(half16 v); -OVERLOADABLE ushort16 convert_ushort16_sat_rtz(half16 v); -OVERLOADABLE ushort16 convert_ushort16_sat_rtp(half16 v); -OVERLOADABLE ushort16 convert_ushort16_sat_rtn(half16 v); -OVERLOADABLE char16 convert_char16_sat_rte(half16 v); -OVERLOADABLE char16 convert_char16_sat_rtz(half16 v); -OVERLOADABLE char16 convert_char16_sat_rtp(half16 v); -OVERLOADABLE char16 convert_char16_sat_rtn(half16 v); -OVERLOADABLE uchar16 convert_uchar16_sat_rte(half16 v); -OVERLOADABLE uchar16 convert_uchar16_sat_rtz(half16 v); -OVERLOADABLE uchar16 convert_uchar16_sat_rtp(half16 v); -OVERLOADABLE uchar16 convert_uchar16_sat_rtn(half16 v); -OVERLOADABLE double convert_double_rte(double x); -OVERLOADABLE double convert_double_rtz(double x); -OVERLOADABLE double convert_double_rtp(double x); -OVERLOADABLE double convert_double_rtn(double x); -OVERLOADABLE double convert_double_rte(float x); -OVERLOADABLE double convert_double_rtz(float x); -OVERLOADABLE double convert_double_rtp(float x); -OVERLOADABLE double convert_double_rtn(float x); -OVERLOADABLE double convert_double_rte(int x); -OVERLOADABLE double convert_double_rtz(int x); -OVERLOADABLE double convert_double_rtp(int x); -OVERLOADABLE double convert_double_rtn(int x); -OVERLOADABLE double convert_double_rte(uint x); -OVERLOADABLE double convert_double_rtz(uint x); -OVERLOADABLE double convert_double_rtp(uint x); -OVERLOADABLE double convert_double_rtn(uint x); -OVERLOADABLE double convert_double_rte(short x); -OVERLOADABLE double convert_double_rtz(short x); -OVERLOADABLE double convert_double_rtp(short x); -OVERLOADABLE double convert_double_rtn(short x); -OVERLOADABLE double convert_double_rte(ushort x); -OVERLOADABLE double convert_double_rtz(ushort x); -OVERLOADABLE double convert_double_rtp(ushort x); -OVERLOADABLE double convert_double_rtn(ushort x); -OVERLOADABLE double convert_double_rte(char x); -OVERLOADABLE double convert_double_rtz(char x); -OVERLOADABLE double convert_double_rtp(char x); -OVERLOADABLE double convert_double_rtn(char x); -OVERLOADABLE double convert_double_rte(uchar x); -OVERLOADABLE double convert_double_rtz(uchar x); -OVERLOADABLE double convert_double_rtp(uchar x); -OVERLOADABLE double convert_double_rtn(uchar x); -OVERLOADABLE double2 convert_double2_rte(double2 v); -OVERLOADABLE double2 convert_double2_rtz(double2 v); -OVERLOADABLE double2 convert_double2_rtp(double2 v); -OVERLOADABLE double2 convert_double2_rtn(double2 v); -OVERLOADABLE double2 convert_double2_rte(float2 v); -OVERLOADABLE double2 convert_double2_rtz(float2 v); -OVERLOADABLE double2 convert_double2_rtp(float2 v); -OVERLOADABLE double2 convert_double2_rtn(float2 v); -OVERLOADABLE double2 convert_double2_rte(int2 v); -OVERLOADABLE double2 convert_double2_rtz(int2 v); -OVERLOADABLE double2 convert_double2_rtp(int2 v); -OVERLOADABLE double2 convert_double2_rtn(int2 v); -OVERLOADABLE double2 convert_double2_rte(uint2 v); -OVERLOADABLE double2 convert_double2_rtz(uint2 v); -OVERLOADABLE double2 convert_double2_rtp(uint2 v); -OVERLOADABLE double2 convert_double2_rtn(uint2 v); -OVERLOADABLE double2 convert_double2_rte(short2 v); -OVERLOADABLE double2 convert_double2_rtz(short2 v); -OVERLOADABLE double2 convert_double2_rtp(short2 v); -OVERLOADABLE double2 convert_double2_rtn(short2 v); -OVERLOADABLE double2 convert_double2_rte(ushort2 v); -OVERLOADABLE double2 convert_double2_rtz(ushort2 v); -OVERLOADABLE double2 convert_double2_rtp(ushort2 v); -OVERLOADABLE double2 convert_double2_rtn(ushort2 v); -OVERLOADABLE double2 convert_double2_rte(char2 v); -OVERLOADABLE double2 convert_double2_rtz(char2 v); -OVERLOADABLE double2 convert_double2_rtp(char2 v); -OVERLOADABLE double2 convert_double2_rtn(char2 v); -OVERLOADABLE double2 convert_double2_rte(uchar2 v); -OVERLOADABLE double2 convert_double2_rtz(uchar2 v); -OVERLOADABLE double2 convert_double2_rtp(uchar2 v); -OVERLOADABLE double2 convert_double2_rtn(uchar2 v); -OVERLOADABLE double3 convert_double3_rte(double3 v); -OVERLOADABLE double3 convert_double3_rtz(double3 v); -OVERLOADABLE double3 convert_double3_rtp(double3 v); -OVERLOADABLE double3 convert_double3_rtn(double3 v); -OVERLOADABLE double3 convert_double3_rte(float3 v); -OVERLOADABLE double3 convert_double3_rtz(float3 v); -OVERLOADABLE double3 convert_double3_rtp(float3 v); -OVERLOADABLE double3 convert_double3_rtn(float3 v); -OVERLOADABLE double3 convert_double3_rte(int3 v); -OVERLOADABLE double3 convert_double3_rtz(int3 v); -OVERLOADABLE double3 convert_double3_rtp(int3 v); -OVERLOADABLE double3 convert_double3_rtn(int3 v); -OVERLOADABLE double3 convert_double3_rte(uint3 v); -OVERLOADABLE double3 convert_double3_rtz(uint3 v); -OVERLOADABLE double3 convert_double3_rtp(uint3 v); -OVERLOADABLE double3 convert_double3_rtn(uint3 v); -OVERLOADABLE double3 convert_double3_rte(short3 v); -OVERLOADABLE double3 convert_double3_rtz(short3 v); -OVERLOADABLE double3 convert_double3_rtp(short3 v); -OVERLOADABLE double3 convert_double3_rtn(short3 v); -OVERLOADABLE double3 convert_double3_rte(ushort3 v); -OVERLOADABLE double3 convert_double3_rtz(ushort3 v); -OVERLOADABLE double3 convert_double3_rtp(ushort3 v); -OVERLOADABLE double3 convert_double3_rtn(ushort3 v); -OVERLOADABLE double3 convert_double3_rte(char3 v); -OVERLOADABLE double3 convert_double3_rtz(char3 v); -OVERLOADABLE double3 convert_double3_rtp(char3 v); -OVERLOADABLE double3 convert_double3_rtn(char3 v); -OVERLOADABLE double3 convert_double3_rte(uchar3 v); -OVERLOADABLE double3 convert_double3_rtz(uchar3 v); -OVERLOADABLE double3 convert_double3_rtp(uchar3 v); -OVERLOADABLE double3 convert_double3_rtn(uchar3 v); -OVERLOADABLE double4 convert_double4_rte(double4 v); -OVERLOADABLE double4 convert_double4_rtz(double4 v); -OVERLOADABLE double4 convert_double4_rtp(double4 v); -OVERLOADABLE double4 convert_double4_rtn(double4 v); -OVERLOADABLE double4 convert_double4_rte(float4 v); -OVERLOADABLE double4 convert_double4_rtz(float4 v); -OVERLOADABLE double4 convert_double4_rtp(float4 v); -OVERLOADABLE double4 convert_double4_rtn(float4 v); -OVERLOADABLE double4 convert_double4_rte(int4 v); -OVERLOADABLE double4 convert_double4_rtz(int4 v); -OVERLOADABLE double4 convert_double4_rtp(int4 v); -OVERLOADABLE double4 convert_double4_rtn(int4 v); -OVERLOADABLE double4 convert_double4_rte(uint4 v); -OVERLOADABLE double4 convert_double4_rtz(uint4 v); -OVERLOADABLE double4 convert_double4_rtp(uint4 v); -OVERLOADABLE double4 convert_double4_rtn(uint4 v); -OVERLOADABLE double4 convert_double4_rte(short4 v); -OVERLOADABLE double4 convert_double4_rtz(short4 v); -OVERLOADABLE double4 convert_double4_rtp(short4 v); -OVERLOADABLE double4 convert_double4_rtn(short4 v); -OVERLOADABLE double4 convert_double4_rte(ushort4 v); -OVERLOADABLE double4 convert_double4_rtz(ushort4 v); -OVERLOADABLE double4 convert_double4_rtp(ushort4 v); -OVERLOADABLE double4 convert_double4_rtn(ushort4 v); -OVERLOADABLE double4 convert_double4_rte(char4 v); -OVERLOADABLE double4 convert_double4_rtz(char4 v); -OVERLOADABLE double4 convert_double4_rtp(char4 v); -OVERLOADABLE double4 convert_double4_rtn(char4 v); -OVERLOADABLE double4 convert_double4_rte(uchar4 v); -OVERLOADABLE double4 convert_double4_rtz(uchar4 v); -OVERLOADABLE double4 convert_double4_rtp(uchar4 v); -OVERLOADABLE double4 convert_double4_rtn(uchar4 v); -OVERLOADABLE double8 convert_double8_rte(double8 v); -OVERLOADABLE double8 convert_double8_rtz(double8 v); -OVERLOADABLE double8 convert_double8_rtp(double8 v); -OVERLOADABLE double8 convert_double8_rtn(double8 v); -OVERLOADABLE double8 convert_double8_rte(float8 v); -OVERLOADABLE double8 convert_double8_rtz(float8 v); -OVERLOADABLE double8 convert_double8_rtp(float8 v); -OVERLOADABLE double8 convert_double8_rtn(float8 v); -OVERLOADABLE double8 convert_double8_rte(int8 v); -OVERLOADABLE double8 convert_double8_rtz(int8 v); -OVERLOADABLE double8 convert_double8_rtp(int8 v); -OVERLOADABLE double8 convert_double8_rtn(int8 v); -OVERLOADABLE double8 convert_double8_rte(uint8 v); -OVERLOADABLE double8 convert_double8_rtz(uint8 v); -OVERLOADABLE double8 convert_double8_rtp(uint8 v); -OVERLOADABLE double8 convert_double8_rtn(uint8 v); -OVERLOADABLE double8 convert_double8_rte(short8 v); -OVERLOADABLE double8 convert_double8_rtz(short8 v); -OVERLOADABLE double8 convert_double8_rtp(short8 v); -OVERLOADABLE double8 convert_double8_rtn(short8 v); -OVERLOADABLE double8 convert_double8_rte(ushort8 v); -OVERLOADABLE double8 convert_double8_rtz(ushort8 v); -OVERLOADABLE double8 convert_double8_rtp(ushort8 v); -OVERLOADABLE double8 convert_double8_rtn(ushort8 v); -OVERLOADABLE double8 convert_double8_rte(char8 v); -OVERLOADABLE double8 convert_double8_rtz(char8 v); -OVERLOADABLE double8 convert_double8_rtp(char8 v); -OVERLOADABLE double8 convert_double8_rtn(char8 v); -OVERLOADABLE double8 convert_double8_rte(uchar8 v); -OVERLOADABLE double8 convert_double8_rtz(uchar8 v); -OVERLOADABLE double8 convert_double8_rtp(uchar8 v); -OVERLOADABLE double8 convert_double8_rtn(uchar8 v); -OVERLOADABLE double16 convert_double16_rte(double16 v); -OVERLOADABLE double16 convert_double16_rtz(double16 v); -OVERLOADABLE double16 convert_double16_rtp(double16 v); -OVERLOADABLE double16 convert_double16_rtn(double16 v); -OVERLOADABLE double16 convert_double16_rte(float16 v); -OVERLOADABLE double16 convert_double16_rtz(float16 v); -OVERLOADABLE double16 convert_double16_rtp(float16 v); -OVERLOADABLE double16 convert_double16_rtn(float16 v); -OVERLOADABLE double16 convert_double16_rte(int16 v); -OVERLOADABLE double16 convert_double16_rtz(int16 v); -OVERLOADABLE double16 convert_double16_rtp(int16 v); -OVERLOADABLE double16 convert_double16_rtn(int16 v); -OVERLOADABLE double16 convert_double16_rte(uint16 v); -OVERLOADABLE double16 convert_double16_rtz(uint16 v); -OVERLOADABLE double16 convert_double16_rtp(uint16 v); -OVERLOADABLE double16 convert_double16_rtn(uint16 v); -OVERLOADABLE double16 convert_double16_rte(short16 v); -OVERLOADABLE double16 convert_double16_rtz(short16 v); -OVERLOADABLE double16 convert_double16_rtp(short16 v); -OVERLOADABLE double16 convert_double16_rtn(short16 v); -OVERLOADABLE double16 convert_double16_rte(ushort16 v); -OVERLOADABLE double16 convert_double16_rtz(ushort16 v); -OVERLOADABLE double16 convert_double16_rtp(ushort16 v); -OVERLOADABLE double16 convert_double16_rtn(ushort16 v); -OVERLOADABLE double16 convert_double16_rte(char16 v); -OVERLOADABLE double16 convert_double16_rtz(char16 v); -OVERLOADABLE double16 convert_double16_rtp(char16 v); -OVERLOADABLE double16 convert_double16_rtn(char16 v); -OVERLOADABLE double16 convert_double16_rte(uchar16 v); -OVERLOADABLE double16 convert_double16_rtz(uchar16 v); -OVERLOADABLE double16 convert_double16_rtp(uchar16 v); -OVERLOADABLE double16 convert_double16_rtn(uchar16 v); -OVERLOADABLE double convert_double_rte(ulong x); -OVERLOADABLE double convert_double_rtz(ulong x); -OVERLOADABLE double convert_double_rtp(ulong x); -OVERLOADABLE double convert_double_rtn(ulong x); -OVERLOADABLE double convert_double_rte(long x); -OVERLOADABLE double convert_double_rtz(long x); -OVERLOADABLE double convert_double_rtp(long x); -OVERLOADABLE double convert_double_rtn(long x); -OVERLOADABLE double2 convert_double2_rte(ulong2 v); -OVERLOADABLE double2 convert_double2_rtz(ulong2 v); -OVERLOADABLE double2 convert_double2_rtp(ulong2 v); -OVERLOADABLE double2 convert_double2_rtn(ulong2 v); -OVERLOADABLE double2 convert_double2_rte(long2 v); -OVERLOADABLE double2 convert_double2_rtz(long2 v); -OVERLOADABLE double2 convert_double2_rtp(long2 v); -OVERLOADABLE double2 convert_double2_rtn(long2 v); -OVERLOADABLE double3 convert_double3_rte(ulong3 v); -OVERLOADABLE double3 convert_double3_rtz(ulong3 v); -OVERLOADABLE double3 convert_double3_rtp(ulong3 v); -OVERLOADABLE double3 convert_double3_rtn(ulong3 v); -OVERLOADABLE double3 convert_double3_rte(long3 v); -OVERLOADABLE double3 convert_double3_rtz(long3 v); -OVERLOADABLE double3 convert_double3_rtp(long3 v); -OVERLOADABLE double3 convert_double3_rtn(long3 v); -OVERLOADABLE double4 convert_double4_rte(ulong4 v); -OVERLOADABLE double4 convert_double4_rtz(ulong4 v); -OVERLOADABLE double4 convert_double4_rtp(ulong4 v); -OVERLOADABLE double4 convert_double4_rtn(ulong4 v); -OVERLOADABLE double4 convert_double4_rte(long4 v); -OVERLOADABLE double4 convert_double4_rtz(long4 v); -OVERLOADABLE double4 convert_double4_rtp(long4 v); -OVERLOADABLE double4 convert_double4_rtn(long4 v); -OVERLOADABLE double8 convert_double8_rte(ulong8 v); -OVERLOADABLE double8 convert_double8_rtz(ulong8 v); -OVERLOADABLE double8 convert_double8_rtp(ulong8 v); -OVERLOADABLE double8 convert_double8_rtn(ulong8 v); -OVERLOADABLE double8 convert_double8_rte(long8 v); -OVERLOADABLE double8 convert_double8_rtz(long8 v); -OVERLOADABLE double8 convert_double8_rtp(long8 v); -OVERLOADABLE double8 convert_double8_rtn(long8 v); -OVERLOADABLE double16 convert_double16_rte(ulong16 v); -OVERLOADABLE double16 convert_double16_rtz(ulong16 v); -OVERLOADABLE double16 convert_double16_rtp(ulong16 v); -OVERLOADABLE double16 convert_double16_rtn(ulong16 v); -OVERLOADABLE double16 convert_double16_rte(long16 v); -OVERLOADABLE double16 convert_double16_rtz(long16 v); -OVERLOADABLE double16 convert_double16_rtp(long16 v); -OVERLOADABLE double16 convert_double16_rtn(long16 v); -#endif /* __OCL_CONVERT_H__ */ diff --git a/drivers/pocl-gen7/lib/beignet/include/ocl_defines.h b/drivers/pocl-gen7/lib/beignet/include/ocl_defines.h deleted file mode 100644 index 1e030d2..0000000 --- a/drivers/pocl-gen7/lib/beignet/include/ocl_defines.h +++ /dev/null @@ -1,170 +0,0 @@ -/* - * Copyright © 2012 - 2014 Intel Corporation - * - * This library is free software; you can redistribute it and/or - * modify it under the terms of the GNU Lesser General Public - * License as published by the Free Software Foundation; either - * version 2.1 of the License, or (at your option) any later version. - * - * This library is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU - * Lesser General Public License for more details. - * - * You should have received a copy of the GNU Lesser General Public - * License along with this library. If not, see . - * - */ -#ifndef __OCL_COMMON_DEF_H__ -#define __OCL_COMMON_DEF_H__ - -#define __CL_VERSION_1_0__ 100 -#define __CL_VERSION_1_1__ 110 -#define __CL_VERSION_1_2__ 120 -#define CL_VERSION_1_0 100 -#define CL_VERSION_1_1 110 -#define CL_VERSION_1_2 120 -#if (__OPENCL_C_VERSION__ >= 200 && __OPENCL_C_VERSION__ < 300) -#define __OPENCL_VERSION__ 200 -#define CL_VERSION_2_0 200 -#elif (__OPENCL_C_VERSION__ >= 300) -/* OpenCL C 3.0 with none of the optional 2.0 features: the 1.2 library */ -#define __OPENCL_VERSION__ 300 -#define CL_VERSION_2_0 200 -#define CL_VERSION_3_0 300 -#else -#define __OPENCL_VERSION__ 120 -#endif -#define __ENDIAN_LITTLE__ 1 -#define __IMAGE_SUPPORT__ 1 -#define __kernel_exec(X, TYPE) __kernel __attribute__((work_group_size_hint(X,1,1))) \ - __attribute__((vec_type_hint(TYPE))) -#define kernel_exec(X, TYPE) __kernel_exec(X, TYPE) - -#endif /* end of __OCL_COMMON_DEF_H__ */ -// This file includes defines that are common to both kernel code and -// the NVPTX back-end. -#ifndef __OCL_COMMON_DEFINES__ -#define __OCL_COMMON_DEFINES__ -// -// Common defines for Image intrinsics -// Channel order -#define CLK_HAS_ALPHA(color) (color == CLK_A || color == CLK_RA || color == CLK_RGBA || color == CLK_BGRA || color == CLK_ARGB || color == CLK_sRGBA || color == CLK_sBGRA) -enum { - CLK_R = 0x10B0, - CLK_A = 0x10B1, - CLK_RG = 0x10B2, - CLK_RA = 0x10B3, - CLK_RGB = 0x10B4, - CLK_RGBA = 0x10B5, - CLK_BGRA = 0x10B6, - CLK_ARGB = 0x10B7, - -#if (__NV_CL_C_VERSION == __NV_CL_C_VERSION_1_0) - CLK_xRGB = 0x10B7, -#endif - - CLK_INTENSITY = 0x10B8, - CLK_LUMINANCE = 0x10B9 - -#if (__NV_CL_C_VERSION >= __NV_CL_C_VERSION_1_1) - , - CLK_Rx = 0x10BA, - CLK_RGx = 0x10BB, - CLK_RGBx = 0x10BC -#endif -#if (__NV_CL_C_VERSION >= __NV_CL_C_VERSION_2_0) - , - CLK_sRGBA = 0x10C1, - CLK_sBGRA = 0x10C2 -#endif -}; - - -typedef enum clk_channel_type { - // valid formats for float return types - CLK_SNORM_INT8 = 0x10D0, // four channel RGBA unorm8 - CLK_SNORM_INT16 = 0x10D1, // four channel RGBA unorm16 - CLK_UNORM_INT8 = 0x10D2, // four channel RGBA unorm8 - CLK_UNORM_INT16 = 0x10D3, // four channel RGBA unorm16 - CLK_HALF_FLOAT = 0x10DD, // four channel RGBA half - CLK_FLOAT = 0x10DE, // four channel RGBA float - -#if (__NV_CL_C_VERSION >= __NV_CL_C_VERSION_1_1) - CLK_UNORM_SHORT_565 = 0x10D4, - CLK_UNORM_SHORT_555 = 0x10D5, - CLK_UNORM_INT_101010 = 0x10D6, -#endif - - // valid only for integer return types - CLK_SIGNED_INT8 = 0x10D7, - CLK_SIGNED_INT16 = 0x10D8, - CLK_SIGNED_INT32 = 0x10D9, - CLK_UNSIGNED_INT8 = 0x10DA, - CLK_UNSIGNED_INT16 = 0x10DB, - CLK_UNSIGNED_INT32 = 0x10DC, - - // CI SPI for CPU - __CLK_UNORM_INT8888 , // four channel ARGB unorm8 - __CLK_UNORM_INT8888R, // four channel BGRA unorm8 - - __CLK_VALID_IMAGE_TYPE_COUNT, - __CLK_INVALID_IMAGE_TYPE = __CLK_VALID_IMAGE_TYPE_COUNT, - __CLK_VALID_IMAGE_TYPE_MASK_BITS = 4, // number of bits required to - // represent any image type - __CLK_VALID_IMAGE_TYPE_MASK = ( 1 << __CLK_VALID_IMAGE_TYPE_MASK_BITS ) - 1 -}clk_channel_type; - -typedef enum clk_sampler_type { - __CLK_NORMALIZED_BASE = 0, - CLK_NORMALIZED_COORDS_FALSE = 0, - CLK_NORMALIZED_COORDS_TRUE = (1 << __CLK_NORMALIZED_BASE), - __CLK_NORMALIZED_MASK = (CLK_NORMALIZED_COORDS_FALSE | - CLK_NORMALIZED_COORDS_TRUE), - __CLK_NORMALIZED_BITS = 1, // number of bits required to - // represent normalization - __CLK_ADDRESS_BASE = 0, - CLK_ADDRESS_NONE = (0 << __CLK_ADDRESS_BASE), - CLK_ADDRESS_CLAMP_TO_EDGE = (2 << __CLK_ADDRESS_BASE), - CLK_ADDRESS_CLAMP = (4 << __CLK_ADDRESS_BASE), - CLK_ADDRESS_REPEAT = (6 << __CLK_ADDRESS_BASE), - CLK_ADDRESS_MIRROR = (8 << __CLK_ADDRESS_BASE), - -#if (__NV_CL_C_VERSION >= __NV_CL_C_VERSION_1_1) - CLK_ADDRESS_MIRRORED_REPEAT = CLK_ADDRESS_MIRROR, -#endif - __CLK_ADDRESS_MASK = (CLK_ADDRESS_NONE | CLK_ADDRESS_CLAMP | - CLK_ADDRESS_CLAMP_TO_EDGE | - CLK_ADDRESS_REPEAT | CLK_ADDRESS_MIRROR), - __CLK_ADDRESS_BITS = 4, // number of bits required to - // represent address info - __CLK_FILTER_BASE = (__CLK_ADDRESS_BASE + __CLK_ADDRESS_BITS), - CLK_FILTER_ANISOTROPIC = (0 << __CLK_FILTER_BASE), - CLK_FILTER_NEAREST = (1 << __CLK_FILTER_BASE), - CLK_FILTER_LINEAR = (2 << __CLK_FILTER_BASE), - __CLK_FILTER_MASK = (CLK_FILTER_NEAREST | CLK_FILTER_LINEAR | - CLK_FILTER_ANISOTROPIC), - __CLK_FILTER_BITS = 2, // number of bits required to - // represent address info - - __CLK_MIP_BASE = (__CLK_FILTER_BASE + __CLK_FILTER_BITS), - CLK_MIP_NEAREST = (0 << __CLK_MIP_BASE), - CLK_MIP_LINEAR = (1 << __CLK_MIP_BASE), - CLK_MIP_ANISOTROPIC = (2 << __CLK_MIP_BASE), - __CLK_MIP_MASK = (CLK_MIP_NEAREST | CLK_MIP_LINEAR | - CLK_MIP_ANISOTROPIC), - __CLK_MIP_BITS = 2, - - __CLK_SAMPLER_BITS = (__CLK_MIP_BASE + __CLK_MIP_BITS), - __CLK_SAMPLER_MASK = (__CLK_MIP_MASK | __CLK_FILTER_MASK | - __CLK_NORMALIZED_MASK | __CLK_ADDRESS_MASK), - - __CLK_SAMPLER_ARG_BASE = (__CLK_MIP_BASE + __CLK_SAMPLER_BITS), - __CLK_SAMPLER_ARG_BITS = 8, - __CLK_SAMPLER_ARG_MASK = (((1 << __CLK_SAMPLER_ARG_BITS) - 1) << __CLK_SAMPLER_ARG_BASE), - __CLK_SAMPLER_ARG_KEY_BIT = (1 << (__CLK_SAMPLER_ARG_BASE + __CLK_SAMPLER_ARG_BITS)), - __CLK_SAMPLER_ARG_KEY_BITS = 1, - -} clk_sampler_type; - -#endif /* __OCL_COMMON_DEFINES__ */ diff --git a/drivers/pocl-gen7/lib/beignet/include/ocl_enqueue.h b/drivers/pocl-gen7/lib/beignet/include/ocl_enqueue.h deleted file mode 100644 index 8e9fd32..0000000 --- a/drivers/pocl-gen7/lib/beignet/include/ocl_enqueue.h +++ /dev/null @@ -1,101 +0,0 @@ -/* - * Copyright © 2012 - 2014 Intel Corporation - * - * This library is free software; you can redistribute it and/or - * modify it under the terms of the GNU Lesser General Public - * License as published by the Free Software Foundation; either - * version 2.1 of the License, or (at your option) any later version. - * - * This library is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU - * Lesser General Public License for more details. - * - * You should have received a copy of the GNU Lesser General Public - * License along with this library. If not, see . - * - */ - -#ifndef __OCL_ENQUEUE_H__ -#define __OCL_ENQUEUE_H__ - -#include "ocl_types.h" -#define CLK_ENQUEUE_FLAGS_WAIT_KERNEL 0 -#define CLK_ENQUEUE_FLAGS_NO_WAIT 1 -#define CLK_ENQUEUE_FLAGS_WAIT_WORK_GROUP 2 -#define CLK_SUCCESS 0 -#define CL_COMPLETE 0 -#define CLK_PROFILING_COMMAND_EXEC_TIME 0 - -struct ndrange_info_t { - int type; - int global_work_size[3]; - int local_work_size[3]; - int global_work_offset[3]; -}; - -struct Block_literal { - void *isa; // initialized to &_NSConcreteStackBlock or &_NSConcreteGlobalBlock - int flags; - int reserved; - __global void* invoke; - struct Block_descriptor_1 { - unsigned long int reserved; // NULL - unsigned long int size; // sizeof(struct Block_literal_1) - // optional helper functions - void *copy_helper; // IFF (1<<25) - void *dispose_helper; // IFF (1<<25) - // required ABI.2010.3.16 - const char *signature; // IFF (1<<30) - } *descriptor; - // imported variables -}; - -#if __clang_major__*10 + __clang_minor__ >= 50 -typedef struct ndrange_info_t ndrange_t; -#endif - -#if __clang_major__*10 + __clang_minor__ >= 50 -#define BLOCK_TYPE void* -#else -#define BLOCK_TYPE __private void* -#endif - -#if __clang_major__*10 + __clang_minor__ >= 40 -#define EVENT_TYPE clk_event_t* -#else -#define EVENT_TYPE __private clk_event_t* -#endif - -clk_event_t create_user_event(void); -void retain_event(clk_event_t event); -void release_event(clk_event_t event); -void set_user_event_status(clk_event_t event, int status); -bool is_valid_event(clk_event_t event); -void capture_event_profiling_info(clk_event_t event, int name, global void *value); - -uint __get_kernel_work_group_size_impl(BLOCK_TYPE block); -uint __get_kernel_preferred_work_group_multiple_impl(BLOCK_TYPE block); - -int __enqueue_kernel_basic(queue_t q, int flag, ndrange_t ndrange, BLOCK_TYPE block); -int __enqueue_kernel_basic_events(queue_t q, int flag, ndrange_t ndrange, - uint num_events_in_wait_list, const EVENT_TYPE event_wait_list, - EVENT_TYPE event_ret, BLOCK_TYPE block); - -queue_t get_default_queue(void); -int __gen_enqueue_kernel_slm(queue_t q, int flag, ndrange_t ndrange, BLOCK_TYPE block, int count, __private int* slm_sizes); - -OVERLOADABLE ndrange_t ndrange_1D(size_t global_work_size); -OVERLOADABLE ndrange_t ndrange_1D(size_t global_work_size, size_t local_work_size); -OVERLOADABLE ndrange_t ndrange_1D(size_t global_work_offset, size_t global_work_size, size_t local_work_size); - -OVERLOADABLE ndrange_t ndrange_2D(const size_t global_work_size[2]); -OVERLOADABLE ndrange_t ndrange_2D(const size_t global_work_size[2], const size_t local_work_size[2]); -OVERLOADABLE ndrange_t ndrange_2D(const size_t global_work_offset[2], const size_t global_work_size[2], const size_t local_work_size[2]); - -OVERLOADABLE ndrange_t ndrange_3D(const size_t global_work_size[3]); -OVERLOADABLE ndrange_t ndrange_3D(const size_t global_work_size[3], const size_t local_work_size[3]); -OVERLOADABLE ndrange_t ndrange_3D(const size_t global_work_offset[3], const size_t global_work_size[3], const size_t local_work_size[3]); - -int enqueue_marker (queue_t queue, uint num_events_in_wait_list, const clk_event_t *event_wait_list, clk_event_t *event_ret); -#endif diff --git a/drivers/pocl-gen7/lib/beignet/include/ocl_float.h b/drivers/pocl-gen7/lib/beignet/include/ocl_float.h deleted file mode 100644 index 77b78bb..0000000 --- a/drivers/pocl-gen7/lib/beignet/include/ocl_float.h +++ /dev/null @@ -1,117 +0,0 @@ -/* - * Copyright © 2012 - 2014 Intel Corporation - * - * This library is free software; you can redistribute it and/or - * modify it under the terms of the GNU Lesser General Public - * License as published by the Free Software Foundation; either - * version 2.1 of the License, or (at your option) any later version. - * - * This library is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU - * Lesser General Public License for more details. - * - * You should have received a copy of the GNU Lesser General Public - * License along with this library. If not, see . - * - */ -#ifndef __OCL_FLOAT_H__ -#define __OCL_FLOAT_H__ - -///////////////////////////////////////////////////////////////////////////// -// OpenCL floating-point macros and pragmas -///////////////////////////////////////////////////////////////////////////// -#define FLT_DIG 6 -#define FLT_MANT_DIG 24 -#define FLT_MAX_10_EXP +38 -#define FLT_MAX_EXP +128 -#define FLT_MIN_10_EXP -37 -#define FLT_MIN_EXP -125 -#define FLT_RADIX 2 -#define FLT_ONE 1.0000000000e+00 /* 0x3F800000 */ -#define FLT_MAX 0x1.fffffep127f -#define FLT_MIN 0x1.0p-126f -#define FLT_EPSILON 0x1.0p-23f - -#define MAXFLOAT 3.40282347e38F -INLINE_OVERLOADABLE float __ocl_inff(void) { - union { uint u; float f; } u; - u.u = 0x7F800000; - return u.f; -} -INLINE_OVERLOADABLE float __ocl_nanf(void) { - union { uint u; float f; } u; - u.u = 0x7F800001; - return u.f; -} -typedef union -{ - float value; - uint word; -} float_shape_type; - -/* Get a 32 bit int from a float. */ -#ifndef GEN_OCL_GET_FLOAT_WORD -# define GEN_OCL_GET_FLOAT_WORD(i,d) \ -do { \ - float_shape_type gf_u; \ - gf_u.value = (d); \ - (i) = gf_u.word; \ -} while (0) -#endif -/* Set a float from a 32 bit int. */ -#ifndef GEN_OCL_SET_FLOAT_WORD -# define GEN_OCL_SET_FLOAT_WORD(d,i) \ -do { \ - float_shape_type sf_u; \ - sf_u.word = (i); \ - (d) = sf_u.value; \ -} while (0) -#endif - -INLINE_OVERLOADABLE int __ocl_finitef (float x){ - unsigned ix; - GEN_OCL_GET_FLOAT_WORD (ix, x); - return (ix & 0x7fffffff) < 0x7f800000; -} - -#define HUGE_VALF (__ocl_inff()) -#define INFINITY (__ocl_inff()) -#define NAN (__ocl_nanf()) -#define M_E_F 2.718281828459045F -#define M_LOG2E_F 1.4426950408889634F -#define M_LOG10E_F 0.43429448190325176F -#define M_LOG210_F 3.3219280948873626F -#define M_LN2_F 0.6931471805599453F -#define M_LN10_F 2.302585092994046F -#define M_PI_F 3.141592653589793F -#define M_PI_2_F 1.5707963267948966F -#define M_PI_4_F 0.7853981633974483F -#define M_1_PI_F 0.3183098861837907F -#define M_2_PI_F 0.6366197723675814F -#define M_180_PI_F 57.295779513082321F -#define M_2_SQRTPI_F 1.1283791670955126F -#define M_SQRT2_F 1.4142135623730951F -#define M_SQRT1_2_F 0.7071067811865476F -#define FP_ILOGB0 (-0x7FFFFFFF-1) -#define FP_ILOGBNAN FP_ILOGB0 - -#define DF_EXP_MASK 0x7FF0000000000000UL -#define DF_MAX_NORMAL 0x7FF0000000000000UL -#define DF_MAN_MASK 0xFFFFFFFFFFFFFUL -#define DF_MIN_NORMAL 0x10000000000000UL -#define DF_ABS_MASK 0x7FFFFFFFFFFFFFFFUL -#define DF_POSITIVE_INF 0x7FF0000000000000UL -#define DF_SIGN_MASK 0x8000000000000000UL -#define DF_IMPLICITE_ONE 0x10000000000000UL -#define DF_EXP_OFFSET 52 -#define DF_SIGN_OFFSET 63 -#define DF_EXP_BIAS 1023 -#define DF_NEGTIVE_INF 0xFFF0000000000000 - -#define SF_POSITIVE_INF 0x7F800000 -#define SF_NAN 0x7FFFFFFF - -#define M_PI 3.141592653589793238462643383279 - -#endif /* __OCL_FLOAT_H__ */ diff --git a/drivers/pocl-gen7/lib/beignet/include/ocl_geometric.h b/drivers/pocl-gen7/lib/beignet/include/ocl_geometric.h deleted file mode 100644 index 6a312f8..0000000 --- a/drivers/pocl-gen7/lib/beignet/include/ocl_geometric.h +++ /dev/null @@ -1,80 +0,0 @@ -/* - * Copyright © 2012 - 2014 Intel Corporation - * - * This library is free software; you can redistribute it and/or - * modify it under the terms of the GNU Lesser General Public - * License as published by the Free Software Foundation; either - * version 2.1 of the License, or (at your option) any later version. - * - * This library is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU - * Lesser General Public License for more details. - * - * You should have received a copy of the GNU Lesser General Public - * License along with this library. If not, see . - * - */ -#ifndef __OCL_GEOMETRIC_H__ -#define __OCL_GEOMETRIC_H__ - -#include "ocl_types.h" - -OVERLOADABLE float dot(float p0, float p1); -OVERLOADABLE float dot(float2 p0, float2 p1); -OVERLOADABLE float dot(float3 p0, float3 p1); -OVERLOADABLE float dot(float4 p0, float4 p1); -OVERLOADABLE half dot(half p0, half p1); -OVERLOADABLE half dot(half2 p0, half2 p1); -OVERLOADABLE half dot(half3 p0, half3 p1); -OVERLOADABLE half dot(half4 p0, half4 p1); -OVERLOADABLE float length(float x); -OVERLOADABLE float length(float2 x); -OVERLOADABLE float length(float3 x); -OVERLOADABLE float length(float4 x); -OVERLOADABLE float distance(float x, float y); -OVERLOADABLE float distance(float2 x, float2 y); -OVERLOADABLE float distance(float3 x, float3 y); -OVERLOADABLE float distance(float4 x, float4 y); -OVERLOADABLE float normalize(float x); -OVERLOADABLE float2 normalize(float2 x); -OVERLOADABLE float3 normalize(float3 x); -OVERLOADABLE float4 normalize(float4 x); - -OVERLOADABLE float fast_length(float x); -OVERLOADABLE float fast_length(float2 x); -OVERLOADABLE float fast_length(float3 x); -OVERLOADABLE float fast_length(float4 x); -OVERLOADABLE float fast_distance(float x, float y); -OVERLOADABLE float fast_distance(float2 x, float2 y); -OVERLOADABLE float fast_distance(float3 x, float3 y); -OVERLOADABLE float fast_distance(float4 x, float4 y); -OVERLOADABLE float fast_normalize(float x); -OVERLOADABLE float2 fast_normalize(float2 x); -OVERLOADABLE float3 fast_normalize(float3 x); -OVERLOADABLE float4 fast_normalize(float4 x); - -OVERLOADABLE float3 cross(float3 v0, float3 v1); -OVERLOADABLE float4 cross(float4 v0, float4 v1); - -OVERLOADABLE double dot(double p0, double p1); -OVERLOADABLE double dot(double2 p0, double2 p1); -OVERLOADABLE double dot(double3 p0, double3 p1); -OVERLOADABLE double dot(double4 p0, double4 p1); -OVERLOADABLE double length(double x); -OVERLOADABLE double length(double2 x); -OVERLOADABLE double length(double3 x); -OVERLOADABLE double length(double4 x); -OVERLOADABLE double distance(double x, double y); -OVERLOADABLE double distance(double2 x, double2 y); -OVERLOADABLE double distance(double3 x, double3 y); -OVERLOADABLE double distance(double4 x, double4 y); -OVERLOADABLE double normalize(double x); -OVERLOADABLE double2 normalize(double2 x); -OVERLOADABLE double3 normalize(double3 x); -OVERLOADABLE double4 normalize(double4 x); -OVERLOADABLE double3 cross(double3 v0, double3 v1); -OVERLOADABLE double4 cross(double4 v0, double4 v1); - - -#endif diff --git a/drivers/pocl-gen7/lib/beignet/include/ocl_image.h b/drivers/pocl-gen7/lib/beignet/include/ocl_image.h deleted file mode 100644 index 23c0690..0000000 --- a/drivers/pocl-gen7/lib/beignet/include/ocl_image.h +++ /dev/null @@ -1,200 +0,0 @@ -/* - * Copyright © 2012 - 2014 Intel Corporation - * - * This library is free software; you can redistribute it and/or - * modify it under the terms of the GNU Lesser General Public - * License as published by the Free Software Foundation; either - * version 2.1 of the License, or (at your option) any later version. - * - * This library is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU - * Lesser General Public License for more details. - * - * You should have received a copy of the GNU Lesser General Public - * License along with this library. If not, see . - * - */ -#ifndef __OCL_IMAGE_H__ -#define __OCL_IMAGE_H__ - -#include "ocl_types.h" - -#define int1 int -#define float1 float - -#pragma OPENCL EXTENSION cl_khr_3d_image_writes : enable - -#define DECL_IMAGE_READ_SAMPLE_RETTYPE(IMG_TYPE, DATA_YPE, SUFFIX, N) \ - OVERLOADABLE DATA_YPE read_image ## SUFFIX(IMG_TYPE cl_image, const sampler_t sampler, int##N coord); \ - OVERLOADABLE DATA_YPE read_image ## SUFFIX(IMG_TYPE cl_image, const sampler_t sampler, float##N coord); - -#define DECL_IMAGE_READ_NO_SAMPLE_RETTYPE(IMG_TYPE, DATA_YPE, SUFFIX, N) \ - OVERLOADABLE DATA_YPE read_image ## SUFFIX(IMG_TYPE cl_image, int##N coord); - -#define DECL_IMAGE_WRITE_RETTYPE(IMG_TYPE, DATA_YPE, SUFFIX, N) \ - OVERLOADABLE void write_image ## SUFFIX(IMG_TYPE cl_image, int##N coord, DATA_YPE color); - -#define DECL_IMAGE_TYPE_READ_NO_SAMPLE(IMG_TYPE, N)\ - DECL_IMAGE_READ_NO_SAMPLE_RETTYPE(IMG_TYPE, int4, i, N) \ - DECL_IMAGE_READ_NO_SAMPLE_RETTYPE(IMG_TYPE, uint4, ui, N) \ - DECL_IMAGE_READ_NO_SAMPLE_RETTYPE(IMG_TYPE, float4, f, N) - -#define DECL_IMAGE_TYPE_READ_SAMPLE(IMG_TYPE, N)\ - DECL_IMAGE_READ_SAMPLE_RETTYPE(IMG_TYPE, int4, i, N) \ - DECL_IMAGE_READ_SAMPLE_RETTYPE(IMG_TYPE, uint4, ui, N) \ - DECL_IMAGE_READ_SAMPLE_RETTYPE(IMG_TYPE, float4, f, N) - -#define DECL_IMAGE_TYPE_WRITE(IMG_TYPE, N)\ - DECL_IMAGE_WRITE_RETTYPE(IMG_TYPE, int4, i, N) \ - DECL_IMAGE_WRITE_RETTYPE(IMG_TYPE, uint4, ui, N) \ - DECL_IMAGE_WRITE_RETTYPE(IMG_TYPE, float4, f, N) - -#if (__OPENCL_C_VERSION__ >= 200 && __OPENCL_C_VERSION__ < 300) -#define DECL_IMAGE(IMG_TYPE, N) \ - DECL_IMAGE_TYPE_READ_NO_SAMPLE(read_only IMG_TYPE, N) \ - DECL_IMAGE_TYPE_READ_NO_SAMPLE(read_write IMG_TYPE, N) \ - DECL_IMAGE_TYPE_READ_SAMPLE(read_only IMG_TYPE, N) \ - DECL_IMAGE_TYPE_WRITE(write_only IMG_TYPE, N) \ - DECL_IMAGE_TYPE_WRITE(read_write IMG_TYPE, N) -#else -#define DECL_IMAGE(IMG_TYPE, N) \ - DECL_IMAGE_TYPE_READ_NO_SAMPLE(read_only IMG_TYPE, N) \ - DECL_IMAGE_TYPE_READ_SAMPLE(read_only IMG_TYPE, N) \ - DECL_IMAGE_TYPE_WRITE(write_only IMG_TYPE, N) -#endif - -DECL_IMAGE(image1d_t, 1) -DECL_IMAGE(image2d_t, 2) -DECL_IMAGE(image1d_array_t, 2) -DECL_IMAGE(image3d_t, 3) -DECL_IMAGE(image3d_t, 4) -DECL_IMAGE(image2d_array_t, 3) -DECL_IMAGE(image2d_array_t, 4) - -#undef DECL_IMAGE - -#if (__OPENCL_C_VERSION__ >= 200 && __OPENCL_C_VERSION__ < 300) -#define DECL_IMAGE(IMG_TYPE, N) \ - DECL_IMAGE_TYPE_READ_NO_SAMPLE(read_only IMG_TYPE, N) \ - DECL_IMAGE_TYPE_READ_NO_SAMPLE(read_write IMG_TYPE, N) \ - DECL_IMAGE_TYPE_WRITE(write_only IMG_TYPE, N) \ - DECL_IMAGE_TYPE_WRITE(read_write IMG_TYPE, N) -#else -#define DECL_IMAGE(IMG_TYPE, N) \ - DECL_IMAGE_TYPE_READ_NO_SAMPLE(read_only IMG_TYPE, N) \ - DECL_IMAGE_TYPE_WRITE(write_only IMG_TYPE, N) -#endif - -DECL_IMAGE(image1d_buffer_t, 1) - -#undef int1 -#undef float1 -#undef DECL_IMAGE_TYPE_READ_NO_SAMPLE -#undef DECL_IMAGE_TYPE_WRITE -#undef DECL_IMAGE - -OVERLOADABLE int get_image_channel_data_type(read_only image1d_t image); -OVERLOADABLE int get_image_channel_order(read_only image1d_t image); -OVERLOADABLE int get_image_width(read_only image1d_t image); - -OVERLOADABLE int get_image_channel_data_type(read_only image1d_buffer_t image); -OVERLOADABLE int get_image_channel_order(read_only image1d_buffer_t image); -OVERLOADABLE int get_image_width(read_only image1d_buffer_t image); - -OVERLOADABLE int get_image_channel_data_type(read_only image2d_t image); -OVERLOADABLE int get_image_channel_order(read_only image2d_t image); -OVERLOADABLE int get_image_width(read_only image2d_t image); -OVERLOADABLE int get_image_height(read_only image2d_t image); -OVERLOADABLE int2 get_image_dim(read_only image2d_t image); - -OVERLOADABLE int get_image_channel_data_type(read_only image1d_array_t image); -OVERLOADABLE int get_image_channel_order(read_only image1d_array_t image); -OVERLOADABLE int get_image_width(read_only image1d_array_t image); -OVERLOADABLE size_t get_image_array_size(read_only image1d_array_t image); - -OVERLOADABLE int get_image_channel_data_type(read_only image3d_t image); -OVERLOADABLE int get_image_channel_order(read_only image3d_t image); -OVERLOADABLE int get_image_width(read_only image3d_t image); -OVERLOADABLE int get_image_height(read_only image3d_t image); -OVERLOADABLE int get_image_depth(read_only image3d_t image); -OVERLOADABLE int4 get_image_dim(read_only image3d_t image); - -OVERLOADABLE int get_image_channel_data_type(read_only image2d_array_t image); -OVERLOADABLE int get_image_channel_order(read_only image2d_array_t image); -OVERLOADABLE int get_image_width(read_only image2d_array_t image); -OVERLOADABLE int get_image_height(read_only image2d_array_t image); -OVERLOADABLE int2 get_image_dim(read_only image2d_array_t image); -OVERLOADABLE size_t get_image_array_size(read_only image2d_array_t image); - -#if __clang_major__*10 + __clang_minor__ >= 39 -OVERLOADABLE int get_image_channel_data_type(write_only image1d_t image); -OVERLOADABLE int get_image_channel_order(write_only image1d_t image); -OVERLOADABLE int get_image_width(write_only image1d_t image); - -OVERLOADABLE int get_image_channel_data_type(write_only image1d_buffer_t image); -OVERLOADABLE int get_image_channel_order(write_only image1d_buffer_t image); -OVERLOADABLE int get_image_width(write_only image1d_buffer_t image); - -OVERLOADABLE int get_image_channel_data_type(write_only image2d_t image); -OVERLOADABLE int get_image_channel_order(write_only image2d_t image); -OVERLOADABLE int get_image_width(write_only image2d_t image); -OVERLOADABLE int get_image_height(write_only image2d_t image); -OVERLOADABLE int2 get_image_dim(write_only image2d_t image); - -OVERLOADABLE int get_image_channel_data_type(write_only image1d_array_t image); -OVERLOADABLE int get_image_channel_order(write_only image1d_array_t image); -OVERLOADABLE int get_image_width(write_only image1d_array_t image); -OVERLOADABLE size_t get_image_array_size(write_only image1d_array_t image); - -OVERLOADABLE int get_image_channel_data_type(write_only image3d_t image); -OVERLOADABLE int get_image_channel_order(write_only image3d_t image); -OVERLOADABLE int get_image_width(write_only image3d_t image); -OVERLOADABLE int get_image_height(write_only image3d_t image); -OVERLOADABLE int get_image_depth(write_only image3d_t image); -OVERLOADABLE int4 get_image_dim(write_only image3d_t image); - -OVERLOADABLE int get_image_channel_data_type(write_only image2d_array_t image); -OVERLOADABLE int get_image_channel_order(write_only image2d_array_t image); -OVERLOADABLE int get_image_width(write_only image2d_array_t image); -OVERLOADABLE int get_image_height(write_only image2d_array_t image); -OVERLOADABLE int2 get_image_dim(write_only image2d_array_t image); -OVERLOADABLE size_t get_image_array_size(write_only image2d_array_t image); -#endif - -#if (__OPENCL_C_VERSION__ >= 200 && __OPENCL_C_VERSION__ < 300) -OVERLOADABLE int get_image_channel_data_type(read_write image1d_t image); -OVERLOADABLE int get_image_channel_order(read_write image1d_t image); -OVERLOADABLE int get_image_width(read_write image1d_t image); - -OVERLOADABLE int get_image_channel_data_type(read_write image1d_buffer_t image); -OVERLOADABLE int get_image_channel_order(read_write image1d_buffer_t image); -OVERLOADABLE int get_image_width(read_write image1d_buffer_t image); - -OVERLOADABLE int get_image_channel_data_type(read_write image2d_t image); -OVERLOADABLE int get_image_channel_order(read_write image2d_t image); -OVERLOADABLE int get_image_width(read_write image2d_t image); -OVERLOADABLE int get_image_height(read_write image2d_t image); -OVERLOADABLE int2 get_image_dim(read_write image2d_t image); - -OVERLOADABLE int get_image_channel_data_type(read_write image1d_array_t image); -OVERLOADABLE int get_image_channel_order(read_write image1d_array_t image); -OVERLOADABLE int get_image_width(read_write image1d_array_t image); -OVERLOADABLE size_t get_image_array_size(read_write image1d_array_t image); - -OVERLOADABLE int get_image_channel_data_type(read_write image3d_t image); -OVERLOADABLE int get_image_channel_order(read_write image3d_t image); -OVERLOADABLE int get_image_width(read_write image3d_t image); -OVERLOADABLE int get_image_height(read_write image3d_t image); -OVERLOADABLE int get_image_depth(read_write image3d_t image); -OVERLOADABLE int4 get_image_dim(read_write image3d_t image); - -OVERLOADABLE int get_image_channel_data_type(read_write image2d_array_t image); -OVERLOADABLE int get_image_channel_order(read_write image2d_array_t image); -OVERLOADABLE int get_image_width(read_write image2d_array_t image); -OVERLOADABLE int get_image_height(read_write image2d_array_t image); -OVERLOADABLE int2 get_image_dim(read_write image2d_array_t image); -OVERLOADABLE size_t get_image_array_size(read_write image2d_array_t image); -#endif - -#endif diff --git a/drivers/pocl-gen7/lib/beignet/include/ocl_integer.h b/drivers/pocl-gen7/lib/beignet/include/ocl_integer.h deleted file mode 100644 index 60dec4b..0000000 --- a/drivers/pocl-gen7/lib/beignet/include/ocl_integer.h +++ /dev/null @@ -1,1108 +0,0 @@ -/* - * Copyright © 2012 - 2014 Intel Corporation - * - * This library is free software; you can redistribute it and/or - * modify it under the terms of the GNU Lesser General Public - * License as published by the Free Software Foundation; either - * version 2.1 of the License, or (at your option) any later version. - * - * This library is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU - * Lesser General Public License for more details. - * - * You should have received a copy of the GNU Lesser General Public - * License along with this library. If not, see . - * - */ -#ifndef __OCL_INTEGER_H__ -#define __OCL_INTEGER_H__ - -#include "ocl_types.h" - -#define CHAR_BIT 8 -#define CHAR_MAX SCHAR_MAX -#define CHAR_MIN SCHAR_MIN -#define INT_MAX 2147483647 -#define INT_MIN (-2147483647 - 1) -#define LONG_MAX 0x7fffffffffffffffL -#define LONG_MIN (-0x7fffffffffffffffL - 1) -#define SCHAR_MAX 127 -#define SCHAR_MIN (-127 - 1) -#define SHRT_MAX 32767 -#define SHRT_MIN (-32767 - 1) -#define UCHAR_MAX 255 -#define USHRT_MAX 65535 -#define UINT_MAX 0xffffffff -#define ULONG_MAX 0xffffffffffffffffUL - -OVERLOADABLE char clz(char x); -OVERLOADABLE uchar clz(uchar x); -OVERLOADABLE short clz(short x); -OVERLOADABLE ushort clz(ushort x); -OVERLOADABLE int clz(int x); -OVERLOADABLE uint clz(uint x); -OVERLOADABLE long clz(long x); -OVERLOADABLE ulong clz(ulong x); - -char clz_s8(char); -uchar clz_u8(uchar); -short clz_s16(short); -ushort clz_u16(ushort); -int clz_s32(int); -uint clz_u32(uint); -long clz_s64(long); -ulong clz_u64(ulong); - -OVERLOADABLE char ctz(char x); -OVERLOADABLE uchar ctz(uchar x); -OVERLOADABLE short ctz(short x); -OVERLOADABLE ushort ctz(ushort x); -OVERLOADABLE int ctz(int x); -OVERLOADABLE uint ctz(uint x); -OVERLOADABLE long ctz(long x); -OVERLOADABLE ulong ctz(ulong x); - -char ctz_s8(char); -uchar ctz_u8(uchar); -short ctz_s16(short); -ushort ctz_u16(ushort); -int ctz_s32(int); -uint ctz_u32(uint); -long ctz_s64(long); -ulong ctz_u64(ulong); - -OVERLOADABLE char popcount(char x); -OVERLOADABLE uchar popcount(uchar x); -OVERLOADABLE short popcount(short x); -OVERLOADABLE ushort popcount(ushort x); -OVERLOADABLE int popcount(int x); -OVERLOADABLE uint popcount(uint x); -OVERLOADABLE long popcount(long x); -OVERLOADABLE ulong popcount(ulong x); - -OVERLOADABLE char mul_hi(char x, char y); -OVERLOADABLE uchar mul_hi(uchar x, uchar y); -OVERLOADABLE short mul_hi(short x, short y); -OVERLOADABLE ushort mul_hi(ushort x, ushort y); -OVERLOADABLE int mul_hi(int x, int y); -OVERLOADABLE uint mul_hi(uint x, uint y); -OVERLOADABLE long mul_hi(long x, long y); -OVERLOADABLE ulong mul_hi(ulong x, ulong y); - -#define SDEF(TYPE) \ -OVERLOADABLE TYPE add_sat(TYPE x, TYPE y); \ -OVERLOADABLE TYPE sub_sat(TYPE x, TYPE y); -SDEF(char); -SDEF(short); -SDEF(int); -SDEF(long); -#undef SDEF -#define UDEF(TYPE) \ -OVERLOADABLE TYPE add_sat(TYPE x, TYPE y); \ -OVERLOADABLE TYPE sub_sat(TYPE x, TYPE y); -UDEF(uchar); -UDEF(ushort); -UDEF(uint); -UDEF(ulong); -#undef UDEF - -#define DEF(type) OVERLOADABLE type mad_hi(type a, type b, type c); -DEF(char) -DEF(uchar) -DEF(short) -DEF(ushort) -DEF(int) -DEF(uint) -DEF(long) -DEF(ulong) -#undef DEF - -OVERLOADABLE int mul24(int a, int b); -OVERLOADABLE uint mul24(uint a, uint b); - -OVERLOADABLE int mad24(int a, int b, int c); -OVERLOADABLE uint mad24(uint a, uint b, uint c); - -OVERLOADABLE char mad_sat(char a, char b, char c) ; -OVERLOADABLE uchar mad_sat(uchar a, uchar b, uchar c); -OVERLOADABLE short mad_sat(short a, short b, short c); -OVERLOADABLE ushort mad_sat(ushort a, ushort b, ushort c); -OVERLOADABLE int mad_sat(int a, int b, int c); -OVERLOADABLE uint mad_sat(uint a, uint b, uint c); -OVERLOADABLE long mad_sat(long a, long b, long c); -OVERLOADABLE ulong mad_sat(ulong a, ulong b, ulong c); - -#define DEF(type, m) OVERLOADABLE type rotate(type x, type y); -DEF(char, 7) -DEF(uchar, 7) -DEF(short, 15) -DEF(ushort, 15) -DEF(int, 31) -DEF(uint, 31) -DEF(long, 63) -DEF(ulong, 63) -#undef DEF - -OVERLOADABLE short upsample(char hi, uchar lo); -OVERLOADABLE ushort upsample(uchar hi, uchar lo); -OVERLOADABLE int upsample(short hi, ushort lo); -OVERLOADABLE uint upsample(ushort hi, ushort lo); -OVERLOADABLE long upsample(int hi, uint lo); -OVERLOADABLE ulong upsample(uint hi, uint lo); - -#define DEC DEF(char); DEF(uchar); DEF(short); DEF(ushort) -#define DEF(type) OVERLOADABLE type hadd(type x, type y); -DEC -#undef DEF -#define DEF(type) OVERLOADABLE type rhadd(type x, type y); -DEC -#undef DEF -#undef DEC -OVERLOADABLE int hadd(int x, int y); -OVERLOADABLE uint hadd(uint x, uint y); -OVERLOADABLE int rhadd(int x, int y); -OVERLOADABLE uint rhadd(uint x, uint y); -OVERLOADABLE long hadd(long x, long y); -OVERLOADABLE ulong hadd(ulong x, ulong y); -OVERLOADABLE long rhadd(long x, long y); -OVERLOADABLE ulong rhadd(ulong x, ulong y); - -#define DEC(TYPE) OVERLOADABLE u##TYPE abs(TYPE x); -DEC(int) -DEC(short) -DEC(char) -#undef DEC -OVERLOADABLE ulong abs(long x); -/* For unsigned types, do nothing. */ -#define DEC(TYPE) OVERLOADABLE TYPE abs(TYPE x); -DEC(uint) -DEC(ushort) -DEC(uchar) -DEC(ulong) -#undef DEC - -/* Char and short type abs diff */ -/* promote char and short to int and will be no module overflow */ -#define DEC(TYPE, UTYPE) OVERLOADABLE UTYPE abs_diff(TYPE x, TYPE y); -DEC(char, uchar) -DEC(uchar, uchar) -DEC(short, ushort) -DEC(ushort, ushort) -#undef DEC - -OVERLOADABLE uint abs_diff (uint x, uint y); -OVERLOADABLE uint abs_diff (int x, int y); -OVERLOADABLE ulong abs_diff (long x, long y); -OVERLOADABLE ulong abs_diff (ulong x, ulong y); - - -#define DECL_MIN_MAX_CLAMP(TYPE) \ -OVERLOADABLE TYPE max(TYPE a, TYPE b); \ -OVERLOADABLE TYPE min(TYPE a, TYPE b); \ -OVERLOADABLE TYPE clamp(TYPE v, TYPE l, TYPE u); -DECL_MIN_MAX_CLAMP(int) -DECL_MIN_MAX_CLAMP(short) -DECL_MIN_MAX_CLAMP(char) -DECL_MIN_MAX_CLAMP(uint) -DECL_MIN_MAX_CLAMP(unsigned short) -DECL_MIN_MAX_CLAMP(unsigned char) -DECL_MIN_MAX_CLAMP(long) -DECL_MIN_MAX_CLAMP(ulong) -#undef DECL_MIN_MAX_CLAMP -//Begin from this part is autogenerated. -//Don't modify it manually. -//integer builtin functions -//ugentype abs (gentype x) - -OVERLOADABLE uchar2 abs (char2 param0); -OVERLOADABLE uchar3 abs (char3 param0); -OVERLOADABLE uchar4 abs (char4 param0); -OVERLOADABLE uchar8 abs (char8 param0); -OVERLOADABLE uchar16 abs (char16 param0); -OVERLOADABLE ushort2 abs (short2 param0); -OVERLOADABLE ushort3 abs (short3 param0); -OVERLOADABLE ushort4 abs (short4 param0); -OVERLOADABLE ushort8 abs (short8 param0); -OVERLOADABLE ushort16 abs (short16 param0); -OVERLOADABLE uint2 abs (int2 param0); -OVERLOADABLE uint3 abs (int3 param0); -OVERLOADABLE uint4 abs (int4 param0); -OVERLOADABLE uint8 abs (int8 param0); -OVERLOADABLE uint16 abs (int16 param0); -OVERLOADABLE ulong2 abs (long2 param0); -OVERLOADABLE ulong3 abs (long3 param0); -OVERLOADABLE ulong4 abs (long4 param0); -OVERLOADABLE ulong8 abs (long8 param0); -OVERLOADABLE ulong16 abs (long16 param0); -OVERLOADABLE uchar2 abs (uchar2 param0); -OVERLOADABLE uchar3 abs (uchar3 param0); -OVERLOADABLE uchar4 abs (uchar4 param0); -OVERLOADABLE uchar8 abs (uchar8 param0); -OVERLOADABLE uchar16 abs (uchar16 param0); -OVERLOADABLE ushort2 abs (ushort2 param0); -OVERLOADABLE ushort3 abs (ushort3 param0); -OVERLOADABLE ushort4 abs (ushort4 param0); -OVERLOADABLE ushort8 abs (ushort8 param0); -OVERLOADABLE ushort16 abs (ushort16 param0); -OVERLOADABLE uint2 abs (uint2 param0); -OVERLOADABLE uint3 abs (uint3 param0); -OVERLOADABLE uint4 abs (uint4 param0); -OVERLOADABLE uint8 abs (uint8 param0); -OVERLOADABLE uint16 abs (uint16 param0); -OVERLOADABLE ulong2 abs (ulong2 param0); -OVERLOADABLE ulong3 abs (ulong3 param0); -OVERLOADABLE ulong4 abs (ulong4 param0); -OVERLOADABLE ulong8 abs (ulong8 param0); -OVERLOADABLE ulong16 abs (ulong16 param0); - -//ugentype abs_diff (gentype x, gentype y) - -OVERLOADABLE uchar2 abs_diff (char2 param0, char2 param1); -OVERLOADABLE uchar3 abs_diff (char3 param0, char3 param1); -OVERLOADABLE uchar4 abs_diff (char4 param0, char4 param1); -OVERLOADABLE uchar8 abs_diff (char8 param0, char8 param1); -OVERLOADABLE uchar16 abs_diff (char16 param0, char16 param1); -OVERLOADABLE ushort2 abs_diff (short2 param0, short2 param1); -OVERLOADABLE ushort3 abs_diff (short3 param0, short3 param1); -OVERLOADABLE ushort4 abs_diff (short4 param0, short4 param1); -OVERLOADABLE ushort8 abs_diff (short8 param0, short8 param1); -OVERLOADABLE ushort16 abs_diff (short16 param0, short16 param1); -OVERLOADABLE uint2 abs_diff (int2 param0, int2 param1); -OVERLOADABLE uint3 abs_diff (int3 param0, int3 param1); -OVERLOADABLE uint4 abs_diff (int4 param0, int4 param1); -OVERLOADABLE uint8 abs_diff (int8 param0, int8 param1); -OVERLOADABLE uint16 abs_diff (int16 param0, int16 param1); -OVERLOADABLE ulong2 abs_diff (long2 param0, long2 param1); -OVERLOADABLE ulong3 abs_diff (long3 param0, long3 param1); -OVERLOADABLE ulong4 abs_diff (long4 param0, long4 param1); -OVERLOADABLE ulong8 abs_diff (long8 param0, long8 param1); -OVERLOADABLE ulong16 abs_diff (long16 param0, long16 param1); -OVERLOADABLE uchar2 abs_diff (uchar2 param0, uchar2 param1); -OVERLOADABLE uchar3 abs_diff (uchar3 param0, uchar3 param1); -OVERLOADABLE uchar4 abs_diff (uchar4 param0, uchar4 param1); -OVERLOADABLE uchar8 abs_diff (uchar8 param0, uchar8 param1); -OVERLOADABLE uchar16 abs_diff (uchar16 param0, uchar16 param1); -OVERLOADABLE ushort2 abs_diff (ushort2 param0, ushort2 param1); -OVERLOADABLE ushort3 abs_diff (ushort3 param0, ushort3 param1); -OVERLOADABLE ushort4 abs_diff (ushort4 param0, ushort4 param1); -OVERLOADABLE ushort8 abs_diff (ushort8 param0, ushort8 param1); -OVERLOADABLE ushort16 abs_diff (ushort16 param0, ushort16 param1); -OVERLOADABLE uint2 abs_diff (uint2 param0, uint2 param1); -OVERLOADABLE uint3 abs_diff (uint3 param0, uint3 param1); -OVERLOADABLE uint4 abs_diff (uint4 param0, uint4 param1); -OVERLOADABLE uint8 abs_diff (uint8 param0, uint8 param1); -OVERLOADABLE uint16 abs_diff (uint16 param0, uint16 param1); -OVERLOADABLE ulong2 abs_diff (ulong2 param0, ulong2 param1); -OVERLOADABLE ulong3 abs_diff (ulong3 param0, ulong3 param1); -OVERLOADABLE ulong4 abs_diff (ulong4 param0, ulong4 param1); -OVERLOADABLE ulong8 abs_diff (ulong8 param0, ulong8 param1); -OVERLOADABLE ulong16 abs_diff (ulong16 param0, ulong16 param1); - -//gentype add_sat (gentype x, gentype y) - -OVERLOADABLE char2 add_sat (char2 param0, char2 param1); -OVERLOADABLE char3 add_sat (char3 param0, char3 param1); -OVERLOADABLE char4 add_sat (char4 param0, char4 param1); -OVERLOADABLE char8 add_sat (char8 param0, char8 param1); -OVERLOADABLE char16 add_sat (char16 param0, char16 param1); -OVERLOADABLE short2 add_sat (short2 param0, short2 param1); -OVERLOADABLE short3 add_sat (short3 param0, short3 param1); -OVERLOADABLE short4 add_sat (short4 param0, short4 param1); -OVERLOADABLE short8 add_sat (short8 param0, short8 param1); -OVERLOADABLE short16 add_sat (short16 param0, short16 param1); -OVERLOADABLE int2 add_sat (int2 param0, int2 param1); -OVERLOADABLE int3 add_sat (int3 param0, int3 param1); -OVERLOADABLE int4 add_sat (int4 param0, int4 param1); -OVERLOADABLE int8 add_sat (int8 param0, int8 param1); -OVERLOADABLE int16 add_sat (int16 param0, int16 param1); -OVERLOADABLE long2 add_sat (long2 param0, long2 param1); -OVERLOADABLE long3 add_sat (long3 param0, long3 param1); -OVERLOADABLE long4 add_sat (long4 param0, long4 param1); -OVERLOADABLE long8 add_sat (long8 param0, long8 param1); -OVERLOADABLE long16 add_sat (long16 param0, long16 param1); -OVERLOADABLE uchar2 add_sat (uchar2 param0, uchar2 param1); -OVERLOADABLE uchar3 add_sat (uchar3 param0, uchar3 param1); -OVERLOADABLE uchar4 add_sat (uchar4 param0, uchar4 param1); -OVERLOADABLE uchar8 add_sat (uchar8 param0, uchar8 param1); -OVERLOADABLE uchar16 add_sat (uchar16 param0, uchar16 param1); -OVERLOADABLE ushort2 add_sat (ushort2 param0, ushort2 param1); -OVERLOADABLE ushort3 add_sat (ushort3 param0, ushort3 param1); -OVERLOADABLE ushort4 add_sat (ushort4 param0, ushort4 param1); -OVERLOADABLE ushort8 add_sat (ushort8 param0, ushort8 param1); -OVERLOADABLE ushort16 add_sat (ushort16 param0, ushort16 param1); -OVERLOADABLE uint2 add_sat (uint2 param0, uint2 param1); -OVERLOADABLE uint3 add_sat (uint3 param0, uint3 param1); -OVERLOADABLE uint4 add_sat (uint4 param0, uint4 param1); -OVERLOADABLE uint8 add_sat (uint8 param0, uint8 param1); -OVERLOADABLE uint16 add_sat (uint16 param0, uint16 param1); -OVERLOADABLE ulong2 add_sat (ulong2 param0, ulong2 param1); -OVERLOADABLE ulong3 add_sat (ulong3 param0, ulong3 param1); -OVERLOADABLE ulong4 add_sat (ulong4 param0, ulong4 param1); -OVERLOADABLE ulong8 add_sat (ulong8 param0, ulong8 param1); -OVERLOADABLE ulong16 add_sat (ulong16 param0, ulong16 param1); - -//gentype hadd (gentype x, gentype y) - -OVERLOADABLE char2 hadd (char2 param0, char2 param1); -OVERLOADABLE char3 hadd (char3 param0, char3 param1); -OVERLOADABLE char4 hadd (char4 param0, char4 param1); -OVERLOADABLE char8 hadd (char8 param0, char8 param1); -OVERLOADABLE char16 hadd (char16 param0, char16 param1); -OVERLOADABLE short2 hadd (short2 param0, short2 param1); -OVERLOADABLE short3 hadd (short3 param0, short3 param1); -OVERLOADABLE short4 hadd (short4 param0, short4 param1); -OVERLOADABLE short8 hadd (short8 param0, short8 param1); -OVERLOADABLE short16 hadd (short16 param0, short16 param1); -OVERLOADABLE int2 hadd (int2 param0, int2 param1); -OVERLOADABLE int3 hadd (int3 param0, int3 param1); -OVERLOADABLE int4 hadd (int4 param0, int4 param1); -OVERLOADABLE int8 hadd (int8 param0, int8 param1); -OVERLOADABLE int16 hadd (int16 param0, int16 param1); -OVERLOADABLE long2 hadd (long2 param0, long2 param1); -OVERLOADABLE long3 hadd (long3 param0, long3 param1); -OVERLOADABLE long4 hadd (long4 param0, long4 param1); -OVERLOADABLE long8 hadd (long8 param0, long8 param1); -OVERLOADABLE long16 hadd (long16 param0, long16 param1); -OVERLOADABLE uchar2 hadd (uchar2 param0, uchar2 param1); -OVERLOADABLE uchar3 hadd (uchar3 param0, uchar3 param1); -OVERLOADABLE uchar4 hadd (uchar4 param0, uchar4 param1); -OVERLOADABLE uchar8 hadd (uchar8 param0, uchar8 param1); -OVERLOADABLE uchar16 hadd (uchar16 param0, uchar16 param1); -OVERLOADABLE ushort2 hadd (ushort2 param0, ushort2 param1); -OVERLOADABLE ushort3 hadd (ushort3 param0, ushort3 param1); -OVERLOADABLE ushort4 hadd (ushort4 param0, ushort4 param1); -OVERLOADABLE ushort8 hadd (ushort8 param0, ushort8 param1); -OVERLOADABLE ushort16 hadd (ushort16 param0, ushort16 param1); -OVERLOADABLE uint2 hadd (uint2 param0, uint2 param1); -OVERLOADABLE uint3 hadd (uint3 param0, uint3 param1); -OVERLOADABLE uint4 hadd (uint4 param0, uint4 param1); -OVERLOADABLE uint8 hadd (uint8 param0, uint8 param1); -OVERLOADABLE uint16 hadd (uint16 param0, uint16 param1); -OVERLOADABLE ulong2 hadd (ulong2 param0, ulong2 param1); -OVERLOADABLE ulong3 hadd (ulong3 param0, ulong3 param1); -OVERLOADABLE ulong4 hadd (ulong4 param0, ulong4 param1); -OVERLOADABLE ulong8 hadd (ulong8 param0, ulong8 param1); -OVERLOADABLE ulong16 hadd (ulong16 param0, ulong16 param1); - -//gentype rhadd (gentype x, gentype y) - -OVERLOADABLE char2 rhadd (char2 param0, char2 param1); -OVERLOADABLE char3 rhadd (char3 param0, char3 param1); -OVERLOADABLE char4 rhadd (char4 param0, char4 param1); -OVERLOADABLE char8 rhadd (char8 param0, char8 param1); -OVERLOADABLE char16 rhadd (char16 param0, char16 param1); -OVERLOADABLE short2 rhadd (short2 param0, short2 param1); -OVERLOADABLE short3 rhadd (short3 param0, short3 param1); -OVERLOADABLE short4 rhadd (short4 param0, short4 param1); -OVERLOADABLE short8 rhadd (short8 param0, short8 param1); -OVERLOADABLE short16 rhadd (short16 param0, short16 param1); -OVERLOADABLE int2 rhadd (int2 param0, int2 param1); -OVERLOADABLE int3 rhadd (int3 param0, int3 param1); -OVERLOADABLE int4 rhadd (int4 param0, int4 param1); -OVERLOADABLE int8 rhadd (int8 param0, int8 param1); -OVERLOADABLE int16 rhadd (int16 param0, int16 param1); -OVERLOADABLE long2 rhadd (long2 param0, long2 param1); -OVERLOADABLE long3 rhadd (long3 param0, long3 param1); -OVERLOADABLE long4 rhadd (long4 param0, long4 param1); -OVERLOADABLE long8 rhadd (long8 param0, long8 param1); -OVERLOADABLE long16 rhadd (long16 param0, long16 param1); -OVERLOADABLE uchar2 rhadd (uchar2 param0, uchar2 param1); -OVERLOADABLE uchar3 rhadd (uchar3 param0, uchar3 param1); -OVERLOADABLE uchar4 rhadd (uchar4 param0, uchar4 param1); -OVERLOADABLE uchar8 rhadd (uchar8 param0, uchar8 param1); -OVERLOADABLE uchar16 rhadd (uchar16 param0, uchar16 param1); -OVERLOADABLE ushort2 rhadd (ushort2 param0, ushort2 param1); -OVERLOADABLE ushort3 rhadd (ushort3 param0, ushort3 param1); -OVERLOADABLE ushort4 rhadd (ushort4 param0, ushort4 param1); -OVERLOADABLE ushort8 rhadd (ushort8 param0, ushort8 param1); -OVERLOADABLE ushort16 rhadd (ushort16 param0, ushort16 param1); -OVERLOADABLE uint2 rhadd (uint2 param0, uint2 param1); -OVERLOADABLE uint3 rhadd (uint3 param0, uint3 param1); -OVERLOADABLE uint4 rhadd (uint4 param0, uint4 param1); -OVERLOADABLE uint8 rhadd (uint8 param0, uint8 param1); -OVERLOADABLE uint16 rhadd (uint16 param0, uint16 param1); -OVERLOADABLE ulong2 rhadd (ulong2 param0, ulong2 param1); -OVERLOADABLE ulong3 rhadd (ulong3 param0, ulong3 param1); -OVERLOADABLE ulong4 rhadd (ulong4 param0, ulong4 param1); -OVERLOADABLE ulong8 rhadd (ulong8 param0, ulong8 param1); -OVERLOADABLE ulong16 rhadd (ulong16 param0, ulong16 param1); - -//gentype clamp (gentype x, gentype minval, gentype maxval) - -OVERLOADABLE char2 clamp (char2 param0, char2 param1, char2 param2); -OVERLOADABLE char3 clamp (char3 param0, char3 param1, char3 param2); -OVERLOADABLE char4 clamp (char4 param0, char4 param1, char4 param2); -OVERLOADABLE char8 clamp (char8 param0, char8 param1, char8 param2); -OVERLOADABLE char16 clamp (char16 param0, char16 param1, char16 param2); -OVERLOADABLE short2 clamp (short2 param0, short2 param1, short2 param2); -OVERLOADABLE short3 clamp (short3 param0, short3 param1, short3 param2); -OVERLOADABLE short4 clamp (short4 param0, short4 param1, short4 param2); -OVERLOADABLE short8 clamp (short8 param0, short8 param1, short8 param2); -OVERLOADABLE short16 clamp (short16 param0, short16 param1, short16 param2); -OVERLOADABLE int2 clamp (int2 param0, int2 param1, int2 param2); -OVERLOADABLE int3 clamp (int3 param0, int3 param1, int3 param2); -OVERLOADABLE int4 clamp (int4 param0, int4 param1, int4 param2); -OVERLOADABLE int8 clamp (int8 param0, int8 param1, int8 param2); -OVERLOADABLE int16 clamp (int16 param0, int16 param1, int16 param2); -OVERLOADABLE long2 clamp (long2 param0, long2 param1, long2 param2); -OVERLOADABLE long3 clamp (long3 param0, long3 param1, long3 param2); -OVERLOADABLE long4 clamp (long4 param0, long4 param1, long4 param2); -OVERLOADABLE long8 clamp (long8 param0, long8 param1, long8 param2); -OVERLOADABLE long16 clamp (long16 param0, long16 param1, long16 param2); -OVERLOADABLE uchar2 clamp (uchar2 param0, uchar2 param1, uchar2 param2); -OVERLOADABLE uchar3 clamp (uchar3 param0, uchar3 param1, uchar3 param2); -OVERLOADABLE uchar4 clamp (uchar4 param0, uchar4 param1, uchar4 param2); -OVERLOADABLE uchar8 clamp (uchar8 param0, uchar8 param1, uchar8 param2); -OVERLOADABLE uchar16 clamp (uchar16 param0, uchar16 param1, uchar16 param2); -OVERLOADABLE ushort2 clamp (ushort2 param0, ushort2 param1, ushort2 param2); -OVERLOADABLE ushort3 clamp (ushort3 param0, ushort3 param1, ushort3 param2); -OVERLOADABLE ushort4 clamp (ushort4 param0, ushort4 param1, ushort4 param2); -OVERLOADABLE ushort8 clamp (ushort8 param0, ushort8 param1, ushort8 param2); -OVERLOADABLE ushort16 clamp (ushort16 param0, ushort16 param1, ushort16 param2); -OVERLOADABLE uint2 clamp (uint2 param0, uint2 param1, uint2 param2); -OVERLOADABLE uint3 clamp (uint3 param0, uint3 param1, uint3 param2); -OVERLOADABLE uint4 clamp (uint4 param0, uint4 param1, uint4 param2); -OVERLOADABLE uint8 clamp (uint8 param0, uint8 param1, uint8 param2); -OVERLOADABLE uint16 clamp (uint16 param0, uint16 param1, uint16 param2); -OVERLOADABLE ulong2 clamp (ulong2 param0, ulong2 param1, ulong2 param2); -OVERLOADABLE ulong3 clamp (ulong3 param0, ulong3 param1, ulong3 param2); -OVERLOADABLE ulong4 clamp (ulong4 param0, ulong4 param1, ulong4 param2); -OVERLOADABLE ulong8 clamp (ulong8 param0, ulong8 param1, ulong8 param2); -OVERLOADABLE ulong16 clamp (ulong16 param0, ulong16 param1, ulong16 param2); - -//gentype clamp (gentype x, sgentype minval, sgentype maxval) - -OVERLOADABLE char2 clamp (char2 param0, char param1, char param2); -OVERLOADABLE char3 clamp (char3 param0, char param1, char param2); -OVERLOADABLE char4 clamp (char4 param0, char param1, char param2); -OVERLOADABLE char8 clamp (char8 param0, char param1, char param2); -OVERLOADABLE char16 clamp (char16 param0, char param1, char param2); -OVERLOADABLE short2 clamp (short2 param0, short param1, short param2); -OVERLOADABLE short3 clamp (short3 param0, short param1, short param2); -OVERLOADABLE short4 clamp (short4 param0, short param1, short param2); -OVERLOADABLE short8 clamp (short8 param0, short param1, short param2); -OVERLOADABLE short16 clamp (short16 param0, short param1, short param2); -OVERLOADABLE int2 clamp (int2 param0, int param1, int param2); -OVERLOADABLE int3 clamp (int3 param0, int param1, int param2); -OVERLOADABLE int4 clamp (int4 param0, int param1, int param2); -OVERLOADABLE int8 clamp (int8 param0, int param1, int param2); -OVERLOADABLE int16 clamp (int16 param0, int param1, int param2); -OVERLOADABLE long2 clamp (long2 param0, long param1, long param2); -OVERLOADABLE long3 clamp (long3 param0, long param1, long param2); -OVERLOADABLE long4 clamp (long4 param0, long param1, long param2); -OVERLOADABLE long8 clamp (long8 param0, long param1, long param2); -OVERLOADABLE long16 clamp (long16 param0, long param1, long param2); -OVERLOADABLE uchar2 clamp (uchar2 param0, uchar param1, uchar param2); -OVERLOADABLE uchar3 clamp (uchar3 param0, uchar param1, uchar param2); -OVERLOADABLE uchar4 clamp (uchar4 param0, uchar param1, uchar param2); -OVERLOADABLE uchar8 clamp (uchar8 param0, uchar param1, uchar param2); -OVERLOADABLE uchar16 clamp (uchar16 param0, uchar param1, uchar param2); -OVERLOADABLE ushort2 clamp (ushort2 param0, ushort param1, ushort param2); -OVERLOADABLE ushort3 clamp (ushort3 param0, ushort param1, ushort param2); -OVERLOADABLE ushort4 clamp (ushort4 param0, ushort param1, ushort param2); -OVERLOADABLE ushort8 clamp (ushort8 param0, ushort param1, ushort param2); -OVERLOADABLE ushort16 clamp (ushort16 param0, ushort param1, ushort param2); -OVERLOADABLE uint2 clamp (uint2 param0, uint param1, uint param2); -OVERLOADABLE uint3 clamp (uint3 param0, uint param1, uint param2); -OVERLOADABLE uint4 clamp (uint4 param0, uint param1, uint param2); -OVERLOADABLE uint8 clamp (uint8 param0, uint param1, uint param2); -OVERLOADABLE uint16 clamp (uint16 param0, uint param1, uint param2); -OVERLOADABLE ulong2 clamp (ulong2 param0, ulong param1, ulong param2); -OVERLOADABLE ulong3 clamp (ulong3 param0, ulong param1, ulong param2); -OVERLOADABLE ulong4 clamp (ulong4 param0, ulong param1, ulong param2); -OVERLOADABLE ulong8 clamp (ulong8 param0, ulong param1, ulong param2); -OVERLOADABLE ulong16 clamp (ulong16 param0, ulong param1, ulong param2); - -//gentype clz (gentype x) - -OVERLOADABLE char2 clz (char2 param0); -OVERLOADABLE char3 clz (char3 param0); -OVERLOADABLE char4 clz (char4 param0); -OVERLOADABLE char8 clz (char8 param0); -OVERLOADABLE char16 clz (char16 param0); -OVERLOADABLE short2 clz (short2 param0); -OVERLOADABLE short3 clz (short3 param0); -OVERLOADABLE short4 clz (short4 param0); -OVERLOADABLE short8 clz (short8 param0); -OVERLOADABLE short16 clz (short16 param0); -OVERLOADABLE int2 clz (int2 param0); -OVERLOADABLE int3 clz (int3 param0); -OVERLOADABLE int4 clz (int4 param0); -OVERLOADABLE int8 clz (int8 param0); -OVERLOADABLE int16 clz (int16 param0); -OVERLOADABLE long2 clz (long2 param0); -OVERLOADABLE long3 clz (long3 param0); -OVERLOADABLE long4 clz (long4 param0); -OVERLOADABLE long8 clz (long8 param0); -OVERLOADABLE long16 clz (long16 param0); -OVERLOADABLE uchar2 clz (uchar2 param0); -OVERLOADABLE uchar3 clz (uchar3 param0); -OVERLOADABLE uchar4 clz (uchar4 param0); -OVERLOADABLE uchar8 clz (uchar8 param0); -OVERLOADABLE uchar16 clz (uchar16 param0); -OVERLOADABLE ushort2 clz (ushort2 param0); -OVERLOADABLE ushort3 clz (ushort3 param0); -OVERLOADABLE ushort4 clz (ushort4 param0); -OVERLOADABLE ushort8 clz (ushort8 param0); -OVERLOADABLE ushort16 clz (ushort16 param0); -OVERLOADABLE uint2 clz (uint2 param0); -OVERLOADABLE uint3 clz (uint3 param0); -OVERLOADABLE uint4 clz (uint4 param0); -OVERLOADABLE uint8 clz (uint8 param0); -OVERLOADABLE uint16 clz (uint16 param0); -OVERLOADABLE ulong2 clz (ulong2 param0); -OVERLOADABLE ulong3 clz (ulong3 param0); -OVERLOADABLE ulong4 clz (ulong4 param0); -OVERLOADABLE ulong8 clz (ulong8 param0); -OVERLOADABLE ulong16 clz (ulong16 param0); - -//gentype ctz (gentype x) - -OVERLOADABLE char2 ctz (char2 param0); -OVERLOADABLE char3 ctz (char3 param0); -OVERLOADABLE char4 ctz (char4 param0); -OVERLOADABLE char8 ctz (char8 param0); -OVERLOADABLE char16 ctz (char16 param0); -OVERLOADABLE short2 ctz (short2 param0); -OVERLOADABLE short3 ctz (short3 param0); -OVERLOADABLE short4 ctz (short4 param0); -OVERLOADABLE short8 ctz (short8 param0); -OVERLOADABLE short16 ctz (short16 param0); -OVERLOADABLE int2 ctz (int2 param0); -OVERLOADABLE int3 ctz (int3 param0); -OVERLOADABLE int4 ctz (int4 param0); -OVERLOADABLE int8 ctz (int8 param0); -OVERLOADABLE int16 ctz (int16 param0); -OVERLOADABLE long2 ctz (long2 param0); -OVERLOADABLE long3 ctz (long3 param0); -OVERLOADABLE long4 ctz (long4 param0); -OVERLOADABLE long8 ctz (long8 param0); -OVERLOADABLE long16 ctz (long16 param0); -OVERLOADABLE uchar2 ctz (uchar2 param0); -OVERLOADABLE uchar3 ctz (uchar3 param0); -OVERLOADABLE uchar4 ctz (uchar4 param0); -OVERLOADABLE uchar8 ctz (uchar8 param0); -OVERLOADABLE uchar16 ctz (uchar16 param0); -OVERLOADABLE ushort2 ctz (ushort2 param0); -OVERLOADABLE ushort3 ctz (ushort3 param0); -OVERLOADABLE ushort4 ctz (ushort4 param0); -OVERLOADABLE ushort8 ctz (ushort8 param0); -OVERLOADABLE ushort16 ctz (ushort16 param0); -OVERLOADABLE uint2 ctz (uint2 param0); -OVERLOADABLE uint3 ctz (uint3 param0); -OVERLOADABLE uint4 ctz (uint4 param0); -OVERLOADABLE uint8 ctz (uint8 param0); -OVERLOADABLE uint16 ctz (uint16 param0); -OVERLOADABLE ulong2 ctz (ulong2 param0); -OVERLOADABLE ulong3 ctz (ulong3 param0); -OVERLOADABLE ulong4 ctz (ulong4 param0); -OVERLOADABLE ulong8 ctz (ulong8 param0); -OVERLOADABLE ulong16 ctz (ulong16 param0); - -//gentype mad_hi (gentype a, gentype b, gentype c) - -OVERLOADABLE char2 mad_hi (char2 param0, char2 param1, char2 param2); -OVERLOADABLE char3 mad_hi (char3 param0, char3 param1, char3 param2); -OVERLOADABLE char4 mad_hi (char4 param0, char4 param1, char4 param2); -OVERLOADABLE char8 mad_hi (char8 param0, char8 param1, char8 param2); -OVERLOADABLE char16 mad_hi (char16 param0, char16 param1, char16 param2); -OVERLOADABLE short2 mad_hi (short2 param0, short2 param1, short2 param2); -OVERLOADABLE short3 mad_hi (short3 param0, short3 param1, short3 param2); -OVERLOADABLE short4 mad_hi (short4 param0, short4 param1, short4 param2); -OVERLOADABLE short8 mad_hi (short8 param0, short8 param1, short8 param2); -OVERLOADABLE short16 mad_hi (short16 param0, short16 param1, short16 param2); -OVERLOADABLE int2 mad_hi (int2 param0, int2 param1, int2 param2); -OVERLOADABLE int3 mad_hi (int3 param0, int3 param1, int3 param2); -OVERLOADABLE int4 mad_hi (int4 param0, int4 param1, int4 param2); -OVERLOADABLE int8 mad_hi (int8 param0, int8 param1, int8 param2); -OVERLOADABLE int16 mad_hi (int16 param0, int16 param1, int16 param2); -OVERLOADABLE long2 mad_hi (long2 param0, long2 param1, long2 param2); -OVERLOADABLE long3 mad_hi (long3 param0, long3 param1, long3 param2); -OVERLOADABLE long4 mad_hi (long4 param0, long4 param1, long4 param2); -OVERLOADABLE long8 mad_hi (long8 param0, long8 param1, long8 param2); -OVERLOADABLE long16 mad_hi (long16 param0, long16 param1, long16 param2); -OVERLOADABLE uchar2 mad_hi (uchar2 param0, uchar2 param1, uchar2 param2); -OVERLOADABLE uchar3 mad_hi (uchar3 param0, uchar3 param1, uchar3 param2); -OVERLOADABLE uchar4 mad_hi (uchar4 param0, uchar4 param1, uchar4 param2); -OVERLOADABLE uchar8 mad_hi (uchar8 param0, uchar8 param1, uchar8 param2); -OVERLOADABLE uchar16 mad_hi (uchar16 param0, uchar16 param1, uchar16 param2); -OVERLOADABLE ushort2 mad_hi (ushort2 param0, ushort2 param1, ushort2 param2); -OVERLOADABLE ushort3 mad_hi (ushort3 param0, ushort3 param1, ushort3 param2); -OVERLOADABLE ushort4 mad_hi (ushort4 param0, ushort4 param1, ushort4 param2); -OVERLOADABLE ushort8 mad_hi (ushort8 param0, ushort8 param1, ushort8 param2); -OVERLOADABLE ushort16 mad_hi (ushort16 param0, ushort16 param1, ushort16 param2); -OVERLOADABLE uint2 mad_hi (uint2 param0, uint2 param1, uint2 param2); -OVERLOADABLE uint3 mad_hi (uint3 param0, uint3 param1, uint3 param2); -OVERLOADABLE uint4 mad_hi (uint4 param0, uint4 param1, uint4 param2); -OVERLOADABLE uint8 mad_hi (uint8 param0, uint8 param1, uint8 param2); -OVERLOADABLE uint16 mad_hi (uint16 param0, uint16 param1, uint16 param2); -OVERLOADABLE ulong2 mad_hi (ulong2 param0, ulong2 param1, ulong2 param2); -OVERLOADABLE ulong3 mad_hi (ulong3 param0, ulong3 param1, ulong3 param2); -OVERLOADABLE ulong4 mad_hi (ulong4 param0, ulong4 param1, ulong4 param2); -OVERLOADABLE ulong8 mad_hi (ulong8 param0, ulong8 param1, ulong8 param2); -OVERLOADABLE ulong16 mad_hi (ulong16 param0, ulong16 param1, ulong16 param2); - -//gentype mad_sat (gentype a, gentype b, gentype c) - -OVERLOADABLE char2 mad_sat (char2 param0, char2 param1, char2 param2); -OVERLOADABLE char3 mad_sat (char3 param0, char3 param1, char3 param2); -OVERLOADABLE char4 mad_sat (char4 param0, char4 param1, char4 param2); -OVERLOADABLE char8 mad_sat (char8 param0, char8 param1, char8 param2); -OVERLOADABLE char16 mad_sat (char16 param0, char16 param1, char16 param2); -OVERLOADABLE short2 mad_sat (short2 param0, short2 param1, short2 param2); -OVERLOADABLE short3 mad_sat (short3 param0, short3 param1, short3 param2); -OVERLOADABLE short4 mad_sat (short4 param0, short4 param1, short4 param2); -OVERLOADABLE short8 mad_sat (short8 param0, short8 param1, short8 param2); -OVERLOADABLE short16 mad_sat (short16 param0, short16 param1, short16 param2); -OVERLOADABLE int2 mad_sat (int2 param0, int2 param1, int2 param2); -OVERLOADABLE int3 mad_sat (int3 param0, int3 param1, int3 param2); -OVERLOADABLE int4 mad_sat (int4 param0, int4 param1, int4 param2); -OVERLOADABLE int8 mad_sat (int8 param0, int8 param1, int8 param2); -OVERLOADABLE int16 mad_sat (int16 param0, int16 param1, int16 param2); -OVERLOADABLE long2 mad_sat (long2 param0, long2 param1, long2 param2); -OVERLOADABLE long3 mad_sat (long3 param0, long3 param1, long3 param2); -OVERLOADABLE long4 mad_sat (long4 param0, long4 param1, long4 param2); -OVERLOADABLE long8 mad_sat (long8 param0, long8 param1, long8 param2); -OVERLOADABLE long16 mad_sat (long16 param0, long16 param1, long16 param2); -OVERLOADABLE uchar2 mad_sat (uchar2 param0, uchar2 param1, uchar2 param2); -OVERLOADABLE uchar3 mad_sat (uchar3 param0, uchar3 param1, uchar3 param2); -OVERLOADABLE uchar4 mad_sat (uchar4 param0, uchar4 param1, uchar4 param2); -OVERLOADABLE uchar8 mad_sat (uchar8 param0, uchar8 param1, uchar8 param2); -OVERLOADABLE uchar16 mad_sat (uchar16 param0, uchar16 param1, uchar16 param2); -OVERLOADABLE ushort2 mad_sat (ushort2 param0, ushort2 param1, ushort2 param2); -OVERLOADABLE ushort3 mad_sat (ushort3 param0, ushort3 param1, ushort3 param2); -OVERLOADABLE ushort4 mad_sat (ushort4 param0, ushort4 param1, ushort4 param2); -OVERLOADABLE ushort8 mad_sat (ushort8 param0, ushort8 param1, ushort8 param2); -OVERLOADABLE ushort16 mad_sat (ushort16 param0, ushort16 param1, ushort16 param2); -OVERLOADABLE uint2 mad_sat (uint2 param0, uint2 param1, uint2 param2); -OVERLOADABLE uint3 mad_sat (uint3 param0, uint3 param1, uint3 param2); -OVERLOADABLE uint4 mad_sat (uint4 param0, uint4 param1, uint4 param2); -OVERLOADABLE uint8 mad_sat (uint8 param0, uint8 param1, uint8 param2); -OVERLOADABLE uint16 mad_sat (uint16 param0, uint16 param1, uint16 param2); -OVERLOADABLE ulong2 mad_sat (ulong2 param0, ulong2 param1, ulong2 param2); -OVERLOADABLE ulong3 mad_sat (ulong3 param0, ulong3 param1, ulong3 param2); -OVERLOADABLE ulong4 mad_sat (ulong4 param0, ulong4 param1, ulong4 param2); -OVERLOADABLE ulong8 mad_sat (ulong8 param0, ulong8 param1, ulong8 param2); -OVERLOADABLE ulong16 mad_sat (ulong16 param0, ulong16 param1, ulong16 param2); - -//gentype max (gentype x, gentype y) - -OVERLOADABLE char2 max (char2 param0, char2 param1); -OVERLOADABLE char3 max (char3 param0, char3 param1); -OVERLOADABLE char4 max (char4 param0, char4 param1); -OVERLOADABLE char8 max (char8 param0, char8 param1); -OVERLOADABLE char16 max (char16 param0, char16 param1); -OVERLOADABLE short2 max (short2 param0, short2 param1); -OVERLOADABLE short3 max (short3 param0, short3 param1); -OVERLOADABLE short4 max (short4 param0, short4 param1); -OVERLOADABLE short8 max (short8 param0, short8 param1); -OVERLOADABLE short16 max (short16 param0, short16 param1); -OVERLOADABLE int2 max (int2 param0, int2 param1); -OVERLOADABLE int3 max (int3 param0, int3 param1); -OVERLOADABLE int4 max (int4 param0, int4 param1); -OVERLOADABLE int8 max (int8 param0, int8 param1); -OVERLOADABLE int16 max (int16 param0, int16 param1); -OVERLOADABLE long2 max (long2 param0, long2 param1); -OVERLOADABLE long3 max (long3 param0, long3 param1); -OVERLOADABLE long4 max (long4 param0, long4 param1); -OVERLOADABLE long8 max (long8 param0, long8 param1); -OVERLOADABLE long16 max (long16 param0, long16 param1); -OVERLOADABLE uchar2 max (uchar2 param0, uchar2 param1); -OVERLOADABLE uchar3 max (uchar3 param0, uchar3 param1); -OVERLOADABLE uchar4 max (uchar4 param0, uchar4 param1); -OVERLOADABLE uchar8 max (uchar8 param0, uchar8 param1); -OVERLOADABLE uchar16 max (uchar16 param0, uchar16 param1); -OVERLOADABLE ushort2 max (ushort2 param0, ushort2 param1); -OVERLOADABLE ushort3 max (ushort3 param0, ushort3 param1); -OVERLOADABLE ushort4 max (ushort4 param0, ushort4 param1); -OVERLOADABLE ushort8 max (ushort8 param0, ushort8 param1); -OVERLOADABLE ushort16 max (ushort16 param0, ushort16 param1); -OVERLOADABLE uint2 max (uint2 param0, uint2 param1); -OVERLOADABLE uint3 max (uint3 param0, uint3 param1); -OVERLOADABLE uint4 max (uint4 param0, uint4 param1); -OVERLOADABLE uint8 max (uint8 param0, uint8 param1); -OVERLOADABLE uint16 max (uint16 param0, uint16 param1); -OVERLOADABLE ulong2 max (ulong2 param0, ulong2 param1); -OVERLOADABLE ulong3 max (ulong3 param0, ulong3 param1); -OVERLOADABLE ulong4 max (ulong4 param0, ulong4 param1); -OVERLOADABLE ulong8 max (ulong8 param0, ulong8 param1); -OVERLOADABLE ulong16 max (ulong16 param0, ulong16 param1); - -//gentype max (gentype x, sgentype y) - -OVERLOADABLE char2 max (char2 param0, char param1); -OVERLOADABLE char3 max (char3 param0, char param1); -OVERLOADABLE char4 max (char4 param0, char param1); -OVERLOADABLE char8 max (char8 param0, char param1); -OVERLOADABLE char16 max (char16 param0, char param1); -OVERLOADABLE short2 max (short2 param0, short param1); -OVERLOADABLE short3 max (short3 param0, short param1); -OVERLOADABLE short4 max (short4 param0, short param1); -OVERLOADABLE short8 max (short8 param0, short param1); -OVERLOADABLE short16 max (short16 param0, short param1); -OVERLOADABLE int2 max (int2 param0, int param1); -OVERLOADABLE int3 max (int3 param0, int param1); -OVERLOADABLE int4 max (int4 param0, int param1); -OVERLOADABLE int8 max (int8 param0, int param1); -OVERLOADABLE int16 max (int16 param0, int param1); -OVERLOADABLE long2 max (long2 param0, long param1); -OVERLOADABLE long3 max (long3 param0, long param1); -OVERLOADABLE long4 max (long4 param0, long param1); -OVERLOADABLE long8 max (long8 param0, long param1); -OVERLOADABLE long16 max (long16 param0, long param1); -OVERLOADABLE uchar2 max (uchar2 param0, uchar param1); -OVERLOADABLE uchar3 max (uchar3 param0, uchar param1); -OVERLOADABLE uchar4 max (uchar4 param0, uchar param1); -OVERLOADABLE uchar8 max (uchar8 param0, uchar param1); -OVERLOADABLE uchar16 max (uchar16 param0, uchar param1); -OVERLOADABLE ushort2 max (ushort2 param0, ushort param1); -OVERLOADABLE ushort3 max (ushort3 param0, ushort param1); -OVERLOADABLE ushort4 max (ushort4 param0, ushort param1); -OVERLOADABLE ushort8 max (ushort8 param0, ushort param1); -OVERLOADABLE ushort16 max (ushort16 param0, ushort param1); -OVERLOADABLE uint2 max (uint2 param0, uint param1); -OVERLOADABLE uint3 max (uint3 param0, uint param1); -OVERLOADABLE uint4 max (uint4 param0, uint param1); -OVERLOADABLE uint8 max (uint8 param0, uint param1); -OVERLOADABLE uint16 max (uint16 param0, uint param1); -OVERLOADABLE ulong2 max (ulong2 param0, ulong param1); -OVERLOADABLE ulong3 max (ulong3 param0, ulong param1); -OVERLOADABLE ulong4 max (ulong4 param0, ulong param1); -OVERLOADABLE ulong8 max (ulong8 param0, ulong param1); -OVERLOADABLE ulong16 max (ulong16 param0, ulong param1); - -//gentype min (gentype x, gentype y) - -OVERLOADABLE char2 min (char2 param0, char2 param1); -OVERLOADABLE char3 min (char3 param0, char3 param1); -OVERLOADABLE char4 min (char4 param0, char4 param1); -OVERLOADABLE char8 min (char8 param0, char8 param1); -OVERLOADABLE char16 min (char16 param0, char16 param1); -OVERLOADABLE short2 min (short2 param0, short2 param1); -OVERLOADABLE short3 min (short3 param0, short3 param1); -OVERLOADABLE short4 min (short4 param0, short4 param1); -OVERLOADABLE short8 min (short8 param0, short8 param1); -OVERLOADABLE short16 min (short16 param0, short16 param1); -OVERLOADABLE int2 min (int2 param0, int2 param1); -OVERLOADABLE int3 min (int3 param0, int3 param1); -OVERLOADABLE int4 min (int4 param0, int4 param1); -OVERLOADABLE int8 min (int8 param0, int8 param1); -OVERLOADABLE int16 min (int16 param0, int16 param1); -OVERLOADABLE long2 min (long2 param0, long2 param1); -OVERLOADABLE long3 min (long3 param0, long3 param1); -OVERLOADABLE long4 min (long4 param0, long4 param1); -OVERLOADABLE long8 min (long8 param0, long8 param1); -OVERLOADABLE long16 min (long16 param0, long16 param1); -OVERLOADABLE uchar2 min (uchar2 param0, uchar2 param1); -OVERLOADABLE uchar3 min (uchar3 param0, uchar3 param1); -OVERLOADABLE uchar4 min (uchar4 param0, uchar4 param1); -OVERLOADABLE uchar8 min (uchar8 param0, uchar8 param1); -OVERLOADABLE uchar16 min (uchar16 param0, uchar16 param1); -OVERLOADABLE ushort2 min (ushort2 param0, ushort2 param1); -OVERLOADABLE ushort3 min (ushort3 param0, ushort3 param1); -OVERLOADABLE ushort4 min (ushort4 param0, ushort4 param1); -OVERLOADABLE ushort8 min (ushort8 param0, ushort8 param1); -OVERLOADABLE ushort16 min (ushort16 param0, ushort16 param1); -OVERLOADABLE uint2 min (uint2 param0, uint2 param1); -OVERLOADABLE uint3 min (uint3 param0, uint3 param1); -OVERLOADABLE uint4 min (uint4 param0, uint4 param1); -OVERLOADABLE uint8 min (uint8 param0, uint8 param1); -OVERLOADABLE uint16 min (uint16 param0, uint16 param1); -OVERLOADABLE ulong2 min (ulong2 param0, ulong2 param1); -OVERLOADABLE ulong3 min (ulong3 param0, ulong3 param1); -OVERLOADABLE ulong4 min (ulong4 param0, ulong4 param1); -OVERLOADABLE ulong8 min (ulong8 param0, ulong8 param1); -OVERLOADABLE ulong16 min (ulong16 param0, ulong16 param1); - -//gentype min (gentype x, sgentype y) - -OVERLOADABLE char2 min (char2 param0, char param1); -OVERLOADABLE char3 min (char3 param0, char param1); -OVERLOADABLE char4 min (char4 param0, char param1); -OVERLOADABLE char8 min (char8 param0, char param1); -OVERLOADABLE char16 min (char16 param0, char param1); -OVERLOADABLE short2 min (short2 param0, short param1); -OVERLOADABLE short3 min (short3 param0, short param1); -OVERLOADABLE short4 min (short4 param0, short param1); -OVERLOADABLE short8 min (short8 param0, short param1); -OVERLOADABLE short16 min (short16 param0, short param1); -OVERLOADABLE int2 min (int2 param0, int param1); -OVERLOADABLE int3 min (int3 param0, int param1); -OVERLOADABLE int4 min (int4 param0, int param1); -OVERLOADABLE int8 min (int8 param0, int param1); -OVERLOADABLE int16 min (int16 param0, int param1); -OVERLOADABLE long2 min (long2 param0, long param1); -OVERLOADABLE long3 min (long3 param0, long param1); -OVERLOADABLE long4 min (long4 param0, long param1); -OVERLOADABLE long8 min (long8 param0, long param1); -OVERLOADABLE long16 min (long16 param0, long param1); -OVERLOADABLE uchar2 min (uchar2 param0, uchar param1); -OVERLOADABLE uchar3 min (uchar3 param0, uchar param1); -OVERLOADABLE uchar4 min (uchar4 param0, uchar param1); -OVERLOADABLE uchar8 min (uchar8 param0, uchar param1); -OVERLOADABLE uchar16 min (uchar16 param0, uchar param1); -OVERLOADABLE ushort2 min (ushort2 param0, ushort param1); -OVERLOADABLE ushort3 min (ushort3 param0, ushort param1); -OVERLOADABLE ushort4 min (ushort4 param0, ushort param1); -OVERLOADABLE ushort8 min (ushort8 param0, ushort param1); -OVERLOADABLE ushort16 min (ushort16 param0, ushort param1); -OVERLOADABLE uint2 min (uint2 param0, uint param1); -OVERLOADABLE uint3 min (uint3 param0, uint param1); -OVERLOADABLE uint4 min (uint4 param0, uint param1); -OVERLOADABLE uint8 min (uint8 param0, uint param1); -OVERLOADABLE uint16 min (uint16 param0, uint param1); -OVERLOADABLE ulong2 min (ulong2 param0, ulong param1); -OVERLOADABLE ulong3 min (ulong3 param0, ulong param1); -OVERLOADABLE ulong4 min (ulong4 param0, ulong param1); -OVERLOADABLE ulong8 min (ulong8 param0, ulong param1); -OVERLOADABLE ulong16 min (ulong16 param0, ulong param1); - -//gentype mul_hi (gentype x, gentype y) - -OVERLOADABLE char2 mul_hi (char2 param0, char2 param1); -OVERLOADABLE char3 mul_hi (char3 param0, char3 param1); -OVERLOADABLE char4 mul_hi (char4 param0, char4 param1); -OVERLOADABLE char8 mul_hi (char8 param0, char8 param1); -OVERLOADABLE char16 mul_hi (char16 param0, char16 param1); -OVERLOADABLE short2 mul_hi (short2 param0, short2 param1); -OVERLOADABLE short3 mul_hi (short3 param0, short3 param1); -OVERLOADABLE short4 mul_hi (short4 param0, short4 param1); -OVERLOADABLE short8 mul_hi (short8 param0, short8 param1); -OVERLOADABLE short16 mul_hi (short16 param0, short16 param1); -OVERLOADABLE int2 mul_hi (int2 param0, int2 param1); -OVERLOADABLE int3 mul_hi (int3 param0, int3 param1); -OVERLOADABLE int4 mul_hi (int4 param0, int4 param1); -OVERLOADABLE int8 mul_hi (int8 param0, int8 param1); -OVERLOADABLE int16 mul_hi (int16 param0, int16 param1); -OVERLOADABLE long2 mul_hi (long2 param0, long2 param1); -OVERLOADABLE long3 mul_hi (long3 param0, long3 param1); -OVERLOADABLE long4 mul_hi (long4 param0, long4 param1); -OVERLOADABLE long8 mul_hi (long8 param0, long8 param1); -OVERLOADABLE long16 mul_hi (long16 param0, long16 param1); -OVERLOADABLE uchar2 mul_hi (uchar2 param0, uchar2 param1); -OVERLOADABLE uchar3 mul_hi (uchar3 param0, uchar3 param1); -OVERLOADABLE uchar4 mul_hi (uchar4 param0, uchar4 param1); -OVERLOADABLE uchar8 mul_hi (uchar8 param0, uchar8 param1); -OVERLOADABLE uchar16 mul_hi (uchar16 param0, uchar16 param1); -OVERLOADABLE ushort2 mul_hi (ushort2 param0, ushort2 param1); -OVERLOADABLE ushort3 mul_hi (ushort3 param0, ushort3 param1); -OVERLOADABLE ushort4 mul_hi (ushort4 param0, ushort4 param1); -OVERLOADABLE ushort8 mul_hi (ushort8 param0, ushort8 param1); -OVERLOADABLE ushort16 mul_hi (ushort16 param0, ushort16 param1); -OVERLOADABLE uint2 mul_hi (uint2 param0, uint2 param1); -OVERLOADABLE uint3 mul_hi (uint3 param0, uint3 param1); -OVERLOADABLE uint4 mul_hi (uint4 param0, uint4 param1); -OVERLOADABLE uint8 mul_hi (uint8 param0, uint8 param1); -OVERLOADABLE uint16 mul_hi (uint16 param0, uint16 param1); -OVERLOADABLE ulong2 mul_hi (ulong2 param0, ulong2 param1); -OVERLOADABLE ulong3 mul_hi (ulong3 param0, ulong3 param1); -OVERLOADABLE ulong4 mul_hi (ulong4 param0, ulong4 param1); -OVERLOADABLE ulong8 mul_hi (ulong8 param0, ulong8 param1); -OVERLOADABLE ulong16 mul_hi (ulong16 param0, ulong16 param1); - -//gentype rotate (gentype v, gentype i) - -OVERLOADABLE char2 rotate (char2 param0, char2 param1); -OVERLOADABLE char3 rotate (char3 param0, char3 param1); -OVERLOADABLE char4 rotate (char4 param0, char4 param1); -OVERLOADABLE char8 rotate (char8 param0, char8 param1); -OVERLOADABLE char16 rotate (char16 param0, char16 param1); -OVERLOADABLE short2 rotate (short2 param0, short2 param1); -OVERLOADABLE short3 rotate (short3 param0, short3 param1); -OVERLOADABLE short4 rotate (short4 param0, short4 param1); -OVERLOADABLE short8 rotate (short8 param0, short8 param1); -OVERLOADABLE short16 rotate (short16 param0, short16 param1); -OVERLOADABLE int2 rotate (int2 param0, int2 param1); -OVERLOADABLE int3 rotate (int3 param0, int3 param1); -OVERLOADABLE int4 rotate (int4 param0, int4 param1); -OVERLOADABLE int8 rotate (int8 param0, int8 param1); -OVERLOADABLE int16 rotate (int16 param0, int16 param1); -OVERLOADABLE long2 rotate (long2 param0, long2 param1); -OVERLOADABLE long3 rotate (long3 param0, long3 param1); -OVERLOADABLE long4 rotate (long4 param0, long4 param1); -OVERLOADABLE long8 rotate (long8 param0, long8 param1); -OVERLOADABLE long16 rotate (long16 param0, long16 param1); -OVERLOADABLE uchar2 rotate (uchar2 param0, uchar2 param1); -OVERLOADABLE uchar3 rotate (uchar3 param0, uchar3 param1); -OVERLOADABLE uchar4 rotate (uchar4 param0, uchar4 param1); -OVERLOADABLE uchar8 rotate (uchar8 param0, uchar8 param1); -OVERLOADABLE uchar16 rotate (uchar16 param0, uchar16 param1); -OVERLOADABLE ushort2 rotate (ushort2 param0, ushort2 param1); -OVERLOADABLE ushort3 rotate (ushort3 param0, ushort3 param1); -OVERLOADABLE ushort4 rotate (ushort4 param0, ushort4 param1); -OVERLOADABLE ushort8 rotate (ushort8 param0, ushort8 param1); -OVERLOADABLE ushort16 rotate (ushort16 param0, ushort16 param1); -OVERLOADABLE uint2 rotate (uint2 param0, uint2 param1); -OVERLOADABLE uint3 rotate (uint3 param0, uint3 param1); -OVERLOADABLE uint4 rotate (uint4 param0, uint4 param1); -OVERLOADABLE uint8 rotate (uint8 param0, uint8 param1); -OVERLOADABLE uint16 rotate (uint16 param0, uint16 param1); -OVERLOADABLE ulong2 rotate (ulong2 param0, ulong2 param1); -OVERLOADABLE ulong3 rotate (ulong3 param0, ulong3 param1); -OVERLOADABLE ulong4 rotate (ulong4 param0, ulong4 param1); -OVERLOADABLE ulong8 rotate (ulong8 param0, ulong8 param1); -OVERLOADABLE ulong16 rotate (ulong16 param0, ulong16 param1); - -//gentype sub_sat (gentype x, gentype y) - -OVERLOADABLE char2 sub_sat (char2 param0, char2 param1); -OVERLOADABLE char3 sub_sat (char3 param0, char3 param1); -OVERLOADABLE char4 sub_sat (char4 param0, char4 param1); -OVERLOADABLE char8 sub_sat (char8 param0, char8 param1); -OVERLOADABLE char16 sub_sat (char16 param0, char16 param1); -OVERLOADABLE short2 sub_sat (short2 param0, short2 param1); -OVERLOADABLE short3 sub_sat (short3 param0, short3 param1); -OVERLOADABLE short4 sub_sat (short4 param0, short4 param1); -OVERLOADABLE short8 sub_sat (short8 param0, short8 param1); -OVERLOADABLE short16 sub_sat (short16 param0, short16 param1); -OVERLOADABLE int2 sub_sat (int2 param0, int2 param1); -OVERLOADABLE int3 sub_sat (int3 param0, int3 param1); -OVERLOADABLE int4 sub_sat (int4 param0, int4 param1); -OVERLOADABLE int8 sub_sat (int8 param0, int8 param1); -OVERLOADABLE int16 sub_sat (int16 param0, int16 param1); -OVERLOADABLE long2 sub_sat (long2 param0, long2 param1); -OVERLOADABLE long3 sub_sat (long3 param0, long3 param1); -OVERLOADABLE long4 sub_sat (long4 param0, long4 param1); -OVERLOADABLE long8 sub_sat (long8 param0, long8 param1); -OVERLOADABLE long16 sub_sat (long16 param0, long16 param1); -OVERLOADABLE uchar2 sub_sat (uchar2 param0, uchar2 param1); -OVERLOADABLE uchar3 sub_sat (uchar3 param0, uchar3 param1); -OVERLOADABLE uchar4 sub_sat (uchar4 param0, uchar4 param1); -OVERLOADABLE uchar8 sub_sat (uchar8 param0, uchar8 param1); -OVERLOADABLE uchar16 sub_sat (uchar16 param0, uchar16 param1); -OVERLOADABLE ushort2 sub_sat (ushort2 param0, ushort2 param1); -OVERLOADABLE ushort3 sub_sat (ushort3 param0, ushort3 param1); -OVERLOADABLE ushort4 sub_sat (ushort4 param0, ushort4 param1); -OVERLOADABLE ushort8 sub_sat (ushort8 param0, ushort8 param1); -OVERLOADABLE ushort16 sub_sat (ushort16 param0, ushort16 param1); -OVERLOADABLE uint2 sub_sat (uint2 param0, uint2 param1); -OVERLOADABLE uint3 sub_sat (uint3 param0, uint3 param1); -OVERLOADABLE uint4 sub_sat (uint4 param0, uint4 param1); -OVERLOADABLE uint8 sub_sat (uint8 param0, uint8 param1); -OVERLOADABLE uint16 sub_sat (uint16 param0, uint16 param1); -OVERLOADABLE ulong2 sub_sat (ulong2 param0, ulong2 param1); -OVERLOADABLE ulong3 sub_sat (ulong3 param0, ulong3 param1); -OVERLOADABLE ulong4 sub_sat (ulong4 param0, ulong4 param1); -OVERLOADABLE ulong8 sub_sat (ulong8 param0, ulong8 param1); -OVERLOADABLE ulong16 sub_sat (ulong16 param0, ulong16 param1); - -//shortn upsample (charn hi, ucharn lo) - -OVERLOADABLE short2 upsample (char2 param0, uchar2 param1); -OVERLOADABLE short3 upsample (char3 param0, uchar3 param1); -OVERLOADABLE short4 upsample (char4 param0, uchar4 param1); -OVERLOADABLE short8 upsample (char8 param0, uchar8 param1); -OVERLOADABLE short16 upsample (char16 param0, uchar16 param1); - -//ushortn upsample (ucharn hi, ucharn lo) - -OVERLOADABLE ushort2 upsample (uchar2 param0, uchar2 param1); -OVERLOADABLE ushort3 upsample (uchar3 param0, uchar3 param1); -OVERLOADABLE ushort4 upsample (uchar4 param0, uchar4 param1); -OVERLOADABLE ushort8 upsample (uchar8 param0, uchar8 param1); -OVERLOADABLE ushort16 upsample (uchar16 param0, uchar16 param1); - -//intn upsample (shortn hi, ushortn lo) - -OVERLOADABLE int2 upsample (short2 param0, ushort2 param1); -OVERLOADABLE int3 upsample (short3 param0, ushort3 param1); -OVERLOADABLE int4 upsample (short4 param0, ushort4 param1); -OVERLOADABLE int8 upsample (short8 param0, ushort8 param1); -OVERLOADABLE int16 upsample (short16 param0, ushort16 param1); - -//uintn upsample (ushortn hi, ushortn lo) - -OVERLOADABLE uint2 upsample (ushort2 param0, ushort2 param1); -OVERLOADABLE uint3 upsample (ushort3 param0, ushort3 param1); -OVERLOADABLE uint4 upsample (ushort4 param0, ushort4 param1); -OVERLOADABLE uint8 upsample (ushort8 param0, ushort8 param1); -OVERLOADABLE uint16 upsample (ushort16 param0, ushort16 param1); - -//longn upsample (intn hi, uintn lo) - -OVERLOADABLE long2 upsample (int2 param0, uint2 param1); -OVERLOADABLE long3 upsample (int3 param0, uint3 param1); -OVERLOADABLE long4 upsample (int4 param0, uint4 param1); -OVERLOADABLE long8 upsample (int8 param0, uint8 param1); -OVERLOADABLE long16 upsample (int16 param0, uint16 param1); - -//ulongn upsample (uintn hi, uintn lo) - -OVERLOADABLE ulong2 upsample (uint2 param0, uint2 param1); -OVERLOADABLE ulong3 upsample (uint3 param0, uint3 param1); -OVERLOADABLE ulong4 upsample (uint4 param0, uint4 param1); -OVERLOADABLE ulong8 upsample (uint8 param0, uint8 param1); -OVERLOADABLE ulong16 upsample (uint16 param0, uint16 param1); - -//gentype popcount (gentype x) - -OVERLOADABLE char2 popcount (char2 param0); -OVERLOADABLE char3 popcount (char3 param0); -OVERLOADABLE char4 popcount (char4 param0); -OVERLOADABLE char8 popcount (char8 param0); -OVERLOADABLE char16 popcount (char16 param0); -OVERLOADABLE short2 popcount (short2 param0); -OVERLOADABLE short3 popcount (short3 param0); -OVERLOADABLE short4 popcount (short4 param0); -OVERLOADABLE short8 popcount (short8 param0); -OVERLOADABLE short16 popcount (short16 param0); -OVERLOADABLE int2 popcount (int2 param0); -OVERLOADABLE int3 popcount (int3 param0); -OVERLOADABLE int4 popcount (int4 param0); -OVERLOADABLE int8 popcount (int8 param0); -OVERLOADABLE int16 popcount (int16 param0); -OVERLOADABLE long2 popcount (long2 param0); -OVERLOADABLE long3 popcount (long3 param0); -OVERLOADABLE long4 popcount (long4 param0); -OVERLOADABLE long8 popcount (long8 param0); -OVERLOADABLE long16 popcount (long16 param0); -OVERLOADABLE uchar2 popcount (uchar2 param0); -OVERLOADABLE uchar3 popcount (uchar3 param0); -OVERLOADABLE uchar4 popcount (uchar4 param0); -OVERLOADABLE uchar8 popcount (uchar8 param0); -OVERLOADABLE uchar16 popcount (uchar16 param0); -OVERLOADABLE ushort2 popcount (ushort2 param0); -OVERLOADABLE ushort3 popcount (ushort3 param0); -OVERLOADABLE ushort4 popcount (ushort4 param0); -OVERLOADABLE ushort8 popcount (ushort8 param0); -OVERLOADABLE ushort16 popcount (ushort16 param0); -OVERLOADABLE uint2 popcount (uint2 param0); -OVERLOADABLE uint3 popcount (uint3 param0); -OVERLOADABLE uint4 popcount (uint4 param0); -OVERLOADABLE uint8 popcount (uint8 param0); -OVERLOADABLE uint16 popcount (uint16 param0); -OVERLOADABLE ulong2 popcount (ulong2 param0); -OVERLOADABLE ulong3 popcount (ulong3 param0); -OVERLOADABLE ulong4 popcount (ulong4 param0); -OVERLOADABLE ulong8 popcount (ulong8 param0); -OVERLOADABLE ulong16 popcount (ulong16 param0); - -//fast_integer builtin functions -//gentype mad24 (gentype x, gentype y, gentype z) - -OVERLOADABLE uint2 mad24 (uint2 param0, uint2 param1, uint2 param2); -OVERLOADABLE uint3 mad24 (uint3 param0, uint3 param1, uint3 param2); -OVERLOADABLE uint4 mad24 (uint4 param0, uint4 param1, uint4 param2); -OVERLOADABLE uint8 mad24 (uint8 param0, uint8 param1, uint8 param2); -OVERLOADABLE uint16 mad24 (uint16 param0, uint16 param1, uint16 param2); -OVERLOADABLE int2 mad24 (int2 param0, int2 param1, int2 param2); -OVERLOADABLE int3 mad24 (int3 param0, int3 param1, int3 param2); -OVERLOADABLE int4 mad24 (int4 param0, int4 param1, int4 param2); -OVERLOADABLE int8 mad24 (int8 param0, int8 param1, int8 param2); -OVERLOADABLE int16 mad24 (int16 param0, int16 param1, int16 param2); - -//gentype mul24 (gentype x, gentype y) - -OVERLOADABLE uint2 mul24 (uint2 param0, uint2 param1); -OVERLOADABLE uint3 mul24 (uint3 param0, uint3 param1); -OVERLOADABLE uint4 mul24 (uint4 param0, uint4 param1); -OVERLOADABLE uint8 mul24 (uint8 param0, uint8 param1); -OVERLOADABLE uint16 mul24 (uint16 param0, uint16 param1); -OVERLOADABLE int2 mul24 (int2 param0, int2 param1); -OVERLOADABLE int3 mul24 (int3 param0, int3 param1); -OVERLOADABLE int4 mul24 (int4 param0, int4 param1); -OVERLOADABLE int8 mul24 (int8 param0, int8 param1); -OVERLOADABLE int16 mul24 (int16 param0, int16 param1); - -#endif diff --git a/drivers/pocl-gen7/lib/beignet/include/ocl_math.h b/drivers/pocl-gen7/lib/beignet/include/ocl_math.h deleted file mode 100644 index 7ce2fc7..0000000 --- a/drivers/pocl-gen7/lib/beignet/include/ocl_math.h +++ /dev/null @@ -1,549 +0,0 @@ -/* - * Copyright © 2012 - 2014 Intel Corporation - * - * This library is free software; you can redistribute it and/or - * modify it under the terms of the GNU Lesser General Public - * License as published by the Free Software Foundation; either - * version 2.1 of the License, or (at your option) any later version. - * - * This library is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU - * Lesser General Public License for more details. - * - * You should have received a copy of the GNU Lesser General Public - * License along with this library. If not, see . - * - */ -#ifndef __OCL_MATH_H__ -#define __OCL_MATH_H__ - -#include "ocl_types.h" -#include "ocl_math_common.h" - - -OVERLOADABLE float lgamma_r(float x, global int *signgamp); -OVERLOADABLE float lgamma_r(float x, local int *signgamp); -OVERLOADABLE float lgamma_r(float x, private int *signgamp); -OVERLOADABLE float sincos(float x, global float *cosval); -OVERLOADABLE float sincos(float x, local float *cosval); -OVERLOADABLE float sincos(float x, private float *cosval); -OVERLOADABLE float frexp(float x, global int *exp); -OVERLOADABLE float frexp(float x, local int *exp); -OVERLOADABLE float frexp(float x, private int *exp); -OVERLOADABLE float modf(float x, global float *i); -OVERLOADABLE float modf(float x, local float *i); -OVERLOADABLE float modf(float x, private float *i); -OVERLOADABLE float fract(float x, global float *p); -OVERLOADABLE float fract(float x, local float *p); -OVERLOADABLE float fract(float x, private float *p); -OVERLOADABLE float remquo(float x, float y, global int *quo); -OVERLOADABLE float remquo(float x, float y, local int *quo); -OVERLOADABLE float remquo(float x, float y, private int *quo); - - -OVERLOADABLE half lgamma_r(half x, global int *signgamp); -OVERLOADABLE half lgamma_r(half x, local int *signgamp); -OVERLOADABLE half lgamma_r(half x, private int *signgamp); -OVERLOADABLE half sincos(half x, global half *cosval); -OVERLOADABLE half sincos(half x, local half *cosval); -OVERLOADABLE half sincos(half x, private half *cosval); -OVERLOADABLE half frexp(half x, global int *exp); -OVERLOADABLE half frexp(half x, local int *exp); -OVERLOADABLE half frexp(half x, private int *exp); -OVERLOADABLE half modf(half x, global half *i); -OVERLOADABLE half modf(half x, local half *i); -OVERLOADABLE half modf(half x, private half *i); -OVERLOADABLE half fract(half x, global half *p); -OVERLOADABLE half fract(half x, local half *p); -OVERLOADABLE half fract(half x, private half *p); -OVERLOADABLE half remquo(half x, half y, global int *quo); -OVERLOADABLE half remquo(half x, half y, local int *quo); -OVERLOADABLE half remquo(half x, half y, private int *quo); - - - -//------- double ----------- -OVERLOADABLE double fract(double x, global double *p); -OVERLOADABLE double fract(double x, local double *p); -OVERLOADABLE double fract(double x, private double *p); -OVERLOADABLE double frexp(double x, global int *exp); -OVERLOADABLE double frexp(double x, local int *exp); -OVERLOADABLE double frexp(double x, private int *exp); -OVERLOADABLE double lgamma_r(double x, global int *signgamp); -OVERLOADABLE double lgamma_r(double x, local int *signgamp); -OVERLOADABLE double lgamma_r(double x, private int *signgamp); -OVERLOADABLE double modf(double x, global double *i); -OVERLOADABLE double modf(double x, local double *i); -OVERLOADABLE double modf(double x, private double *i); -OVERLOADABLE double remquo(double x, double y, global int *quo); -OVERLOADABLE double remquo(double x, double y, local int *quo); -OVERLOADABLE double remquo(double x, double y, private int *quo); -OVERLOADABLE double sincos(double x, global double *cosval); -OVERLOADABLE double sincos(double x, local double *cosval); -OVERLOADABLE double sincos(double x, private double *cosval); - - -//Begin from this part is autogenerated. -//Don't modify it manually. -//math builtin functions -//gentype fract (gentype x, __global gentype *iptr) - -OVERLOADABLE float2 fract (float2 param0, __global float2 *param1); -OVERLOADABLE float3 fract (float3 param0, __global float3 *param1); -OVERLOADABLE float4 fract (float4 param0, __global float4 *param1); -OVERLOADABLE float8 fract (float8 param0, __global float8 *param1); -OVERLOADABLE float16 fract (float16 param0, __global float16 *param1); -OVERLOADABLE double2 fract (double2 param0, __global double2 *param1); -OVERLOADABLE double3 fract (double3 param0, __global double3 *param1); -OVERLOADABLE double4 fract (double4 param0, __global double4 *param1); -OVERLOADABLE double8 fract (double8 param0, __global double8 *param1); -OVERLOADABLE double16 fract (double16 param0, __global double16 *param1); -OVERLOADABLE half2 fract (half2 param0, __global half2 *param1); -OVERLOADABLE half3 fract (half3 param0, __global half3 *param1); -OVERLOADABLE half4 fract (half4 param0, __global half4 *param1); -OVERLOADABLE half8 fract (half8 param0, __global half8 *param1); -OVERLOADABLE half16 fract (half16 param0, __global half16 *param1); - -//gentype fract (gentype x, __local gentype *iptr) - -OVERLOADABLE float2 fract (float2 param0, __local float2 *param1); -OVERLOADABLE float3 fract (float3 param0, __local float3 *param1); -OVERLOADABLE float4 fract (float4 param0, __local float4 *param1); -OVERLOADABLE float8 fract (float8 param0, __local float8 *param1); -OVERLOADABLE float16 fract (float16 param0, __local float16 *param1); -OVERLOADABLE double2 fract (double2 param0, __local double2 *param1); -OVERLOADABLE double3 fract (double3 param0, __local double3 *param1); -OVERLOADABLE double4 fract (double4 param0, __local double4 *param1); -OVERLOADABLE double8 fract (double8 param0, __local double8 *param1); -OVERLOADABLE double16 fract (double16 param0, __local double16 *param1); -OVERLOADABLE half2 fract (half2 param0, __local half2 *param1); -OVERLOADABLE half3 fract (half3 param0, __local half3 *param1); -OVERLOADABLE half4 fract (half4 param0, __local half4 *param1); -OVERLOADABLE half8 fract (half8 param0, __local half8 *param1); -OVERLOADABLE half16 fract (half16 param0, __local half16 *param1); - -//gentype fract (gentype x, __private gentype *iptr) - -OVERLOADABLE float2 fract (float2 param0, __private float2 *param1); -OVERLOADABLE float3 fract (float3 param0, __private float3 *param1); -OVERLOADABLE float4 fract (float4 param0, __private float4 *param1); -OVERLOADABLE float8 fract (float8 param0, __private float8 *param1); -OVERLOADABLE float16 fract (float16 param0, __private float16 *param1); -OVERLOADABLE double2 fract (double2 param0, __private double2 *param1); -OVERLOADABLE double3 fract (double3 param0, __private double3 *param1); -OVERLOADABLE double4 fract (double4 param0, __private double4 *param1); -OVERLOADABLE double8 fract (double8 param0, __private double8 *param1); -OVERLOADABLE double16 fract (double16 param0, __private double16 *param1); -OVERLOADABLE half2 fract (half2 param0, __private half2 *param1); -OVERLOADABLE half3 fract (half3 param0, __private half3 *param1); -OVERLOADABLE half4 fract (half4 param0, __private half4 *param1); -OVERLOADABLE half8 fract (half8 param0, __private half8 *param1); -OVERLOADABLE half16 fract (half16 param0, __private half16 *param1); - -//floatn frexp (floatn x, __global intn *exp) - -OVERLOADABLE float2 frexp (float2 param0, __global int2 *param1); -OVERLOADABLE float3 frexp (float3 param0, __global int3 *param1); -OVERLOADABLE float4 frexp (float4 param0, __global int4 *param1); -OVERLOADABLE float8 frexp (float8 param0, __global int8 *param1); -OVERLOADABLE float16 frexp (float16 param0, __global int16 *param1); - -//floatn frexp (floatn x, __local intn *exp) - -OVERLOADABLE float2 frexp (float2 param0, __local int2 *param1); -OVERLOADABLE float3 frexp (float3 param0, __local int3 *param1); -OVERLOADABLE float4 frexp (float4 param0, __local int4 *param1); -OVERLOADABLE float8 frexp (float8 param0, __local int8 *param1); -OVERLOADABLE float16 frexp (float16 param0, __local int16 *param1); - -//floatn frexp (floatn x, __private intn *exp) - -OVERLOADABLE float2 frexp (float2 param0, __private int2 *param1); -OVERLOADABLE float3 frexp (float3 param0, __private int3 *param1); -OVERLOADABLE float4 frexp (float4 param0, __private int4 *param1); -OVERLOADABLE float8 frexp (float8 param0, __private int8 *param1); -OVERLOADABLE float16 frexp (float16 param0, __private int16 *param1); - -//float frexp (float x, __global int *exp) - - -//float frexp (float x, __local int *exp) - - -//float frexp (float x, __private int *exp) - - -//halfn frexp (halfn x, __global intn *exp) - -OVERLOADABLE half2 frexp (half2 param0, __global int2 *param1); -OVERLOADABLE half3 frexp (half3 param0, __global int3 *param1); -OVERLOADABLE half4 frexp (half4 param0, __global int4 *param1); -OVERLOADABLE half8 frexp (half8 param0, __global int8 *param1); -OVERLOADABLE half16 frexp (half16 param0, __global int16 *param1); - -//halfn frexp (halfn x, __local intn *exp) - -OVERLOADABLE half2 frexp (half2 param0, __local int2 *param1); -OVERLOADABLE half3 frexp (half3 param0, __local int3 *param1); -OVERLOADABLE half4 frexp (half4 param0, __local int4 *param1); -OVERLOADABLE half8 frexp (half8 param0, __local int8 *param1); -OVERLOADABLE half16 frexp (half16 param0, __local int16 *param1); - -//halfn frexp (halfn x, __private intn *exp) - -OVERLOADABLE half2 frexp (half2 param0, __private int2 *param1); -OVERLOADABLE half3 frexp (half3 param0, __private int3 *param1); -OVERLOADABLE half4 frexp (half4 param0, __private int4 *param1); -OVERLOADABLE half8 frexp (half8 param0, __private int8 *param1); -OVERLOADABLE half16 frexp (half16 param0, __private int16 *param1); - -//half frexp (half x, __global int *exp) - - -//half frexp (half x, __local int *exp) - - -//half frexp (half x, __private int *exp) - - -//doublen frexp (doublen x, __global intn *exp) - -OVERLOADABLE double2 frexp (double2 param0, __global int2 *param1); -OVERLOADABLE double3 frexp (double3 param0, __global int3 *param1); -OVERLOADABLE double4 frexp (double4 param0, __global int4 *param1); -OVERLOADABLE double8 frexp (double8 param0, __global int8 *param1); -OVERLOADABLE double16 frexp (double16 param0, __global int16 *param1); - -//doublen frexp (doublen x, __local intn *exp) - -OVERLOADABLE double2 frexp (double2 param0, __local int2 *param1); -OVERLOADABLE double3 frexp (double3 param0, __local int3 *param1); -OVERLOADABLE double4 frexp (double4 param0, __local int4 *param1); -OVERLOADABLE double8 frexp (double8 param0, __local int8 *param1); -OVERLOADABLE double16 frexp (double16 param0, __local int16 *param1); - -//doublen frexp (doublen x, __private intn *exp) - -OVERLOADABLE double2 frexp (double2 param0, __private int2 *param1); -OVERLOADABLE double3 frexp (double3 param0, __private int3 *param1); -OVERLOADABLE double4 frexp (double4 param0, __private int4 *param1); -OVERLOADABLE double8 frexp (double8 param0, __private int8 *param1); -OVERLOADABLE double16 frexp (double16 param0, __private int16 *param1); - -//double frexp (double x, __global int *exp) - - -//double frexp (double x, __local int *exp) - - -//double frexp (double x, __private int *exp) - - -//floatn lgamma_r (floatn x, __global intn *signp) - -OVERLOADABLE float2 lgamma_r (float2 param0, __global int2 *param1); -OVERLOADABLE float3 lgamma_r (float3 param0, __global int3 *param1); -OVERLOADABLE float4 lgamma_r (float4 param0, __global int4 *param1); -OVERLOADABLE float8 lgamma_r (float8 param0, __global int8 *param1); -OVERLOADABLE float16 lgamma_r (float16 param0, __global int16 *param1); - -//floatn lgamma_r (floatn x, __local intn *signp) - -OVERLOADABLE float2 lgamma_r (float2 param0, __local int2 *param1); -OVERLOADABLE float3 lgamma_r (float3 param0, __local int3 *param1); -OVERLOADABLE float4 lgamma_r (float4 param0, __local int4 *param1); -OVERLOADABLE float8 lgamma_r (float8 param0, __local int8 *param1); -OVERLOADABLE float16 lgamma_r (float16 param0, __local int16 *param1); - -//floatn lgamma_r (floatn x, __private intn *signp) - -OVERLOADABLE float2 lgamma_r (float2 param0, __private int2 *param1); -OVERLOADABLE float3 lgamma_r (float3 param0, __private int3 *param1); -OVERLOADABLE float4 lgamma_r (float4 param0, __private int4 *param1); -OVERLOADABLE float8 lgamma_r (float8 param0, __private int8 *param1); -OVERLOADABLE float16 lgamma_r (float16 param0, __private int16 *param1); - -//float lgamma_r (float x, __global int *signp) - - -//float lgamma_r (float x, __local int *signp) - - -//float lgamma_r (float x, __private int *signp) - - -//halfn lgamma_r (halfn x, __global intn *signp) - -OVERLOADABLE half2 lgamma_r (half2 param0, __global int2 *param1); -OVERLOADABLE half3 lgamma_r (half3 param0, __global int3 *param1); -OVERLOADABLE half4 lgamma_r (half4 param0, __global int4 *param1); -OVERLOADABLE half8 lgamma_r (half8 param0, __global int8 *param1); -OVERLOADABLE half16 lgamma_r (half16 param0, __global int16 *param1); - -//halfn lgamma_r (halfn x, __local intn *signp) - -OVERLOADABLE half2 lgamma_r (half2 param0, __local int2 *param1); -OVERLOADABLE half3 lgamma_r (half3 param0, __local int3 *param1); -OVERLOADABLE half4 lgamma_r (half4 param0, __local int4 *param1); -OVERLOADABLE half8 lgamma_r (half8 param0, __local int8 *param1); -OVERLOADABLE half16 lgamma_r (half16 param0, __local int16 *param1); - -//halfn lgamma_r (halfn x, __private intn *signp) - -OVERLOADABLE half2 lgamma_r (half2 param0, __private int2 *param1); -OVERLOADABLE half3 lgamma_r (half3 param0, __private int3 *param1); -OVERLOADABLE half4 lgamma_r (half4 param0, __private int4 *param1); -OVERLOADABLE half8 lgamma_r (half8 param0, __private int8 *param1); -OVERLOADABLE half16 lgamma_r (half16 param0, __private int16 *param1); - -//half lgamma_r (half x, __global int *signp) - - -//half lgamma_r (half x, __local int *signp) - - -//half lgamma_r (half x, __private int *signp) - - -//doublen lgamma_r (doublen x, __global intn *signp) - -OVERLOADABLE double2 lgamma_r (double2 param0, __global int2 *param1); -OVERLOADABLE double3 lgamma_r (double3 param0, __global int3 *param1); -OVERLOADABLE double4 lgamma_r (double4 param0, __global int4 *param1); -OVERLOADABLE double8 lgamma_r (double8 param0, __global int8 *param1); -OVERLOADABLE double16 lgamma_r (double16 param0, __global int16 *param1); - -//doublen lgamma_r (doublen x, __local intn *signp) - -OVERLOADABLE double2 lgamma_r (double2 param0, __local int2 *param1); -OVERLOADABLE double3 lgamma_r (double3 param0, __local int3 *param1); -OVERLOADABLE double4 lgamma_r (double4 param0, __local int4 *param1); -OVERLOADABLE double8 lgamma_r (double8 param0, __local int8 *param1); -OVERLOADABLE double16 lgamma_r (double16 param0, __local int16 *param1); - -//doublen lgamma_r (doublen x, __private intn *signp) - -OVERLOADABLE double2 lgamma_r (double2 param0, __private int2 *param1); -OVERLOADABLE double3 lgamma_r (double3 param0, __private int3 *param1); -OVERLOADABLE double4 lgamma_r (double4 param0, __private int4 *param1); -OVERLOADABLE double8 lgamma_r (double8 param0, __private int8 *param1); -OVERLOADABLE double16 lgamma_r (double16 param0, __private int16 *param1); - -//double lgamma_r (double x, __global int *signp) - - -//double lgamma_r (double x, __local int *signp) - - -//double lgamma_r (double x, __private int *signp) - - -//gentype modf (gentype x, __global gentype *iptr) - -OVERLOADABLE float2 modf (float2 param0, __global float2 *param1); -OVERLOADABLE float3 modf (float3 param0, __global float3 *param1); -OVERLOADABLE float4 modf (float4 param0, __global float4 *param1); -OVERLOADABLE float8 modf (float8 param0, __global float8 *param1); -OVERLOADABLE float16 modf (float16 param0, __global float16 *param1); -OVERLOADABLE double2 modf (double2 param0, __global double2 *param1); -OVERLOADABLE double3 modf (double3 param0, __global double3 *param1); -OVERLOADABLE double4 modf (double4 param0, __global double4 *param1); -OVERLOADABLE double8 modf (double8 param0, __global double8 *param1); -OVERLOADABLE double16 modf (double16 param0, __global double16 *param1); -OVERLOADABLE half2 modf (half2 param0, __global half2 *param1); -OVERLOADABLE half3 modf (half3 param0, __global half3 *param1); -OVERLOADABLE half4 modf (half4 param0, __global half4 *param1); -OVERLOADABLE half8 modf (half8 param0, __global half8 *param1); -OVERLOADABLE half16 modf (half16 param0, __global half16 *param1); - -//gentype modf (gentype x, __local gentype *iptr) - -OVERLOADABLE float2 modf (float2 param0, __local float2 *param1); -OVERLOADABLE float3 modf (float3 param0, __local float3 *param1); -OVERLOADABLE float4 modf (float4 param0, __local float4 *param1); -OVERLOADABLE float8 modf (float8 param0, __local float8 *param1); -OVERLOADABLE float16 modf (float16 param0, __local float16 *param1); -OVERLOADABLE double2 modf (double2 param0, __local double2 *param1); -OVERLOADABLE double3 modf (double3 param0, __local double3 *param1); -OVERLOADABLE double4 modf (double4 param0, __local double4 *param1); -OVERLOADABLE double8 modf (double8 param0, __local double8 *param1); -OVERLOADABLE double16 modf (double16 param0, __local double16 *param1); -OVERLOADABLE half2 modf (half2 param0, __local half2 *param1); -OVERLOADABLE half3 modf (half3 param0, __local half3 *param1); -OVERLOADABLE half4 modf (half4 param0, __local half4 *param1); -OVERLOADABLE half8 modf (half8 param0, __local half8 *param1); -OVERLOADABLE half16 modf (half16 param0, __local half16 *param1); - -//gentype modf (gentype x, __private gentype *iptr) - -OVERLOADABLE float2 modf (float2 param0, __private float2 *param1); -OVERLOADABLE float3 modf (float3 param0, __private float3 *param1); -OVERLOADABLE float4 modf (float4 param0, __private float4 *param1); -OVERLOADABLE float8 modf (float8 param0, __private float8 *param1); -OVERLOADABLE float16 modf (float16 param0, __private float16 *param1); -OVERLOADABLE double2 modf (double2 param0, __private double2 *param1); -OVERLOADABLE double3 modf (double3 param0, __private double3 *param1); -OVERLOADABLE double4 modf (double4 param0, __private double4 *param1); -OVERLOADABLE double8 modf (double8 param0, __private double8 *param1); -OVERLOADABLE double16 modf (double16 param0, __private double16 *param1); -OVERLOADABLE half2 modf (half2 param0, __private half2 *param1); -OVERLOADABLE half3 modf (half3 param0, __private half3 *param1); -OVERLOADABLE half4 modf (half4 param0, __private half4 *param1); -OVERLOADABLE half8 modf (half8 param0, __private half8 *param1); -OVERLOADABLE half16 modf (half16 param0, __private half16 *param1); - -//floatn remquo (floatn x, floatn y, __global intn *quo) - -OVERLOADABLE float2 remquo (float2 param0, float2 param1, __global int2 *param2); -OVERLOADABLE float3 remquo (float3 param0, float3 param1, __global int3 *param2); -OVERLOADABLE float4 remquo (float4 param0, float4 param1, __global int4 *param2); -OVERLOADABLE float8 remquo (float8 param0, float8 param1, __global int8 *param2); -OVERLOADABLE float16 remquo (float16 param0, float16 param1, __global int16 *param2); - -//floatn remquo (floatn x, floatn y, __local intn *quo) - -OVERLOADABLE float2 remquo (float2 param0, float2 param1, __local int2 *param2); -OVERLOADABLE float3 remquo (float3 param0, float3 param1, __local int3 *param2); -OVERLOADABLE float4 remquo (float4 param0, float4 param1, __local int4 *param2); -OVERLOADABLE float8 remquo (float8 param0, float8 param1, __local int8 *param2); -OVERLOADABLE float16 remquo (float16 param0, float16 param1, __local int16 *param2); - -//floatn remquo (floatn x, floatn y, __private intn *quo) - -OVERLOADABLE float2 remquo (float2 param0, float2 param1, __private int2 *param2); -OVERLOADABLE float3 remquo (float3 param0, float3 param1, __private int3 *param2); -OVERLOADABLE float4 remquo (float4 param0, float4 param1, __private int4 *param2); -OVERLOADABLE float8 remquo (float8 param0, float8 param1, __private int8 *param2); -OVERLOADABLE float16 remquo (float16 param0, float16 param1, __private int16 *param2); - -//float remquo (float x, float y, __global int *quo) - - -//float remquo (float x, float y, __local int *quo) - - -//float remquo (float x, float y, __private int *quo) - - -//halfn remquo (halfn x, halfn y, __global intn *quo) - -OVERLOADABLE half2 remquo (half2 param0, half2 param1, __global int2 *param2); -OVERLOADABLE half3 remquo (half3 param0, half3 param1, __global int3 *param2); -OVERLOADABLE half4 remquo (half4 param0, half4 param1, __global int4 *param2); -OVERLOADABLE half8 remquo (half8 param0, half8 param1, __global int8 *param2); -OVERLOADABLE half16 remquo (half16 param0, half16 param1, __global int16 *param2); - -//halfn remquo (halfn x, halfn y, __local intn *quo) - -OVERLOADABLE half2 remquo (half2 param0, half2 param1, __local int2 *param2); -OVERLOADABLE half3 remquo (half3 param0, half3 param1, __local int3 *param2); -OVERLOADABLE half4 remquo (half4 param0, half4 param1, __local int4 *param2); -OVERLOADABLE half8 remquo (half8 param0, half8 param1, __local int8 *param2); -OVERLOADABLE half16 remquo (half16 param0, half16 param1, __local int16 *param2); - -//halfn remquo (halfn x, halfn y, __private intn *quo) - -OVERLOADABLE half2 remquo (half2 param0, half2 param1, __private int2 *param2); -OVERLOADABLE half3 remquo (half3 param0, half3 param1, __private int3 *param2); -OVERLOADABLE half4 remquo (half4 param0, half4 param1, __private int4 *param2); -OVERLOADABLE half8 remquo (half8 param0, half8 param1, __private int8 *param2); -OVERLOADABLE half16 remquo (half16 param0, half16 param1, __private int16 *param2); - -//half remquo (half x, half y, __global int *quo) - - -//half remquo (half x, half y, __local int *quo) - - -//half remquo (half x, half y, __private int *quo) - - -//doublen remquo (doublen x, doublen y, __global intn *quo) - -OVERLOADABLE double2 remquo (double2 param0, double2 param1, __global int2 *param2); -OVERLOADABLE double3 remquo (double3 param0, double3 param1, __global int3 *param2); -OVERLOADABLE double4 remquo (double4 param0, double4 param1, __global int4 *param2); -OVERLOADABLE double8 remquo (double8 param0, double8 param1, __global int8 *param2); -OVERLOADABLE double16 remquo (double16 param0, double16 param1, __global int16 *param2); - -//doublen remquo (doublen x, doublen y, __local intn *quo) - -OVERLOADABLE double2 remquo (double2 param0, double2 param1, __local int2 *param2); -OVERLOADABLE double3 remquo (double3 param0, double3 param1, __local int3 *param2); -OVERLOADABLE double4 remquo (double4 param0, double4 param1, __local int4 *param2); -OVERLOADABLE double8 remquo (double8 param0, double8 param1, __local int8 *param2); -OVERLOADABLE double16 remquo (double16 param0, double16 param1, __local int16 *param2); - -//doublen remquo (doublen x, doublen y, __private intn *quo) - -OVERLOADABLE double2 remquo (double2 param0, double2 param1, __private int2 *param2); -OVERLOADABLE double3 remquo (double3 param0, double3 param1, __private int3 *param2); -OVERLOADABLE double4 remquo (double4 param0, double4 param1, __private int4 *param2); -OVERLOADABLE double8 remquo (double8 param0, double8 param1, __private int8 *param2); -OVERLOADABLE double16 remquo (double16 param0, double16 param1, __private int16 *param2); - -//double remquo (double x, double y, __global int *quo) - - -//double remquo (double x, double y, __local int *quo) - - -//double remquo (double x, double y, __private int *quo) - - -//gentype sincos (gentype x, __global gentype *cosval) - -OVERLOADABLE float2 sincos (float2 param0, __global float2 *param1); -OVERLOADABLE float3 sincos (float3 param0, __global float3 *param1); -OVERLOADABLE float4 sincos (float4 param0, __global float4 *param1); -OVERLOADABLE float8 sincos (float8 param0, __global float8 *param1); -OVERLOADABLE float16 sincos (float16 param0, __global float16 *param1); -OVERLOADABLE double2 sincos (double2 param0, __global double2 *param1); -OVERLOADABLE double3 sincos (double3 param0, __global double3 *param1); -OVERLOADABLE double4 sincos (double4 param0, __global double4 *param1); -OVERLOADABLE double8 sincos (double8 param0, __global double8 *param1); -OVERLOADABLE double16 sincos (double16 param0, __global double16 *param1); -OVERLOADABLE half2 sincos (half2 param0, __global half2 *param1); -OVERLOADABLE half3 sincos (half3 param0, __global half3 *param1); -OVERLOADABLE half4 sincos (half4 param0, __global half4 *param1); -OVERLOADABLE half8 sincos (half8 param0, __global half8 *param1); -OVERLOADABLE half16 sincos (half16 param0, __global half16 *param1); - -//gentype sincos (gentype x, __local gentype *cosval) - -OVERLOADABLE float2 sincos (float2 param0, __local float2 *param1); -OVERLOADABLE float3 sincos (float3 param0, __local float3 *param1); -OVERLOADABLE float4 sincos (float4 param0, __local float4 *param1); -OVERLOADABLE float8 sincos (float8 param0, __local float8 *param1); -OVERLOADABLE float16 sincos (float16 param0, __local float16 *param1); -OVERLOADABLE double2 sincos (double2 param0, __local double2 *param1); -OVERLOADABLE double3 sincos (double3 param0, __local double3 *param1); -OVERLOADABLE double4 sincos (double4 param0, __local double4 *param1); -OVERLOADABLE double8 sincos (double8 param0, __local double8 *param1); -OVERLOADABLE double16 sincos (double16 param0, __local double16 *param1); -OVERLOADABLE half2 sincos (half2 param0, __local half2 *param1); -OVERLOADABLE half3 sincos (half3 param0, __local half3 *param1); -OVERLOADABLE half4 sincos (half4 param0, __local half4 *param1); -OVERLOADABLE half8 sincos (half8 param0, __local half8 *param1); -OVERLOADABLE half16 sincos (half16 param0, __local half16 *param1); - -//gentype sincos (gentype x, __private gentype *cosval) - -OVERLOADABLE float2 sincos (float2 param0, __private float2 *param1); -OVERLOADABLE float3 sincos (float3 param0, __private float3 *param1); -OVERLOADABLE float4 sincos (float4 param0, __private float4 *param1); -OVERLOADABLE float8 sincos (float8 param0, __private float8 *param1); -OVERLOADABLE float16 sincos (float16 param0, __private float16 *param1); -OVERLOADABLE double2 sincos (double2 param0, __private double2 *param1); -OVERLOADABLE double3 sincos (double3 param0, __private double3 *param1); -OVERLOADABLE double4 sincos (double4 param0, __private double4 *param1); -OVERLOADABLE double8 sincos (double8 param0, __private double8 *param1); -OVERLOADABLE double16 sincos (double16 param0, __private double16 *param1); -OVERLOADABLE half2 sincos (half2 param0, __private half2 *param1); -OVERLOADABLE half3 sincos (half3 param0, __private half3 *param1); -OVERLOADABLE half4 sincos (half4 param0, __private half4 *param1); -OVERLOADABLE half8 sincos (half8 param0, __private half8 *param1); -OVERLOADABLE half16 sincos (half16 param0, __private half16 *param1); - -#endif diff --git a/drivers/pocl-gen7/lib/beignet/include/ocl_math_20.h b/drivers/pocl-gen7/lib/beignet/include/ocl_math_20.h deleted file mode 100644 index 1e183eb..0000000 --- a/drivers/pocl-gen7/lib/beignet/include/ocl_math_20.h +++ /dev/null @@ -1,202 +0,0 @@ -/* - * Copyright © 2012 - 2014 Intel Corporation - * - * This library is free software; you can redistribute it and/or - * modify it under the terms of the GNU Lesser General Public - * License as published by the Free Software Foundation; either - * version 2.1 of the License, or (at your option) any later version. - * - * This library is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU - * Lesser General Public License for more details. - * - * You should have received a copy of the GNU Lesser General Public - * License along with this library. If not, see . - * - */ -#ifndef __OCL_MATH_20_H__ -#define __OCL_MATH_20_H__ - -#include "ocl_types.h" -#include "ocl_math_common.h" - -OVERLOADABLE float lgamma_r(float x, int *signgamp); -OVERLOADABLE float sincos(float x, float *cosval); -OVERLOADABLE float modf(float x, float *i); -OVERLOADABLE float frexp(float x, int *exp); -OVERLOADABLE float fract(float x, float *p); -OVERLOADABLE float remquo(float x, float y, int *quo); - -OVERLOADABLE half lgamma_r(half x, int *signgamp); -OVERLOADABLE half sincos(half x, half *cosval); -OVERLOADABLE half frexp(half x, int *exp); -OVERLOADABLE half modf(half x, half *i); -OVERLOADABLE half fract(half x, half *p); -OVERLOADABLE half remquo(half x, half y, int *quo); - -//------- double ----------- -OVERLOADABLE double fract(double x, double *p); -OVERLOADABLE double frexp(double x, int *exp); -OVERLOADABLE double lgamma_r(double x, int *signgamp); -OVERLOADABLE double modf(double x, double *i); -OVERLOADABLE double remquo(double x, double y, int *quo); -OVERLOADABLE double sincos(double x, double *cosval); - -//Begin from this part is autogenerated. -//Don't modify it manually. -//math builtin functions -//gentype fract (gentype x, __generic gentype *iptr) - -OVERLOADABLE float2 fract (float2 param0, __generic float2 *param1); -OVERLOADABLE float3 fract (float3 param0, __generic float3 *param1); -OVERLOADABLE float4 fract (float4 param0, __generic float4 *param1); -OVERLOADABLE float8 fract (float8 param0, __generic float8 *param1); -OVERLOADABLE float16 fract (float16 param0, __generic float16 *param1); -OVERLOADABLE double2 fract (double2 param0, __generic double2 *param1); -OVERLOADABLE double3 fract (double3 param0, __generic double3 *param1); -OVERLOADABLE double4 fract (double4 param0, __generic double4 *param1); -OVERLOADABLE double8 fract (double8 param0, __generic double8 *param1); -OVERLOADABLE double16 fract (double16 param0, __generic double16 *param1); -OVERLOADABLE half2 fract (half2 param0, __generic half2 *param1); -OVERLOADABLE half3 fract (half3 param0, __generic half3 *param1); -OVERLOADABLE half4 fract (half4 param0, __generic half4 *param1); -OVERLOADABLE half8 fract (half8 param0, __generic half8 *param1); -OVERLOADABLE half16 fract (half16 param0, __generic half16 *param1); - -//floatn frexp (floatn x, __generic intn *exp) - -OVERLOADABLE float2 frexp (float2 param0, __generic int2 *param1); -OVERLOADABLE float3 frexp (float3 param0, __generic int3 *param1); -OVERLOADABLE float4 frexp (float4 param0, __generic int4 *param1); -OVERLOADABLE float8 frexp (float8 param0, __generic int8 *param1); -OVERLOADABLE float16 frexp (float16 param0, __generic int16 *param1); - -//float frexp (float x, __generic int *exp) - - -//halfn frexp (halfn x, __generic intn *exp) - -OVERLOADABLE half2 frexp (half2 param0, __generic int2 *param1); -OVERLOADABLE half3 frexp (half3 param0, __generic int3 *param1); -OVERLOADABLE half4 frexp (half4 param0, __generic int4 *param1); -OVERLOADABLE half8 frexp (half8 param0, __generic int8 *param1); -OVERLOADABLE half16 frexp (half16 param0, __generic int16 *param1); - -//half frexp (half x, __generic int *exp) - - -//doublen frexp (doublen x, __generic intn *exp) - -OVERLOADABLE double2 frexp (double2 param0, __generic int2 *param1); -OVERLOADABLE double3 frexp (double3 param0, __generic int3 *param1); -OVERLOADABLE double4 frexp (double4 param0, __generic int4 *param1); -OVERLOADABLE double8 frexp (double8 param0, __generic int8 *param1); -OVERLOADABLE double16 frexp (double16 param0, __generic int16 *param1); - -//double frexp (double x, __generic int *exp) - - -//floatn lgamma_r (floatn x, __generic intn *signp) - -OVERLOADABLE float2 lgamma_r (float2 param0, __generic int2 *param1); -OVERLOADABLE float3 lgamma_r (float3 param0, __generic int3 *param1); -OVERLOADABLE float4 lgamma_r (float4 param0, __generic int4 *param1); -OVERLOADABLE float8 lgamma_r (float8 param0, __generic int8 *param1); -OVERLOADABLE float16 lgamma_r (float16 param0, __generic int16 *param1); - -//float lgamma_r (float x, __generic int *signp) - - -//halfn lgamma_r (halfn x, __generic intn *signp) - -OVERLOADABLE half2 lgamma_r (half2 param0, __generic int2 *param1); -OVERLOADABLE half3 lgamma_r (half3 param0, __generic int3 *param1); -OVERLOADABLE half4 lgamma_r (half4 param0, __generic int4 *param1); -OVERLOADABLE half8 lgamma_r (half8 param0, __generic int8 *param1); -OVERLOADABLE half16 lgamma_r (half16 param0, __generic int16 *param1); - -//half lgamma_r (half x, __generic int *signp) - - -//doublen lgamma_r (doublen x, __generic intn *signp) - -OVERLOADABLE double2 lgamma_r (double2 param0, __generic int2 *param1); -OVERLOADABLE double3 lgamma_r (double3 param0, __generic int3 *param1); -OVERLOADABLE double4 lgamma_r (double4 param0, __generic int4 *param1); -OVERLOADABLE double8 lgamma_r (double8 param0, __generic int8 *param1); -OVERLOADABLE double16 lgamma_r (double16 param0, __generic int16 *param1); - -//double lgamma_r (double x, __generic int *signp) - - -//gentype modf (gentype x, __generic gentype *iptr) - -OVERLOADABLE float2 modf (float2 param0, __generic float2 *param1); -OVERLOADABLE float3 modf (float3 param0, __generic float3 *param1); -OVERLOADABLE float4 modf (float4 param0, __generic float4 *param1); -OVERLOADABLE float8 modf (float8 param0, __generic float8 *param1); -OVERLOADABLE float16 modf (float16 param0, __generic float16 *param1); -OVERLOADABLE double2 modf (double2 param0, __generic double2 *param1); -OVERLOADABLE double3 modf (double3 param0, __generic double3 *param1); -OVERLOADABLE double4 modf (double4 param0, __generic double4 *param1); -OVERLOADABLE double8 modf (double8 param0, __generic double8 *param1); -OVERLOADABLE double16 modf (double16 param0, __generic double16 *param1); -OVERLOADABLE half2 modf (half2 param0, __generic half2 *param1); -OVERLOADABLE half3 modf (half3 param0, __generic half3 *param1); -OVERLOADABLE half4 modf (half4 param0, __generic half4 *param1); -OVERLOADABLE half8 modf (half8 param0, __generic half8 *param1); -OVERLOADABLE half16 modf (half16 param0, __generic half16 *param1); - -//floatn remquo (floatn x, floatn y, __generic intn *quo) - -OVERLOADABLE float2 remquo (float2 param0, float2 param1, __generic int2 *param2); -OVERLOADABLE float3 remquo (float3 param0, float3 param1, __generic int3 *param2); -OVERLOADABLE float4 remquo (float4 param0, float4 param1, __generic int4 *param2); -OVERLOADABLE float8 remquo (float8 param0, float8 param1, __generic int8 *param2); -OVERLOADABLE float16 remquo (float16 param0, float16 param1, __generic int16 *param2); - -//float remquo (float x, float y, __generic int *quo) - - -//halfn remquo (halfn x, halfn y, __generic intn *quo) - -OVERLOADABLE half2 remquo (half2 param0, half2 param1, __generic int2 *param2); -OVERLOADABLE half3 remquo (half3 param0, half3 param1, __generic int3 *param2); -OVERLOADABLE half4 remquo (half4 param0, half4 param1, __generic int4 *param2); -OVERLOADABLE half8 remquo (half8 param0, half8 param1, __generic int8 *param2); -OVERLOADABLE half16 remquo (half16 param0, half16 param1, __generic int16 *param2); - -//half remquo (half x, half y, __generic int *quo) - - -//doublen remquo (doublen x, doublen y, __generic intn *quo) - -OVERLOADABLE double2 remquo (double2 param0, double2 param1, __generic int2 *param2); -OVERLOADABLE double3 remquo (double3 param0, double3 param1, __generic int3 *param2); -OVERLOADABLE double4 remquo (double4 param0, double4 param1, __generic int4 *param2); -OVERLOADABLE double8 remquo (double8 param0, double8 param1, __generic int8 *param2); -OVERLOADABLE double16 remquo (double16 param0, double16 param1, __generic int16 *param2); - -//double remquo (double x, double y, __generic int *quo) - - -//gentype sincos (gentype x, __generic gentype *cosval) - -OVERLOADABLE float2 sincos (float2 param0, __generic float2 *param1); -OVERLOADABLE float3 sincos (float3 param0, __generic float3 *param1); -OVERLOADABLE float4 sincos (float4 param0, __generic float4 *param1); -OVERLOADABLE float8 sincos (float8 param0, __generic float8 *param1); -OVERLOADABLE float16 sincos (float16 param0, __generic float16 *param1); -OVERLOADABLE double2 sincos (double2 param0, __generic double2 *param1); -OVERLOADABLE double3 sincos (double3 param0, __generic double3 *param1); -OVERLOADABLE double4 sincos (double4 param0, __generic double4 *param1); -OVERLOADABLE double8 sincos (double8 param0, __generic double8 *param1); -OVERLOADABLE double16 sincos (double16 param0, __generic double16 *param1); -OVERLOADABLE half2 sincos (half2 param0, __generic half2 *param1); -OVERLOADABLE half3 sincos (half3 param0, __generic half3 *param1); -OVERLOADABLE half4 sincos (half4 param0, __generic half4 *param1); -OVERLOADABLE half8 sincos (half8 param0, __generic half8 *param1); -OVERLOADABLE half16 sincos (half16 param0, __generic half16 *param1); - -#endif diff --git a/drivers/pocl-gen7/lib/beignet/include/ocl_math_common.h b/drivers/pocl-gen7/lib/beignet/include/ocl_math_common.h deleted file mode 100644 index c502891..0000000 --- a/drivers/pocl-gen7/lib/beignet/include/ocl_math_common.h +++ /dev/null @@ -1,1995 +0,0 @@ -/* - * Copyright © 2012 - 2014 Intel Corporation - * - * This library is free software; you can redistribute it and/or - * modify it under the terms of the GNU Lesser General Public - * License as published by the Free Software Foundation; either - * version 2.1 of the License, or (at your option) any later version. - * - * This library is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU - * Lesser General Public License for more details. - * - * You should have received a copy of the GNU Lesser General Public - * License along with this library. If not, see . - * - */ -#ifndef __OCL_MATH_COMMON_H__ -#define __OCL_MATH_COMMON_H__ - -#include "ocl_types.h" - -OVERLOADABLE float cospi(float x); -OVERLOADABLE float cosh(float x); -OVERLOADABLE float acos(float x); -OVERLOADABLE float acospi(float x); -OVERLOADABLE float acosh(float x); -OVERLOADABLE float sinpi(float x); -OVERLOADABLE float sinh(float x); -OVERLOADABLE float asin(float x); -OVERLOADABLE float asinpi(float x); -OVERLOADABLE float asinh(float x); -OVERLOADABLE float tanpi(float x); -OVERLOADABLE float tanh(float x); -OVERLOADABLE float atan(float x); -OVERLOADABLE float atan2(float y, float x); -OVERLOADABLE float atan2pi(float y, float x); -OVERLOADABLE float atanpi(float x); -OVERLOADABLE float atanh(float x); -OVERLOADABLE float cbrt(float x); -OVERLOADABLE float rint(float x); -OVERLOADABLE float copysign(float x, float y); -OVERLOADABLE float erf(float x); -OVERLOADABLE float erfc(float x); -OVERLOADABLE float fmod (float x, float y); -OVERLOADABLE float remainder(float x, float p); -OVERLOADABLE float ldexp(float x, int n); -OVERLOADABLE float powr(float x, float y); -OVERLOADABLE float pow(float x, float y); -//no pow, we use powr instead -OVERLOADABLE float fabs(float x); -OVERLOADABLE float trunc(float x); -OVERLOADABLE float round(float x); -OVERLOADABLE float floor(float x); -OVERLOADABLE float ceil(float x); -OVERLOADABLE float log(float x); -OVERLOADABLE float log2(float x); -OVERLOADABLE float log10(float x); -OVERLOADABLE float exp(float x); -OVERLOADABLE float exp10(float x); -OVERLOADABLE float expm1(float x); -OVERLOADABLE float fmin(float a, float b); -OVERLOADABLE float fmax(float a, float b); -OVERLOADABLE float fma(float a, float b, float c); -OVERLOADABLE float fdim(float x, float y); -OVERLOADABLE float maxmag(float x, float y); -OVERLOADABLE float minmag(float x, float y); -OVERLOADABLE float exp2(float x); -OVERLOADABLE float mad(float a, float b, float c); -OVERLOADABLE float sin(float x); -OVERLOADABLE float cos(float x); -OVERLOADABLE float tan(float x); -OVERLOADABLE float tgamma(float x); -OVERLOADABLE float lgamma(float x); - -OVERLOADABLE float log1p(float x); -OVERLOADABLE float logb(float x); -OVERLOADABLE int ilogb(float x); -OVERLOADABLE float nan(uint code); -OVERLOADABLE float sqrt(float x); -OVERLOADABLE float rsqrt(float x); -OVERLOADABLE float hypot(float x, float y); -OVERLOADABLE float nextafter(float x, float y); -OVERLOADABLE float pown(float x, int n); -OVERLOADABLE float rootn(float x, int n); - -// native -OVERLOADABLE float native_cos(float x); -OVERLOADABLE float native_divide(float x, float y); -OVERLOADABLE float native_exp(float x); -OVERLOADABLE float native_exp2(float x); -OVERLOADABLE float native_exp10(float x); -OVERLOADABLE float native_log(float x); -OVERLOADABLE float native_log2(float x); -OVERLOADABLE float native_log10(float x); -OVERLOADABLE float native_powr(float x, float y); -OVERLOADABLE float native_recip(float x); -OVERLOADABLE float native_rsqrt(float x); -OVERLOADABLE float native_sin(float x); -OVERLOADABLE float native_sqrt(float x); -OVERLOADABLE float native_tan(float x); - - -// Half float version. -OVERLOADABLE half cospi(half x); -OVERLOADABLE half cosh(half x); -OVERLOADABLE half acos(half x); -OVERLOADABLE half acospi(half x); -OVERLOADABLE half acosh(half x); -OVERLOADABLE half sinpi(half x); -OVERLOADABLE half sinh(half x); -OVERLOADABLE half asin(half x); -OVERLOADABLE half asinpi(half x); -OVERLOADABLE half asinh(half x); -OVERLOADABLE half tanpi(half x); -OVERLOADABLE half tanh(half x); -OVERLOADABLE half atan(half x); -OVERLOADABLE half atan2(half y, half x); -OVERLOADABLE half atan2pi(half y, half x); -OVERLOADABLE half atanpi(half x); -OVERLOADABLE half atanh(half x); -OVERLOADABLE half cbrt(half x); -OVERLOADABLE half rint(half x); -OVERLOADABLE half copysign(half x, half y); -OVERLOADABLE half erf(half x); -OVERLOADABLE half erfc(half x); -OVERLOADABLE half fmod (half x, half y); -OVERLOADABLE half remainder(half x, half p); -OVERLOADABLE half ldexp(half x, int n); -OVERLOADABLE half powr(half x, half y); -OVERLOADABLE half pow(half x, half y); -//no pow, we use powr instead -OVERLOADABLE half fabs(half x); -OVERLOADABLE half trunc(half x); -OVERLOADABLE half round(half x); -OVERLOADABLE half floor(half x); -OVERLOADABLE half ceil(half x); -OVERLOADABLE half log(half x); -OVERLOADABLE half log2(half x); -OVERLOADABLE half log10(half x); -OVERLOADABLE half exp(half x); -OVERLOADABLE half exp10(half x); -OVERLOADABLE half expm1(half x); -OVERLOADABLE half fmin(half a, half b); -OVERLOADABLE half fmax(half a, half b); -OVERLOADABLE half fma(half a, half b, half c); -OVERLOADABLE half fdim(half x, half y); -OVERLOADABLE half maxmag(half x, half y); -OVERLOADABLE half minmag(half x, half y); -OVERLOADABLE half exp2(half x); -OVERLOADABLE half mad(half a, half b, half c); -OVERLOADABLE half sin(half x); -OVERLOADABLE half cos(half x); -OVERLOADABLE half tan(half x); -OVERLOADABLE half tgamma(half x); -OVERLOADABLE half lgamma(half x); -OVERLOADABLE half log1p(half x); -OVERLOADABLE half logb(half x); -OVERLOADABLE int ilogb(half x); -OVERLOADABLE half nan(ushort code); -OVERLOADABLE half pown(half x, int n); -OVERLOADABLE half rootn(half x, int n); -OVERLOADABLE half hypot(half x, half y); -OVERLOADABLE half nextafter(half x, half y); -OVERLOADABLE half sqrt(half x); -OVERLOADABLE half rsqrt(half x); - - -// native half -OVERLOADABLE half native_cos(half x); -OVERLOADABLE half native_divide(half x, half y); -OVERLOADABLE half native_exp(half x); -OVERLOADABLE half native_exp2(half x); -OVERLOADABLE half native_exp10(half x); -OVERLOADABLE half native_log(half x); -OVERLOADABLE half native_log2(half x); -OVERLOADABLE half native_log10(half x); -OVERLOADABLE half native_powr(half x, half y); -OVERLOADABLE half native_recip(half x); -OVERLOADABLE half native_rsqrt(half x); -OVERLOADABLE half native_sin(half x); -OVERLOADABLE half native_sqrt(half x); -OVERLOADABLE half native_tan(half x); - -// half accuracy -OVERLOADABLE float half_cos(float x); -OVERLOADABLE float half_divide(float x, float y); -OVERLOADABLE float half_exp(float x); -OVERLOADABLE float half_exp2(float x); -OVERLOADABLE float half_exp10(float x); -OVERLOADABLE float half_log(float x); -OVERLOADABLE float half_log2(float x); -OVERLOADABLE float half_log10(float x); -OVERLOADABLE float half_powr(float x, float y); -OVERLOADABLE float half_recip(float x); -OVERLOADABLE float half_rsqrt(float x); -OVERLOADABLE float half_sin(float x); -OVERLOADABLE float half_sqrt(float x); -OVERLOADABLE float half_tan(float x); - - -OVERLOADABLE double acos(double x); -OVERLOADABLE double acospi(double x); -OVERLOADABLE double acosh(double x); -OVERLOADABLE double asin(double x); -OVERLOADABLE double asinpi(double x); -OVERLOADABLE double asinh(double x); -OVERLOADABLE double atan(double x); -OVERLOADABLE double atan2(double x, double y); -OVERLOADABLE double atanpi(double x); -OVERLOADABLE double atan2pi(double x, double y); -OVERLOADABLE double atanh(double x); -OVERLOADABLE double exp(double x); -OVERLOADABLE double expm1(double x); -OVERLOADABLE double exp2(double x); -OVERLOADABLE double exp10(double x); -OVERLOADABLE double erf(double x); -OVERLOADABLE double erfc(double x); -OVERLOADABLE double cbrt(double x); -OVERLOADABLE double ceil(double x); -OVERLOADABLE double copysign(double x, double y); -OVERLOADABLE double cos(double x); -OVERLOADABLE double cosh(double x); -OVERLOADABLE double cospi(double x); -OVERLOADABLE double fabs(double x); -OVERLOADABLE double fdim(double x, double y); -OVERLOADABLE double floor(double x); -OVERLOADABLE double fmax(double a, double b); -OVERLOADABLE double fmin(double a, double b); -OVERLOADABLE double fmod (double x, double y); -OVERLOADABLE double fma(double x, double y, double z); -OVERLOADABLE double maxmag(double x, double y); -OVERLOADABLE double minmag(double x, double y); -OVERLOADABLE double hypot(double x, double y); -OVERLOADABLE double ldexp(double x, int n); -OVERLOADABLE double log(double x); -OVERLOADABLE double log2(double x); -OVERLOADABLE double log10(double x); -OVERLOADABLE double log1p(double x); -OVERLOADABLE double logb(double x); -OVERLOADABLE int ilogb(double x); -OVERLOADABLE double lgamma(double x); -OVERLOADABLE double mad(double a, double b, double c); -OVERLOADABLE double nan(ulong code); -OVERLOADABLE double nextafter(double x, double y); -OVERLOADABLE double pow(double x, double y); -OVERLOADABLE double pown(double x, int n); -OVERLOADABLE double powr(double x, double y); -OVERLOADABLE double remainder(double x, double p); -OVERLOADABLE double rint(double x); -OVERLOADABLE double round(double x); -OVERLOADABLE double rootn(double x, int n); -OVERLOADABLE double rsqrt(double x); -OVERLOADABLE double sin(double x); -OVERLOADABLE double sinh(double x); -OVERLOADABLE double sinpi(double x); -OVERLOADABLE double sqrt(double x); -OVERLOADABLE double tan(double x); -OVERLOADABLE double tanh(double x); -OVERLOADABLE double tanpi(double x); -OVERLOADABLE double tgamma(double x); -OVERLOADABLE double trunc(double x); - - - -//Begin from this part is autogenerated. -//Don't modify it manually. -//math builtin functions -//gentype acos (gentype) - -OVERLOADABLE float2 acos (float2 param0); -OVERLOADABLE float3 acos (float3 param0); -OVERLOADABLE float4 acos (float4 param0); -OVERLOADABLE float8 acos (float8 param0); -OVERLOADABLE float16 acos (float16 param0); -OVERLOADABLE double2 acos (double2 param0); -OVERLOADABLE double3 acos (double3 param0); -OVERLOADABLE double4 acos (double4 param0); -OVERLOADABLE double8 acos (double8 param0); -OVERLOADABLE double16 acos (double16 param0); -OVERLOADABLE half2 acos (half2 param0); -OVERLOADABLE half3 acos (half3 param0); -OVERLOADABLE half4 acos (half4 param0); -OVERLOADABLE half8 acos (half8 param0); -OVERLOADABLE half16 acos (half16 param0); - -//gentype acosh (gentype) - -OVERLOADABLE float2 acosh (float2 param0); -OVERLOADABLE float3 acosh (float3 param0); -OVERLOADABLE float4 acosh (float4 param0); -OVERLOADABLE float8 acosh (float8 param0); -OVERLOADABLE float16 acosh (float16 param0); -OVERLOADABLE double2 acosh (double2 param0); -OVERLOADABLE double3 acosh (double3 param0); -OVERLOADABLE double4 acosh (double4 param0); -OVERLOADABLE double8 acosh (double8 param0); -OVERLOADABLE double16 acosh (double16 param0); -OVERLOADABLE half2 acosh (half2 param0); -OVERLOADABLE half3 acosh (half3 param0); -OVERLOADABLE half4 acosh (half4 param0); -OVERLOADABLE half8 acosh (half8 param0); -OVERLOADABLE half16 acosh (half16 param0); - -//gentype acospi (gentype x) - -OVERLOADABLE float2 acospi (float2 param0); -OVERLOADABLE float3 acospi (float3 param0); -OVERLOADABLE float4 acospi (float4 param0); -OVERLOADABLE float8 acospi (float8 param0); -OVERLOADABLE float16 acospi (float16 param0); -OVERLOADABLE double2 acospi (double2 param0); -OVERLOADABLE double3 acospi (double3 param0); -OVERLOADABLE double4 acospi (double4 param0); -OVERLOADABLE double8 acospi (double8 param0); -OVERLOADABLE double16 acospi (double16 param0); -OVERLOADABLE half2 acospi (half2 param0); -OVERLOADABLE half3 acospi (half3 param0); -OVERLOADABLE half4 acospi (half4 param0); -OVERLOADABLE half8 acospi (half8 param0); -OVERLOADABLE half16 acospi (half16 param0); - -//gentype asin (gentype) - -OVERLOADABLE float2 asin (float2 param0); -OVERLOADABLE float3 asin (float3 param0); -OVERLOADABLE float4 asin (float4 param0); -OVERLOADABLE float8 asin (float8 param0); -OVERLOADABLE float16 asin (float16 param0); -OVERLOADABLE double2 asin (double2 param0); -OVERLOADABLE double3 asin (double3 param0); -OVERLOADABLE double4 asin (double4 param0); -OVERLOADABLE double8 asin (double8 param0); -OVERLOADABLE double16 asin (double16 param0); -OVERLOADABLE half2 asin (half2 param0); -OVERLOADABLE half3 asin (half3 param0); -OVERLOADABLE half4 asin (half4 param0); -OVERLOADABLE half8 asin (half8 param0); -OVERLOADABLE half16 asin (half16 param0); - -//gentype asinh (gentype) - -OVERLOADABLE float2 asinh (float2 param0); -OVERLOADABLE float3 asinh (float3 param0); -OVERLOADABLE float4 asinh (float4 param0); -OVERLOADABLE float8 asinh (float8 param0); -OVERLOADABLE float16 asinh (float16 param0); -OVERLOADABLE double2 asinh (double2 param0); -OVERLOADABLE double3 asinh (double3 param0); -OVERLOADABLE double4 asinh (double4 param0); -OVERLOADABLE double8 asinh (double8 param0); -OVERLOADABLE double16 asinh (double16 param0); -OVERLOADABLE half2 asinh (half2 param0); -OVERLOADABLE half3 asinh (half3 param0); -OVERLOADABLE half4 asinh (half4 param0); -OVERLOADABLE half8 asinh (half8 param0); -OVERLOADABLE half16 asinh (half16 param0); - -//gentype asinpi (gentype x) - -OVERLOADABLE float2 asinpi (float2 param0); -OVERLOADABLE float3 asinpi (float3 param0); -OVERLOADABLE float4 asinpi (float4 param0); -OVERLOADABLE float8 asinpi (float8 param0); -OVERLOADABLE float16 asinpi (float16 param0); -OVERLOADABLE double2 asinpi (double2 param0); -OVERLOADABLE double3 asinpi (double3 param0); -OVERLOADABLE double4 asinpi (double4 param0); -OVERLOADABLE double8 asinpi (double8 param0); -OVERLOADABLE double16 asinpi (double16 param0); -OVERLOADABLE half2 asinpi (half2 param0); -OVERLOADABLE half3 asinpi (half3 param0); -OVERLOADABLE half4 asinpi (half4 param0); -OVERLOADABLE half8 asinpi (half8 param0); -OVERLOADABLE half16 asinpi (half16 param0); - -//gentype atan (gentype y_over_x) - -OVERLOADABLE float2 atan (float2 param0); -OVERLOADABLE float3 atan (float3 param0); -OVERLOADABLE float4 atan (float4 param0); -OVERLOADABLE float8 atan (float8 param0); -OVERLOADABLE float16 atan (float16 param0); -OVERLOADABLE double2 atan (double2 param0); -OVERLOADABLE double3 atan (double3 param0); -OVERLOADABLE double4 atan (double4 param0); -OVERLOADABLE double8 atan (double8 param0); -OVERLOADABLE double16 atan (double16 param0); -OVERLOADABLE half2 atan (half2 param0); -OVERLOADABLE half3 atan (half3 param0); -OVERLOADABLE half4 atan (half4 param0); -OVERLOADABLE half8 atan (half8 param0); -OVERLOADABLE half16 atan (half16 param0); - -//gentype atan2 (gentype y, gentype x) - -OVERLOADABLE float2 atan2 (float2 param0, float2 param1); -OVERLOADABLE float3 atan2 (float3 param0, float3 param1); -OVERLOADABLE float4 atan2 (float4 param0, float4 param1); -OVERLOADABLE float8 atan2 (float8 param0, float8 param1); -OVERLOADABLE float16 atan2 (float16 param0, float16 param1); -OVERLOADABLE double2 atan2 (double2 param0, double2 param1); -OVERLOADABLE double3 atan2 (double3 param0, double3 param1); -OVERLOADABLE double4 atan2 (double4 param0, double4 param1); -OVERLOADABLE double8 atan2 (double8 param0, double8 param1); -OVERLOADABLE double16 atan2 (double16 param0, double16 param1); -OVERLOADABLE half2 atan2 (half2 param0, half2 param1); -OVERLOADABLE half3 atan2 (half3 param0, half3 param1); -OVERLOADABLE half4 atan2 (half4 param0, half4 param1); -OVERLOADABLE half8 atan2 (half8 param0, half8 param1); -OVERLOADABLE half16 atan2 (half16 param0, half16 param1); - -//gentype atanh (gentype) - -OVERLOADABLE float2 atanh (float2 param0); -OVERLOADABLE float3 atanh (float3 param0); -OVERLOADABLE float4 atanh (float4 param0); -OVERLOADABLE float8 atanh (float8 param0); -OVERLOADABLE float16 atanh (float16 param0); -OVERLOADABLE double2 atanh (double2 param0); -OVERLOADABLE double3 atanh (double3 param0); -OVERLOADABLE double4 atanh (double4 param0); -OVERLOADABLE double8 atanh (double8 param0); -OVERLOADABLE double16 atanh (double16 param0); -OVERLOADABLE half2 atanh (half2 param0); -OVERLOADABLE half3 atanh (half3 param0); -OVERLOADABLE half4 atanh (half4 param0); -OVERLOADABLE half8 atanh (half8 param0); -OVERLOADABLE half16 atanh (half16 param0); - -//gentype atanpi (gentype x) - -OVERLOADABLE float2 atanpi (float2 param0); -OVERLOADABLE float3 atanpi (float3 param0); -OVERLOADABLE float4 atanpi (float4 param0); -OVERLOADABLE float8 atanpi (float8 param0); -OVERLOADABLE float16 atanpi (float16 param0); -OVERLOADABLE double2 atanpi (double2 param0); -OVERLOADABLE double3 atanpi (double3 param0); -OVERLOADABLE double4 atanpi (double4 param0); -OVERLOADABLE double8 atanpi (double8 param0); -OVERLOADABLE double16 atanpi (double16 param0); -OVERLOADABLE half2 atanpi (half2 param0); -OVERLOADABLE half3 atanpi (half3 param0); -OVERLOADABLE half4 atanpi (half4 param0); -OVERLOADABLE half8 atanpi (half8 param0); -OVERLOADABLE half16 atanpi (half16 param0); - -//gentype atan2pi (gentype y, gentype x) - -OVERLOADABLE float2 atan2pi (float2 param0, float2 param1); -OVERLOADABLE float3 atan2pi (float3 param0, float3 param1); -OVERLOADABLE float4 atan2pi (float4 param0, float4 param1); -OVERLOADABLE float8 atan2pi (float8 param0, float8 param1); -OVERLOADABLE float16 atan2pi (float16 param0, float16 param1); -OVERLOADABLE double2 atan2pi (double2 param0, double2 param1); -OVERLOADABLE double3 atan2pi (double3 param0, double3 param1); -OVERLOADABLE double4 atan2pi (double4 param0, double4 param1); -OVERLOADABLE double8 atan2pi (double8 param0, double8 param1); -OVERLOADABLE double16 atan2pi (double16 param0, double16 param1); -OVERLOADABLE half2 atan2pi (half2 param0, half2 param1); -OVERLOADABLE half3 atan2pi (half3 param0, half3 param1); -OVERLOADABLE half4 atan2pi (half4 param0, half4 param1); -OVERLOADABLE half8 atan2pi (half8 param0, half8 param1); -OVERLOADABLE half16 atan2pi (half16 param0, half16 param1); - -//gentype cbrt (gentype) - -OVERLOADABLE float2 cbrt (float2 param0); -OVERLOADABLE float3 cbrt (float3 param0); -OVERLOADABLE float4 cbrt (float4 param0); -OVERLOADABLE float8 cbrt (float8 param0); -OVERLOADABLE float16 cbrt (float16 param0); -OVERLOADABLE double2 cbrt (double2 param0); -OVERLOADABLE double3 cbrt (double3 param0); -OVERLOADABLE double4 cbrt (double4 param0); -OVERLOADABLE double8 cbrt (double8 param0); -OVERLOADABLE double16 cbrt (double16 param0); -OVERLOADABLE half2 cbrt (half2 param0); -OVERLOADABLE half3 cbrt (half3 param0); -OVERLOADABLE half4 cbrt (half4 param0); -OVERLOADABLE half8 cbrt (half8 param0); -OVERLOADABLE half16 cbrt (half16 param0); - -//gentype ceil (gentype) - -OVERLOADABLE float2 ceil (float2 param0); -OVERLOADABLE float3 ceil (float3 param0); -OVERLOADABLE float4 ceil (float4 param0); -OVERLOADABLE float8 ceil (float8 param0); -OVERLOADABLE float16 ceil (float16 param0); -OVERLOADABLE double2 ceil (double2 param0); -OVERLOADABLE double3 ceil (double3 param0); -OVERLOADABLE double4 ceil (double4 param0); -OVERLOADABLE double8 ceil (double8 param0); -OVERLOADABLE double16 ceil (double16 param0); -OVERLOADABLE half2 ceil (half2 param0); -OVERLOADABLE half3 ceil (half3 param0); -OVERLOADABLE half4 ceil (half4 param0); -OVERLOADABLE half8 ceil (half8 param0); -OVERLOADABLE half16 ceil (half16 param0); - -//gentype copysign (gentype x, gentype y) - -OVERLOADABLE float2 copysign (float2 param0, float2 param1); -OVERLOADABLE float3 copysign (float3 param0, float3 param1); -OVERLOADABLE float4 copysign (float4 param0, float4 param1); -OVERLOADABLE float8 copysign (float8 param0, float8 param1); -OVERLOADABLE float16 copysign (float16 param0, float16 param1); -OVERLOADABLE double2 copysign (double2 param0, double2 param1); -OVERLOADABLE double3 copysign (double3 param0, double3 param1); -OVERLOADABLE double4 copysign (double4 param0, double4 param1); -OVERLOADABLE double8 copysign (double8 param0, double8 param1); -OVERLOADABLE double16 copysign (double16 param0, double16 param1); -OVERLOADABLE half2 copysign (half2 param0, half2 param1); -OVERLOADABLE half3 copysign (half3 param0, half3 param1); -OVERLOADABLE half4 copysign (half4 param0, half4 param1); -OVERLOADABLE half8 copysign (half8 param0, half8 param1); -OVERLOADABLE half16 copysign (half16 param0, half16 param1); - -//gentype cos (gentype) - -OVERLOADABLE float2 cos (float2 param0); -OVERLOADABLE float3 cos (float3 param0); -OVERLOADABLE float4 cos (float4 param0); -OVERLOADABLE float8 cos (float8 param0); -OVERLOADABLE float16 cos (float16 param0); -OVERLOADABLE double2 cos (double2 param0); -OVERLOADABLE double3 cos (double3 param0); -OVERLOADABLE double4 cos (double4 param0); -OVERLOADABLE double8 cos (double8 param0); -OVERLOADABLE double16 cos (double16 param0); -OVERLOADABLE half2 cos (half2 param0); -OVERLOADABLE half3 cos (half3 param0); -OVERLOADABLE half4 cos (half4 param0); -OVERLOADABLE half8 cos (half8 param0); -OVERLOADABLE half16 cos (half16 param0); - -//gentype cosh (gentype) - -OVERLOADABLE float2 cosh (float2 param0); -OVERLOADABLE float3 cosh (float3 param0); -OVERLOADABLE float4 cosh (float4 param0); -OVERLOADABLE float8 cosh (float8 param0); -OVERLOADABLE float16 cosh (float16 param0); -OVERLOADABLE double2 cosh (double2 param0); -OVERLOADABLE double3 cosh (double3 param0); -OVERLOADABLE double4 cosh (double4 param0); -OVERLOADABLE double8 cosh (double8 param0); -OVERLOADABLE double16 cosh (double16 param0); -OVERLOADABLE half2 cosh (half2 param0); -OVERLOADABLE half3 cosh (half3 param0); -OVERLOADABLE half4 cosh (half4 param0); -OVERLOADABLE half8 cosh (half8 param0); -OVERLOADABLE half16 cosh (half16 param0); - -//gentype cospi (gentype x) - -OVERLOADABLE float2 cospi (float2 param0); -OVERLOADABLE float3 cospi (float3 param0); -OVERLOADABLE float4 cospi (float4 param0); -OVERLOADABLE float8 cospi (float8 param0); -OVERLOADABLE float16 cospi (float16 param0); -OVERLOADABLE double2 cospi (double2 param0); -OVERLOADABLE double3 cospi (double3 param0); -OVERLOADABLE double4 cospi (double4 param0); -OVERLOADABLE double8 cospi (double8 param0); -OVERLOADABLE double16 cospi (double16 param0); -OVERLOADABLE half2 cospi (half2 param0); -OVERLOADABLE half3 cospi (half3 param0); -OVERLOADABLE half4 cospi (half4 param0); -OVERLOADABLE half8 cospi (half8 param0); -OVERLOADABLE half16 cospi (half16 param0); - -//gentype erfc (gentype) - -OVERLOADABLE float2 erfc (float2 param0); -OVERLOADABLE float3 erfc (float3 param0); -OVERLOADABLE float4 erfc (float4 param0); -OVERLOADABLE float8 erfc (float8 param0); -OVERLOADABLE float16 erfc (float16 param0); -OVERLOADABLE double2 erfc (double2 param0); -OVERLOADABLE double3 erfc (double3 param0); -OVERLOADABLE double4 erfc (double4 param0); -OVERLOADABLE double8 erfc (double8 param0); -OVERLOADABLE double16 erfc (double16 param0); -OVERLOADABLE half2 erfc (half2 param0); -OVERLOADABLE half3 erfc (half3 param0); -OVERLOADABLE half4 erfc (half4 param0); -OVERLOADABLE half8 erfc (half8 param0); -OVERLOADABLE half16 erfc (half16 param0); - -//gentype erf (gentype) - -OVERLOADABLE float2 erf (float2 param0); -OVERLOADABLE float3 erf (float3 param0); -OVERLOADABLE float4 erf (float4 param0); -OVERLOADABLE float8 erf (float8 param0); -OVERLOADABLE float16 erf (float16 param0); -OVERLOADABLE double2 erf (double2 param0); -OVERLOADABLE double3 erf (double3 param0); -OVERLOADABLE double4 erf (double4 param0); -OVERLOADABLE double8 erf (double8 param0); -OVERLOADABLE double16 erf (double16 param0); -OVERLOADABLE half2 erf (half2 param0); -OVERLOADABLE half3 erf (half3 param0); -OVERLOADABLE half4 erf (half4 param0); -OVERLOADABLE half8 erf (half8 param0); -OVERLOADABLE half16 erf (half16 param0); - -//gentype exp (gentype x) - -OVERLOADABLE float2 exp (float2 param0); -OVERLOADABLE float3 exp (float3 param0); -OVERLOADABLE float4 exp (float4 param0); -OVERLOADABLE float8 exp (float8 param0); -OVERLOADABLE float16 exp (float16 param0); -OVERLOADABLE double2 exp (double2 param0); -OVERLOADABLE double3 exp (double3 param0); -OVERLOADABLE double4 exp (double4 param0); -OVERLOADABLE double8 exp (double8 param0); -OVERLOADABLE double16 exp (double16 param0); -OVERLOADABLE half2 exp (half2 param0); -OVERLOADABLE half3 exp (half3 param0); -OVERLOADABLE half4 exp (half4 param0); -OVERLOADABLE half8 exp (half8 param0); -OVERLOADABLE half16 exp (half16 param0); - -//gentype exp2 (gentype) - -OVERLOADABLE float2 exp2 (float2 param0); -OVERLOADABLE float3 exp2 (float3 param0); -OVERLOADABLE float4 exp2 (float4 param0); -OVERLOADABLE float8 exp2 (float8 param0); -OVERLOADABLE float16 exp2 (float16 param0); -OVERLOADABLE double2 exp2 (double2 param0); -OVERLOADABLE double3 exp2 (double3 param0); -OVERLOADABLE double4 exp2 (double4 param0); -OVERLOADABLE double8 exp2 (double8 param0); -OVERLOADABLE double16 exp2 (double16 param0); -OVERLOADABLE half2 exp2 (half2 param0); -OVERLOADABLE half3 exp2 (half3 param0); -OVERLOADABLE half4 exp2 (half4 param0); -OVERLOADABLE half8 exp2 (half8 param0); -OVERLOADABLE half16 exp2 (half16 param0); - -//gentype exp10 (gentype) - -OVERLOADABLE float2 exp10 (float2 param0); -OVERLOADABLE float3 exp10 (float3 param0); -OVERLOADABLE float4 exp10 (float4 param0); -OVERLOADABLE float8 exp10 (float8 param0); -OVERLOADABLE float16 exp10 (float16 param0); -OVERLOADABLE double2 exp10 (double2 param0); -OVERLOADABLE double3 exp10 (double3 param0); -OVERLOADABLE double4 exp10 (double4 param0); -OVERLOADABLE double8 exp10 (double8 param0); -OVERLOADABLE double16 exp10 (double16 param0); -OVERLOADABLE half2 exp10 (half2 param0); -OVERLOADABLE half3 exp10 (half3 param0); -OVERLOADABLE half4 exp10 (half4 param0); -OVERLOADABLE half8 exp10 (half8 param0); -OVERLOADABLE half16 exp10 (half16 param0); - -//gentype expm1 (gentype x) - -OVERLOADABLE float2 expm1 (float2 param0); -OVERLOADABLE float3 expm1 (float3 param0); -OVERLOADABLE float4 expm1 (float4 param0); -OVERLOADABLE float8 expm1 (float8 param0); -OVERLOADABLE float16 expm1 (float16 param0); -OVERLOADABLE double2 expm1 (double2 param0); -OVERLOADABLE double3 expm1 (double3 param0); -OVERLOADABLE double4 expm1 (double4 param0); -OVERLOADABLE double8 expm1 (double8 param0); -OVERLOADABLE double16 expm1 (double16 param0); -OVERLOADABLE half2 expm1 (half2 param0); -OVERLOADABLE half3 expm1 (half3 param0); -OVERLOADABLE half4 expm1 (half4 param0); -OVERLOADABLE half8 expm1 (half8 param0); -OVERLOADABLE half16 expm1 (half16 param0); - -//gentype fabs (gentype) - -OVERLOADABLE float2 fabs (float2 param0); -OVERLOADABLE float3 fabs (float3 param0); -OVERLOADABLE float4 fabs (float4 param0); -OVERLOADABLE float8 fabs (float8 param0); -OVERLOADABLE float16 fabs (float16 param0); -OVERLOADABLE double2 fabs (double2 param0); -OVERLOADABLE double3 fabs (double3 param0); -OVERLOADABLE double4 fabs (double4 param0); -OVERLOADABLE double8 fabs (double8 param0); -OVERLOADABLE double16 fabs (double16 param0); -OVERLOADABLE half2 fabs (half2 param0); -OVERLOADABLE half3 fabs (half3 param0); -OVERLOADABLE half4 fabs (half4 param0); -OVERLOADABLE half8 fabs (half8 param0); -OVERLOADABLE half16 fabs (half16 param0); - -//gentype fdim (gentype x, gentype y) - -OVERLOADABLE float2 fdim (float2 param0, float2 param1); -OVERLOADABLE float3 fdim (float3 param0, float3 param1); -OVERLOADABLE float4 fdim (float4 param0, float4 param1); -OVERLOADABLE float8 fdim (float8 param0, float8 param1); -OVERLOADABLE float16 fdim (float16 param0, float16 param1); -OVERLOADABLE double2 fdim (double2 param0, double2 param1); -OVERLOADABLE double3 fdim (double3 param0, double3 param1); -OVERLOADABLE double4 fdim (double4 param0, double4 param1); -OVERLOADABLE double8 fdim (double8 param0, double8 param1); -OVERLOADABLE double16 fdim (double16 param0, double16 param1); -OVERLOADABLE half2 fdim (half2 param0, half2 param1); -OVERLOADABLE half3 fdim (half3 param0, half3 param1); -OVERLOADABLE half4 fdim (half4 param0, half4 param1); -OVERLOADABLE half8 fdim (half8 param0, half8 param1); -OVERLOADABLE half16 fdim (half16 param0, half16 param1); - -//gentype floor (gentype) - -OVERLOADABLE float2 floor (float2 param0); -OVERLOADABLE float3 floor (float3 param0); -OVERLOADABLE float4 floor (float4 param0); -OVERLOADABLE float8 floor (float8 param0); -OVERLOADABLE float16 floor (float16 param0); -OVERLOADABLE double2 floor (double2 param0); -OVERLOADABLE double3 floor (double3 param0); -OVERLOADABLE double4 floor (double4 param0); -OVERLOADABLE double8 floor (double8 param0); -OVERLOADABLE double16 floor (double16 param0); -OVERLOADABLE half2 floor (half2 param0); -OVERLOADABLE half3 floor (half3 param0); -OVERLOADABLE half4 floor (half4 param0); -OVERLOADABLE half8 floor (half8 param0); -OVERLOADABLE half16 floor (half16 param0); - -//gentype fma (gentype a, gentype b, gentype c) - -OVERLOADABLE float2 fma (float2 param0, float2 param1, float2 param2); -OVERLOADABLE float3 fma (float3 param0, float3 param1, float3 param2); -OVERLOADABLE float4 fma (float4 param0, float4 param1, float4 param2); -OVERLOADABLE float8 fma (float8 param0, float8 param1, float8 param2); -OVERLOADABLE float16 fma (float16 param0, float16 param1, float16 param2); -OVERLOADABLE double2 fma (double2 param0, double2 param1, double2 param2); -OVERLOADABLE double3 fma (double3 param0, double3 param1, double3 param2); -OVERLOADABLE double4 fma (double4 param0, double4 param1, double4 param2); -OVERLOADABLE double8 fma (double8 param0, double8 param1, double8 param2); -OVERLOADABLE double16 fma (double16 param0, double16 param1, double16 param2); -OVERLOADABLE half2 fma (half2 param0, half2 param1, half2 param2); -OVERLOADABLE half3 fma (half3 param0, half3 param1, half3 param2); -OVERLOADABLE half4 fma (half4 param0, half4 param1, half4 param2); -OVERLOADABLE half8 fma (half8 param0, half8 param1, half8 param2); -OVERLOADABLE half16 fma (half16 param0, half16 param1, half16 param2); - -//gentype fmax (gentype x, gentype y) - -OVERLOADABLE float2 fmax (float2 param0, float2 param1); -OVERLOADABLE float3 fmax (float3 param0, float3 param1); -OVERLOADABLE float4 fmax (float4 param0, float4 param1); -OVERLOADABLE float8 fmax (float8 param0, float8 param1); -OVERLOADABLE float16 fmax (float16 param0, float16 param1); -OVERLOADABLE double2 fmax (double2 param0, double2 param1); -OVERLOADABLE double3 fmax (double3 param0, double3 param1); -OVERLOADABLE double4 fmax (double4 param0, double4 param1); -OVERLOADABLE double8 fmax (double8 param0, double8 param1); -OVERLOADABLE double16 fmax (double16 param0, double16 param1); -OVERLOADABLE half2 fmax (half2 param0, half2 param1); -OVERLOADABLE half3 fmax (half3 param0, half3 param1); -OVERLOADABLE half4 fmax (half4 param0, half4 param1); -OVERLOADABLE half8 fmax (half8 param0, half8 param1); -OVERLOADABLE half16 fmax (half16 param0, half16 param1); - -//gentypef fmax (gentypef x, float y) - -OVERLOADABLE float2 fmax (float2 param0, float param1); -OVERLOADABLE float3 fmax (float3 param0, float param1); -OVERLOADABLE float4 fmax (float4 param0, float param1); -OVERLOADABLE float8 fmax (float8 param0, float param1); -OVERLOADABLE float16 fmax (float16 param0, float param1); - -//gentypeh fmax (gentypeh x, half y) - -OVERLOADABLE half2 fmax (half2 param0, half param1); -OVERLOADABLE half3 fmax (half3 param0, half param1); -OVERLOADABLE half4 fmax (half4 param0, half param1); -OVERLOADABLE half8 fmax (half8 param0, half param1); -OVERLOADABLE half16 fmax (half16 param0, half param1); - -//gentyped fmax (gentyped x, double y) - -OVERLOADABLE double2 fmax (double2 param0, double param1); -OVERLOADABLE double3 fmax (double3 param0, double param1); -OVERLOADABLE double4 fmax (double4 param0, double param1); -OVERLOADABLE double8 fmax (double8 param0, double param1); -OVERLOADABLE double16 fmax (double16 param0, double param1); - -//gentype fmin (gentype x, gentype y) - -OVERLOADABLE float2 fmin (float2 param0, float2 param1); -OVERLOADABLE float3 fmin (float3 param0, float3 param1); -OVERLOADABLE float4 fmin (float4 param0, float4 param1); -OVERLOADABLE float8 fmin (float8 param0, float8 param1); -OVERLOADABLE float16 fmin (float16 param0, float16 param1); -OVERLOADABLE double2 fmin (double2 param0, double2 param1); -OVERLOADABLE double3 fmin (double3 param0, double3 param1); -OVERLOADABLE double4 fmin (double4 param0, double4 param1); -OVERLOADABLE double8 fmin (double8 param0, double8 param1); -OVERLOADABLE double16 fmin (double16 param0, double16 param1); -OVERLOADABLE half2 fmin (half2 param0, half2 param1); -OVERLOADABLE half3 fmin (half3 param0, half3 param1); -OVERLOADABLE half4 fmin (half4 param0, half4 param1); -OVERLOADABLE half8 fmin (half8 param0, half8 param1); -OVERLOADABLE half16 fmin (half16 param0, half16 param1); - -//gentypef fmin (gentypef x, float y) - -OVERLOADABLE float2 fmin (float2 param0, float param1); -OVERLOADABLE float3 fmin (float3 param0, float param1); -OVERLOADABLE float4 fmin (float4 param0, float param1); -OVERLOADABLE float8 fmin (float8 param0, float param1); -OVERLOADABLE float16 fmin (float16 param0, float param1); - -//gentypeh fmin (gentypeh x, half y) - -OVERLOADABLE half2 fmin (half2 param0, half param1); -OVERLOADABLE half3 fmin (half3 param0, half param1); -OVERLOADABLE half4 fmin (half4 param0, half param1); -OVERLOADABLE half8 fmin (half8 param0, half param1); -OVERLOADABLE half16 fmin (half16 param0, half param1); - -//gentyped fmin (gentyped x, double y) - -OVERLOADABLE double2 fmin (double2 param0, double param1); -OVERLOADABLE double3 fmin (double3 param0, double param1); -OVERLOADABLE double4 fmin (double4 param0, double param1); -OVERLOADABLE double8 fmin (double8 param0, double param1); -OVERLOADABLE double16 fmin (double16 param0, double param1); - -//gentype fmod (gentype x, gentype y) - -OVERLOADABLE float2 fmod (float2 param0, float2 param1); -OVERLOADABLE float3 fmod (float3 param0, float3 param1); -OVERLOADABLE float4 fmod (float4 param0, float4 param1); -OVERLOADABLE float8 fmod (float8 param0, float8 param1); -OVERLOADABLE float16 fmod (float16 param0, float16 param1); -OVERLOADABLE double2 fmod (double2 param0, double2 param1); -OVERLOADABLE double3 fmod (double3 param0, double3 param1); -OVERLOADABLE double4 fmod (double4 param0, double4 param1); -OVERLOADABLE double8 fmod (double8 param0, double8 param1); -OVERLOADABLE double16 fmod (double16 param0, double16 param1); -OVERLOADABLE half2 fmod (half2 param0, half2 param1); -OVERLOADABLE half3 fmod (half3 param0, half3 param1); -OVERLOADABLE half4 fmod (half4 param0, half4 param1); -OVERLOADABLE half8 fmod (half8 param0, half8 param1); -OVERLOADABLE half16 fmod (half16 param0, half16 param1); - -//gentype hypot (gentype x, gentype y) - -OVERLOADABLE float2 hypot (float2 param0, float2 param1); -OVERLOADABLE float3 hypot (float3 param0, float3 param1); -OVERLOADABLE float4 hypot (float4 param0, float4 param1); -OVERLOADABLE float8 hypot (float8 param0, float8 param1); -OVERLOADABLE float16 hypot (float16 param0, float16 param1); -OVERLOADABLE double2 hypot (double2 param0, double2 param1); -OVERLOADABLE double3 hypot (double3 param0, double3 param1); -OVERLOADABLE double4 hypot (double4 param0, double4 param1); -OVERLOADABLE double8 hypot (double8 param0, double8 param1); -OVERLOADABLE double16 hypot (double16 param0, double16 param1); -OVERLOADABLE half2 hypot (half2 param0, half2 param1); -OVERLOADABLE half3 hypot (half3 param0, half3 param1); -OVERLOADABLE half4 hypot (half4 param0, half4 param1); -OVERLOADABLE half8 hypot (half8 param0, half8 param1); -OVERLOADABLE half16 hypot (half16 param0, half16 param1); - -//intn ilogb (floatn x) - -OVERLOADABLE int2 ilogb (float2 param0); -OVERLOADABLE int3 ilogb (float3 param0); -OVERLOADABLE int4 ilogb (float4 param0); -OVERLOADABLE int8 ilogb (float8 param0); -OVERLOADABLE int16 ilogb (float16 param0); - -//int ilogb (float x) - - -//shortn ilogb (halfn x) - -OVERLOADABLE short2 ilogb (half2 param0); -OVERLOADABLE short3 ilogb (half3 param0); -OVERLOADABLE short4 ilogb (half4 param0); -OVERLOADABLE short8 ilogb (half8 param0); -OVERLOADABLE short16 ilogb (half16 param0); - -//short ilogb (half x) - - -//int ilogb (double x) - - -//floatn ldexp (floatn x, intn k) - -OVERLOADABLE float2 ldexp (float2 param0, int2 param1); -OVERLOADABLE float3 ldexp (float3 param0, int3 param1); -OVERLOADABLE float4 ldexp (float4 param0, int4 param1); -OVERLOADABLE float8 ldexp (float8 param0, int8 param1); -OVERLOADABLE float16 ldexp (float16 param0, int16 param1); - -//floatn ldexp (floatn x, int k) - -OVERLOADABLE float2 ldexp (float2 param0, int param1); -OVERLOADABLE float3 ldexp (float3 param0, int param1); -OVERLOADABLE float4 ldexp (float4 param0, int param1); -OVERLOADABLE float8 ldexp (float8 param0, int param1); -OVERLOADABLE float16 ldexp (float16 param0, int param1); - -//float ldexp (float x, int k) - - -//halfn ldexp (halfn x, intn k) - -OVERLOADABLE half2 ldexp (half2 param0, int2 param1); -OVERLOADABLE half3 ldexp (half3 param0, int3 param1); -OVERLOADABLE half4 ldexp (half4 param0, int4 param1); -OVERLOADABLE half8 ldexp (half8 param0, int8 param1); -OVERLOADABLE half16 ldexp (half16 param0, int16 param1); - -//halfn ldexp (halfn x, int k) - -OVERLOADABLE half2 ldexp (half2 param0, int param1); -OVERLOADABLE half3 ldexp (half3 param0, int param1); -OVERLOADABLE half4 ldexp (half4 param0, int param1); -OVERLOADABLE half8 ldexp (half8 param0, int param1); -OVERLOADABLE half16 ldexp (half16 param0, int param1); - -//half ldexp (half x, int k) - - -//double ldexp (double x, int k) - - -//gentype lgamma (gentype x) - -OVERLOADABLE float2 lgamma (float2 param0); -OVERLOADABLE float3 lgamma (float3 param0); -OVERLOADABLE float4 lgamma (float4 param0); -OVERLOADABLE float8 lgamma (float8 param0); -OVERLOADABLE float16 lgamma (float16 param0); -OVERLOADABLE double2 lgamma (double2 param0); -OVERLOADABLE double3 lgamma (double3 param0); -OVERLOADABLE double4 lgamma (double4 param0); -OVERLOADABLE double8 lgamma (double8 param0); -OVERLOADABLE double16 lgamma (double16 param0); -OVERLOADABLE half2 lgamma (half2 param0); -OVERLOADABLE half3 lgamma (half3 param0); -OVERLOADABLE half4 lgamma (half4 param0); -OVERLOADABLE half8 lgamma (half8 param0); -OVERLOADABLE half16 lgamma (half16 param0); - -//gentype log (gentype) - -OVERLOADABLE float2 log (float2 param0); -OVERLOADABLE float3 log (float3 param0); -OVERLOADABLE float4 log (float4 param0); -OVERLOADABLE float8 log (float8 param0); -OVERLOADABLE float16 log (float16 param0); -OVERLOADABLE double2 log (double2 param0); -OVERLOADABLE double3 log (double3 param0); -OVERLOADABLE double4 log (double4 param0); -OVERLOADABLE double8 log (double8 param0); -OVERLOADABLE double16 log (double16 param0); -OVERLOADABLE half2 log (half2 param0); -OVERLOADABLE half3 log (half3 param0); -OVERLOADABLE half4 log (half4 param0); -OVERLOADABLE half8 log (half8 param0); -OVERLOADABLE half16 log (half16 param0); - -//gentype log2 (gentype) - -OVERLOADABLE float2 log2 (float2 param0); -OVERLOADABLE float3 log2 (float3 param0); -OVERLOADABLE float4 log2 (float4 param0); -OVERLOADABLE float8 log2 (float8 param0); -OVERLOADABLE float16 log2 (float16 param0); -OVERLOADABLE double2 log2 (double2 param0); -OVERLOADABLE double3 log2 (double3 param0); -OVERLOADABLE double4 log2 (double4 param0); -OVERLOADABLE double8 log2 (double8 param0); -OVERLOADABLE double16 log2 (double16 param0); -OVERLOADABLE half2 log2 (half2 param0); -OVERLOADABLE half3 log2 (half3 param0); -OVERLOADABLE half4 log2 (half4 param0); -OVERLOADABLE half8 log2 (half8 param0); -OVERLOADABLE half16 log2 (half16 param0); - -//gentype log10 (gentype) - -OVERLOADABLE float2 log10 (float2 param0); -OVERLOADABLE float3 log10 (float3 param0); -OVERLOADABLE float4 log10 (float4 param0); -OVERLOADABLE float8 log10 (float8 param0); -OVERLOADABLE float16 log10 (float16 param0); -OVERLOADABLE double2 log10 (double2 param0); -OVERLOADABLE double3 log10 (double3 param0); -OVERLOADABLE double4 log10 (double4 param0); -OVERLOADABLE double8 log10 (double8 param0); -OVERLOADABLE double16 log10 (double16 param0); -OVERLOADABLE half2 log10 (half2 param0); -OVERLOADABLE half3 log10 (half3 param0); -OVERLOADABLE half4 log10 (half4 param0); -OVERLOADABLE half8 log10 (half8 param0); -OVERLOADABLE half16 log10 (half16 param0); - -//gentype log1p (gentype x) - -OVERLOADABLE float2 log1p (float2 param0); -OVERLOADABLE float3 log1p (float3 param0); -OVERLOADABLE float4 log1p (float4 param0); -OVERLOADABLE float8 log1p (float8 param0); -OVERLOADABLE float16 log1p (float16 param0); -OVERLOADABLE double2 log1p (double2 param0); -OVERLOADABLE double3 log1p (double3 param0); -OVERLOADABLE double4 log1p (double4 param0); -OVERLOADABLE double8 log1p (double8 param0); -OVERLOADABLE double16 log1p (double16 param0); -OVERLOADABLE half2 log1p (half2 param0); -OVERLOADABLE half3 log1p (half3 param0); -OVERLOADABLE half4 log1p (half4 param0); -OVERLOADABLE half8 log1p (half8 param0); -OVERLOADABLE half16 log1p (half16 param0); - -//gentype logb (gentype x) - -OVERLOADABLE float2 logb (float2 param0); -OVERLOADABLE float3 logb (float3 param0); -OVERLOADABLE float4 logb (float4 param0); -OVERLOADABLE float8 logb (float8 param0); -OVERLOADABLE float16 logb (float16 param0); -OVERLOADABLE double2 logb (double2 param0); -OVERLOADABLE double3 logb (double3 param0); -OVERLOADABLE double4 logb (double4 param0); -OVERLOADABLE double8 logb (double8 param0); -OVERLOADABLE double16 logb (double16 param0); -OVERLOADABLE half2 logb (half2 param0); -OVERLOADABLE half3 logb (half3 param0); -OVERLOADABLE half4 logb (half4 param0); -OVERLOADABLE half8 logb (half8 param0); -OVERLOADABLE half16 logb (half16 param0); - -//gentype mad (gentype a, gentype b, gentype c) - -OVERLOADABLE float2 mad (float2 param0, float2 param1, float2 param2); -OVERLOADABLE float3 mad (float3 param0, float3 param1, float3 param2); -OVERLOADABLE float4 mad (float4 param0, float4 param1, float4 param2); -OVERLOADABLE float8 mad (float8 param0, float8 param1, float8 param2); -OVERLOADABLE float16 mad (float16 param0, float16 param1, float16 param2); -OVERLOADABLE double2 mad (double2 param0, double2 param1, double2 param2); -OVERLOADABLE double3 mad (double3 param0, double3 param1, double3 param2); -OVERLOADABLE double4 mad (double4 param0, double4 param1, double4 param2); -OVERLOADABLE double8 mad (double8 param0, double8 param1, double8 param2); -OVERLOADABLE double16 mad (double16 param0, double16 param1, double16 param2); -OVERLOADABLE half2 mad (half2 param0, half2 param1, half2 param2); -OVERLOADABLE half3 mad (half3 param0, half3 param1, half3 param2); -OVERLOADABLE half4 mad (half4 param0, half4 param1, half4 param2); -OVERLOADABLE half8 mad (half8 param0, half8 param1, half8 param2); -OVERLOADABLE half16 mad (half16 param0, half16 param1, half16 param2); - -//gentype maxmag (gentype x, gentype y) - -OVERLOADABLE float2 maxmag (float2 param0, float2 param1); -OVERLOADABLE float3 maxmag (float3 param0, float3 param1); -OVERLOADABLE float4 maxmag (float4 param0, float4 param1); -OVERLOADABLE float8 maxmag (float8 param0, float8 param1); -OVERLOADABLE float16 maxmag (float16 param0, float16 param1); -OVERLOADABLE double2 maxmag (double2 param0, double2 param1); -OVERLOADABLE double3 maxmag (double3 param0, double3 param1); -OVERLOADABLE double4 maxmag (double4 param0, double4 param1); -OVERLOADABLE double8 maxmag (double8 param0, double8 param1); -OVERLOADABLE double16 maxmag (double16 param0, double16 param1); -OVERLOADABLE half2 maxmag (half2 param0, half2 param1); -OVERLOADABLE half3 maxmag (half3 param0, half3 param1); -OVERLOADABLE half4 maxmag (half4 param0, half4 param1); -OVERLOADABLE half8 maxmag (half8 param0, half8 param1); -OVERLOADABLE half16 maxmag (half16 param0, half16 param1); - -//gentype minmag (gentype x, gentype y) - -OVERLOADABLE float2 minmag (float2 param0, float2 param1); -OVERLOADABLE float3 minmag (float3 param0, float3 param1); -OVERLOADABLE float4 minmag (float4 param0, float4 param1); -OVERLOADABLE float8 minmag (float8 param0, float8 param1); -OVERLOADABLE float16 minmag (float16 param0, float16 param1); -OVERLOADABLE double2 minmag (double2 param0, double2 param1); -OVERLOADABLE double3 minmag (double3 param0, double3 param1); -OVERLOADABLE double4 minmag (double4 param0, double4 param1); -OVERLOADABLE double8 minmag (double8 param0, double8 param1); -OVERLOADABLE double16 minmag (double16 param0, double16 param1); -OVERLOADABLE half2 minmag (half2 param0, half2 param1); -OVERLOADABLE half3 minmag (half3 param0, half3 param1); -OVERLOADABLE half4 minmag (half4 param0, half4 param1); -OVERLOADABLE half8 minmag (half8 param0, half8 param1); -OVERLOADABLE half16 minmag (half16 param0, half16 param1); - -//floatn nan (uintn nancode) - -OVERLOADABLE float2 nan (uint2 param0); -OVERLOADABLE float3 nan (uint3 param0); -OVERLOADABLE float4 nan (uint4 param0); -OVERLOADABLE float8 nan (uint8 param0); -OVERLOADABLE float16 nan (uint16 param0); - -//float nan (uint nancode) - - -//halfn nan (ushortn nancode) - -OVERLOADABLE half2 nan (ushort2 param0); -OVERLOADABLE half3 nan (ushort3 param0); -OVERLOADABLE half4 nan (ushort4 param0); -OVERLOADABLE half8 nan (ushort8 param0); -OVERLOADABLE half16 nan (ushort16 param0); - -//half nan (ushort nancode) - - -//double nan (ulong nancode) - - -//gentype nextafter (gentype x, gentype y) - -OVERLOADABLE float2 nextafter (float2 param0, float2 param1); -OVERLOADABLE float3 nextafter (float3 param0, float3 param1); -OVERLOADABLE float4 nextafter (float4 param0, float4 param1); -OVERLOADABLE float8 nextafter (float8 param0, float8 param1); -OVERLOADABLE float16 nextafter (float16 param0, float16 param1); -OVERLOADABLE double2 nextafter (double2 param0, double2 param1); -OVERLOADABLE double3 nextafter (double3 param0, double3 param1); -OVERLOADABLE double4 nextafter (double4 param0, double4 param1); -OVERLOADABLE double8 nextafter (double8 param0, double8 param1); -OVERLOADABLE double16 nextafter (double16 param0, double16 param1); -OVERLOADABLE half2 nextafter (half2 param0, half2 param1); -OVERLOADABLE half3 nextafter (half3 param0, half3 param1); -OVERLOADABLE half4 nextafter (half4 param0, half4 param1); -OVERLOADABLE half8 nextafter (half8 param0, half8 param1); -OVERLOADABLE half16 nextafter (half16 param0, half16 param1); - -//gentype pow (gentype x, gentype y) - -OVERLOADABLE float2 pow (float2 param0, float2 param1); -OVERLOADABLE float3 pow (float3 param0, float3 param1); -OVERLOADABLE float4 pow (float4 param0, float4 param1); -OVERLOADABLE float8 pow (float8 param0, float8 param1); -OVERLOADABLE float16 pow (float16 param0, float16 param1); -OVERLOADABLE double2 pow (double2 param0, double2 param1); -OVERLOADABLE double3 pow (double3 param0, double3 param1); -OVERLOADABLE double4 pow (double4 param0, double4 param1); -OVERLOADABLE double8 pow (double8 param0, double8 param1); -OVERLOADABLE double16 pow (double16 param0, double16 param1); -OVERLOADABLE half2 pow (half2 param0, half2 param1); -OVERLOADABLE half3 pow (half3 param0, half3 param1); -OVERLOADABLE half4 pow (half4 param0, half4 param1); -OVERLOADABLE half8 pow (half8 param0, half8 param1); -OVERLOADABLE half16 pow (half16 param0, half16 param1); - -//floatn pown (floatn x, intn y) - -OVERLOADABLE float2 pown (float2 param0, int2 param1); -OVERLOADABLE float3 pown (float3 param0, int3 param1); -OVERLOADABLE float4 pown (float4 param0, int4 param1); -OVERLOADABLE float8 pown (float8 param0, int8 param1); -OVERLOADABLE float16 pown (float16 param0, int16 param1); - -//float pown (float x, int y) - - -//halfn pown (halfn x, intn y) - -OVERLOADABLE half2 pown (half2 param0, int2 param1); -OVERLOADABLE half3 pown (half3 param0, int3 param1); -OVERLOADABLE half4 pown (half4 param0, int4 param1); -OVERLOADABLE half8 pown (half8 param0, int8 param1); -OVERLOADABLE half16 pown (half16 param0, int16 param1); - -//half pown (half x, int y) - - -//double pown (double x, int y) - - -//gentype powr (gentype x, gentype y) - -OVERLOADABLE float2 powr (float2 param0, float2 param1); -OVERLOADABLE float3 powr (float3 param0, float3 param1); -OVERLOADABLE float4 powr (float4 param0, float4 param1); -OVERLOADABLE float8 powr (float8 param0, float8 param1); -OVERLOADABLE float16 powr (float16 param0, float16 param1); -OVERLOADABLE double2 powr (double2 param0, double2 param1); -OVERLOADABLE double3 powr (double3 param0, double3 param1); -OVERLOADABLE double4 powr (double4 param0, double4 param1); -OVERLOADABLE double8 powr (double8 param0, double8 param1); -OVERLOADABLE double16 powr (double16 param0, double16 param1); -OVERLOADABLE half2 powr (half2 param0, half2 param1); -OVERLOADABLE half3 powr (half3 param0, half3 param1); -OVERLOADABLE half4 powr (half4 param0, half4 param1); -OVERLOADABLE half8 powr (half8 param0, half8 param1); -OVERLOADABLE half16 powr (half16 param0, half16 param1); - -//gentype remainder (gentype x, gentype y) - -OVERLOADABLE float2 remainder (float2 param0, float2 param1); -OVERLOADABLE float3 remainder (float3 param0, float3 param1); -OVERLOADABLE float4 remainder (float4 param0, float4 param1); -OVERLOADABLE float8 remainder (float8 param0, float8 param1); -OVERLOADABLE float16 remainder (float16 param0, float16 param1); -OVERLOADABLE double2 remainder (double2 param0, double2 param1); -OVERLOADABLE double3 remainder (double3 param0, double3 param1); -OVERLOADABLE double4 remainder (double4 param0, double4 param1); -OVERLOADABLE double8 remainder (double8 param0, double8 param1); -OVERLOADABLE double16 remainder (double16 param0, double16 param1); -OVERLOADABLE half2 remainder (half2 param0, half2 param1); -OVERLOADABLE half3 remainder (half3 param0, half3 param1); -OVERLOADABLE half4 remainder (half4 param0, half4 param1); -OVERLOADABLE half8 remainder (half8 param0, half8 param1); -OVERLOADABLE half16 remainder (half16 param0, half16 param1); - -//gentype rint (gentype) - -OVERLOADABLE float2 rint (float2 param0); -OVERLOADABLE float3 rint (float3 param0); -OVERLOADABLE float4 rint (float4 param0); -OVERLOADABLE float8 rint (float8 param0); -OVERLOADABLE float16 rint (float16 param0); -OVERLOADABLE double2 rint (double2 param0); -OVERLOADABLE double3 rint (double3 param0); -OVERLOADABLE double4 rint (double4 param0); -OVERLOADABLE double8 rint (double8 param0); -OVERLOADABLE double16 rint (double16 param0); -OVERLOADABLE half2 rint (half2 param0); -OVERLOADABLE half3 rint (half3 param0); -OVERLOADABLE half4 rint (half4 param0); -OVERLOADABLE half8 rint (half8 param0); -OVERLOADABLE half16 rint (half16 param0); - -//floatn rootn (floatn x, intn y) - -OVERLOADABLE float2 rootn (float2 param0, int2 param1); -OVERLOADABLE float3 rootn (float3 param0, int3 param1); -OVERLOADABLE float4 rootn (float4 param0, int4 param1); -OVERLOADABLE float8 rootn (float8 param0, int8 param1); -OVERLOADABLE float16 rootn (float16 param0, int16 param1); - -//halfn rootn (halfn x, intn y) - -OVERLOADABLE half2 rootn (half2 param0, int2 param1); -OVERLOADABLE half3 rootn (half3 param0, int3 param1); -OVERLOADABLE half4 rootn (half4 param0, int4 param1); -OVERLOADABLE half8 rootn (half8 param0, int8 param1); -OVERLOADABLE half16 rootn (half16 param0, int16 param1); - -//gentype round (gentype x) - -OVERLOADABLE float2 round (float2 param0); -OVERLOADABLE float3 round (float3 param0); -OVERLOADABLE float4 round (float4 param0); -OVERLOADABLE float8 round (float8 param0); -OVERLOADABLE float16 round (float16 param0); -OVERLOADABLE double2 round (double2 param0); -OVERLOADABLE double3 round (double3 param0); -OVERLOADABLE double4 round (double4 param0); -OVERLOADABLE double8 round (double8 param0); -OVERLOADABLE double16 round (double16 param0); -OVERLOADABLE half2 round (half2 param0); -OVERLOADABLE half3 round (half3 param0); -OVERLOADABLE half4 round (half4 param0); -OVERLOADABLE half8 round (half8 param0); -OVERLOADABLE half16 round (half16 param0); - -//gentype rsqrt (gentype) - -OVERLOADABLE float2 rsqrt (float2 param0); -OVERLOADABLE float3 rsqrt (float3 param0); -OVERLOADABLE float4 rsqrt (float4 param0); -OVERLOADABLE float8 rsqrt (float8 param0); -OVERLOADABLE float16 rsqrt (float16 param0); -OVERLOADABLE double2 rsqrt (double2 param0); -OVERLOADABLE double3 rsqrt (double3 param0); -OVERLOADABLE double4 rsqrt (double4 param0); -OVERLOADABLE double8 rsqrt (double8 param0); -OVERLOADABLE double16 rsqrt (double16 param0); -OVERLOADABLE half2 rsqrt (half2 param0); -OVERLOADABLE half3 rsqrt (half3 param0); -OVERLOADABLE half4 rsqrt (half4 param0); -OVERLOADABLE half8 rsqrt (half8 param0); -OVERLOADABLE half16 rsqrt (half16 param0); - -//gentype sin (gentype) - -OVERLOADABLE float2 sin (float2 param0); -OVERLOADABLE float3 sin (float3 param0); -OVERLOADABLE float4 sin (float4 param0); -OVERLOADABLE float8 sin (float8 param0); -OVERLOADABLE float16 sin (float16 param0); -OVERLOADABLE double2 sin (double2 param0); -OVERLOADABLE double3 sin (double3 param0); -OVERLOADABLE double4 sin (double4 param0); -OVERLOADABLE double8 sin (double8 param0); -OVERLOADABLE double16 sin (double16 param0); -OVERLOADABLE half2 sin (half2 param0); -OVERLOADABLE half3 sin (half3 param0); -OVERLOADABLE half4 sin (half4 param0); -OVERLOADABLE half8 sin (half8 param0); -OVERLOADABLE half16 sin (half16 param0); - -//gentype sinh (gentype) - -OVERLOADABLE float2 sinh (float2 param0); -OVERLOADABLE float3 sinh (float3 param0); -OVERLOADABLE float4 sinh (float4 param0); -OVERLOADABLE float8 sinh (float8 param0); -OVERLOADABLE float16 sinh (float16 param0); -OVERLOADABLE double2 sinh (double2 param0); -OVERLOADABLE double3 sinh (double3 param0); -OVERLOADABLE double4 sinh (double4 param0); -OVERLOADABLE double8 sinh (double8 param0); -OVERLOADABLE double16 sinh (double16 param0); -OVERLOADABLE half2 sinh (half2 param0); -OVERLOADABLE half3 sinh (half3 param0); -OVERLOADABLE half4 sinh (half4 param0); -OVERLOADABLE half8 sinh (half8 param0); -OVERLOADABLE half16 sinh (half16 param0); - -//gentype sinpi (gentype x) - -OVERLOADABLE float2 sinpi (float2 param0); -OVERLOADABLE float3 sinpi (float3 param0); -OVERLOADABLE float4 sinpi (float4 param0); -OVERLOADABLE float8 sinpi (float8 param0); -OVERLOADABLE float16 sinpi (float16 param0); -OVERLOADABLE double2 sinpi (double2 param0); -OVERLOADABLE double3 sinpi (double3 param0); -OVERLOADABLE double4 sinpi (double4 param0); -OVERLOADABLE double8 sinpi (double8 param0); -OVERLOADABLE double16 sinpi (double16 param0); -OVERLOADABLE half2 sinpi (half2 param0); -OVERLOADABLE half3 sinpi (half3 param0); -OVERLOADABLE half4 sinpi (half4 param0); -OVERLOADABLE half8 sinpi (half8 param0); -OVERLOADABLE half16 sinpi (half16 param0); - -//gentype sqrt (gentype) - -OVERLOADABLE float2 sqrt (float2 param0); -OVERLOADABLE float3 sqrt (float3 param0); -OVERLOADABLE float4 sqrt (float4 param0); -OVERLOADABLE float8 sqrt (float8 param0); -OVERLOADABLE float16 sqrt (float16 param0); -OVERLOADABLE double2 sqrt (double2 param0); -OVERLOADABLE double3 sqrt (double3 param0); -OVERLOADABLE double4 sqrt (double4 param0); -OVERLOADABLE double8 sqrt (double8 param0); -OVERLOADABLE double16 sqrt (double16 param0); -OVERLOADABLE half2 sqrt (half2 param0); -OVERLOADABLE half3 sqrt (half3 param0); -OVERLOADABLE half4 sqrt (half4 param0); -OVERLOADABLE half8 sqrt (half8 param0); -OVERLOADABLE half16 sqrt (half16 param0); - -//gentype tan (gentype) - -OVERLOADABLE float2 tan (float2 param0); -OVERLOADABLE float3 tan (float3 param0); -OVERLOADABLE float4 tan (float4 param0); -OVERLOADABLE float8 tan (float8 param0); -OVERLOADABLE float16 tan (float16 param0); -OVERLOADABLE double2 tan (double2 param0); -OVERLOADABLE double3 tan (double3 param0); -OVERLOADABLE double4 tan (double4 param0); -OVERLOADABLE double8 tan (double8 param0); -OVERLOADABLE double16 tan (double16 param0); -OVERLOADABLE half2 tan (half2 param0); -OVERLOADABLE half3 tan (half3 param0); -OVERLOADABLE half4 tan (half4 param0); -OVERLOADABLE half8 tan (half8 param0); -OVERLOADABLE half16 tan (half16 param0); - -//gentype tanh (gentype) - -OVERLOADABLE float2 tanh (float2 param0); -OVERLOADABLE float3 tanh (float3 param0); -OVERLOADABLE float4 tanh (float4 param0); -OVERLOADABLE float8 tanh (float8 param0); -OVERLOADABLE float16 tanh (float16 param0); -OVERLOADABLE double2 tanh (double2 param0); -OVERLOADABLE double3 tanh (double3 param0); -OVERLOADABLE double4 tanh (double4 param0); -OVERLOADABLE double8 tanh (double8 param0); -OVERLOADABLE double16 tanh (double16 param0); -OVERLOADABLE half2 tanh (half2 param0); -OVERLOADABLE half3 tanh (half3 param0); -OVERLOADABLE half4 tanh (half4 param0); -OVERLOADABLE half8 tanh (half8 param0); -OVERLOADABLE half16 tanh (half16 param0); - -//gentype tanpi (gentype x) - -OVERLOADABLE float2 tanpi (float2 param0); -OVERLOADABLE float3 tanpi (float3 param0); -OVERLOADABLE float4 tanpi (float4 param0); -OVERLOADABLE float8 tanpi (float8 param0); -OVERLOADABLE float16 tanpi (float16 param0); -OVERLOADABLE double2 tanpi (double2 param0); -OVERLOADABLE double3 tanpi (double3 param0); -OVERLOADABLE double4 tanpi (double4 param0); -OVERLOADABLE double8 tanpi (double8 param0); -OVERLOADABLE double16 tanpi (double16 param0); -OVERLOADABLE half2 tanpi (half2 param0); -OVERLOADABLE half3 tanpi (half3 param0); -OVERLOADABLE half4 tanpi (half4 param0); -OVERLOADABLE half8 tanpi (half8 param0); -OVERLOADABLE half16 tanpi (half16 param0); - -//gentype tgamma (gentype) - -OVERLOADABLE float2 tgamma (float2 param0); -OVERLOADABLE float3 tgamma (float3 param0); -OVERLOADABLE float4 tgamma (float4 param0); -OVERLOADABLE float8 tgamma (float8 param0); -OVERLOADABLE float16 tgamma (float16 param0); -OVERLOADABLE double2 tgamma (double2 param0); -OVERLOADABLE double3 tgamma (double3 param0); -OVERLOADABLE double4 tgamma (double4 param0); -OVERLOADABLE double8 tgamma (double8 param0); -OVERLOADABLE double16 tgamma (double16 param0); -OVERLOADABLE half2 tgamma (half2 param0); -OVERLOADABLE half3 tgamma (half3 param0); -OVERLOADABLE half4 tgamma (half4 param0); -OVERLOADABLE half8 tgamma (half8 param0); -OVERLOADABLE half16 tgamma (half16 param0); - -//gentype trunc (gentype) - -OVERLOADABLE float2 trunc (float2 param0); -OVERLOADABLE float3 trunc (float3 param0); -OVERLOADABLE float4 trunc (float4 param0); -OVERLOADABLE float8 trunc (float8 param0); -OVERLOADABLE float16 trunc (float16 param0); -OVERLOADABLE double2 trunc (double2 param0); -OVERLOADABLE double3 trunc (double3 param0); -OVERLOADABLE double4 trunc (double4 param0); -OVERLOADABLE double8 trunc (double8 param0); -OVERLOADABLE double16 trunc (double16 param0); -OVERLOADABLE half2 trunc (half2 param0); -OVERLOADABLE half3 trunc (half3 param0); -OVERLOADABLE half4 trunc (half4 param0); -OVERLOADABLE half8 trunc (half8 param0); -OVERLOADABLE half16 trunc (half16 param0); - -//gentype native_cos (gentype x) - -OVERLOADABLE float2 native_cos (float2 param0); -OVERLOADABLE float3 native_cos (float3 param0); -OVERLOADABLE float4 native_cos (float4 param0); -OVERLOADABLE float8 native_cos (float8 param0); -OVERLOADABLE float16 native_cos (float16 param0); -OVERLOADABLE half2 native_cos (half2 param0); -OVERLOADABLE half3 native_cos (half3 param0); -OVERLOADABLE half4 native_cos (half4 param0); -OVERLOADABLE half8 native_cos (half8 param0); -OVERLOADABLE half16 native_cos (half16 param0); - -//gentype native_divide (gentype x, gentype y) - -OVERLOADABLE float2 native_divide (float2 param0, float2 param1); -OVERLOADABLE float3 native_divide (float3 param0, float3 param1); -OVERLOADABLE float4 native_divide (float4 param0, float4 param1); -OVERLOADABLE float8 native_divide (float8 param0, float8 param1); -OVERLOADABLE float16 native_divide (float16 param0, float16 param1); -OVERLOADABLE half2 native_divide (half2 param0, half2 param1); -OVERLOADABLE half3 native_divide (half3 param0, half3 param1); -OVERLOADABLE half4 native_divide (half4 param0, half4 param1); -OVERLOADABLE half8 native_divide (half8 param0, half8 param1); -OVERLOADABLE half16 native_divide (half16 param0, half16 param1); - -//gentype native_exp (gentype x) - -OVERLOADABLE float2 native_exp (float2 param0); -OVERLOADABLE float3 native_exp (float3 param0); -OVERLOADABLE float4 native_exp (float4 param0); -OVERLOADABLE float8 native_exp (float8 param0); -OVERLOADABLE float16 native_exp (float16 param0); -OVERLOADABLE half2 native_exp (half2 param0); -OVERLOADABLE half3 native_exp (half3 param0); -OVERLOADABLE half4 native_exp (half4 param0); -OVERLOADABLE half8 native_exp (half8 param0); -OVERLOADABLE half16 native_exp (half16 param0); - -//gentype native_exp2 (gentype x) - -OVERLOADABLE float2 native_exp2 (float2 param0); -OVERLOADABLE float3 native_exp2 (float3 param0); -OVERLOADABLE float4 native_exp2 (float4 param0); -OVERLOADABLE float8 native_exp2 (float8 param0); -OVERLOADABLE float16 native_exp2 (float16 param0); -OVERLOADABLE half2 native_exp2 (half2 param0); -OVERLOADABLE half3 native_exp2 (half3 param0); -OVERLOADABLE half4 native_exp2 (half4 param0); -OVERLOADABLE half8 native_exp2 (half8 param0); -OVERLOADABLE half16 native_exp2 (half16 param0); - -//gentype native_exp10 (gentype x) - -OVERLOADABLE float2 native_exp10 (float2 param0); -OVERLOADABLE float3 native_exp10 (float3 param0); -OVERLOADABLE float4 native_exp10 (float4 param0); -OVERLOADABLE float8 native_exp10 (float8 param0); -OVERLOADABLE float16 native_exp10 (float16 param0); -OVERLOADABLE half2 native_exp10 (half2 param0); -OVERLOADABLE half3 native_exp10 (half3 param0); -OVERLOADABLE half4 native_exp10 (half4 param0); -OVERLOADABLE half8 native_exp10 (half8 param0); -OVERLOADABLE half16 native_exp10 (half16 param0); - -//gentype native_log (gentype x) - -OVERLOADABLE float2 native_log (float2 param0); -OVERLOADABLE float3 native_log (float3 param0); -OVERLOADABLE float4 native_log (float4 param0); -OVERLOADABLE float8 native_log (float8 param0); -OVERLOADABLE float16 native_log (float16 param0); -OVERLOADABLE half2 native_log (half2 param0); -OVERLOADABLE half3 native_log (half3 param0); -OVERLOADABLE half4 native_log (half4 param0); -OVERLOADABLE half8 native_log (half8 param0); -OVERLOADABLE half16 native_log (half16 param0); - -//gentype native_log2 (gentype x) - -OVERLOADABLE float2 native_log2 (float2 param0); -OVERLOADABLE float3 native_log2 (float3 param0); -OVERLOADABLE float4 native_log2 (float4 param0); -OVERLOADABLE float8 native_log2 (float8 param0); -OVERLOADABLE float16 native_log2 (float16 param0); -OVERLOADABLE half2 native_log2 (half2 param0); -OVERLOADABLE half3 native_log2 (half3 param0); -OVERLOADABLE half4 native_log2 (half4 param0); -OVERLOADABLE half8 native_log2 (half8 param0); -OVERLOADABLE half16 native_log2 (half16 param0); - -//gentype native_log10 (gentype x) - -OVERLOADABLE float2 native_log10 (float2 param0); -OVERLOADABLE float3 native_log10 (float3 param0); -OVERLOADABLE float4 native_log10 (float4 param0); -OVERLOADABLE float8 native_log10 (float8 param0); -OVERLOADABLE float16 native_log10 (float16 param0); -OVERLOADABLE half2 native_log10 (half2 param0); -OVERLOADABLE half3 native_log10 (half3 param0); -OVERLOADABLE half4 native_log10 (half4 param0); -OVERLOADABLE half8 native_log10 (half8 param0); -OVERLOADABLE half16 native_log10 (half16 param0); - -//gentype native_powr (gentype x, gentype y) - -OVERLOADABLE float2 native_powr (float2 param0, float2 param1); -OVERLOADABLE float3 native_powr (float3 param0, float3 param1); -OVERLOADABLE float4 native_powr (float4 param0, float4 param1); -OVERLOADABLE float8 native_powr (float8 param0, float8 param1); -OVERLOADABLE float16 native_powr (float16 param0, float16 param1); -OVERLOADABLE half2 native_powr (half2 param0, half2 param1); -OVERLOADABLE half3 native_powr (half3 param0, half3 param1); -OVERLOADABLE half4 native_powr (half4 param0, half4 param1); -OVERLOADABLE half8 native_powr (half8 param0, half8 param1); -OVERLOADABLE half16 native_powr (half16 param0, half16 param1); - -//gentype native_recip (gentype x) - -OVERLOADABLE float2 native_recip (float2 param0); -OVERLOADABLE float3 native_recip (float3 param0); -OVERLOADABLE float4 native_recip (float4 param0); -OVERLOADABLE float8 native_recip (float8 param0); -OVERLOADABLE float16 native_recip (float16 param0); -OVERLOADABLE half2 native_recip (half2 param0); -OVERLOADABLE half3 native_recip (half3 param0); -OVERLOADABLE half4 native_recip (half4 param0); -OVERLOADABLE half8 native_recip (half8 param0); -OVERLOADABLE half16 native_recip (half16 param0); - -//gentype native_rsqrt (gentype x) - -OVERLOADABLE float2 native_rsqrt (float2 param0); -OVERLOADABLE float3 native_rsqrt (float3 param0); -OVERLOADABLE float4 native_rsqrt (float4 param0); -OVERLOADABLE float8 native_rsqrt (float8 param0); -OVERLOADABLE float16 native_rsqrt (float16 param0); -OVERLOADABLE half2 native_rsqrt (half2 param0); -OVERLOADABLE half3 native_rsqrt (half3 param0); -OVERLOADABLE half4 native_rsqrt (half4 param0); -OVERLOADABLE half8 native_rsqrt (half8 param0); -OVERLOADABLE half16 native_rsqrt (half16 param0); - -//gentype native_sin (gentype x) - -OVERLOADABLE float2 native_sin (float2 param0); -OVERLOADABLE float3 native_sin (float3 param0); -OVERLOADABLE float4 native_sin (float4 param0); -OVERLOADABLE float8 native_sin (float8 param0); -OVERLOADABLE float16 native_sin (float16 param0); -OVERLOADABLE half2 native_sin (half2 param0); -OVERLOADABLE half3 native_sin (half3 param0); -OVERLOADABLE half4 native_sin (half4 param0); -OVERLOADABLE half8 native_sin (half8 param0); -OVERLOADABLE half16 native_sin (half16 param0); - -//gentype native_sqrt (gentype x) - -OVERLOADABLE float2 native_sqrt (float2 param0); -OVERLOADABLE float3 native_sqrt (float3 param0); -OVERLOADABLE float4 native_sqrt (float4 param0); -OVERLOADABLE float8 native_sqrt (float8 param0); -OVERLOADABLE float16 native_sqrt (float16 param0); -OVERLOADABLE half2 native_sqrt (half2 param0); -OVERLOADABLE half3 native_sqrt (half3 param0); -OVERLOADABLE half4 native_sqrt (half4 param0); -OVERLOADABLE half8 native_sqrt (half8 param0); -OVERLOADABLE half16 native_sqrt (half16 param0); - -//gentype native_tan (gentype x) - -OVERLOADABLE float2 native_tan (float2 param0); -OVERLOADABLE float3 native_tan (float3 param0); -OVERLOADABLE float4 native_tan (float4 param0); -OVERLOADABLE float8 native_tan (float8 param0); -OVERLOADABLE float16 native_tan (float16 param0); -OVERLOADABLE half2 native_tan (half2 param0); -OVERLOADABLE half3 native_tan (half3 param0); -OVERLOADABLE half4 native_tan (half4 param0); -OVERLOADABLE half8 native_tan (half8 param0); -OVERLOADABLE half16 native_tan (half16 param0); - -//half_native_math builtin functions -//gentype half_cos (gentype x) - -OVERLOADABLE float2 half_cos (float2 param0); -OVERLOADABLE float3 half_cos (float3 param0); -OVERLOADABLE float4 half_cos (float4 param0); -OVERLOADABLE float8 half_cos (float8 param0); -OVERLOADABLE float16 half_cos (float16 param0); - -//gentype half_divide (gentype x, gentype y) - -OVERLOADABLE float2 half_divide (float2 param0, float2 param1); -OVERLOADABLE float3 half_divide (float3 param0, float3 param1); -OVERLOADABLE float4 half_divide (float4 param0, float4 param1); -OVERLOADABLE float8 half_divide (float8 param0, float8 param1); -OVERLOADABLE float16 half_divide (float16 param0, float16 param1); - -//gentype half_exp (gentype x) - -OVERLOADABLE float2 half_exp (float2 param0); -OVERLOADABLE float3 half_exp (float3 param0); -OVERLOADABLE float4 half_exp (float4 param0); -OVERLOADABLE float8 half_exp (float8 param0); -OVERLOADABLE float16 half_exp (float16 param0); - -//gentype half_exp2 (gentype x) - -OVERLOADABLE float2 half_exp2 (float2 param0); -OVERLOADABLE float3 half_exp2 (float3 param0); -OVERLOADABLE float4 half_exp2 (float4 param0); -OVERLOADABLE float8 half_exp2 (float8 param0); -OVERLOADABLE float16 half_exp2 (float16 param0); - -//gentype half_exp10 (gentype x) - -OVERLOADABLE float2 half_exp10 (float2 param0); -OVERLOADABLE float3 half_exp10 (float3 param0); -OVERLOADABLE float4 half_exp10 (float4 param0); -OVERLOADABLE float8 half_exp10 (float8 param0); -OVERLOADABLE float16 half_exp10 (float16 param0); - -//gentype half_log (gentype x) - -OVERLOADABLE float2 half_log (float2 param0); -OVERLOADABLE float3 half_log (float3 param0); -OVERLOADABLE float4 half_log (float4 param0); -OVERLOADABLE float8 half_log (float8 param0); -OVERLOADABLE float16 half_log (float16 param0); - -//gentype half_log2 (gentype x) - -OVERLOADABLE float2 half_log2 (float2 param0); -OVERLOADABLE float3 half_log2 (float3 param0); -OVERLOADABLE float4 half_log2 (float4 param0); -OVERLOADABLE float8 half_log2 (float8 param0); -OVERLOADABLE float16 half_log2 (float16 param0); - -//gentype half_log10 (gentype x) - -OVERLOADABLE float2 half_log10 (float2 param0); -OVERLOADABLE float3 half_log10 (float3 param0); -OVERLOADABLE float4 half_log10 (float4 param0); -OVERLOADABLE float8 half_log10 (float8 param0); -OVERLOADABLE float16 half_log10 (float16 param0); - -//gentype half_powr (gentype x, gentype y) - -OVERLOADABLE float2 half_powr (float2 param0, float2 param1); -OVERLOADABLE float3 half_powr (float3 param0, float3 param1); -OVERLOADABLE float4 half_powr (float4 param0, float4 param1); -OVERLOADABLE float8 half_powr (float8 param0, float8 param1); -OVERLOADABLE float16 half_powr (float16 param0, float16 param1); - -//gentype half_recip (gentype x) - -OVERLOADABLE float2 half_recip (float2 param0); -OVERLOADABLE float3 half_recip (float3 param0); -OVERLOADABLE float4 half_recip (float4 param0); -OVERLOADABLE float8 half_recip (float8 param0); -OVERLOADABLE float16 half_recip (float16 param0); - -//gentype half_rsqrt (gentype x) - -OVERLOADABLE float2 half_rsqrt (float2 param0); -OVERLOADABLE float3 half_rsqrt (float3 param0); -OVERLOADABLE float4 half_rsqrt (float4 param0); -OVERLOADABLE float8 half_rsqrt (float8 param0); -OVERLOADABLE float16 half_rsqrt (float16 param0); - -//gentype half_sin (gentype x) - -OVERLOADABLE float2 half_sin (float2 param0); -OVERLOADABLE float3 half_sin (float3 param0); -OVERLOADABLE float4 half_sin (float4 param0); -OVERLOADABLE float8 half_sin (float8 param0); -OVERLOADABLE float16 half_sin (float16 param0); - -//gentype half_sqrt (gentype x) - -OVERLOADABLE float2 half_sqrt (float2 param0); -OVERLOADABLE float3 half_sqrt (float3 param0); -OVERLOADABLE float4 half_sqrt (float4 param0); -OVERLOADABLE float8 half_sqrt (float8 param0); -OVERLOADABLE float16 half_sqrt (float16 param0); - -//gentype half_tan (gentype x) - -OVERLOADABLE float2 half_tan (float2 param0); -OVERLOADABLE float3 half_tan (float3 param0); -OVERLOADABLE float4 half_tan (float4 param0); -OVERLOADABLE float8 half_tan (float8 param0); -OVERLOADABLE float16 half_tan (float16 param0); - -//double acos (double) - - -//double acosh (double) - - -//double acospi (double x) - - -//double asin (double) - - -//double asinh (double) - - -//double asinpi (double x) - - -//double atan (double y_over_x) - - -//double atan2 (double y, double x) - - -//double atanh (double) - - -//double atanpi (double x) - - -//double atan2pi (double y, double x) - - -//double cbrt (double) - - -//double ceil (double) - - -//double copysign (double x, double y) - - -//double cos (double) - - -//double cosh (double) - - -//double cospi (double x) - - -//double erfc (double) - - -//double erf (double) - - -//double exp (double x) - - -//double exp2 (double) - - -//double exp10 (double) - - -//double expm1 (double x) - - -//double fabs (double) - - -//double fdim (double x, double y) - - -//double floor (double) - - -//double fma (double a, double b, double c) - - -//double fmax (double x, double y) - - -//double fmax (double x, double y) - - -//double fmin (double x, double y) - - -//double fmin (double x, double y) - - -//double fmod (double x, double y) - - -//double hypot (double x, double y) - - -//intn ilogb (doublen x) - -OVERLOADABLE int2 ilogb (double2 param0); -OVERLOADABLE int3 ilogb (double3 param0); -OVERLOADABLE int4 ilogb (double4 param0); -OVERLOADABLE int8 ilogb (double8 param0); -OVERLOADABLE int16 ilogb (double16 param0); - -//int ilogb (double x) - - -//doublen ldexp (doublen x, intn k) - -OVERLOADABLE double2 ldexp (double2 param0, int2 param1); -OVERLOADABLE double3 ldexp (double3 param0, int3 param1); -OVERLOADABLE double4 ldexp (double4 param0, int4 param1); -OVERLOADABLE double8 ldexp (double8 param0, int8 param1); -OVERLOADABLE double16 ldexp (double16 param0, int16 param1); - -//doublen ldexp (doublen x, int k) - -OVERLOADABLE double2 ldexp (double2 param0, int param1); -OVERLOADABLE double3 ldexp (double3 param0, int param1); -OVERLOADABLE double4 ldexp (double4 param0, int param1); -OVERLOADABLE double8 ldexp (double8 param0, int param1); -OVERLOADABLE double16 ldexp (double16 param0, int param1); - -//double ldexp (double x, int k) - - -//double lgamma (double x) - - -//double log (double) - - -//double log2 (double) - - -//double log10 (double) - - -//double log1p (double x) - - -//double logb (double x) - - -//double mad (double a, double b, double c) - - -//double maxmag (double x, double y) - - -//double minmag (double x, double y) - - -//double modf (double x, double *iptr) - - -//doublen nan (ulongn nancode) - -OVERLOADABLE double2 nan (ulong2 param0); -OVERLOADABLE double3 nan (ulong3 param0); -OVERLOADABLE double4 nan (ulong4 param0); -OVERLOADABLE double8 nan (ulong8 param0); -OVERLOADABLE double16 nan (ulong16 param0); - -//double nan (ulong nancode) - - -//double nextafter (double x, double y) - - -//double pow (double x, double y) - - -//doublen pown (doublen x, intn y) - -OVERLOADABLE double2 pown (double2 param0, int2 param1); -OVERLOADABLE double3 pown (double3 param0, int3 param1); -OVERLOADABLE double4 pown (double4 param0, int4 param1); -OVERLOADABLE double8 pown (double8 param0, int8 param1); -OVERLOADABLE double16 pown (double16 param0, int16 param1); - -//double pown (double x, int y) - - -//double powr (double x, double y) - - -//double remainder (double x, double y) - - -//double rint (double) - - -//doublen rootn (doublen x, intn y) - -OVERLOADABLE double2 rootn (double2 param0, int2 param1); -OVERLOADABLE double3 rootn (double3 param0, int3 param1); -OVERLOADABLE double4 rootn (double4 param0, int4 param1); -OVERLOADABLE double8 rootn (double8 param0, int8 param1); -OVERLOADABLE double16 rootn (double16 param0, int16 param1); - -//double rootn (double x, int y) - - -//double round (double x) - - -//double rsqrt (double) - - -//double sin (double) - - -//double sincos (double x, double *cosval) - - -//double sinh (double) - - -//double sinpi (double x) - - -//double sqrt (double) - - -//double tan (double) - - -//double tanh (double) - - -//double tanpi (double x) - - -//double tgamma (double) - - -//double trunc (double) - - -#endif diff --git a/drivers/pocl-gen7/lib/beignet/include/ocl_memcpy.h b/drivers/pocl-gen7/lib/beignet/include/ocl_memcpy.h deleted file mode 100644 index 2672298..0000000 --- a/drivers/pocl-gen7/lib/beignet/include/ocl_memcpy.h +++ /dev/null @@ -1,51 +0,0 @@ -/* - * Copyright © 2012 - 2014 Intel Corporation - * - * This library is free software; you can redistribute it and/or - * modify it under the terms of the GNU Lesser General Public - * License as published by the Free Software Foundation; either - * version 2.1 of the License, or (at your option) any later version. - * - * This library is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU - * Lesser General Public License for more details. - * - * You should have received a copy of the GNU Lesser General Public - * License along with this library. If not, see . - * - */ -#ifndef __OCL_MEMCPY_H__ -#define __OCL_MEMCPY_H__ -#include "ocl_types.h" - -///////////////////////////////////////////////////////////////////////////// -// memcopy functions -///////////////////////////////////////////////////////////////////////////// -void __gen_memcpy_gg_align(__global uchar* dst, __global uchar* src, size_t size); -void __gen_memcpy_gp_align(__global uchar* dst, __private uchar* src, size_t size); -void __gen_memcpy_gl_align(__global uchar* dst, __local uchar* src, size_t size); -void __gen_memcpy_gc_align(__global uchar* dst, __constant uchar* src, size_t size); -void __gen_memcpy_pg_align(__private uchar* dst, __global uchar* src, size_t size); -void __gen_memcpy_pp_align(__private uchar* dst, __private uchar* src, size_t size); -void __gen_memcpy_pl_align(__private uchar* dst, __local uchar* src, size_t size); -void __gen_memcpy_pc_align(__private uchar* dst, __constant uchar* src, size_t size); -void __gen_memcpy_lg_align(__local uchar* dst, __global uchar* src, size_t size); -void __gen_memcpy_lp_align(__local uchar* dst, __private uchar* src, size_t size); -void __gen_memcpy_ll_align(__local uchar* dst, __local uchar* src, size_t size); -void __gen_memcpy_lc_align(__local uchar* dst, __constant uchar* src, size_t size); - -void __gen_memcpy_gg(__global uchar* dst, __global uchar* src, size_t size); -void __gen_memcpy_gp(__global uchar* dst, __private uchar* src, size_t size); -void __gen_memcpy_gl(__global uchar* dst, __local uchar* src, size_t size); -void __gen_memcpy_gc(__global uchar* dst, __constant uchar* src, size_t size); -void __gen_memcpy_pg(__private uchar* dst, __global uchar* src, size_t size); -void __gen_memcpy_pp(__private uchar* dst, __private uchar* src, size_t size); -void __gen_memcpy_pl(__private uchar* dst, __local uchar* src, size_t size); -void __gen_memcpy_pc(__private uchar* dst, __constant uchar* src, size_t size); -void __gen_memcpy_lg(__local uchar* dst, __global uchar* src, size_t size); -void __gen_memcpy_lp(__local uchar* dst, __private uchar* src, size_t size); -void __gen_memcpy_ll(__local uchar* dst, __local uchar* src, size_t size); -void __gen_memcpy_lc(__local uchar* dst, __constant uchar* src, size_t size); - -#endif /* __OCL_MEMCPY_H__ */ diff --git a/drivers/pocl-gen7/lib/beignet/include/ocl_memset.h b/drivers/pocl-gen7/lib/beignet/include/ocl_memset.h deleted file mode 100644 index 2d444ad..0000000 --- a/drivers/pocl-gen7/lib/beignet/include/ocl_memset.h +++ /dev/null @@ -1,33 +0,0 @@ -/* - * Copyright © 2012 - 2014 Intel Corporation - * - * This library is free software; you can redistribute it and/or - * modify it under the terms of the GNU Lesser General Public - * License as published by the Free Software Foundation; either - * version 2.1 of the License, or (at your option) any later version. - * - * This library is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU - * Lesser General Public License for more details. - * - * You should have received a copy of the GNU Lesser General Public - * License along with this library. If not, see . - * - */ -#ifndef __OCL_MEMSET_H__ -#define __OCL_MEMSET_H__ -#include "ocl_types.h" - -///////////////////////////////////////////////////////////////////////////// -// memcopy functions -///////////////////////////////////////////////////////////////////////////// -void __gen_memset_g_align(__global uchar* dst, uchar val, size_t size); -void __gen_memset_p_align(__private uchar* dst, uchar val, size_t size); -void __gen_memset_l_align(__local uchar* dst, uchar val, size_t size); - -void __gen_memset_g(__global uchar* dst, uchar val, size_t size); -void __gen_memset_p(__private uchar* dst, uchar val, size_t size); -void __gen_memset_l(__local uchar* dst, uchar val, size_t size); - -#endif /* __OCL_MEMSET_H__ */ diff --git a/drivers/pocl-gen7/lib/beignet/include/ocl_misc.h b/drivers/pocl-gen7/lib/beignet/include/ocl_misc.h deleted file mode 100644 index 865ad38..0000000 --- a/drivers/pocl-gen7/lib/beignet/include/ocl_misc.h +++ /dev/null @@ -1,168 +0,0 @@ -/* - * Copyright © 2012 - 2014 Intel Corporation - * - * This library is free software; you can redistribute it and/or - * modify it under the terms of the GNU Lesser General Public - * License as published by the Free Software Foundation; either - * version 2.1 of the License, or (at your option) any later version. - * - * This library is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU - * Lesser General Public License for more details. - * - * You should have received a copy of the GNU Lesser General Public - * License along with this library. If not, see . - * - */ -#ifndef __OCL_MISC_H__ -#define __OCL_MISC_H__ - -#include "ocl_types.h" - -#define DEC2(TYPE, XTYPE, MASKTYPE) \ - OVERLOADABLE TYPE##2 shuffle(XTYPE x, MASKTYPE##2 mask); - -#define DEC4(TYPE, XTYPE, MASKTYPE) \ - OVERLOADABLE TYPE##4 shuffle(XTYPE x, MASKTYPE##4 mask); - -#define DEC8(TYPE, XTYPE, MASKTYPE) \ - OVERLOADABLE TYPE##8 shuffle(XTYPE x, MASKTYPE##8 mask); - -#define DEC16(TYPE, XTYPE, MASKTYPE) \ - OVERLOADABLE TYPE##16 shuffle(XTYPE x, MASKTYPE##16 mask); - -#define DEFMASK(TYPE, MASKTYPE) \ - DEC2(TYPE, TYPE##2, MASKTYPE); DEC2(TYPE, TYPE##4, MASKTYPE); DEC2(TYPE, TYPE##8, MASKTYPE); DEC2(TYPE, TYPE##16, MASKTYPE) \ - DEC4(TYPE, TYPE##2, MASKTYPE); DEC4(TYPE, TYPE##4, MASKTYPE); DEC4(TYPE, TYPE##8, MASKTYPE); DEC4(TYPE, TYPE##16, MASKTYPE) \ - DEC8(TYPE, TYPE##2, MASKTYPE); DEC8(TYPE, TYPE##4, MASKTYPE); DEC8(TYPE, TYPE##8, MASKTYPE); DEC8(TYPE, TYPE##16, MASKTYPE) \ - DEC16(TYPE, TYPE##2, MASKTYPE); DEC16(TYPE, TYPE##4, MASKTYPE); DEC16(TYPE, TYPE##8, MASKTYPE); DEC16(TYPE, TYPE##16, MASKTYPE) - -#define DEF(TYPE) \ - DEFMASK(TYPE, uchar) \ - DEFMASK(TYPE, ushort) \ - DEFMASK(TYPE, uint) \ - DEFMASK(TYPE, ulong) - -DEF(char) -DEF(uchar) -DEF(short) -DEF(ushort) -DEF(half) -DEF(int) -DEF(uint) -DEF(float) -DEF(long) -DEF(ulong) -DEF(double) -#undef DEF -#undef DEFMASK -#undef DEC2 -#undef DEC4 -#undef DEC8 -#undef DEC16 - -#define DEC2(TYPE, ARGTYPE, TEMPTYPE, MASKTYPE) \ - OVERLOADABLE TYPE##2 shuffle2(ARGTYPE x, ARGTYPE y, MASKTYPE##2 mask); - -#define DEC2X(TYPE, MASKTYPE) \ - OVERLOADABLE TYPE##2 shuffle2(TYPE##16 x, TYPE##16 y, MASKTYPE##2 mask); - -#define DEC4(TYPE, ARGTYPE, TEMPTYPE, MASKTYPE) \ - OVERLOADABLE TYPE##4 shuffle2(ARGTYPE x, ARGTYPE y, MASKTYPE##4 mask); - -#define DEC4X(TYPE, MASKTYPE) \ - OVERLOADABLE TYPE##4 shuffle2(TYPE##16 x, TYPE##16 y, MASKTYPE##4 mask); - -#define DEC8(TYPE, ARGTYPE, TEMPTYPE, MASKTYPE) \ - OVERLOADABLE TYPE##8 shuffle2(ARGTYPE x, ARGTYPE y, MASKTYPE##8 mask); - -#define DEC8X(TYPE, MASKTYPE) \ - OVERLOADABLE TYPE##8 shuffle2(TYPE##16 x, TYPE##16 y, MASKTYPE##8 mask); - -#define DEC16(TYPE, ARGTYPE, TEMPTYPE, MASKTYPE) \ - OVERLOADABLE TYPE##16 shuffle2(ARGTYPE x, ARGTYPE y, MASKTYPE##16 mask); - -#define DEC16X(TYPE, MASKTYPE) \ - OVERLOADABLE TYPE##16 shuffle2(TYPE##16 x, TYPE##16 y, MASKTYPE##16 mask); - -#define DEFMASK(TYPE, MASKTYPE) \ - DEC2(TYPE, TYPE##2, TYPE##4, MASKTYPE) \ - DEC2(TYPE, TYPE##4, TYPE##8, MASKTYPE) \ - DEC2(TYPE, TYPE##8, TYPE##16, MASKTYPE) \ - DEC2X(TYPE, MASKTYPE) \ - DEC4(TYPE, TYPE##2, TYPE##4, MASKTYPE) \ - DEC4(TYPE, TYPE##4, TYPE##8, MASKTYPE) \ - DEC4(TYPE, TYPE##8, TYPE##16, MASKTYPE) \ - DEC4X(TYPE, MASKTYPE) \ - DEC8(TYPE, TYPE##2, TYPE##4, MASKTYPE) \ - DEC8(TYPE, TYPE##4, TYPE##8, MASKTYPE) \ - DEC8(TYPE, TYPE##8, TYPE##16, MASKTYPE) \ - DEC8X(TYPE, MASKTYPE) \ - DEC16(TYPE, TYPE##2, TYPE##4, MASKTYPE) \ - DEC16(TYPE, TYPE##4, TYPE##8, MASKTYPE) \ - DEC16(TYPE, TYPE##8, TYPE##16, MASKTYPE) \ - DEC16X(TYPE, MASKTYPE) - -#define DEF(TYPE) \ - DEFMASK(TYPE, uchar) \ - DEFMASK(TYPE, ushort) \ - DEFMASK(TYPE, uint) \ - DEFMASK(TYPE, ulong) - -DEF(char) -DEF(uchar) -DEF(short) -DEF(ushort) -DEF(half) -DEF(int) -DEF(uint) -DEF(float) -DEF(long) -DEF(ulong) -DEF(double) -#undef DEF -#undef DEFMASK -#undef DEC2 -#undef DEC2X -#undef DEC4 -#undef DEC4X -#undef DEC8 -#undef DEC8X -#undef DEC16 -#undef DEC16X - -struct time_stamp { - // time tick - ulong tick; - // If context-switch or frequency change occurs since last read of tm, - // event will be non-zero, otherwise, it will be zero. - uint event; -}; - -uint __gen_ocl_region(ushort offset, uint data); - -struct time_stamp __gen_ocl_get_timestamp(void); - -uint8 __gen_ocl_vme(image2d_t, image2d_t, - uint, uint, uint, uint, - uint, uint, uint, uint, - uint, uint, uint, uint, - uint, uint, uint, uint, - uint, uint, uint, uint, - uint, uint, uint, uint, - uint, uint, uint, uint, - uint, uint, uint, uint, - uint, uint, uint, uint, - uint, uint, uint, uint, - int, int, int); - -bool __gen_ocl_in_local(size_t p); -bool __gen_ocl_in_private(size_t p); - -#if (__OPENCL_C_VERSION__ >= 200 && __OPENCL_C_VERSION__ < 300) -local void *__to_local(generic void *p); -global void *__to_global(generic void *p); -private void *__to_private(generic void *p); -#endif -#endif diff --git a/drivers/pocl-gen7/lib/beignet/include/ocl_pipe.h b/drivers/pocl-gen7/lib/beignet/include/ocl_pipe.h deleted file mode 100644 index 349b1dd..0000000 --- a/drivers/pocl-gen7/lib/beignet/include/ocl_pipe.h +++ /dev/null @@ -1,51 +0,0 @@ -/* - * Copyright © 2012 - 2014 Intel Corporation - * - * This library is free software; you can redistribute it and/or - * modify it under the terms of the GNU Lesser General Public - * License as published by the Free Software Foundation; either - * version 2.1 of the License, or (at your option) any later version. - * - * This library is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU - * Lesser General Public License for more details. - * - * You should have received a copy of the GNU Lesser General Public - * License along with this library. If not, see . - * - */ -#ifndef __OCL_PIPE_H__ -#define __OCL_PIPE_H__ - -#include "ocl_types.h" -#include "ocl_work_group.h" -#include "ocl_simd.h" - -/* The pipe read function. */ -int __read_pipe_2(pipe int p, __generic void* dst); -int __read_pipe_4(pipe int p, reserve_id_t id, uint index, void* dst); -reserve_id_t __reserve_read_pipe(pipe int p, uint num); -void __commit_read_pipe(pipe int p, reserve_id_t rid); -reserve_id_t __work_group_reserve_read_pipe(pipe int p, uint num); -void __work_group_commit_read_pipe(pipe int p, reserve_id_t rid); -reserve_id_t __sub_group_reserve_read_pipe(pipe int p, uint num); -void __sub_group_commit_read_pipe(pipe int p, reserve_id_t rid); - -/* The pipe write function. */ -int __write_pipe_2(pipe int p, __generic void* src); -int __write_pipe_4(pipe int p, reserve_id_t id, uint index, void* src); -reserve_id_t __reserve_write_pipe(pipe int p, uint num); -void __commit_write_pipe(pipe int p, reserve_id_t rid); -reserve_id_t __work_group_reserve_write_pipe(pipe int p, uint num); -void __work_group_commit_write_pipe(pipe int p, reserve_id_t rid); -reserve_id_t __sub_group_reserve_write_pipe(pipe int p, uint num); -void __sub_group_commit_write_pipe(pipe int p, reserve_id_t rid); - -/* The reserve_id_t function. */ -bool is_valid_reserve_id(reserve_id_t rid); - -/* The pipe query function. */ -uint __get_pipe_num_packets(pipe int p); -uint __get_pipe_max_packets(pipe int p); -#endif diff --git a/drivers/pocl-gen7/lib/beignet/include/ocl_printf.h b/drivers/pocl-gen7/lib/beignet/include/ocl_printf.h deleted file mode 100644 index 27cef27..0000000 --- a/drivers/pocl-gen7/lib/beignet/include/ocl_printf.h +++ /dev/null @@ -1,35 +0,0 @@ -/* - * Copyright © 2012 - 2014 Intel Corporation - * - * This library is free software; you can redistribute it and/or - * modify it under the terms of the GNU Lesser General Public - * License as published by the Free Software Foundation; either - * version 2.1 of the License, or (at your option) any later version. - * - * This library is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU - * Lesser General Public License for more details. - * - * You should have received a copy of the GNU Lesser General Public - * License along with this library. If not, see . - * - */ -#ifndef __OCL_PRINTF_H__ -#define __OCL_PRINTF_H__ - -#include "ocl_types.h" - -/* The printf function. */ -/* From LLVM 3.4, c string are all in constant address space */ -#if 100*__clang_major__ + __clang_minor__ < 304 -int __gen_ocl_printf_stub(const char * format, ...); -int __gen_ocl_puts_stub(const char * format); -#else -int __gen_ocl_printf_stub(constant char * format, ...); -int __gen_ocl_puts_stub(constant char * format); -#endif -#define printf __gen_ocl_printf_stub -#define puts __gen_ocl_puts_stub - -#endif diff --git a/drivers/pocl-gen7/lib/beignet/include/ocl_relational.h b/drivers/pocl-gen7/lib/beignet/include/ocl_relational.h deleted file mode 100644 index f035747..0000000 --- a/drivers/pocl-gen7/lib/beignet/include/ocl_relational.h +++ /dev/null @@ -1,677 +0,0 @@ -/* - * Copyright © 2012 - 2014 Intel Corporation - * - * This library is free software; you can redistribute it and/or - * modify it under the terms of the GNU Lesser General Public - * License as published by the Free Software Foundation; either - * version 2.1 of the License, or (at your option) any later version. - * - * This library is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU - * Lesser General Public License for more details. - * - * You should have received a copy of the GNU Lesser General Public - * License along with this library. If not, see . - * - */ -#ifndef __OCL_RELATIONAL_H__ -#define __OCL_RELATIONAL_H__ - -#include "ocl_types.h" -#include "ocl_as.h" - -OVERLOADABLE int isequal(float x, float y); -OVERLOADABLE int isnotequal(float x, float y); -OVERLOADABLE int isgreater(float x, float y); -OVERLOADABLE int isgreaterequal(float x, float y); -OVERLOADABLE int isless(float x, float y); -OVERLOADABLE int islessequal(float x, float y); -OVERLOADABLE int islessgreater(float x, float y); - -OVERLOADABLE int isfinite(float x); -OVERLOADABLE int isinf(float x); -OVERLOADABLE int isnan(float x); -OVERLOADABLE int isnormal(float x); - -OVERLOADABLE int isordered(float x, float y); -OVERLOADABLE int isunordered(float x, float y); -OVERLOADABLE int signbit(float x); - -// Half half version. -OVERLOADABLE int isequal(half x, half y); -OVERLOADABLE int isnotequal(half x, half y); -OVERLOADABLE int isgreater(half x, half y); -OVERLOADABLE int isgreaterequal(half x, half y); -OVERLOADABLE int isless(half x, half y); -OVERLOADABLE int islessequal(half x, half y); -OVERLOADABLE int islessgreater(half x, half y); - -OVERLOADABLE int isfinite(half x); -OVERLOADABLE int isinf(half x); -OVERLOADABLE int isnan(half x); -OVERLOADABLE int isnormal(half x); - -OVERLOADABLE int isordered(half x, half y); -OVERLOADABLE int isunordered(half x, half y); -OVERLOADABLE int signbit(half x); - -OVERLOADABLE int isequal(double x, double y); -OVERLOADABLE int isnotequal(double x, double y); -OVERLOADABLE int isgreater(double x, double y); -OVERLOADABLE int isgreaterequal(double x, double y); -OVERLOADABLE int isless(double x, double y); -OVERLOADABLE int islessequal(double x, double y); -OVERLOADABLE int islessgreater(double x, double y); - -OVERLOADABLE int isfinite(double x); -OVERLOADABLE int isinf(double x); -OVERLOADABLE int isnan(double x); -OVERLOADABLE int isnormal(double x); - -OVERLOADABLE int isordered(double x, double y); -OVERLOADABLE int isunordered(double x, double y); -OVERLOADABLE int signbit(double x); - -// any -#define DEC1(type) OVERLOADABLE int any(type a); -#define DEC2(type) OVERLOADABLE int any(type a); -#define DEC3(type) OVERLOADABLE int any(type a); -#define DEC4(type) OVERLOADABLE int any(type a); -#define DEC8(type) OVERLOADABLE int any(type a); -#define DEC16(type) OVERLOADABLE int any(type a); -DEC1(char); -DEC1(short); -DEC1(int); -DEC1(long); -#define DEC(n) DEC##n(char##n); DEC##n(short##n); DEC##n(int##n); DEC##n(long##n); -DEC(2); -DEC(3); -DEC(4); -DEC(8); -DEC(16); -#undef DEC -#undef DEC1 -#undef DEC2 -#undef DEC3 -#undef DEC4 -#undef DEC8 -#undef DEC16 - -// all -#define DEC1(type) OVERLOADABLE int all(type a); -#define DEC2(type) OVERLOADABLE int all(type a); -#define DEC3(type) OVERLOADABLE int all(type a); -#define DEC4(type) OVERLOADABLE int all(type a); -#define DEC8(type) OVERLOADABLE int all(type a); -#define DEC16(type) OVERLOADABLE int all(type a); -DEC1(char) -DEC1(short) -DEC1(int) -DEC1(long) -#define DEC(n) DEC##n(char##n) DEC##n(short##n) DEC##n(int##n) DEC##n(long##n) -DEC(2) -DEC(3) -DEC(4) -DEC(8) -DEC(16) -#undef DEC -#undef DEC1 -#undef DEC2 -#undef DEC3 -#undef DEC4 -#undef DEC8 -#undef DEC16 - -#define DEF(type) OVERLOADABLE type bitselect(type a, type b, type c); -DEF(char) DEF(uchar) DEF(short) DEF(ushort) DEF(int) DEF(uint) -DEF(long) DEF(ulong) -#undef DEF -OVERLOADABLE float bitselect(float a, float b, float c); -OVERLOADABLE half bitselect(half a, half b, half c); -OVERLOADABLE double bitselect(double a, double b, double c); - - -#define DEF(TYPE1, TYPE2) \ -OVERLOADABLE TYPE1 select(TYPE1 src0, TYPE1 src1, TYPE2 cond); -DEF(char, char) -DEF(char, uchar) -DEF(uchar, char) -DEF(uchar, uchar) -DEF(short, short) -DEF(short, ushort) -DEF(ushort, short) -DEF(ushort, ushort) -DEF(int, int) -DEF(int, uint) -DEF(uint, int) -DEF(uint, uint) -DEF(long, long) -DEF(long, ulong) -DEF(ulong, long) -DEF(ulong, ulong) -DEF(float, int) -DEF(float, uint) -DEF(half, short) -DEF(half, ushort) -#undef DEF -//Begin from this part is autogenerated. -//Don't modify it manually. -//relational builtin functions -//intn isequal (floatn x, floatn y) - -OVERLOADABLE int2 isequal (float2 param0, float2 param1); -OVERLOADABLE int3 isequal (float3 param0, float3 param1); -OVERLOADABLE int4 isequal (float4 param0, float4 param1); -OVERLOADABLE int8 isequal (float8 param0, float8 param1); -OVERLOADABLE int16 isequal (float16 param0, float16 param1); - -//shortn isequal (halfn x, halfn y) - -OVERLOADABLE short2 isequal (half2 param0, half2 param1); -OVERLOADABLE short3 isequal (half3 param0, half3 param1); -OVERLOADABLE short4 isequal (half4 param0, half4 param1); -OVERLOADABLE short8 isequal (half8 param0, half8 param1); -OVERLOADABLE short16 isequal (half16 param0, half16 param1); - -//longn isequal (doublen x, doublen y) - -OVERLOADABLE long2 isequal (double2 param0, double2 param1); -OVERLOADABLE long3 isequal (double3 param0, double3 param1); -OVERLOADABLE long4 isequal (double4 param0, double4 param1); -OVERLOADABLE long8 isequal (double8 param0, double8 param1); -OVERLOADABLE long16 isequal (double16 param0, double16 param1); - -//intn isnotequal (floatn x, floatn y) - -OVERLOADABLE int2 isnotequal (float2 param0, float2 param1); -OVERLOADABLE int3 isnotequal (float3 param0, float3 param1); -OVERLOADABLE int4 isnotequal (float4 param0, float4 param1); -OVERLOADABLE int8 isnotequal (float8 param0, float8 param1); -OVERLOADABLE int16 isnotequal (float16 param0, float16 param1); - -//shortn isnotequal (halfn x, halfn y) - -OVERLOADABLE short2 isnotequal (half2 param0, half2 param1); -OVERLOADABLE short3 isnotequal (half3 param0, half3 param1); -OVERLOADABLE short4 isnotequal (half4 param0, half4 param1); -OVERLOADABLE short8 isnotequal (half8 param0, half8 param1); -OVERLOADABLE short16 isnotequal (half16 param0, half16 param1); - -//longn isnotequal (doublen x, doublen y) - -OVERLOADABLE long2 isnotequal (double2 param0, double2 param1); -OVERLOADABLE long3 isnotequal (double3 param0, double3 param1); -OVERLOADABLE long4 isnotequal (double4 param0, double4 param1); -OVERLOADABLE long8 isnotequal (double8 param0, double8 param1); -OVERLOADABLE long16 isnotequal (double16 param0, double16 param1); - -//intn isgreater (floatn x, floatn y) - -OVERLOADABLE int2 isgreater (float2 param0, float2 param1); -OVERLOADABLE int3 isgreater (float3 param0, float3 param1); -OVERLOADABLE int4 isgreater (float4 param0, float4 param1); -OVERLOADABLE int8 isgreater (float8 param0, float8 param1); -OVERLOADABLE int16 isgreater (float16 param0, float16 param1); - -//shortn isgreater (halfn x, halfn y) - -OVERLOADABLE short2 isgreater (half2 param0, half2 param1); -OVERLOADABLE short3 isgreater (half3 param0, half3 param1); -OVERLOADABLE short4 isgreater (half4 param0, half4 param1); -OVERLOADABLE short8 isgreater (half8 param0, half8 param1); -OVERLOADABLE short16 isgreater (half16 param0, half16 param1); - -//longn isgreater (doublen x, doublen y) - -OVERLOADABLE long2 isgreater (double2 param0, double2 param1); -OVERLOADABLE long3 isgreater (double3 param0, double3 param1); -OVERLOADABLE long4 isgreater (double4 param0, double4 param1); -OVERLOADABLE long8 isgreater (double8 param0, double8 param1); -OVERLOADABLE long16 isgreater (double16 param0, double16 param1); - -//intn isgreaterequal (floatn x, floatn y) - -OVERLOADABLE int2 isgreaterequal (float2 param0, float2 param1); -OVERLOADABLE int3 isgreaterequal (float3 param0, float3 param1); -OVERLOADABLE int4 isgreaterequal (float4 param0, float4 param1); -OVERLOADABLE int8 isgreaterequal (float8 param0, float8 param1); -OVERLOADABLE int16 isgreaterequal (float16 param0, float16 param1); - -//shortn isgreaterequal (halfn x, halfn y) - -OVERLOADABLE short2 isgreaterequal (half2 param0, half2 param1); -OVERLOADABLE short3 isgreaterequal (half3 param0, half3 param1); -OVERLOADABLE short4 isgreaterequal (half4 param0, half4 param1); -OVERLOADABLE short8 isgreaterequal (half8 param0, half8 param1); -OVERLOADABLE short16 isgreaterequal (half16 param0, half16 param1); - -//longn isgreaterequal (doublen x, doublen y) - -OVERLOADABLE long2 isgreaterequal (double2 param0, double2 param1); -OVERLOADABLE long3 isgreaterequal (double3 param0, double3 param1); -OVERLOADABLE long4 isgreaterequal (double4 param0, double4 param1); -OVERLOADABLE long8 isgreaterequal (double8 param0, double8 param1); -OVERLOADABLE long16 isgreaterequal (double16 param0, double16 param1); - -//intn isless (floatn x, floatn y) - -OVERLOADABLE int2 isless (float2 param0, float2 param1); -OVERLOADABLE int3 isless (float3 param0, float3 param1); -OVERLOADABLE int4 isless (float4 param0, float4 param1); -OVERLOADABLE int8 isless (float8 param0, float8 param1); -OVERLOADABLE int16 isless (float16 param0, float16 param1); - -//shortn isless (halfn x, halfn y) - -OVERLOADABLE short2 isless (half2 param0, half2 param1); -OVERLOADABLE short3 isless (half3 param0, half3 param1); -OVERLOADABLE short4 isless (half4 param0, half4 param1); -OVERLOADABLE short8 isless (half8 param0, half8 param1); -OVERLOADABLE short16 isless (half16 param0, half16 param1); - -//longn isless (doublen x, doublen y) - -OVERLOADABLE long2 isless (double2 param0, double2 param1); -OVERLOADABLE long3 isless (double3 param0, double3 param1); -OVERLOADABLE long4 isless (double4 param0, double4 param1); -OVERLOADABLE long8 isless (double8 param0, double8 param1); -OVERLOADABLE long16 isless (double16 param0, double16 param1); - -//intn islessequal (floatn x, floatn y) - -OVERLOADABLE int2 islessequal (float2 param0, float2 param1); -OVERLOADABLE int3 islessequal (float3 param0, float3 param1); -OVERLOADABLE int4 islessequal (float4 param0, float4 param1); -OVERLOADABLE int8 islessequal (float8 param0, float8 param1); -OVERLOADABLE int16 islessequal (float16 param0, float16 param1); - -//shortn islessequal (halfn x, halfn y) - -OVERLOADABLE short2 islessequal (half2 param0, half2 param1); -OVERLOADABLE short3 islessequal (half3 param0, half3 param1); -OVERLOADABLE short4 islessequal (half4 param0, half4 param1); -OVERLOADABLE short8 islessequal (half8 param0, half8 param1); -OVERLOADABLE short16 islessequal (half16 param0, half16 param1); - -//longn islessequal (doublen x, doublen y) - -OVERLOADABLE long2 islessequal (double2 param0, double2 param1); -OVERLOADABLE long3 islessequal (double3 param0, double3 param1); -OVERLOADABLE long4 islessequal (double4 param0, double4 param1); -OVERLOADABLE long8 islessequal (double8 param0, double8 param1); -OVERLOADABLE long16 islessequal (double16 param0, double16 param1); - -//intn islessgreater (floatn x, floatn y) - -OVERLOADABLE int2 islessgreater (float2 param0, float2 param1); -OVERLOADABLE int3 islessgreater (float3 param0, float3 param1); -OVERLOADABLE int4 islessgreater (float4 param0, float4 param1); -OVERLOADABLE int8 islessgreater (float8 param0, float8 param1); -OVERLOADABLE int16 islessgreater (float16 param0, float16 param1); - -//shortn islessgreater (halfn x, halfn y) - -OVERLOADABLE short2 islessgreater (half2 param0, half2 param1); -OVERLOADABLE short3 islessgreater (half3 param0, half3 param1); -OVERLOADABLE short4 islessgreater (half4 param0, half4 param1); -OVERLOADABLE short8 islessgreater (half8 param0, half8 param1); -OVERLOADABLE short16 islessgreater (half16 param0, half16 param1); - -//longn islessgreater (doublen x, doublen y) - -OVERLOADABLE long2 islessgreater (double2 param0, double2 param1); -OVERLOADABLE long3 islessgreater (double3 param0, double3 param1); -OVERLOADABLE long4 islessgreater (double4 param0, double4 param1); -OVERLOADABLE long8 islessgreater (double8 param0, double8 param1); -OVERLOADABLE long16 islessgreater (double16 param0, double16 param1); - -//intn isfinite (floatn) - -OVERLOADABLE int2 isfinite (float2 param0); -OVERLOADABLE int3 isfinite (float3 param0); -OVERLOADABLE int4 isfinite (float4 param0); -OVERLOADABLE int8 isfinite (float8 param0); -OVERLOADABLE int16 isfinite (float16 param0); - -//shortn isfinite (halfn) - -OVERLOADABLE short2 isfinite (half2 param0); -OVERLOADABLE short3 isfinite (half3 param0); -OVERLOADABLE short4 isfinite (half4 param0); -OVERLOADABLE short8 isfinite (half8 param0); -OVERLOADABLE short16 isfinite (half16 param0); - -//longn isfinite (doublen) - -OVERLOADABLE long2 isfinite (double2 param0); -OVERLOADABLE long3 isfinite (double3 param0); -OVERLOADABLE long4 isfinite (double4 param0); -OVERLOADABLE long8 isfinite (double8 param0); -OVERLOADABLE long16 isfinite (double16 param0); - -//intn isinf (floatn) - -OVERLOADABLE int2 isinf (float2 param0); -OVERLOADABLE int3 isinf (float3 param0); -OVERLOADABLE int4 isinf (float4 param0); -OVERLOADABLE int8 isinf (float8 param0); -OVERLOADABLE int16 isinf (float16 param0); - -//shortn isinf (halfn) - -OVERLOADABLE short2 isinf (half2 param0); -OVERLOADABLE short3 isinf (half3 param0); -OVERLOADABLE short4 isinf (half4 param0); -OVERLOADABLE short8 isinf (half8 param0); -OVERLOADABLE short16 isinf (half16 param0); - -//longn isinf (doublen) - -OVERLOADABLE long2 isinf (double2 param0); -OVERLOADABLE long3 isinf (double3 param0); -OVERLOADABLE long4 isinf (double4 param0); -OVERLOADABLE long8 isinf (double8 param0); -OVERLOADABLE long16 isinf (double16 param0); - -//intn isnan (floatn) - -OVERLOADABLE int2 isnan (float2 param0); -OVERLOADABLE int3 isnan (float3 param0); -OVERLOADABLE int4 isnan (float4 param0); -OVERLOADABLE int8 isnan (float8 param0); -OVERLOADABLE int16 isnan (float16 param0); - -//shortn isnan (halfn) - -OVERLOADABLE short2 isnan (half2 param0); -OVERLOADABLE short3 isnan (half3 param0); -OVERLOADABLE short4 isnan (half4 param0); -OVERLOADABLE short8 isnan (half8 param0); -OVERLOADABLE short16 isnan (half16 param0); - -//longn isnan (doublen) - -OVERLOADABLE long2 isnan (double2 param0); -OVERLOADABLE long3 isnan (double3 param0); -OVERLOADABLE long4 isnan (double4 param0); -OVERLOADABLE long8 isnan (double8 param0); -OVERLOADABLE long16 isnan (double16 param0); - -//intn isnormal (floatn) - -OVERLOADABLE int2 isnormal (float2 param0); -OVERLOADABLE int3 isnormal (float3 param0); -OVERLOADABLE int4 isnormal (float4 param0); -OVERLOADABLE int8 isnormal (float8 param0); -OVERLOADABLE int16 isnormal (float16 param0); - -//shortn isnormal (halfn) - -OVERLOADABLE short2 isnormal (half2 param0); -OVERLOADABLE short3 isnormal (half3 param0); -OVERLOADABLE short4 isnormal (half4 param0); -OVERLOADABLE short8 isnormal (half8 param0); -OVERLOADABLE short16 isnormal (half16 param0); - -//longn isnormal (doublen) - -OVERLOADABLE long2 isnormal (double2 param0); -OVERLOADABLE long3 isnormal (double3 param0); -OVERLOADABLE long4 isnormal (double4 param0); -OVERLOADABLE long8 isnormal (double8 param0); -OVERLOADABLE long16 isnormal (double16 param0); - -//intn isordered (floatn x, floatn y) - -OVERLOADABLE int2 isordered (float2 param0, float2 param1); -OVERLOADABLE int3 isordered (float3 param0, float3 param1); -OVERLOADABLE int4 isordered (float4 param0, float4 param1); -OVERLOADABLE int8 isordered (float8 param0, float8 param1); -OVERLOADABLE int16 isordered (float16 param0, float16 param1); - -//shortn isordered (halfn x, halfn y) - -OVERLOADABLE short2 isordered (half2 param0, half2 param1); -OVERLOADABLE short3 isordered (half3 param0, half3 param1); -OVERLOADABLE short4 isordered (half4 param0, half4 param1); -OVERLOADABLE short8 isordered (half8 param0, half8 param1); -OVERLOADABLE short16 isordered (half16 param0, half16 param1); - -//longn isordered (doublen x, doublen y) - -OVERLOADABLE long2 isordered (double2 param0, double2 param1); -OVERLOADABLE long3 isordered (double3 param0, double3 param1); -OVERLOADABLE long4 isordered (double4 param0, double4 param1); -OVERLOADABLE long8 isordered (double8 param0, double8 param1); -OVERLOADABLE long16 isordered (double16 param0, double16 param1); - -//intn isunordered (floatn x, floatn y) - -OVERLOADABLE int2 isunordered (float2 param0, float2 param1); -OVERLOADABLE int3 isunordered (float3 param0, float3 param1); -OVERLOADABLE int4 isunordered (float4 param0, float4 param1); -OVERLOADABLE int8 isunordered (float8 param0, float8 param1); -OVERLOADABLE int16 isunordered (float16 param0, float16 param1); - -//shortn isunordered (halfn x, halfn y) - -OVERLOADABLE short2 isunordered (half2 param0, half2 param1); -OVERLOADABLE short3 isunordered (half3 param0, half3 param1); -OVERLOADABLE short4 isunordered (half4 param0, half4 param1); -OVERLOADABLE short8 isunordered (half8 param0, half8 param1); -OVERLOADABLE short16 isunordered (half16 param0, half16 param1); - -//longn isunordered (doublen x, doublen y) - -OVERLOADABLE long2 isunordered (double2 param0, double2 param1); -OVERLOADABLE long3 isunordered (double3 param0, double3 param1); -OVERLOADABLE long4 isunordered (double4 param0, double4 param1); -OVERLOADABLE long8 isunordered (double8 param0, double8 param1); -OVERLOADABLE long16 isunordered (double16 param0, double16 param1); - -//intn signbit (floatn) - -OVERLOADABLE int2 signbit (float2 param0); -OVERLOADABLE int3 signbit (float3 param0); -OVERLOADABLE int4 signbit (float4 param0); -OVERLOADABLE int8 signbit (float8 param0); -OVERLOADABLE int16 signbit (float16 param0); - -//shortn signbit (halfn) - -OVERLOADABLE short2 signbit (half2 param0); -OVERLOADABLE short3 signbit (half3 param0); -OVERLOADABLE short4 signbit (half4 param0); -OVERLOADABLE short8 signbit (half8 param0); -OVERLOADABLE short16 signbit (half16 param0); - -//longn signbit (doublen) - -OVERLOADABLE long2 signbit (double2 param0); -OVERLOADABLE long3 signbit (double3 param0); -OVERLOADABLE long4 signbit (double4 param0); -OVERLOADABLE long8 signbit (double8 param0); -OVERLOADABLE long16 signbit (double16 param0); - -//int any (igentype x) - - -//int all (igentype x) - - -//gentype bitselect (gentype a, gentype b, gentype c) - -OVERLOADABLE char2 bitselect (char2 param0, char2 param1, char2 param2); -OVERLOADABLE char3 bitselect (char3 param0, char3 param1, char3 param2); -OVERLOADABLE char4 bitselect (char4 param0, char4 param1, char4 param2); -OVERLOADABLE char8 bitselect (char8 param0, char8 param1, char8 param2); -OVERLOADABLE char16 bitselect (char16 param0, char16 param1, char16 param2); -OVERLOADABLE short2 bitselect (short2 param0, short2 param1, short2 param2); -OVERLOADABLE short3 bitselect (short3 param0, short3 param1, short3 param2); -OVERLOADABLE short4 bitselect (short4 param0, short4 param1, short4 param2); -OVERLOADABLE short8 bitselect (short8 param0, short8 param1, short8 param2); -OVERLOADABLE short16 bitselect (short16 param0, short16 param1, short16 param2); -OVERLOADABLE int2 bitselect (int2 param0, int2 param1, int2 param2); -OVERLOADABLE int3 bitselect (int3 param0, int3 param1, int3 param2); -OVERLOADABLE int4 bitselect (int4 param0, int4 param1, int4 param2); -OVERLOADABLE int8 bitselect (int8 param0, int8 param1, int8 param2); -OVERLOADABLE int16 bitselect (int16 param0, int16 param1, int16 param2); -OVERLOADABLE long2 bitselect (long2 param0, long2 param1, long2 param2); -OVERLOADABLE long3 bitselect (long3 param0, long3 param1, long3 param2); -OVERLOADABLE long4 bitselect (long4 param0, long4 param1, long4 param2); -OVERLOADABLE long8 bitselect (long8 param0, long8 param1, long8 param2); -OVERLOADABLE long16 bitselect (long16 param0, long16 param1, long16 param2); -OVERLOADABLE uchar2 bitselect (uchar2 param0, uchar2 param1, uchar2 param2); -OVERLOADABLE uchar3 bitselect (uchar3 param0, uchar3 param1, uchar3 param2); -OVERLOADABLE uchar4 bitselect (uchar4 param0, uchar4 param1, uchar4 param2); -OVERLOADABLE uchar8 bitselect (uchar8 param0, uchar8 param1, uchar8 param2); -OVERLOADABLE uchar16 bitselect (uchar16 param0, uchar16 param1, uchar16 param2); -OVERLOADABLE ushort2 bitselect (ushort2 param0, ushort2 param1, ushort2 param2); -OVERLOADABLE ushort3 bitselect (ushort3 param0, ushort3 param1, ushort3 param2); -OVERLOADABLE ushort4 bitselect (ushort4 param0, ushort4 param1, ushort4 param2); -OVERLOADABLE ushort8 bitselect (ushort8 param0, ushort8 param1, ushort8 param2); -OVERLOADABLE ushort16 bitselect (ushort16 param0, ushort16 param1, ushort16 param2); -OVERLOADABLE uint2 bitselect (uint2 param0, uint2 param1, uint2 param2); -OVERLOADABLE uint3 bitselect (uint3 param0, uint3 param1, uint3 param2); -OVERLOADABLE uint4 bitselect (uint4 param0, uint4 param1, uint4 param2); -OVERLOADABLE uint8 bitselect (uint8 param0, uint8 param1, uint8 param2); -OVERLOADABLE uint16 bitselect (uint16 param0, uint16 param1, uint16 param2); -OVERLOADABLE ulong2 bitselect (ulong2 param0, ulong2 param1, ulong2 param2); -OVERLOADABLE ulong3 bitselect (ulong3 param0, ulong3 param1, ulong3 param2); -OVERLOADABLE ulong4 bitselect (ulong4 param0, ulong4 param1, ulong4 param2); -OVERLOADABLE ulong8 bitselect (ulong8 param0, ulong8 param1, ulong8 param2); -OVERLOADABLE ulong16 bitselect (ulong16 param0, ulong16 param1, ulong16 param2); -OVERLOADABLE float2 bitselect (float2 param0, float2 param1, float2 param2); -OVERLOADABLE float3 bitselect (float3 param0, float3 param1, float3 param2); -OVERLOADABLE float4 bitselect (float4 param0, float4 param1, float4 param2); -OVERLOADABLE float8 bitselect (float8 param0, float8 param1, float8 param2); -OVERLOADABLE float16 bitselect (float16 param0, float16 param1, float16 param2); -OVERLOADABLE double2 bitselect (double2 param0, double2 param1, double2 param2); -OVERLOADABLE double3 bitselect (double3 param0, double3 param1, double3 param2); -OVERLOADABLE double4 bitselect (double4 param0, double4 param1, double4 param2); -OVERLOADABLE double8 bitselect (double8 param0, double8 param1, double8 param2); -OVERLOADABLE double16 bitselect (double16 param0, double16 param1, double16 param2); -OVERLOADABLE half2 bitselect (half2 param0, half2 param1, half2 param2); -OVERLOADABLE half3 bitselect (half3 param0, half3 param1, half3 param2); -OVERLOADABLE half4 bitselect (half4 param0, half4 param1, half4 param2); -OVERLOADABLE half8 bitselect (half8 param0, half8 param1, half8 param2); -OVERLOADABLE half16 bitselect (half16 param0, half16 param1, half16 param2); - -//gentype select (gentype a, gentype b, igentype c) - -OVERLOADABLE char2 select (char2 param0, char2 param1, char2 param2); -OVERLOADABLE char3 select (char3 param0, char3 param1, char3 param2); -OVERLOADABLE char4 select (char4 param0, char4 param1, char4 param2); -OVERLOADABLE char8 select (char8 param0, char8 param1, char8 param2); -OVERLOADABLE char16 select (char16 param0, char16 param1, char16 param2); -OVERLOADABLE short2 select (short2 param0, short2 param1, short2 param2); -OVERLOADABLE short3 select (short3 param0, short3 param1, short3 param2); -OVERLOADABLE short4 select (short4 param0, short4 param1, short4 param2); -OVERLOADABLE short8 select (short8 param0, short8 param1, short8 param2); -OVERLOADABLE short16 select (short16 param0, short16 param1, short16 param2); -OVERLOADABLE int2 select (int2 param0, int2 param1, int2 param2); -OVERLOADABLE int3 select (int3 param0, int3 param1, int3 param2); -OVERLOADABLE int4 select (int4 param0, int4 param1, int4 param2); -OVERLOADABLE int8 select (int8 param0, int8 param1, int8 param2); -OVERLOADABLE int16 select (int16 param0, int16 param1, int16 param2); -OVERLOADABLE long2 select (long2 param0, long2 param1, long2 param2); -OVERLOADABLE long3 select (long3 param0, long3 param1, long3 param2); -OVERLOADABLE long4 select (long4 param0, long4 param1, long4 param2); -OVERLOADABLE long8 select (long8 param0, long8 param1, long8 param2); -OVERLOADABLE long16 select (long16 param0, long16 param1, long16 param2); -OVERLOADABLE uchar2 select (uchar2 param0, uchar2 param1, char2 param2); -OVERLOADABLE uchar3 select (uchar3 param0, uchar3 param1, char3 param2); -OVERLOADABLE uchar4 select (uchar4 param0, uchar4 param1, char4 param2); -OVERLOADABLE uchar8 select (uchar8 param0, uchar8 param1, char8 param2); -OVERLOADABLE uchar16 select (uchar16 param0, uchar16 param1, char16 param2); -OVERLOADABLE ushort2 select (ushort2 param0, ushort2 param1, short2 param2); -OVERLOADABLE ushort3 select (ushort3 param0, ushort3 param1, short3 param2); -OVERLOADABLE ushort4 select (ushort4 param0, ushort4 param1, short4 param2); -OVERLOADABLE ushort8 select (ushort8 param0, ushort8 param1, short8 param2); -OVERLOADABLE ushort16 select (ushort16 param0, ushort16 param1, short16 param2); -OVERLOADABLE uint2 select (uint2 param0, uint2 param1, int2 param2); -OVERLOADABLE uint3 select (uint3 param0, uint3 param1, int3 param2); -OVERLOADABLE uint4 select (uint4 param0, uint4 param1, int4 param2); -OVERLOADABLE uint8 select (uint8 param0, uint8 param1, int8 param2); -OVERLOADABLE uint16 select (uint16 param0, uint16 param1, int16 param2); -OVERLOADABLE ulong2 select (ulong2 param0, ulong2 param1, long2 param2); -OVERLOADABLE ulong3 select (ulong3 param0, ulong3 param1, long3 param2); -OVERLOADABLE ulong4 select (ulong4 param0, ulong4 param1, long4 param2); -OVERLOADABLE ulong8 select (ulong8 param0, ulong8 param1, long8 param2); -OVERLOADABLE ulong16 select (ulong16 param0, ulong16 param1, long16 param2); -OVERLOADABLE float2 select (float2 param0, float2 param1, int2 param2); -OVERLOADABLE float3 select (float3 param0, float3 param1, int3 param2); -OVERLOADABLE float4 select (float4 param0, float4 param1, int4 param2); -OVERLOADABLE float8 select (float8 param0, float8 param1, int8 param2); -OVERLOADABLE float16 select (float16 param0, float16 param1, int16 param2); -OVERLOADABLE double2 select (double2 param0, double2 param1, long2 param2); -OVERLOADABLE double3 select (double3 param0, double3 param1, long3 param2); -OVERLOADABLE double4 select (double4 param0, double4 param1, long4 param2); -OVERLOADABLE double8 select (double8 param0, double8 param1, long8 param2); -OVERLOADABLE double16 select (double16 param0, double16 param1, long16 param2); -OVERLOADABLE half2 select (half2 param0, half2 param1, short2 param2); -OVERLOADABLE half3 select (half3 param0, half3 param1, short3 param2); -OVERLOADABLE half4 select (half4 param0, half4 param1, short4 param2); -OVERLOADABLE half8 select (half8 param0, half8 param1, short8 param2); -OVERLOADABLE half16 select (half16 param0, half16 param1, short16 param2); - -//gentype select (gentype a, gentype b, ugentype c) - -OVERLOADABLE char2 select (char2 param0, char2 param1, uchar2 param2); -OVERLOADABLE char3 select (char3 param0, char3 param1, uchar3 param2); -OVERLOADABLE char4 select (char4 param0, char4 param1, uchar4 param2); -OVERLOADABLE char8 select (char8 param0, char8 param1, uchar8 param2); -OVERLOADABLE char16 select (char16 param0, char16 param1, uchar16 param2); -OVERLOADABLE short2 select (short2 param0, short2 param1, ushort2 param2); -OVERLOADABLE short3 select (short3 param0, short3 param1, ushort3 param2); -OVERLOADABLE short4 select (short4 param0, short4 param1, ushort4 param2); -OVERLOADABLE short8 select (short8 param0, short8 param1, ushort8 param2); -OVERLOADABLE short16 select (short16 param0, short16 param1, ushort16 param2); -OVERLOADABLE int2 select (int2 param0, int2 param1, uint2 param2); -OVERLOADABLE int3 select (int3 param0, int3 param1, uint3 param2); -OVERLOADABLE int4 select (int4 param0, int4 param1, uint4 param2); -OVERLOADABLE int8 select (int8 param0, int8 param1, uint8 param2); -OVERLOADABLE int16 select (int16 param0, int16 param1, uint16 param2); -OVERLOADABLE long2 select (long2 param0, long2 param1, ulong2 param2); -OVERLOADABLE long3 select (long3 param0, long3 param1, ulong3 param2); -OVERLOADABLE long4 select (long4 param0, long4 param1, ulong4 param2); -OVERLOADABLE long8 select (long8 param0, long8 param1, ulong8 param2); -OVERLOADABLE long16 select (long16 param0, long16 param1, ulong16 param2); -OVERLOADABLE uchar2 select (uchar2 param0, uchar2 param1, uchar2 param2); -OVERLOADABLE uchar3 select (uchar3 param0, uchar3 param1, uchar3 param2); -OVERLOADABLE uchar4 select (uchar4 param0, uchar4 param1, uchar4 param2); -OVERLOADABLE uchar8 select (uchar8 param0, uchar8 param1, uchar8 param2); -OVERLOADABLE uchar16 select (uchar16 param0, uchar16 param1, uchar16 param2); -OVERLOADABLE ushort2 select (ushort2 param0, ushort2 param1, ushort2 param2); -OVERLOADABLE ushort3 select (ushort3 param0, ushort3 param1, ushort3 param2); -OVERLOADABLE ushort4 select (ushort4 param0, ushort4 param1, ushort4 param2); -OVERLOADABLE ushort8 select (ushort8 param0, ushort8 param1, ushort8 param2); -OVERLOADABLE ushort16 select (ushort16 param0, ushort16 param1, ushort16 param2); -OVERLOADABLE uint2 select (uint2 param0, uint2 param1, uint2 param2); -OVERLOADABLE uint3 select (uint3 param0, uint3 param1, uint3 param2); -OVERLOADABLE uint4 select (uint4 param0, uint4 param1, uint4 param2); -OVERLOADABLE uint8 select (uint8 param0, uint8 param1, uint8 param2); -OVERLOADABLE uint16 select (uint16 param0, uint16 param1, uint16 param2); -OVERLOADABLE ulong2 select (ulong2 param0, ulong2 param1, ulong2 param2); -OVERLOADABLE ulong3 select (ulong3 param0, ulong3 param1, ulong3 param2); -OVERLOADABLE ulong4 select (ulong4 param0, ulong4 param1, ulong4 param2); -OVERLOADABLE ulong8 select (ulong8 param0, ulong8 param1, ulong8 param2); -OVERLOADABLE ulong16 select (ulong16 param0, ulong16 param1, ulong16 param2); -OVERLOADABLE float2 select (float2 param0, float2 param1, uint2 param2); -OVERLOADABLE float3 select (float3 param0, float3 param1, uint3 param2); -OVERLOADABLE float4 select (float4 param0, float4 param1, uint4 param2); -OVERLOADABLE float8 select (float8 param0, float8 param1, uint8 param2); -OVERLOADABLE float16 select (float16 param0, float16 param1, uint16 param2); -OVERLOADABLE double2 select (double2 param0, double2 param1, ulong2 param2); -OVERLOADABLE double3 select (double3 param0, double3 param1, ulong3 param2); -OVERLOADABLE double4 select (double4 param0, double4 param1, ulong4 param2); -OVERLOADABLE double8 select (double8 param0, double8 param1, ulong8 param2); -OVERLOADABLE double16 select (double16 param0, double16 param1, ulong16 param2); -OVERLOADABLE half2 select (half2 param0, half2 param1, ushort2 param2); -OVERLOADABLE half3 select (half3 param0, half3 param1, ushort3 param2); -OVERLOADABLE half4 select (half4 param0, half4 param1, ushort4 param2); -OVERLOADABLE half8 select (half8 param0, half8 param1, ushort8 param2); -OVERLOADABLE half16 select (half16 param0, half16 param1, ushort16 param2); - -#endif diff --git a/drivers/pocl-gen7/lib/beignet/include/ocl_simd.h b/drivers/pocl-gen7/lib/beignet/include/ocl_simd.h deleted file mode 100644 index 9cb56d2..0000000 --- a/drivers/pocl-gen7/lib/beignet/include/ocl_simd.h +++ /dev/null @@ -1,386 +0,0 @@ -/* - * Copyright © 2015 Intel Corporation - * - * This library is free software; you can redistribute it and/or - * modify it under the terms of the GNU Lesser General Public - * License as published by the Free Software Foundation; either - * version 2.1 of the License, or (at your option) any later version. - * - * This library is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU - * Lesser General Public License for more details. - * - * You should have received a copy of the GNU Lesser General Public - * License along with this library. If not, see . - * - */ -#ifndef __OCL_SIMD_H__ -#define __OCL_SIMD_H__ - -#include "ocl_types.h" - -///////////////////////////////////////////////////////////////////////////// -// SIMD level function -///////////////////////////////////////////////////////////////////////////// -int sub_group_any(int); -int sub_group_all(int); - -uint get_simd_size(void); - -uint get_sub_group_size(void); -uint get_max_sub_group_size(void); -uint get_num_sub_groups(void); -uint get_sub_group_id(void); -uint get_sub_group_local_id(void); - -/* broadcast */ -OVERLOADABLE int sub_group_broadcast(int a,uint local_id); -OVERLOADABLE uint sub_group_broadcast(uint a, uint local_id); -OVERLOADABLE long sub_group_broadcast(long a, uint local_id); -OVERLOADABLE ulong sub_group_broadcast(ulong a, uint local_id); -OVERLOADABLE half sub_group_broadcast(half a, uint local_id); -OVERLOADABLE float sub_group_broadcast(float a, uint local_id); -OVERLOADABLE double sub_group_broadcast(double a, uint local_id); -OVERLOADABLE short sub_group_broadcast(short a,uint local_id); -OVERLOADABLE ushort sub_group_broadcast(ushort a, uint local_id); - -OVERLOADABLE short intel_sub_group_broadcast(short a, uint local_id); -OVERLOADABLE ushort intel_sub_group_broadcast(ushort a, uint local_id); -/* reduce add */ -OVERLOADABLE int sub_group_reduce_add(int x); -OVERLOADABLE uint sub_group_reduce_add(uint x); -OVERLOADABLE long sub_group_reduce_add(long x); -OVERLOADABLE ulong sub_group_reduce_add(ulong x); -OVERLOADABLE half sub_group_reduce_add(half x); -OVERLOADABLE float sub_group_reduce_add(float x); -OVERLOADABLE double sub_group_reduce_add(double x); -OVERLOADABLE short sub_group_reduce_add(short x); -OVERLOADABLE ushort sub_group_reduce_add(ushort x); -OVERLOADABLE short intel_sug_group_reduce_add(short x); -OVERLOADABLE ushort intel_sug_group_reduce_add(ushort x); - -/* reduce min */ -OVERLOADABLE int sub_group_reduce_min(int x); -OVERLOADABLE uint sub_group_reduce_min(uint x); -OVERLOADABLE long sub_group_reduce_min(long x); -OVERLOADABLE ulong sub_group_reduce_min(ulong x); -OVERLOADABLE half sub_group_reduce_min(half x); -OVERLOADABLE float sub_group_reduce_min(float x); -OVERLOADABLE double sub_group_reduce_min(double x); -OVERLOADABLE short sub_group_reduce_min(short x); -OVERLOADABLE ushort sub_group_reduce_min(ushort x); -OVERLOADABLE short intel_sug_group_reduce_min(short x); -OVERLOADABLE ushort intel_sug_group_reduce_min(ushort x); - -/* reduce max */ -OVERLOADABLE int sub_group_reduce_max(int x); -OVERLOADABLE uint sub_group_reduce_max(uint x); -OVERLOADABLE long sub_group_reduce_max(long x); -OVERLOADABLE ulong sub_group_reduce_max(ulong x); -OVERLOADABLE half sub_group_reduce_max(half x); -OVERLOADABLE float sub_group_reduce_max(float x); -OVERLOADABLE double sub_group_reduce_max(double x); -OVERLOADABLE short sub_group_reduce_max(short x); -OVERLOADABLE ushort sub_group_reduce_max(ushort x); -OVERLOADABLE short intel_sug_group_reduce_max(short x); -OVERLOADABLE ushort intel_sug_group_reduce_max(ushort x); - -/* scan_inclusive add */ -OVERLOADABLE int sub_group_scan_inclusive_add(int x); -OVERLOADABLE uint sub_group_scan_inclusive_add(uint x); -OVERLOADABLE long sub_group_scan_inclusive_add(long x); -OVERLOADABLE ulong sub_group_scan_inclusive_add(ulong x); -OVERLOADABLE half sub_group_scan_inclusive_add(half x); -OVERLOADABLE float sub_group_scan_inclusive_add(float x); -OVERLOADABLE double sub_group_scan_inclusive_add(double x); -OVERLOADABLE short sub_group_scan_inclusive_add(short x); -OVERLOADABLE ushort sub_group_scan_inclusive_add(ushort x); -OVERLOADABLE short intel_sug_group_scan_inclusive_add(short x); -OVERLOADABLE ushort intel_sug_group_scan_inclusive_add(ushort x); - -/* scan_inclusive min */ -OVERLOADABLE int sub_group_scan_inclusive_min(int x); -OVERLOADABLE uint sub_group_scan_inclusive_min(uint x); -OVERLOADABLE long sub_group_scan_inclusive_min(long x); -OVERLOADABLE ulong sub_group_scan_inclusive_min(ulong x); -OVERLOADABLE half sub_group_scan_inclusive_min(half x); -OVERLOADABLE float sub_group_scan_inclusive_min(float x); -OVERLOADABLE double sub_group_scan_inclusive_min(double x); -OVERLOADABLE short sub_group_scan_inclusive_min(short x); -OVERLOADABLE ushort sub_group_scan_inclusive_min(ushort x); -OVERLOADABLE short intel_sug_group_scan_inclusive_min(short x); -OVERLOADABLE ushort intel_sug_group_scan_inclusive_min(ushort x); - -/* scan_inclusive max */ -OVERLOADABLE int sub_group_scan_inclusive_max(int x); -OVERLOADABLE uint sub_group_scan_inclusive_max(uint x); -OVERLOADABLE long sub_group_scan_inclusive_max(long x); -OVERLOADABLE ulong sub_group_scan_inclusive_max(ulong x); -OVERLOADABLE half sub_group_scan_inclusive_max(half x); -OVERLOADABLE float sub_group_scan_inclusive_max(float x); -OVERLOADABLE double sub_group_scan_inclusive_max(double x); -OVERLOADABLE short sub_group_scan_inclusive_max(short x); -OVERLOADABLE ushort sub_group_scan_inclusive_max(ushort x); -OVERLOADABLE short intel_sug_group_scan_inclusive_max(short x); -OVERLOADABLE ushort intel_sug_group_scan_inclusive_max(ushort x); - -/* scan_exclusive add */ -OVERLOADABLE int sub_group_scan_exclusive_add(int x); -OVERLOADABLE uint sub_group_scan_exclusive_add(uint x); -OVERLOADABLE long sub_group_scan_exclusive_add(long x); -OVERLOADABLE ulong sub_group_scan_exclusive_add(ulong x); -OVERLOADABLE half sub_group_scan_exclusive_add(half x); -OVERLOADABLE float sub_group_scan_exclusive_add(float x); -OVERLOADABLE double sub_group_scan_exclusive_add(double x); -OVERLOADABLE short sub_group_scan_exclusive_add(short x); -OVERLOADABLE ushort sub_group_scan_exclusive_add(ushort x); -OVERLOADABLE short intel_sub_group_scan_exclusive_add(short x); -OVERLOADABLE ushort intel_sub_group_scan_exclusive_add(ushort x); - -/* scan_exclusive min */ -OVERLOADABLE int sub_group_scan_exclusive_min(int x); -OVERLOADABLE uint sub_group_scan_exclusive_min(uint x); -OVERLOADABLE long sub_group_scan_exclusive_min(long x); -OVERLOADABLE ulong sub_group_scan_exclusive_min(ulong x); -OVERLOADABLE half sub_group_scan_exclusive_min(half x); -OVERLOADABLE float sub_group_scan_exclusive_min(float x); -OVERLOADABLE double sub_group_scan_exclusive_min(double x); -OVERLOADABLE short sub_group_scan_exclusive_min(short x); -OVERLOADABLE ushort sub_group_scan_exclusive_min(ushort x); -OVERLOADABLE short intel_sug_group_scan_exclusive_min(short x); -OVERLOADABLE ushort intel_sug_group_scan_exclusive_min(ushort x); - -/* scan_exclusive max */ -OVERLOADABLE int sub_group_scan_exclusive_max(int x); -OVERLOADABLE uint sub_group_scan_exclusive_max(uint x); -OVERLOADABLE long sub_group_scan_exclusive_max(long x); -OVERLOADABLE ulong sub_group_scan_exclusive_max(ulong x); -OVERLOADABLE half sub_group_scan_exclusive_max(half x); -OVERLOADABLE float sub_group_scan_exclusive_max(float x); -OVERLOADABLE double sub_group_scan_exclusive_max(double x); -OVERLOADABLE short sub_group_scan_exclusive_max(short x); -OVERLOADABLE ushort sub_group_scan_exclusive_max(ushort x); -OVERLOADABLE short intel_sug_group_scan_exclusive_max(short x); -OVERLOADABLE ushort intel_sug_group_scan_exclusive_max(ushort x); - -/* shuffle */ -OVERLOADABLE half intel_sub_group_shuffle(half x, uint c); -OVERLOADABLE float intel_sub_group_shuffle(float x, uint c); -OVERLOADABLE int intel_sub_group_shuffle(int x, uint c); -OVERLOADABLE uint intel_sub_group_shuffle(uint x, uint c); -OVERLOADABLE short intel_sub_group_shuffle(short x, uint c); -OVERLOADABLE ushort intel_sub_group_shuffle(ushort x, uint c); - -OVERLOADABLE float intel_sub_group_shuffle_down(float x, float y, uint c); -OVERLOADABLE int intel_sub_group_shuffle_down(int x, int y, uint c); -OVERLOADABLE uint intel_sub_group_shuffle_down(uint x, uint y, uint c); -OVERLOADABLE short intel_sub_group_shuffle_down(short x, short y, uint c); -OVERLOADABLE ushort intel_sub_group_shuffle_down(ushort x, ushort y, uint c); - -OVERLOADABLE float intel_sub_group_shuffle_up(float x, float y, uint c); -OVERLOADABLE int intel_sub_group_shuffle_up(int x, int y, uint c); -OVERLOADABLE uint intel_sub_group_shuffle_up(uint x, uint y, uint c); -OVERLOADABLE short intel_sub_group_shuffle_up(short x, short y, uint c); -OVERLOADABLE ushort intel_sub_group_shuffle_up(ushort x, ushort y, uint c); - -OVERLOADABLE float intel_sub_group_shuffle_xor(float x, uint c); -OVERLOADABLE int intel_sub_group_shuffle_xor(int x, uint c); -OVERLOADABLE uint intel_sub_group_shuffle_xor(uint x, uint c); -OVERLOADABLE short intel_sub_group_shuffle_xor(short x, uint c); -OVERLOADABLE ushort intel_sub_group_shuffle_xor(ushort x, uint c); - -/* blocak read/write */ -OVERLOADABLE uint intel_sub_group_block_read(const global uint* p); -OVERLOADABLE uint2 intel_sub_group_block_read2(const global uint* p); -OVERLOADABLE uint4 intel_sub_group_block_read4(const global uint* p); -OVERLOADABLE uint8 intel_sub_group_block_read8(const global uint* p); - -OVERLOADABLE void intel_sub_group_block_write(__global uint* p, uint data); -OVERLOADABLE void intel_sub_group_block_write2(__global uint* p, uint2 data); -OVERLOADABLE void intel_sub_group_block_write4(__global uint* p, uint4 data); -OVERLOADABLE void intel_sub_group_block_write8(__global uint* p, uint8 data); - -OVERLOADABLE uint intel_sub_group_block_read(image2d_t image, int2 byte_coord); -OVERLOADABLE uint2 intel_sub_group_block_read2(image2d_t image, int2 byte_coord); -OVERLOADABLE uint4 intel_sub_group_block_read4(image2d_t image, int2 byte_coord); -OVERLOADABLE uint8 intel_sub_group_block_read8(image2d_t image, int2 byte_coord); - -OVERLOADABLE void intel_sub_group_block_write(image2d_t image, int2 byte_coord, uint data); -OVERLOADABLE void intel_sub_group_block_write2(image2d_t image, int2 byte_coord, uint2 data); -OVERLOADABLE void intel_sub_group_block_write4(image2d_t image, int2 byte_coord, uint4 data); -OVERLOADABLE void intel_sub_group_block_write8(image2d_t image, int2 byte_coord, uint8 data); - -OVERLOADABLE uint intel_sub_group_block_read_ui(const global uint* p); -OVERLOADABLE uint2 intel_sub_group_block_read_ui2(const global uint* p); -OVERLOADABLE uint4 intel_sub_group_block_read_ui4(const global uint* p); -OVERLOADABLE uint8 intel_sub_group_block_read_ui8(const global uint* p); - -OVERLOADABLE void intel_sub_group_block_write_ui(__global uint* p, uint data); -OVERLOADABLE void intel_sub_group_block_write_ui2(__global uint* p, uint2 data); -OVERLOADABLE void intel_sub_group_block_write_ui4(__global uint* p, uint4 data); -OVERLOADABLE void intel_sub_group_block_write_ui8(__global uint* p, uint8 data); - -OVERLOADABLE uint intel_sub_group_block_read_ui(image2d_t image, int2 byte_coord); -OVERLOADABLE uint2 intel_sub_group_block_read_ui2(image2d_t image, int2 byte_coord); -OVERLOADABLE uint4 intel_sub_group_block_read_ui4(image2d_t image, int2 byte_coord); -OVERLOADABLE uint8 intel_sub_group_block_read_ui8(image2d_t image, int2 byte_coord); - -OVERLOADABLE void intel_sub_group_block_write_ui(image2d_t image, int2 byte_coord, uint data); -OVERLOADABLE void intel_sub_group_block_write_ui2(image2d_t image, int2 byte_coord, uint2 data); -OVERLOADABLE void intel_sub_group_block_write_ui4(image2d_t image, int2 byte_coord, uint4 data); -OVERLOADABLE void intel_sub_group_block_write_ui8(image2d_t image, int2 byte_coord, uint8 data); - -OVERLOADABLE void intel_sub_group_media_block_write_ui(int2 src_byte_offset, int width, int height, uint texels, image2d_t image); -OVERLOADABLE void intel_sub_group_media_block_write_ui2(int2 src_byte_offset, int width, int height, uint2 texels, image2d_t image); -OVERLOADABLE void intel_sub_group_media_block_write_ui4(int2 src_byte_offset, int width, int height, uint4 texels, image2d_t image); -OVERLOADABLE void intel_sub_group_media_block_write_ui8(int2 src_byte_offset, int width, int height, uint8 texels, image2d_t image); - -OVERLOADABLE ushort intel_sub_group_block_read_us(const global ushort* p); -OVERLOADABLE ushort2 intel_sub_group_block_read_us2(const global ushort* p); -OVERLOADABLE ushort4 intel_sub_group_block_read_us4(const global ushort* p); -OVERLOADABLE ushort8 intel_sub_group_block_read_us8(const global ushort* p); - -OVERLOADABLE void intel_sub_group_block_write_us(__global ushort* p, ushort data); -OVERLOADABLE void intel_sub_group_block_write_us2(__global ushort* p, ushort2 data); -OVERLOADABLE void intel_sub_group_block_write_us4(__global ushort* p, ushort4 data); -OVERLOADABLE void intel_sub_group_block_write_us8(__global ushort* p, ushort8 data); - -OVERLOADABLE ushort intel_sub_group_block_read_us(image2d_t image, int2 byte_coord); -OVERLOADABLE ushort2 intel_sub_group_block_read_us2(image2d_t image, int2 byte_coord); -OVERLOADABLE ushort4 intel_sub_group_block_read_us4(image2d_t image, int2 byte_coord); -OVERLOADABLE ushort8 intel_sub_group_block_read_us8(image2d_t image, int2 byte_coord); - -OVERLOADABLE void intel_sub_group_block_write_us(image2d_t image, int2 byte_coord, ushort data); -OVERLOADABLE void intel_sub_group_block_write_us2(image2d_t image, int2 byte_coord, ushort2 data); -OVERLOADABLE void intel_sub_group_block_write_us4(image2d_t image, int2 byte_coord, ushort4 data); -OVERLOADABLE void intel_sub_group_block_write_us8(image2d_t image, int2 byte_coord, ushort8 data); - -OVERLOADABLE void intel_sub_group_media_block_write_uc(int2 src_byte_offset, int width, int height, uchar texels, image2d_t image); -OVERLOADABLE void intel_sub_group_media_block_write_uc2(int2 src_byte_offset, int width, int height, uchar2 texels, image2d_t image); -OVERLOADABLE void intel_sub_group_media_block_write_uc4(int2 src_byte_offset, int width, int height, uchar4 texels, image2d_t image); -OVERLOADABLE void intel_sub_group_media_block_write_uc8(int2 src_byte_offset, int width, int height, uchar8 texels, image2d_t image); -OVERLOADABLE void intel_sub_group_media_block_write_uc16(int2 src_byte_offset, int width, int height, uchar16 texels, image2d_t image); - -OVERLOADABLE void intel_sub_group_media_block_write_us(int2 src_byte_offset, int width, int height, ushort texels, image2d_t image); -OVERLOADABLE void intel_sub_group_media_block_write_us2(int2 src_byte_offset, int width, int height, ushort2 texels, image2d_t image); -OVERLOADABLE void intel_sub_group_media_block_write_us4(int2 src_byte_offset, int width, int height, ushort4 texels, image2d_t image); -OVERLOADABLE void intel_sub_group_media_block_write_us8(int2 src_byte_offset, int width, int height, ushort8 texels, image2d_t image); -OVERLOADABLE void intel_sub_group_media_block_write_us16(int2 src_byte_offset, int width, int height, ushort16 texels, image2d_t image); - -OVERLOADABLE uchar intel_sub_group_media_block_read_uc(int2 src_byte_offset, int width, int height, read_only image2d_t image); -OVERLOADABLE uchar2 intel_sub_group_media_block_read_uc2(int2 src_byte_offset, int width, int height, read_only image2d_t image); -OVERLOADABLE uchar4 intel_sub_group_media_block_read_uc4(int2 src_byte_offset, int width, int height, read_only image2d_t image); -OVERLOADABLE uchar8 intel_sub_group_media_block_read_uc8(int2 src_byte_offset, int width, int height, read_only image2d_t image); -OVERLOADABLE uchar16 intel_sub_group_media_block_read_uc16(int2 src_byte_offset, int width, int height, read_only image2d_t image); - -OVERLOADABLE ushort intel_sub_group_media_block_read_us(int2 src_byte_offset, int width, int height, read_only image2d_t image); -OVERLOADABLE ushort2 intel_sub_group_media_block_read_us2(int2 src_byte_offset, int width, int height, read_only image2d_t image); -OVERLOADABLE ushort4 intel_sub_group_media_block_read_us4(int2 src_byte_offset, int width, int height, read_only image2d_t image); -OVERLOADABLE ushort8 intel_sub_group_media_block_read_us8(int2 src_byte_offset, int width, int height, read_only image2d_t image); -OVERLOADABLE ushort16 intel_sub_group_media_block_read_us16(int2 src_byte_offset, int width, int height, read_only image2d_t image); - -OVERLOADABLE uint intel_sub_group_media_block_read_ui(int2 src_byte_offset, int width, int height, read_only image2d_t image); -OVERLOADABLE uint2 intel_sub_group_media_block_read_ui2(int2 src_byte_offset, int width, int height, read_only image2d_t image); -OVERLOADABLE uint4 intel_sub_group_media_block_read_ui4(int2 src_byte_offset, int width, int height, read_only image2d_t image); -OVERLOADABLE uint8 intel_sub_group_media_block_read_ui8(int2 src_byte_offset, int width, int height, read_only image2d_t image); -//Begin from this part is autogenerated. -//Don't modify it manually. -//simd level functions builtin functions -//floatn intel_sub_group_shuffle(floatn x, uint c) - -OVERLOADABLE float2 intel_sub_group_shuffle (float2 param0, uint param1); -OVERLOADABLE float3 intel_sub_group_shuffle (float3 param0, uint param1); -OVERLOADABLE float4 intel_sub_group_shuffle (float4 param0, uint param1); -OVERLOADABLE float8 intel_sub_group_shuffle (float8 param0, uint param1); -OVERLOADABLE float16 intel_sub_group_shuffle (float16 param0, uint param1); - -//intn intel_sub_group_shuffle(intn x, uint c) - -OVERLOADABLE int2 intel_sub_group_shuffle (int2 param0, uint param1); -OVERLOADABLE int3 intel_sub_group_shuffle (int3 param0, uint param1); -OVERLOADABLE int4 intel_sub_group_shuffle (int4 param0, uint param1); -OVERLOADABLE int8 intel_sub_group_shuffle (int8 param0, uint param1); -OVERLOADABLE int16 intel_sub_group_shuffle (int16 param0, uint param1); - -//uintn intel_sub_group_shuffle(uintn x, uint c) - -OVERLOADABLE uint2 intel_sub_group_shuffle (uint2 param0, uint param1); -OVERLOADABLE uint3 intel_sub_group_shuffle (uint3 param0, uint param1); -OVERLOADABLE uint4 intel_sub_group_shuffle (uint4 param0, uint param1); -OVERLOADABLE uint8 intel_sub_group_shuffle (uint8 param0, uint param1); -OVERLOADABLE uint16 intel_sub_group_shuffle (uint16 param0, uint param1); - -//floatn intel_sub_group_shuffle_down(floatn x, floatn y, uint c) - -OVERLOADABLE float2 intel_sub_group_shuffle_down (float2 param0, float2 param1, uint param2); -OVERLOADABLE float3 intel_sub_group_shuffle_down (float3 param0, float3 param1, uint param2); -OVERLOADABLE float4 intel_sub_group_shuffle_down (float4 param0, float4 param1, uint param2); -OVERLOADABLE float8 intel_sub_group_shuffle_down (float8 param0, float8 param1, uint param2); -OVERLOADABLE float16 intel_sub_group_shuffle_down (float16 param0, float16 param1, uint param2); - -//intn intel_sub_group_shuffle_down(intn x, intn y, uint c) - -OVERLOADABLE int2 intel_sub_group_shuffle_down (int2 param0, int2 param1, uint param2); -OVERLOADABLE int3 intel_sub_group_shuffle_down (int3 param0, int3 param1, uint param2); -OVERLOADABLE int4 intel_sub_group_shuffle_down (int4 param0, int4 param1, uint param2); -OVERLOADABLE int8 intel_sub_group_shuffle_down (int8 param0, int8 param1, uint param2); -OVERLOADABLE int16 intel_sub_group_shuffle_down (int16 param0, int16 param1, uint param2); - -//uintn intel_sub_group_shuffle_down(uintn x, uintn y, uint c) - -OVERLOADABLE uint2 intel_sub_group_shuffle_down (uint2 param0, uint2 param1, uint param2); -OVERLOADABLE uint3 intel_sub_group_shuffle_down (uint3 param0, uint3 param1, uint param2); -OVERLOADABLE uint4 intel_sub_group_shuffle_down (uint4 param0, uint4 param1, uint param2); -OVERLOADABLE uint8 intel_sub_group_shuffle_down (uint8 param0, uint8 param1, uint param2); -OVERLOADABLE uint16 intel_sub_group_shuffle_down (uint16 param0, uint16 param1, uint param2); - -//floatn intel_sub_group_shuffle_up(floatn x, floatn y, uint c) - -OVERLOADABLE float2 intel_sub_group_shuffle_up (float2 param0, float2 param1, uint param2); -OVERLOADABLE float3 intel_sub_group_shuffle_up (float3 param0, float3 param1, uint param2); -OVERLOADABLE float4 intel_sub_group_shuffle_up (float4 param0, float4 param1, uint param2); -OVERLOADABLE float8 intel_sub_group_shuffle_up (float8 param0, float8 param1, uint param2); -OVERLOADABLE float16 intel_sub_group_shuffle_up (float16 param0, float16 param1, uint param2); - -//intn intel_sub_group_shuffle_up(intn x, intn y, uint c) - -OVERLOADABLE int2 intel_sub_group_shuffle_up (int2 param0, int2 param1, uint param2); -OVERLOADABLE int3 intel_sub_group_shuffle_up (int3 param0, int3 param1, uint param2); -OVERLOADABLE int4 intel_sub_group_shuffle_up (int4 param0, int4 param1, uint param2); -OVERLOADABLE int8 intel_sub_group_shuffle_up (int8 param0, int8 param1, uint param2); -OVERLOADABLE int16 intel_sub_group_shuffle_up (int16 param0, int16 param1, uint param2); - -//uintn intel_sub_group_shuffle_up(uintn x, uintn y, uint c) - -OVERLOADABLE uint2 intel_sub_group_shuffle_up (uint2 param0, uint2 param1, uint param2); -OVERLOADABLE uint3 intel_sub_group_shuffle_up (uint3 param0, uint3 param1, uint param2); -OVERLOADABLE uint4 intel_sub_group_shuffle_up (uint4 param0, uint4 param1, uint param2); -OVERLOADABLE uint8 intel_sub_group_shuffle_up (uint8 param0, uint8 param1, uint param2); -OVERLOADABLE uint16 intel_sub_group_shuffle_up (uint16 param0, uint16 param1, uint param2); - -//floatn intel_sub_group_shuffle_xor(floatn x, uint c) - -OVERLOADABLE float2 intel_sub_group_shuffle_xor (float2 param0, uint param1); -OVERLOADABLE float3 intel_sub_group_shuffle_xor (float3 param0, uint param1); -OVERLOADABLE float4 intel_sub_group_shuffle_xor (float4 param0, uint param1); -OVERLOADABLE float8 intel_sub_group_shuffle_xor (float8 param0, uint param1); -OVERLOADABLE float16 intel_sub_group_shuffle_xor (float16 param0, uint param1); - -//intn intel_sub_group_shuffle_xor(intn x, uint c) - -OVERLOADABLE int2 intel_sub_group_shuffle_xor (int2 param0, uint param1); -OVERLOADABLE int3 intel_sub_group_shuffle_xor (int3 param0, uint param1); -OVERLOADABLE int4 intel_sub_group_shuffle_xor (int4 param0, uint param1); -OVERLOADABLE int8 intel_sub_group_shuffle_xor (int8 param0, uint param1); -OVERLOADABLE int16 intel_sub_group_shuffle_xor (int16 param0, uint param1); - -//uintn intel_sub_group_shuffle_xor(uintn x, uint c) - -OVERLOADABLE uint2 intel_sub_group_shuffle_xor (uint2 param0, uint param1); -OVERLOADABLE uint3 intel_sub_group_shuffle_xor (uint3 param0, uint param1); -OVERLOADABLE uint4 intel_sub_group_shuffle_xor (uint4 param0, uint param1); -OVERLOADABLE uint8 intel_sub_group_shuffle_xor (uint8 param0, uint param1); -OVERLOADABLE uint16 intel_sub_group_shuffle_xor (uint16 param0, uint param1); - -#endif diff --git a/drivers/pocl-gen7/lib/beignet/include/ocl_sync.h b/drivers/pocl-gen7/lib/beignet/include/ocl_sync.h deleted file mode 100644 index 22ff89a..0000000 --- a/drivers/pocl-gen7/lib/beignet/include/ocl_sync.h +++ /dev/null @@ -1,33 +0,0 @@ -/* - * Copyright © 2012 - 2014 Intel Corporation - * - * This library is free software; you can redistribute it and/or - * modify it under the terms of the GNU Lesser General Public - * License as published by the Free Software Foundation; either - * version 2.1 of the License, or (at your option) any later version. - * - * This library is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU - * Lesser General Public License for more details. - * - * You should have received a copy of the GNU Lesser General Public - * License along with this library. If not, see . - * - */ -#ifndef __OCL_SYNC_H__ -#define __OCL_SYNC_H__ - -#include "ocl_types.h" - -///////////////////////////////////////////////////////////////////////////// -// Synchronization functions -///////////////////////////////////////////////////////////////////////////// -OVERLOADABLE void barrier(cl_mem_fence_flags flags); -OVERLOADABLE void debugwait(void); -OVERLOADABLE void mem_fence(cl_mem_fence_flags flags); -OVERLOADABLE void read_mem_fence(cl_mem_fence_flags flags); -OVERLOADABLE void write_mem_fence(cl_mem_fence_flags flags); -#define work_group_barrier barrier -cl_mem_fence_flags get_fence(void *ptr); -#endif /* __OCL_SYNC_H__ */ diff --git a/drivers/pocl-gen7/lib/beignet/include/ocl_types.h b/drivers/pocl-gen7/lib/beignet/include/ocl_types.h deleted file mode 100644 index 327624b..0000000 --- a/drivers/pocl-gen7/lib/beignet/include/ocl_types.h +++ /dev/null @@ -1,128 +0,0 @@ -/* - * Copyright © 2012 - 2014 Intel Corporation - * - * This library is free software; you can redistribute it and/or - * modify it under the terms of the GNU Lesser General Public - * License as published by the Free Software Foundation; either - * version 2.1 of the License, or (at your option) any later version. - * - * This library is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU - * Lesser General Public License for more details. - * - * You should have received a copy of the GNU Lesser General Public - * License along with this library. If not, see . - * - */ -#ifndef __OCL_TYPES_H__ -#define __OCL_TYPES_H__ - -#pragma OPENCL EXTENSION cl_khr_fp64 : enable -#pragma OPENCL EXTENSION cl_khr_fp16 : enable -#define DISABLE_ATOMIC_INT64 -#ifndef DISABLE_ATOMIC_INT64 -#pragma OPENCL EXTENSION cl_khr_int64_base_atomics : enable -#pragma OPENCL EXTENSION cl_khr_int64_extended_atomics : enable -#endif -#include "ocl_defines.h" - -#define NULL 0 - -///////////////////////////////////////////////////////////////////////////// -// OpenCL Common Defines -///////////////////////////////////////////////////////////////////////////// -#define INLINE inline __attribute__((always_inline)) -#define OVERLOADABLE __attribute__((overloadable)) -#define PURE __attribute__((pure)) -#define CONST __attribute__((const)) -#define INLINE_OVERLOADABLE inline __attribute__((overloadable,always_inline)) - -///////////////////////////////////////////////////////////////////////////// -// OpenCL built-in scalar data types -///////////////////////////////////////////////////////////////////////////// -typedef unsigned char uchar; -typedef unsigned short ushort; -typedef unsigned int uint; -typedef unsigned long ulong; -typedef __typeof__(sizeof(int)) size_t; -typedef __typeof__((int *)0-(int *)0) ptrdiff_t; -#define __int_t_type(a,b,c) a##b##c -#define __int_type(type,n) __int_t_type(type,n,_TYPE__) -typedef __int_type(__INT,__INTPTR_WIDTH__) intptr_t; -typedef __int_type(__UINT,__INTPTR_WIDTH__) uintptr_t; -#undef __int_type -#undef __int_t_type - -///////////////////////////////////////////////////////////////////////////// -// OpenCL address space -///////////////////////////////////////////////////////////////////////////// -// These are built-ins in LLVM 3.3. -#if 100*__clang_major__ + __clang_minor__ <= 302 -#define __private __attribute__((address_space(0))) -#define __global __attribute__((address_space(1))) -#define __constant __attribute__((address_space(2))) -#define __local __attribute__((address_space(3))) -#define global __global -#define local __local -#define constant __constant -#define private __private -#endif - -///////////////////////////////////////////////////////////////////////////// -// OpenCL built-in vector data types -///////////////////////////////////////////////////////////////////////////// -#define DEF(type) typedef type type##2 __attribute__((ext_vector_type(2)));\ - typedef type type##3 __attribute__((ext_vector_type(3)));\ - typedef type type##4 __attribute__((ext_vector_type(4)));\ - typedef type type##8 __attribute__((ext_vector_type(8)));\ - typedef type type##16 __attribute__((ext_vector_type(16))); -DEF(char); -DEF(uchar); -DEF(short); -DEF(ushort); -DEF(int); -DEF(uint); -DEF(long); -DEF(ulong); -DEF(float); -DEF(double); -DEF(half); -#undef DEF - -///////////////////////////////////////////////////////////////////////////// -// OpenCL atomic related types -///////////////////////////////////////////////////////////////////////////// -//atomic flags -#define CLK_LOCAL_MEM_FENCE (1 << 0) -#define CLK_GLOBAL_MEM_FENCE (1 << 1) -#define CLK_IMAGE_MEM_FENCE (1 << 2) - -typedef uint cl_mem_fence_flags; - -//memory order -typedef enum { - memory_order_relaxed, - memory_order_acquire, - memory_order_release, - memory_order_acq_rel, - memory_order_seq_cst -} memory_order; - -//memory scope -typedef enum { - memory_scope_work_item, - memory_scope_work_group, - memory_scope_device, - memory_scope_all_svm_devices, - memory_scope_sub_group, -} memory_scope; - -///////////////////////////////////////////////////////////////////////////// -// OpenCL built-in event types -///////////////////////////////////////////////////////////////////////////// -// FIXME: -// This is a transitional hack to bypass the LLVM 3.3 built-in types. -// See the Khronos SPIR specification for handling of these types. - -#endif /* __OCL_TYPES_H__ */ diff --git a/drivers/pocl-gen7/lib/beignet/include/ocl_vload.h b/drivers/pocl-gen7/lib/beignet/include/ocl_vload.h deleted file mode 100644 index c26f640..0000000 --- a/drivers/pocl-gen7/lib/beignet/include/ocl_vload.h +++ /dev/null @@ -1,160 +0,0 @@ -/* - * Copyright © 2012 - 2014 Intel Corporation - * - * This library is free software; you can redistribute it and/or - * modify it under the terms of the GNU Lesser General Public - * License as published by the Free Software Foundation; either - * version 2.1 of the License, or (at your option) any later version. - * - * This library is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU - * Lesser General Public License for more details. - * - * You should have received a copy of the GNU Lesser General Public - * License along with this library. If not, see . - * - */ -#ifndef __OCL_VLOAD_H__ -#define __OCL_VLOAD_H__ - -#include "ocl_types.h" - -///////////////////////////////////////////////////////////////////////////// -// Vector loads and stores -///////////////////////////////////////////////////////////////////////////// - -// These loads and stores will use untyped reads and writes, so we can just -// cast to vector loads / stores. Not C99 compliant BTW due to aliasing issue. -// Well we do not care, we do not activate TBAA in the compiler -#define DECL_UNTYPED_RW_SPACE_N(TYPE, DIM, SPACE) \ -OVERLOADABLE TYPE##DIM vload##DIM(size_t offset, const SPACE TYPE *p); \ -OVERLOADABLE void vstore##DIM(TYPE##DIM v, size_t offset, SPACE TYPE *p); - -#define DECL_UNTYPED_RD_SPACE_N(TYPE, DIM, SPACE) \ -OVERLOADABLE TYPE##DIM vload##DIM(size_t offset, const SPACE TYPE *p); - -#define DECL_UNTYPED_V3_SPACE(TYPE, SPACE) \ -OVERLOADABLE void vstore3(TYPE##3 v, size_t offset, SPACE TYPE *p); \ -OVERLOADABLE TYPE##3 vload3(size_t offset, const SPACE TYPE *p); - -#define DECL_UNTYPED_RDV3_SPACE(TYPE, SPACE) \ -OVERLOADABLE TYPE##3 vload3(size_t offset, const SPACE TYPE *p); - -#define DECL_UNTYPED_RW_ALL_SPACE(TYPE, SPACE) \ - DECL_UNTYPED_RW_SPACE_N(TYPE, 2, SPACE) \ - DECL_UNTYPED_V3_SPACE(TYPE, SPACE) \ - DECL_UNTYPED_RW_SPACE_N(TYPE, 4, SPACE) \ - DECL_UNTYPED_RW_SPACE_N(TYPE, 8, SPACE) \ - DECL_UNTYPED_RW_SPACE_N(TYPE, 16, SPACE) - -#define DECL_UNTYPED_RD_ALL_SPACE(TYPE, SPACE) \ - DECL_UNTYPED_RD_SPACE_N(TYPE, 2, SPACE) \ - DECL_UNTYPED_RDV3_SPACE(TYPE, SPACE) \ - DECL_UNTYPED_RD_SPACE_N(TYPE, 4, SPACE) \ - DECL_UNTYPED_RD_SPACE_N(TYPE, 8, SPACE) \ - DECL_UNTYPED_RD_SPACE_N(TYPE, 16, SPACE) - -#define DECL_UNTYPED_RW_ALL(TYPE) \ - DECL_UNTYPED_RW_ALL_SPACE(TYPE, __global) \ - DECL_UNTYPED_RW_ALL_SPACE(TYPE, __local) \ - DECL_UNTYPED_RD_ALL_SPACE(TYPE, __constant) \ - DECL_UNTYPED_RW_ALL_SPACE(TYPE, __private) - -#define DECL_BYTE_RD_SPACE(TYPE, SPACE) \ -OVERLOADABLE TYPE##2 vload2(size_t offset, const SPACE TYPE *p); \ -OVERLOADABLE TYPE##3 vload3(size_t offset, const SPACE TYPE *p); \ -OVERLOADABLE TYPE##4 vload4(size_t offset, const SPACE TYPE *p); \ -OVERLOADABLE TYPE##8 vload8(size_t offset, const SPACE TYPE *p); \ -OVERLOADABLE TYPE##16 vload16(size_t offset, const SPACE TYPE *p); - -#define DECL_BYTE_WR_SPACE(TYPE, SPACE) \ -OVERLOADABLE void vstore2(TYPE##2 v, size_t offset, SPACE TYPE *p); \ -OVERLOADABLE void vstore3(TYPE##3 v, size_t offset, SPACE TYPE *p); \ -OVERLOADABLE void vstore4(TYPE##4 v, size_t offset, SPACE TYPE *p); \ -OVERLOADABLE void vstore8(TYPE##8 v, size_t offset, SPACE TYPE *p); \ -OVERLOADABLE void vstore16(TYPE##16 v, size_t offset, SPACE TYPE *p); - -#define DECL_BYTE_RW_ALL(TYPE) \ - DECL_BYTE_RD_SPACE(TYPE, __global) \ - DECL_BYTE_RD_SPACE(TYPE, __local) \ - DECL_BYTE_RD_SPACE(TYPE, __private) \ - DECL_BYTE_RD_SPACE(TYPE, __constant) \ - DECL_BYTE_WR_SPACE(TYPE, __global) \ - DECL_BYTE_WR_SPACE(TYPE, __local) \ - DECL_BYTE_WR_SPACE(TYPE, __private) - -DECL_BYTE_RW_ALL(char) -DECL_BYTE_RW_ALL(uchar) -DECL_BYTE_RW_ALL(short) -DECL_BYTE_RW_ALL(ushort) -DECL_BYTE_RW_ALL(half) -DECL_UNTYPED_RW_ALL(int) -DECL_UNTYPED_RW_ALL(uint) -DECL_UNTYPED_RW_ALL(long) -DECL_UNTYPED_RW_ALL(ulong) -DECL_UNTYPED_RW_ALL(float) -DECL_UNTYPED_RW_ALL(double) - -#undef DECL_UNTYPED_RW_ALL -#undef DECL_UNTYPED_RW_ALL_SPACE -#undef DECL_UNTYPED_RD_ALL_SPACE -#undef DECL_UNTYPED_RW_SPACE_N -#undef DECL_UNTYPED_RD_SPACE_N -#undef DECL_UNTYPED_V3_SPACE -#undef DECL_UNTYPED_RDV3_SPACE -#undef DECL_BYTE_RD_SPACE -#undef DECL_BYTE_WR_SPACE -#undef DECL_BYTE_RW_ALL - - -#define DECL_HALF_LD_SPACE(SPACE) \ -OVERLOADABLE float vload_half(size_t offset, const SPACE half *p); \ -OVERLOADABLE float vloada_half(size_t offset, const SPACE half *p); \ -OVERLOADABLE float2 vload_half2(size_t offset, const SPACE half *p); \ -OVERLOADABLE float2 vloada_half2(size_t offset, const SPACE half *p); \ -OVERLOADABLE float3 vload_half3(size_t offset, const SPACE half *p); \ -OVERLOADABLE float3 vloada_half3(size_t offset, const SPACE half *p); \ -OVERLOADABLE float4 vload_half4(size_t offset, const SPACE half *p); \ -OVERLOADABLE float4 vloada_half4(size_t offset, const SPACE half *p); \ -OVERLOADABLE float8 vload_half8(size_t offset, const SPACE half *p); \ -OVERLOADABLE float8 vloada_half8(size_t offset, const SPACE half *p); \ -OVERLOADABLE float16 vload_half16(size_t offset, const SPACE half *p); \ -OVERLOADABLE float16 vloada_half16(size_t offset, const SPACE half *p); \ - -#define DECL_HALF_ST_SPACE_ROUND(SPACE, ROUND, FUNC) \ -OVERLOADABLE void vstore_half##ROUND(float data, size_t offset, SPACE half *p); \ -OVERLOADABLE void vstorea_half##ROUND(float data, size_t offset, SPACE half *p); \ -OVERLOADABLE void vstore_half2##ROUND(float2 data, size_t offset, SPACE half *p); \ -OVERLOADABLE void vstorea_half2##ROUND(float2 data, size_t offset, SPACE half *p); \ -OVERLOADABLE void vstore_half3##ROUND(float3 data, size_t offset, SPACE half *p); \ -OVERLOADABLE void vstorea_half3##ROUND(float3 data, size_t offset, SPACE half *p); \ -OVERLOADABLE void vstore_half4##ROUND(float4 data, size_t offset, SPACE half *p); \ -OVERLOADABLE void vstorea_half4##ROUND(float4 data, size_t offset, SPACE half *p); \ -OVERLOADABLE void vstore_half8##ROUND(float8 data, size_t offset, SPACE half *p); \ -OVERLOADABLE void vstorea_half8##ROUND(float8 data, size_t offset, SPACE half *p); \ -OVERLOADABLE void vstore_half16##ROUND(float16 data, size_t offset, SPACE half *p); \ -OVERLOADABLE void vstorea_half16##ROUND(float16 data, size_t offset, SPACE half *p); - -#define DECL_HALF_ST_SPACE(SPACE) \ - DECL_HALF_ST_SPACE_ROUND(SPACE, , dummy) \ - DECL_HALF_ST_SPACE_ROUND(SPACE, _rte, dummy) \ - DECL_HALF_ST_SPACE_ROUND(SPACE, _rtz, dummy) \ - DECL_HALF_ST_SPACE_ROUND(SPACE, _rtp, dummy) \ - DECL_HALF_ST_SPACE_ROUND(SPACE, _rtn, dummy) \ - -DECL_HALF_LD_SPACE(__global) -DECL_HALF_LD_SPACE(__local) -DECL_HALF_LD_SPACE(__constant) -DECL_HALF_LD_SPACE(__private) - -DECL_HALF_ST_SPACE(__global) -DECL_HALF_ST_SPACE(__local) -DECL_HALF_ST_SPACE(__private) - -//#undef DECL_UNTYPED_RW_ALL_SPACE -#undef DECL_HALF_LD_SPACE -#undef DECL_HALF_ST_SPACE -#undef DECL_HALF_ST_SPACE_ROUND - -#endif /* __OCL_VLOAD_H__ */ diff --git a/drivers/pocl-gen7/lib/beignet/include/ocl_vload_20.h b/drivers/pocl-gen7/lib/beignet/include/ocl_vload_20.h deleted file mode 100644 index 3f7fc62..0000000 --- a/drivers/pocl-gen7/lib/beignet/include/ocl_vload_20.h +++ /dev/null @@ -1,150 +0,0 @@ -/* - * Copyright © 2012 - 2014 Intel Corporation - * - * This library is free software; you can redistribute it and/or - * modify it under the terms of the GNU Lesser General Public - * License as published by the Free Software Foundation; either - * version 2.1 of the License, or (at your option) any later version. - * - * This library is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU - * Lesser General Public License for more details. - * - * You should have received a copy of the GNU Lesser General Public - * License along with this library. If not, see . - * - */ -#ifndef __OCL_VLOAD_20_H__ -#define __OCL_VLOAD_20_H__ - -#include "ocl_types.h" - -///////////////////////////////////////////////////////////////////////////// -// Vector loads and stores -///////////////////////////////////////////////////////////////////////////// - -// These loads and stores will use untyped reads and writes, so we can just -// cast to vector loads / stores. Not C99 compliant BTW due to aliasing issue. -// Well we do not care, we do not activate TBAA in the compiler -#define DECL_UNTYPED_RW_SPACE_N(TYPE, DIM, SPACE) \ -OVERLOADABLE TYPE##DIM vload##DIM(size_t offset, const SPACE TYPE *p); \ -OVERLOADABLE void vstore##DIM(TYPE##DIM v, size_t offset, SPACE TYPE *p); - -#define DECL_UNTYPED_RD_SPACE_N(TYPE, DIM, SPACE) \ -OVERLOADABLE TYPE##DIM vload##DIM(size_t offset, const SPACE TYPE *p); - -#define DECL_UNTYPED_V3_SPACE(TYPE, SPACE) \ -OVERLOADABLE void vstore3(TYPE##3 v, size_t offset, SPACE TYPE *p); \ -OVERLOADABLE TYPE##3 vload3(size_t offset, const SPACE TYPE *p); - -#define DECL_UNTYPED_RDV3_SPACE(TYPE, SPACE) \ -OVERLOADABLE TYPE##3 vload3(size_t offset, const SPACE TYPE *p); - -#define DECL_UNTYPED_RW_ALL_SPACE(TYPE, SPACE) \ - DECL_UNTYPED_RW_SPACE_N(TYPE, 2, SPACE) \ - DECL_UNTYPED_V3_SPACE(TYPE, SPACE) \ - DECL_UNTYPED_RW_SPACE_N(TYPE, 4, SPACE) \ - DECL_UNTYPED_RW_SPACE_N(TYPE, 8, SPACE) \ - DECL_UNTYPED_RW_SPACE_N(TYPE, 16, SPACE) - -#define DECL_UNTYPED_RD_ALL_SPACE(TYPE, SPACE) \ - DECL_UNTYPED_RD_SPACE_N(TYPE, 2, SPACE) \ - DECL_UNTYPED_RDV3_SPACE(TYPE, SPACE) \ - DECL_UNTYPED_RD_SPACE_N(TYPE, 4, SPACE) \ - DECL_UNTYPED_RD_SPACE_N(TYPE, 8, SPACE) \ - DECL_UNTYPED_RD_SPACE_N(TYPE, 16, SPACE) - -#define DECL_UNTYPED_RW_ALL(TYPE) \ - DECL_UNTYPED_RD_ALL_SPACE(TYPE, __constant) \ - DECL_UNTYPED_RW_ALL_SPACE(TYPE, __generic) - -#define DECL_BYTE_RD_SPACE(TYPE, SPACE) \ -OVERLOADABLE TYPE##2 vload2(size_t offset, const SPACE TYPE *p); \ -OVERLOADABLE TYPE##3 vload3(size_t offset, const SPACE TYPE *p); \ -OVERLOADABLE TYPE##4 vload4(size_t offset, const SPACE TYPE *p); \ -OVERLOADABLE TYPE##8 vload8(size_t offset, const SPACE TYPE *p); \ -OVERLOADABLE TYPE##16 vload16(size_t offset, const SPACE TYPE *p); - -#define DECL_BYTE_WR_SPACE(TYPE, SPACE) \ -OVERLOADABLE void vstore2(TYPE##2 v, size_t offset, SPACE TYPE *p); \ -OVERLOADABLE void vstore3(TYPE##3 v, size_t offset, SPACE TYPE *p); \ -OVERLOADABLE void vstore4(TYPE##4 v, size_t offset, SPACE TYPE *p); \ -OVERLOADABLE void vstore8(TYPE##8 v, size_t offset, SPACE TYPE *p); \ -OVERLOADABLE void vstore16(TYPE##16 v, size_t offset, SPACE TYPE *p); - -#define DECL_BYTE_RW_ALL(TYPE) \ - DECL_BYTE_RD_SPACE(TYPE, __generic) \ - DECL_BYTE_WR_SPACE(TYPE, __generic) \ - DECL_BYTE_RD_SPACE(TYPE, __constant) - -DECL_BYTE_RW_ALL(char) -DECL_BYTE_RW_ALL(uchar) -DECL_BYTE_RW_ALL(short) -DECL_BYTE_RW_ALL(ushort) -DECL_BYTE_RW_ALL(half) -DECL_UNTYPED_RW_ALL(int) -DECL_UNTYPED_RW_ALL(uint) -DECL_UNTYPED_RW_ALL(long) -DECL_UNTYPED_RW_ALL(ulong) -DECL_UNTYPED_RW_ALL(float) -DECL_UNTYPED_RW_ALL(double) - -#undef DECL_UNTYPED_RW_ALL -#undef DECL_UNTYPED_RW_ALL_SPACE -#undef DECL_UNTYPED_RD_ALL_SPACE -#undef DECL_UNTYPED_RW_SPACE_N -#undef DECL_UNTYPED_RD_SPACE_N -#undef DECL_UNTYPED_V3_SPACE -#undef DECL_UNTYPED_RDV3_SPACE -#undef DECL_BYTE_RD_SPACE -#undef DECL_BYTE_WR_SPACE -#undef DECL_BYTE_RW_ALL - - -#define DECL_HALF_LD_SPACE(SPACE) \ -OVERLOADABLE float vload_half(size_t offset, const SPACE half *p); \ -OVERLOADABLE float vloada_half(size_t offset, const SPACE half *p); \ -OVERLOADABLE float2 vload_half2(size_t offset, const SPACE half *p); \ -OVERLOADABLE float2 vloada_half2(size_t offset, const SPACE half *p); \ -OVERLOADABLE float3 vload_half3(size_t offset, const SPACE half *p); \ -OVERLOADABLE float3 vloada_half3(size_t offset, const SPACE half *p); \ -OVERLOADABLE float4 vload_half4(size_t offset, const SPACE half *p); \ -OVERLOADABLE float4 vloada_half4(size_t offset, const SPACE half *p); \ -OVERLOADABLE float8 vload_half8(size_t offset, const SPACE half *p); \ -OVERLOADABLE float8 vloada_half8(size_t offset, const SPACE half *p); \ -OVERLOADABLE float16 vload_half16(size_t offset, const SPACE half *p); \ -OVERLOADABLE float16 vloada_half16(size_t offset, const SPACE half *p); \ - -#define DECL_HALF_ST_SPACE_ROUND(SPACE, ROUND, FUNC) \ -OVERLOADABLE void vstore_half##ROUND(float data, size_t offset, SPACE half *p); \ -OVERLOADABLE void vstorea_half##ROUND(float data, size_t offset, SPACE half *p); \ -OVERLOADABLE void vstore_half2##ROUND(float2 data, size_t offset, SPACE half *p); \ -OVERLOADABLE void vstorea_half2##ROUND(float2 data, size_t offset, SPACE half *p); \ -OVERLOADABLE void vstore_half3##ROUND(float3 data, size_t offset, SPACE half *p); \ -OVERLOADABLE void vstorea_half3##ROUND(float3 data, size_t offset, SPACE half *p); \ -OVERLOADABLE void vstore_half4##ROUND(float4 data, size_t offset, SPACE half *p); \ -OVERLOADABLE void vstorea_half4##ROUND(float4 data, size_t offset, SPACE half *p); \ -OVERLOADABLE void vstore_half8##ROUND(float8 data, size_t offset, SPACE half *p); \ -OVERLOADABLE void vstorea_half8##ROUND(float8 data, size_t offset, SPACE half *p); \ -OVERLOADABLE void vstore_half16##ROUND(float16 data, size_t offset, SPACE half *p); \ -OVERLOADABLE void vstorea_half16##ROUND(float16 data, size_t offset, SPACE half *p); - -#define DECL_HALF_ST_SPACE(SPACE) \ - DECL_HALF_ST_SPACE_ROUND(SPACE, , dummy) \ - DECL_HALF_ST_SPACE_ROUND(SPACE, _rte, dummy) \ - DECL_HALF_ST_SPACE_ROUND(SPACE, _rtz, dummy) \ - DECL_HALF_ST_SPACE_ROUND(SPACE, _rtp, dummy) \ - DECL_HALF_ST_SPACE_ROUND(SPACE, _rtn, dummy) \ - -DECL_HALF_LD_SPACE(__constant) -DECL_HALF_LD_SPACE(__generic) - -DECL_HALF_ST_SPACE(__generic) - -//#undef DECL_UNTYPED_RW_ALL_SPACE -#undef DECL_HALF_LD_SPACE -#undef DECL_HALF_ST_SPACE -#undef DECL_HALF_ST_SPACE_ROUND - -#endif /* __OCL_VLOAD_20_H__ */ diff --git a/drivers/pocl-gen7/lib/beignet/include/ocl_work_group.h b/drivers/pocl-gen7/lib/beignet/include/ocl_work_group.h deleted file mode 100644 index ebd264f..0000000 --- a/drivers/pocl-gen7/lib/beignet/include/ocl_work_group.h +++ /dev/null @@ -1,118 +0,0 @@ -/* - * Copyright © 2012 - 2014 Intel Corporation - * - * This library is free software; you can redistribute it and/or - * modify it under the terms of the GNU Lesser General Public - * License as published by the Free Software Foundation; either - * version 2.1 of the License, or (at your option) any later version. - * - * This library is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU - * Lesser General Public License for more details. - * - * You should have received a copy of the GNU Lesser General Public - * License along with this library. If not, see . - * - */ -#ifndef __OCL_WORK_GROUP_H__ -#define __OCL_WORK_GROUP_H__ -#include "ocl_types.h" - -int work_group_all(int predicate); -int work_group_any(int predicate); - -/* broadcast */ -OVERLOADABLE int work_group_broadcast(int a, size_t local_id); -OVERLOADABLE uint work_group_broadcast(uint a, size_t local_id); -OVERLOADABLE long work_group_broadcast(long a, size_t local_id); -OVERLOADABLE ulong work_group_broadcast(ulong a, size_t local_id); -OVERLOADABLE float work_group_broadcast(float a, size_t local_id); -OVERLOADABLE double work_group_broadcast(double a, size_t local_id); - -OVERLOADABLE int work_group_broadcast(int a, size_t local_id_x, size_t local_id_y); -OVERLOADABLE uint work_group_broadcast(uint a, size_t local_id_x, size_t local_id_y); -OVERLOADABLE long work_group_broadcast(long a, size_t local_id_x, size_t local_id_y); -OVERLOADABLE ulong work_group_broadcast(ulong a, size_t local_id_x, size_t local_id_y); -OVERLOADABLE float work_group_broadcast(float a, size_t local_id_x, size_t local_id_y); -OVERLOADABLE double work_group_broadcast(double a, size_t local_id_x, size_t local_id_y); - -OVERLOADABLE int work_group_broadcast(int a, size_t local_id_x, size_t local_id_y, size_t local_id_z); -OVERLOADABLE uint work_group_broadcast(uint a, size_t local_id_x, size_t local_id_y, size_t local_id_z); -OVERLOADABLE long work_group_broadcast(long a, size_t local_id_x, size_t local_id_y, size_t local_id_z); -OVERLOADABLE ulong work_group_broadcast(ulong a, size_t local_id_x, size_t local_id_y, size_t local_id_z); -OVERLOADABLE float work_group_broadcast(float a, size_t local_id_x, size_t local_id_y, size_t local_id_z); -OVERLOADABLE double work_group_broadcast(double a, size_t local_id_x, size_t local_id_y, size_t local_id_z); - -/* reduce add */ -OVERLOADABLE int work_group_reduce_add(int x); -OVERLOADABLE uint work_group_reduce_add(uint x); -OVERLOADABLE long work_group_reduce_add(long x); -OVERLOADABLE ulong work_group_reduce_add(ulong x); -OVERLOADABLE float work_group_reduce_add(float x); -OVERLOADABLE double work_group_reduce_add(double x); - -/* reduce min */ -OVERLOADABLE int work_group_reduce_min(int x); -OVERLOADABLE uint work_group_reduce_min(uint x); -OVERLOADABLE long work_group_reduce_min(long x); -OVERLOADABLE ulong work_group_reduce_min(ulong x); -OVERLOADABLE float work_group_reduce_min(float x); -OVERLOADABLE double work_group_reduce_min(double x); - -/* reduce max */ -OVERLOADABLE int work_group_reduce_max(int x); -OVERLOADABLE uint work_group_reduce_max(uint x); -OVERLOADABLE long work_group_reduce_max(long x); -OVERLOADABLE ulong work_group_reduce_max(ulong x); -OVERLOADABLE float work_group_reduce_max(float x); -OVERLOADABLE double work_group_reduce_max(double x); - -/* scan_inclusive add */ -OVERLOADABLE int work_group_scan_inclusive_add(int x); -OVERLOADABLE uint work_group_scan_inclusive_add(uint x); -OVERLOADABLE long work_group_scan_inclusive_add(long x); -OVERLOADABLE ulong work_group_scan_inclusive_add(ulong x); -OVERLOADABLE float work_group_scan_inclusive_add(float x); -OVERLOADABLE double work_group_scan_inclusive_add(double x); - -/* scan_inclusive min */ -OVERLOADABLE int work_group_scan_inclusive_min(int x); -OVERLOADABLE uint work_group_scan_inclusive_min(uint x); -OVERLOADABLE long work_group_scan_inclusive_min(long x); -OVERLOADABLE ulong work_group_scan_inclusive_min(ulong x); -OVERLOADABLE float work_group_scan_inclusive_min(float x); -OVERLOADABLE double work_group_scan_inclusive_min(double x); - -/* scan_inclusive max */ -OVERLOADABLE int work_group_scan_inclusive_max(int x); -OVERLOADABLE uint work_group_scan_inclusive_max(uint x); -OVERLOADABLE long work_group_scan_inclusive_max(long x); -OVERLOADABLE ulong work_group_scan_inclusive_max(ulong x); -OVERLOADABLE float work_group_scan_inclusive_max(float x); -OVERLOADABLE double work_group_scan_inclusive_max(double x); - -/* scan_exclusive add */ -OVERLOADABLE int work_group_scan_exclusive_add(int x); -OVERLOADABLE uint work_group_scan_exclusive_add(uint x); -OVERLOADABLE long work_group_scan_exclusive_add(long x); -OVERLOADABLE ulong work_group_scan_exclusive_add(ulong x); -OVERLOADABLE float work_group_scan_exclusive_add(float x); -OVERLOADABLE double work_group_scan_exclusive_add(double x); - -/* scan_exclusive min */ -OVERLOADABLE int work_group_scan_exclusive_min(int x); -OVERLOADABLE uint work_group_scan_exclusive_min(uint x); -OVERLOADABLE long work_group_scan_exclusive_min(long x); -OVERLOADABLE ulong work_group_scan_exclusive_min(ulong x); -OVERLOADABLE float work_group_scan_exclusive_min(float x); -OVERLOADABLE double work_group_scan_exclusive_min(double x); - -/* scan_exclusive max */ -OVERLOADABLE int work_group_scan_exclusive_max(int x); -OVERLOADABLE uint work_group_scan_exclusive_max(uint x); -OVERLOADABLE long work_group_scan_exclusive_max(long x); -OVERLOADABLE ulong work_group_scan_exclusive_max(ulong x); -OVERLOADABLE float work_group_scan_exclusive_max(float x); -OVERLOADABLE double work_group_scan_exclusive_max(double x); -#endif /* __OCL_WORK_GROUP_H__ */ diff --git a/drivers/pocl-gen7/lib/beignet/include/ocl_workitem.h b/drivers/pocl-gen7/lib/beignet/include/ocl_workitem.h deleted file mode 100644 index 1a96aa8..0000000 --- a/drivers/pocl-gen7/lib/beignet/include/ocl_workitem.h +++ /dev/null @@ -1,35 +0,0 @@ -/* - * Copyright © 2012 - 2014 Intel Corporation - * - * This library is free software; you can redistribute it and/or - * modify it under the terms of the GNU Lesser General Public - * License as published by the Free Software Foundation; either - * version 2.1 of the License, or (at your option) any later version. - * - * This library is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU - * Lesser General Public License for more details. - * - * You should have received a copy of the GNU Lesser General Public - * License along with this library. If not, see . - * - */ -#ifndef __OCL_WORKITEM_H__ -#define __OCL_WORKITEM_H__ - -#include "ocl_types.h" - -OVERLOADABLE uint get_work_dim(void); -OVERLOADABLE size_t get_global_size(uint dimindx); -OVERLOADABLE size_t get_global_id(uint dimindx); -OVERLOADABLE size_t get_local_size(uint dimindx); -OVERLOADABLE size_t get_enqueued_local_size(uint dimindx); -OVERLOADABLE size_t get_local_id(uint dimindx); -OVERLOADABLE size_t get_num_groups(uint dimindx); -OVERLOADABLE size_t get_group_id(uint dimindx); -OVERLOADABLE size_t get_global_offset(uint dimindx); -OVERLOADABLE size_t get_global_linear_id(void); -OVERLOADABLE size_t get_local_linear_id(void); - -#endif /* __OCL_WORKITEM_H__ */ diff --git a/drivers/pocl-gen7/lib/beignet/libgbe.so b/drivers/pocl-gen7/lib/beignet/libgbe.so deleted file mode 100755 index dbe165d..0000000 Binary files a/drivers/pocl-gen7/lib/beignet/libgbe.so and /dev/null differ diff --git a/drivers/pocl-gen7/lib/beignet/libgbeinterp.so b/drivers/pocl-gen7/lib/beignet/libgbeinterp.so deleted file mode 100755 index e56b01f..0000000 Binary files a/drivers/pocl-gen7/lib/beignet/libgbeinterp.so and /dev/null differ diff --git a/drivers/pocl-gen7/lib/libpocl.so b/drivers/pocl-gen7/lib/libpocl.so deleted file mode 120000 index e9e9819..0000000 --- a/drivers/pocl-gen7/lib/libpocl.so +++ /dev/null @@ -1 +0,0 @@ -libpocl.so.2 \ No newline at end of file diff --git a/drivers/pocl-gen7/lib/libpocl.so.2 b/drivers/pocl-gen7/lib/libpocl.so.2 deleted file mode 120000 index f45462d..0000000 --- a/drivers/pocl-gen7/lib/libpocl.so.2 +++ /dev/null @@ -1 +0,0 @@ -libpocl.so.2.16.0 \ No newline at end of file diff --git a/drivers/pocl-gen7/lib/libpocl.so.2.16.0 b/drivers/pocl-gen7/lib/libpocl.so.2.16.0 deleted file mode 100755 index bd74541..0000000 Binary files a/drivers/pocl-gen7/lib/libpocl.so.2.16.0 and /dev/null differ diff --git a/drivers/pocl-gen7/lib/pocl/libpocl-devices-basic.so b/drivers/pocl-gen7/lib/pocl/libpocl-devices-basic.so deleted file mode 100755 index e0a7853..0000000 Binary files a/drivers/pocl-gen7/lib/pocl/libpocl-devices-basic.so and /dev/null differ diff --git a/drivers/pocl-gen7/lib/pocl/libpocl-devices-gen7.so b/drivers/pocl-gen7/lib/pocl/libpocl-devices-gen7.so deleted file mode 100755 index 55e05ab..0000000 Binary files a/drivers/pocl-gen7/lib/pocl/libpocl-devices-gen7.so and /dev/null differ diff --git a/drivers/pocl-gen7/lib/pocl/libpocl-devices-pthread.so b/drivers/pocl-gen7/lib/pocl/libpocl-devices-pthread.so deleted file mode 100755 index b0ec813..0000000 Binary files a/drivers/pocl-gen7/lib/pocl/libpocl-devices-pthread.so and /dev/null differ diff --git a/drivers/pocl-gen7/share/pocl/include/_builtin_renames.h b/drivers/pocl-gen7/share/pocl/include/_builtin_renames.h deleted file mode 100644 index b2b2287..0000000 --- a/drivers/pocl-gen7/share/pocl/include/_builtin_renames.h +++ /dev/null @@ -1,1168 +0,0 @@ -/* pocl/_kernel_renames.h - Rename OpenCL builtin functions to avoid name - clashes with libm functions which are called in implementation. - - Copyright (c) 2011-2013 Erik Schnetter - Perimeter Institute for Theoretical Physics - Copyright (c) 2011-2017 Pekka Jääskeläinen / TUT - - Permission is hereby granted, free of charge, to any person obtaining a copy - of this software and associated documentation files (the "Software"), to deal - in the Software without restriction, including without limitation the rights - to use, copy, modify, merge, publish, distribute, sublicense, and/or sell - copies of the Software, and to permit persons to whom the Software is - furnished to do so, subject to the following conditions: - - The above copyright notice and this permission notice shall be included in - all copies or substantial portions of the Software. - - THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR - IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, - FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE - AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER - LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, - OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN - THE SOFTWARE. -*/ - -#ifndef _KERNEL_RENAMES_H -#define _KERNEL_RENAMES_H - -/* Move built-in declarations and libm functions out of the way. - (There should be a better way of doing so. These functions are - built-in math functions for OpenCL (see Clang's "Builtins.def"). - - Functions defined in libc or libm may also - interfere with OpenCL's functions, since their prototypes will be - wrong. - - We're not using libm anymore, but renames are still important - for SPIR/SPIR-V support. SPIR mangling is different, but when - ocassionally it's the same, it still has different calling - convention; LLVM can replace illegal calls (with incorrect CC) - with an illegal instruction. -*/ - -#define abs _cl_abs -#define abs_diff _cl_abs_diff -#define acos _cl_acos -#define acosh _cl_acosh -#define acospi _cl_acospi -#define add_sat _cl_add_sat -#define all _cl_all -#define any _cl_any -#define asin _cl_asin -#define asinh _cl_asinh -#define asinpi _cl_asinpi -#define async_work_group_strided_copy _cl_async_work_group_strided_copy -#define async_work_group_copy _cl_async_work_group_copy -#define atan _cl_atan -#define atan2 _cl_atan2 -#define atan2pi _cl_atan2pi -#define atanh _cl_atanh -#define atanpi _cl_atanpi -#define bitselect _cl_bitselect -#define cbrt _cl_cbrt -#define ceil _cl_ceil -#define clamp _cl_clamp -#define clz _cl_clz -#define copysign _cl_copysign -#define cos _cl_cos -#define cosh _cl_cosh -#define cospi _cl_cospi -#define cross _cl_cross -#define ctz _cl_ctz -#define degrees _cl_degrees -#define distance _cl_distance -#define dot _cl_dot -#define erf _cl_erf -#define erfc _cl_erfc -#define exp _cl_exp -#define exp10 _cl_exp10 -#define exp2 _cl_exp2 -#define expm1 _cl_expm1 -#define fabs _cl_fabs -#define fast_distance _cl_fast_distance -#define fast_length _cl_fast_length -#define fast_normalize _cl_fast_normalize -#define fdim _cl_fdim -#define floor _cl_floor -#define fma _cl_fma -#define fmax _cl_fmax -#define fmax_common _cl_fmax_common -#define fmin _cl_fmin -#define fmin_common _cl_fmin_common -#define fmod _cl_fmod -#define fract _cl_fract -#define frexp _cl_frexp -#define hadd _cl_hadd -#define half_cos _cl_half_cos -#define half_divide _cl_half_divide -#define half_exp _cl_half_exp -#define half_exp10 _cl_half_exp10 -#define half_exp2 _cl_half_exp2 -#define half_log _cl_half_log -#define half_log10 _cl_half_log10 -#define half_log2 _cl_half_log2 -#define half_powr _cl_half_powr -#define half_recip _cl_half_recip -#define half_rsqrt _cl_half_rsqrt -#define half_sin _cl_half_sin -#define half_sqrt _cl_half_sqrt -#define half_tan _cl_half_tan -#define hypot _cl_hypot -#define ilogb _cl_ilogb -#define isequal _cl_isequal -#define isfinite _cl_isfinite -#define isgreater _cl_isgreater -#define isgreaterequal _cl_isgreaterequal -#define isinf _cl_isinf -#define isless _cl_isless -#define islessequal _cl_islessequal -#define islessgreater _cl_islessgreater -#define isnan _cl_isnan -#define isnormal _cl_isnormal -#define isnotequal _cl_isnotequal -#define isordered _cl_isordered -#define isunordered _cl_isunordered -#define ldexp _cl_ldexp -#define length _cl_length -#define lgamma _cl_lgamma -#define lgamma_r _cl_lgamma_r -#define log _cl_log -#define log10 _cl_log10 -#define log1p _cl_log1p -#define log2 _cl_log2 -#define logb _cl_logb -#define mad _cl_mad -#define mad24 _cl_mad24 -#define mad_hi _cl_mad_hi -#define mad_sat _cl_mad_sat -#define max _cl_max -#define maxmag _cl_maxmag -#define min _cl_min -#define minmag _cl_minmag -#define mix _cl_mix -#define modf _cl_modf -#define mul24 _cl_mul24 -#define mul_hi _cl_mul_hi -#define nan _cl_nan -#define native_cos _cl_native_cos -#define native_divide _cl_native_divide -#define native_exp _cl_native_exp -#define native_exp10 _cl_native_exp10 -#define native_exp2 _cl_native_exp2 -#define native_log _cl_native_log -#define native_log10 _cl_native_log10 -#define native_log2 _cl_native_log2 -#define native_powr _cl_native_powr -#define native_recip _cl_native_recip -#define native_rsqrt _cl_native_rsqrt -#define native_sin _cl_native_sin -#define native_sqrt _cl_native_sqrt -#define native_tan _cl_native_tan -#define nextafter _cl_nextafter -#define normalize _cl_normalize -#define popcount _cl_popcount -#define pow _cl_pow -#define pown _cl_pown -#define powr _cl_powr -#define prefetch _cl_prefetch -#define radians _cl_radians -#define remainder _cl_remainder -#define remquo _cl_remquo -#define rhadd _cl_rhadd -#define rint _cl_rint -#define rootn _cl_rootn -#define rotate _cl_rotate -#define round _cl_round -#define rsqrt _cl_rsqrt -#define select _cl_select -#define shuffle _cl_shuffle -#define shuffle2 _cl_shuffle2 -#define sign _cl_sign -#define signbit _cl_signbit -#define sin _cl_sin -#define sincos _cl_sincos -#define sinh _cl_sinh -#define sinpi _cl_sinpi -#define smoothstep _cl_smoothstep -#define sqrt _cl_sqrt -#define step _cl_step -#define sub_sat _cl_sub_sat -#define tan _cl_tan -#define tanh _cl_tanh -#define tanpi _cl_tanpi -#define tgamma _cl_tgamma -#define trunc _cl_trunc -#define upsample _cl_upsample - -#define vload _cl_vload -#define vstore _cl_vstore -#define vload_half _cl_vload_half -#define vstore_half _cl_vstore_half -#define vloada_half _cl_vloada_half -#define vstorea_half _cl_vstorea_half -#define vload_half_rte _cl_vload_half_rte -#define vstore_half_rte _cl_vstore_half_rte -#define vloada_half_rte _cl_vloada_half_rte -#define vstorea_half_rte _cl_vstorea_half_rte -#define vload_half_rtz _cl_vload_half_rtz -#define vstore_half_rtz _cl_vstore_half_rtz -#define vloada_half_rtz _cl_vloada_half_rtz -#define vstorea_half_rtz _cl_vstorea_half_rtz -#define vload_half_rtp _cl_vload_half_rtp -#define vstore_half_rtp _cl_vstore_half_rtp -#define vloada_half_rtp _cl_vloada_half_rtp -#define vstorea_half_rtp _cl_vstorea_half_rtp -#define vload_half_rtn _cl_vload_half_rtn -#define vstore_half_rtn _cl_vstore_half_rtn -#define vloada_half_rtn _cl_vloada_half_rtn -#define vstorea_half_rtn _cl_vstorea_half_rtn -#define convert_char _cl_convert_char -#define convert_uchar _cl_convert_uchar -#define convert_short _cl_convert_short -#define convert_ushort _cl_convert_ushort -#define convert_int _cl_convert_int -#define convert_uint _cl_convert_uint -#define convert_long _cl_convert_long -#define convert_ulong _cl_convert_ulong -#define convert_float _cl_convert_float -#define convert_double _cl_convert_double -#define convert_char_rte _cl_convert_char_rte -#define convert_uchar_rte _cl_convert_uchar_rte -#define convert_short_rte _cl_convert_short_rte -#define convert_ushort_rte _cl_convert_ushort_rte -#define convert_int_rte _cl_convert_int_rte -#define convert_uint_rte _cl_convert_uint_rte -#define convert_long_rte _cl_convert_long_rte -#define convert_ulong_rte _cl_convert_ulong_rte -#define convert_float_rte _cl_convert_float_rte -#define convert_double_rte _cl_convert_double_rte -#define convert_char_rtz _cl_convert_char_rtz -#define convert_uchar_rtz _cl_convert_uchar_rtz -#define convert_short_rtz _cl_convert_short_rtz -#define convert_ushort_rtz _cl_convert_ushort_rtz -#define convert_int_rtz _cl_convert_int_rtz -#define convert_uint_rtz _cl_convert_uint_rtz -#define convert_long_rtz _cl_convert_long_rtz -#define convert_ulong_rtz _cl_convert_ulong_rtz -#define convert_float_rtz _cl_convert_float_rtz -#define convert_double_rtz _cl_convert_double_rtz -#define convert_char_rtp _cl_convert_char_rtp -#define convert_uchar_rtp _cl_convert_uchar_rtp -#define convert_short_rtp _cl_convert_short_rtp -#define convert_ushort_rtp _cl_convert_ushort_rtp -#define convert_int_rtp _cl_convert_int_rtp -#define convert_uint_rtp _cl_convert_uint_rtp -#define convert_long_rtp _cl_convert_long_rtp -#define convert_ulong_rtp _cl_convert_ulong_rtp -#define convert_float_rtp _cl_convert_float_rtp -#define convert_double_rtp _cl_convert_double_rtp -#define convert_char_rtn _cl_convert_char_rtn -#define convert_uchar_rtn _cl_convert_uchar_rtn -#define convert_short_rtn _cl_convert_short_rtn -#define convert_ushort_rtn _cl_convert_ushort_rtn -#define convert_int_rtn _cl_convert_int_rtn -#define convert_uint_rtn _cl_convert_uint_rtn -#define convert_long_rtn _cl_convert_long_rtn -#define convert_ulong_rtn _cl_convert_ulong_rtn -#define convert_float_rtn _cl_convert_float_rtn -#define convert_double_rtn _cl_convert_double_rtn -#define convert_char_sat _cl_convert_char_sat -#define convert_uchar_sat _cl_convert_uchar_sat -#define convert_short_sat _cl_convert_short_sat -#define convert_ushort_sat _cl_convert_ushort_sat -#define convert_int_sat _cl_convert_int_sat -#define convert_uint_sat _cl_convert_uint_sat -#define convert_long_sat _cl_convert_long_sat -#define convert_ulong_sat _cl_convert_ulong_sat -#define convert_float_sat _cl_convert_float_sat -#define convert_double_sat _cl_convert_double_sat -#define convert_char_sat_rte _cl_convert_char_sat_rte -#define convert_uchar_sat_rte _cl_convert_uchar_sat_rte -#define convert_short_sat_rte _cl_convert_short_sat_rte -#define convert_ushort_sat_rte _cl_convert_ushort_sat_rte -#define convert_int_sat_rte _cl_convert_int_sat_rte -#define convert_uint_sat_rte _cl_convert_uint_sat_rte -#define convert_long_sat_rte _cl_convert_long_sat_rte -#define convert_ulong_sat_rte _cl_convert_ulong_sat_rte -#define convert_float_sat_rte _cl_convert_float_sat_rte -#define convert_double_sat_rte _cl_convert_double_sat_rte -#define convert_char_sat_rtz _cl_convert_char_sat_rtz -#define convert_uchar_sat_rtz _cl_convert_uchar_sat_rtz -#define convert_short_sat_rtz _cl_convert_short_sat_rtz -#define convert_ushort_sat_rtz _cl_convert_ushort_sat_rtz -#define convert_int_sat_rtz _cl_convert_int_sat_rtz -#define convert_uint_sat_rtz _cl_convert_uint_sat_rtz -#define convert_long_sat_rtz _cl_convert_long_sat_rtz -#define convert_ulong_sat_rtz _cl_convert_ulong_sat_rtz -#define convert_float_sat_rtz _cl_convert_float_sat_rtz -#define convert_double_sat_rtz _cl_convert_double_sat_rtz -#define convert_char_sat_rtp _cl_convert_char_sat_rtp -#define convert_uchar_sat_rtp _cl_convert_uchar_sat_rtp -#define convert_short_sat_rtp _cl_convert_short_sat_rtp -#define convert_ushort_sat_rtp _cl_convert_ushort_sat_rtp -#define convert_int_sat_rtp _cl_convert_int_sat_rtp -#define convert_uint_sat_rtp _cl_convert_uint_sat_rtp -#define convert_long_sat_rtp _cl_convert_long_sat_rtp -#define convert_ulong_sat_rtp _cl_convert_ulong_sat_rtp -#define convert_float_sat_rtp _cl_convert_float_sat_rtp -#define convert_double_sat_rtp _cl_convert_double_sat_rtp -#define convert_char_sat_rtn _cl_convert_char_sat_rtn -#define convert_uchar_sat_rtn _cl_convert_uchar_sat_rtn -#define convert_short_sat_rtn _cl_convert_short_sat_rtn -#define convert_ushort_sat_rtn _cl_convert_ushort_sat_rtn -#define convert_int_sat_rtn _cl_convert_int_sat_rtn -#define convert_uint_sat_rtn _cl_convert_uint_sat_rtn -#define convert_long_sat_rtn _cl_convert_long_sat_rtn -#define convert_ulong_sat_rtn _cl_convert_ulong_sat_rtn -#define convert_float_sat_rtn _cl_convert_float_sat_rtn -#define convert_double_sat_rtn _cl_convert_double_sat_rtn - -#define vload2 _cl_vload2 -#define vstore2 _cl_vstore2 -#define vload_half2 _cl_vload_half2 -#define vstore_half2 _cl_vstore_half2 -#define vloada_half2 _cl_vloada_half2 -#define vstorea_half2 _cl_vstorea_half2 -#define vload_half2_rte _cl_vload_half2_rte -#define vstore_half2_rte _cl_vstore_half2_rte -#define vloada_half2_rte _cl_vloada_half2_rte -#define vstorea_half2_rte _cl_vstorea_half2_rte -#define vload_half2_rtz _cl_vload_half2_rtz -#define vstore_half2_rtz _cl_vstore_half2_rtz -#define vloada_half2_rtz _cl_vloada_half2_rtz -#define vstorea_half2_rtz _cl_vstorea_half2_rtz -#define vload_half2_rtp _cl_vload_half2_rtp -#define vstore_half2_rtp _cl_vstore_half2_rtp -#define vloada_half2_rtp _cl_vloada_half2_rtp -#define vstorea_half2_rtp _cl_vstorea_half2_rtp -#define vload_half2_rtn _cl_vload_half2_rtn -#define vstore_half2_rtn _cl_vstore_half2_rtn -#define vloada_half2_rtn _cl_vloada_half2_rtn -#define vstorea_half2_rtn _cl_vstorea_half2_rtn -#define convert_char2 _cl_convert_char2 -#define convert_uchar2 _cl_convert_uchar2 -#define convert_short2 _cl_convert_short2 -#define convert_ushort2 _cl_convert_ushort2 -#define convert_int2 _cl_convert_int2 -#define convert_uint2 _cl_convert_uint2 -#define convert_long2 _cl_convert_long2 -#define convert_ulong2 _cl_convert_ulong2 -#define convert_float2 _cl_convert_float2 -#define convert_double2 _cl_convert_double2 -#define convert_char2_rte _cl_convert_char2_rte -#define convert_uchar2_rte _cl_convert_uchar2_rte -#define convert_short2_rte _cl_convert_short2_rte -#define convert_ushort2_rte _cl_convert_ushort2_rte -#define convert_int2_rte _cl_convert_int2_rte -#define convert_uint2_rte _cl_convert_uint2_rte -#define convert_long2_rte _cl_convert_long2_rte -#define convert_ulong2_rte _cl_convert_ulong2_rte -#define convert_float2_rte _cl_convert_float2_rte -#define convert_double2_rte _cl_convert_double2_rte -#define convert_char2_rtz _cl_convert_char2_rtz -#define convert_uchar2_rtz _cl_convert_uchar2_rtz -#define convert_short2_rtz _cl_convert_short2_rtz -#define convert_ushort2_rtz _cl_convert_ushort2_rtz -#define convert_int2_rtz _cl_convert_int2_rtz -#define convert_uint2_rtz _cl_convert_uint2_rtz -#define convert_long2_rtz _cl_convert_long2_rtz -#define convert_ulong2_rtz _cl_convert_ulong2_rtz -#define convert_float2_rtz _cl_convert_float2_rtz -#define convert_double2_rtz _cl_convert_double2_rtz -#define convert_char2_rtp _cl_convert_char2_rtp -#define convert_uchar2_rtp _cl_convert_uchar2_rtp -#define convert_short2_rtp _cl_convert_short2_rtp -#define convert_ushort2_rtp _cl_convert_ushort2_rtp -#define convert_int2_rtp _cl_convert_int2_rtp -#define convert_uint2_rtp _cl_convert_uint2_rtp -#define convert_long2_rtp _cl_convert_long2_rtp -#define convert_ulong2_rtp _cl_convert_ulong2_rtp -#define convert_float2_rtp _cl_convert_float2_rtp -#define convert_double2_rtp _cl_convert_double2_rtp -#define convert_char2_rtn _cl_convert_char2_rtn -#define convert_uchar2_rtn _cl_convert_uchar2_rtn -#define convert_short2_rtn _cl_convert_short2_rtn -#define convert_ushort2_rtn _cl_convert_ushort2_rtn -#define convert_int2_rtn _cl_convert_int2_rtn -#define convert_uint2_rtn _cl_convert_uint2_rtn -#define convert_long2_rtn _cl_convert_long2_rtn -#define convert_ulong2_rtn _cl_convert_ulong2_rtn -#define convert_float2_rtn _cl_convert_float2_rtn -#define convert_double2_rtn _cl_convert_double2_rtn -#define convert_char2_sat _cl_convert_char2_sat -#define convert_uchar2_sat _cl_convert_uchar2_sat -#define convert_short2_sat _cl_convert_short2_sat -#define convert_ushort2_sat _cl_convert_ushort2_sat -#define convert_int2_sat _cl_convert_int2_sat -#define convert_uint2_sat _cl_convert_uint2_sat -#define convert_long2_sat _cl_convert_long2_sat -#define convert_ulong2_sat _cl_convert_ulong2_sat -#define convert_float2_sat _cl_convert_float2_sat -#define convert_double2_sat _cl_convert_double2_sat -#define convert_char2_sat_rte _cl_convert_char2_sat_rte -#define convert_uchar2_sat_rte _cl_convert_uchar2_sat_rte -#define convert_short2_sat_rte _cl_convert_short2_sat_rte -#define convert_ushort2_sat_rte _cl_convert_ushort2_sat_rte -#define convert_int2_sat_rte _cl_convert_int2_sat_rte -#define convert_uint2_sat_rte _cl_convert_uint2_sat_rte -#define convert_long2_sat_rte _cl_convert_long2_sat_rte -#define convert_ulong2_sat_rte _cl_convert_ulong2_sat_rte -#define convert_float2_sat_rte _cl_convert_float2_sat_rte -#define convert_double2_sat_rte _cl_convert_double2_sat_rte -#define convert_char2_sat_rtz _cl_convert_char2_sat_rtz -#define convert_uchar2_sat_rtz _cl_convert_uchar2_sat_rtz -#define convert_short2_sat_rtz _cl_convert_short2_sat_rtz -#define convert_ushort2_sat_rtz _cl_convert_ushort2_sat_rtz -#define convert_int2_sat_rtz _cl_convert_int2_sat_rtz -#define convert_uint2_sat_rtz _cl_convert_uint2_sat_rtz -#define convert_long2_sat_rtz _cl_convert_long2_sat_rtz -#define convert_ulong2_sat_rtz _cl_convert_ulong2_sat_rtz -#define convert_float2_sat_rtz _cl_convert_float2_sat_rtz -#define convert_double2_sat_rtz _cl_convert_double2_sat_rtz -#define convert_char2_sat_rtp _cl_convert_char2_sat_rtp -#define convert_uchar2_sat_rtp _cl_convert_uchar2_sat_rtp -#define convert_short2_sat_rtp _cl_convert_short2_sat_rtp -#define convert_ushort2_sat_rtp _cl_convert_ushort2_sat_rtp -#define convert_int2_sat_rtp _cl_convert_int2_sat_rtp -#define convert_uint2_sat_rtp _cl_convert_uint2_sat_rtp -#define convert_long2_sat_rtp _cl_convert_long2_sat_rtp -#define convert_ulong2_sat_rtp _cl_convert_ulong2_sat_rtp -#define convert_float2_sat_rtp _cl_convert_float2_sat_rtp -#define convert_double2_sat_rtp _cl_convert_double2_sat_rtp -#define convert_char2_sat_rtn _cl_convert_char2_sat_rtn -#define convert_uchar2_sat_rtn _cl_convert_uchar2_sat_rtn -#define convert_short2_sat_rtn _cl_convert_short2_sat_rtn -#define convert_ushort2_sat_rtn _cl_convert_ushort2_sat_rtn -#define convert_int2_sat_rtn _cl_convert_int2_sat_rtn -#define convert_uint2_sat_rtn _cl_convert_uint2_sat_rtn -#define convert_long2_sat_rtn _cl_convert_long2_sat_rtn -#define convert_ulong2_sat_rtn _cl_convert_ulong2_sat_rtn -#define convert_float2_sat_rtn _cl_convert_float2_sat_rtn -#define convert_double2_sat_rtn _cl_convert_double2_sat_rtn - -#define vload3 _cl_vload3 -#define vstore3 _cl_vstore3 -#define vload_half3 _cl_vload_half3 -#define vstore_half3 _cl_vstore_half3 -#define vloada_half3 _cl_vloada_half3 -#define vstorea_half3 _cl_vstorea_half3 -#define vload_half3_rte _cl_vload_half3_rte -#define vstore_half3_rte _cl_vstore_half3_rte -#define vloada_half3_rte _cl_vloada_half3_rte -#define vstorea_half3_rte _cl_vstorea_half3_rte -#define vload_half3_rtz _cl_vload_half3_rtz -#define vstore_half3_rtz _cl_vstore_half3_rtz -#define vloada_half3_rtz _cl_vloada_half3_rtz -#define vstorea_half3_rtz _cl_vstorea_half3_rtz -#define vload_half3_rtp _cl_vload_half3_rtp -#define vstore_half3_rtp _cl_vstore_half3_rtp -#define vloada_half3_rtp _cl_vloada_half3_rtp -#define vstorea_half3_rtp _cl_vstorea_half3_rtp -#define vload_half3_rtn _cl_vload_half3_rtn -#define vstore_half3_rtn _cl_vstore_half3_rtn -#define vloada_half3_rtn _cl_vloada_half3_rtn -#define vstorea_half3_rtn _cl_vstorea_half3_rtn -#define convert_char3 _cl_convert_char3 -#define convert_uchar3 _cl_convert_uchar3 -#define convert_short3 _cl_convert_short3 -#define convert_ushort3 _cl_convert_ushort3 -#define convert_int3 _cl_convert_int3 -#define convert_uint3 _cl_convert_uint3 -#define convert_long3 _cl_convert_long3 -#define convert_ulong3 _cl_convert_ulong3 -#define convert_float3 _cl_convert_float3 -#define convert_double3 _cl_convert_double3 -#define convert_char3_rte _cl_convert_char3_rte -#define convert_uchar3_rte _cl_convert_uchar3_rte -#define convert_short3_rte _cl_convert_short3_rte -#define convert_ushort3_rte _cl_convert_ushort3_rte -#define convert_int3_rte _cl_convert_int3_rte -#define convert_uint3_rte _cl_convert_uint3_rte -#define convert_long3_rte _cl_convert_long3_rte -#define convert_ulong3_rte _cl_convert_ulong3_rte -#define convert_float3_rte _cl_convert_float3_rte -#define convert_double3_rte _cl_convert_double3_rte -#define convert_char3_rtz _cl_convert_char3_rtz -#define convert_uchar3_rtz _cl_convert_uchar3_rtz -#define convert_short3_rtz _cl_convert_short3_rtz -#define convert_ushort3_rtz _cl_convert_ushort3_rtz -#define convert_int3_rtz _cl_convert_int3_rtz -#define convert_uint3_rtz _cl_convert_uint3_rtz -#define convert_long3_rtz _cl_convert_long3_rtz -#define convert_ulong3_rtz _cl_convert_ulong3_rtz -#define convert_float3_rtz _cl_convert_float3_rtz -#define convert_double3_rtz _cl_convert_double3_rtz -#define convert_char3_rtp _cl_convert_char3_rtp -#define convert_uchar3_rtp _cl_convert_uchar3_rtp -#define convert_short3_rtp _cl_convert_short3_rtp -#define convert_ushort3_rtp _cl_convert_ushort3_rtp -#define convert_int3_rtp _cl_convert_int3_rtp -#define convert_uint3_rtp _cl_convert_uint3_rtp -#define convert_long3_rtp _cl_convert_long3_rtp -#define convert_ulong3_rtp _cl_convert_ulong3_rtp -#define convert_float3_rtp _cl_convert_float3_rtp -#define convert_double3_rtp _cl_convert_double3_rtp -#define convert_char3_rtn _cl_convert_char3_rtn -#define convert_uchar3_rtn _cl_convert_uchar3_rtn -#define convert_short3_rtn _cl_convert_short3_rtn -#define convert_ushort3_rtn _cl_convert_ushort3_rtn -#define convert_int3_rtn _cl_convert_int3_rtn -#define convert_uint3_rtn _cl_convert_uint3_rtn -#define convert_long3_rtn _cl_convert_long3_rtn -#define convert_ulong3_rtn _cl_convert_ulong3_rtn -#define convert_float3_rtn _cl_convert_float3_rtn -#define convert_double3_rtn _cl_convert_double3_rtn -#define convert_char3_sat _cl_convert_char3_sat -#define convert_uchar3_sat _cl_convert_uchar3_sat -#define convert_short3_sat _cl_convert_short3_sat -#define convert_ushort3_sat _cl_convert_ushort3_sat -#define convert_int3_sat _cl_convert_int3_sat -#define convert_uint3_sat _cl_convert_uint3_sat -#define convert_long3_sat _cl_convert_long3_sat -#define convert_ulong3_sat _cl_convert_ulong3_sat -#define convert_float3_sat _cl_convert_float3_sat -#define convert_double3_sat _cl_convert_double3_sat -#define convert_char3_sat_rte _cl_convert_char3_sat_rte -#define convert_uchar3_sat_rte _cl_convert_uchar3_sat_rte -#define convert_short3_sat_rte _cl_convert_short3_sat_rte -#define convert_ushort3_sat_rte _cl_convert_ushort3_sat_rte -#define convert_int3_sat_rte _cl_convert_int3_sat_rte -#define convert_uint3_sat_rte _cl_convert_uint3_sat_rte -#define convert_long3_sat_rte _cl_convert_long3_sat_rte -#define convert_ulong3_sat_rte _cl_convert_ulong3_sat_rte -#define convert_float3_sat_rte _cl_convert_float3_sat_rte -#define convert_double3_sat_rte _cl_convert_double3_sat_rte -#define convert_char3_sat_rtz _cl_convert_char3_sat_rtz -#define convert_uchar3_sat_rtz _cl_convert_uchar3_sat_rtz -#define convert_short3_sat_rtz _cl_convert_short3_sat_rtz -#define convert_ushort3_sat_rtz _cl_convert_ushort3_sat_rtz -#define convert_int3_sat_rtz _cl_convert_int3_sat_rtz -#define convert_uint3_sat_rtz _cl_convert_uint3_sat_rtz -#define convert_long3_sat_rtz _cl_convert_long3_sat_rtz -#define convert_ulong3_sat_rtz _cl_convert_ulong3_sat_rtz -#define convert_float3_sat_rtz _cl_convert_float3_sat_rtz -#define convert_double3_sat_rtz _cl_convert_double3_sat_rtz -#define convert_char3_sat_rtp _cl_convert_char3_sat_rtp -#define convert_uchar3_sat_rtp _cl_convert_uchar3_sat_rtp -#define convert_short3_sat_rtp _cl_convert_short3_sat_rtp -#define convert_ushort3_sat_rtp _cl_convert_ushort3_sat_rtp -#define convert_int3_sat_rtp _cl_convert_int3_sat_rtp -#define convert_uint3_sat_rtp _cl_convert_uint3_sat_rtp -#define convert_long3_sat_rtp _cl_convert_long3_sat_rtp -#define convert_ulong3_sat_rtp _cl_convert_ulong3_sat_rtp -#define convert_float3_sat_rtp _cl_convert_float3_sat_rtp -#define convert_double3_sat_rtp _cl_convert_double3_sat_rtp -#define convert_char3_sat_rtn _cl_convert_char3_sat_rtn -#define convert_uchar3_sat_rtn _cl_convert_uchar3_sat_rtn -#define convert_short3_sat_rtn _cl_convert_short3_sat_rtn -#define convert_ushort3_sat_rtn _cl_convert_ushort3_sat_rtn -#define convert_int3_sat_rtn _cl_convert_int3_sat_rtn -#define convert_uint3_sat_rtn _cl_convert_uint3_sat_rtn -#define convert_long3_sat_rtn _cl_convert_long3_sat_rtn -#define convert_ulong3_sat_rtn _cl_convert_ulong3_sat_rtn -#define convert_float3_sat_rtn _cl_convert_float3_sat_rtn -#define convert_double3_sat_rtn _cl_convert_double3_sat_rtn - -#define vload4 _cl_vload4 -#define vstore4 _cl_vstore4 -#define vload_half4 _cl_vload_half4 -#define vstore_half4 _cl_vstore_half4 -#define vloada_half4 _cl_vloada_half4 -#define vstorea_half4 _cl_vstorea_half4 -#define vload_half4_rte _cl_vload_half4_rte -#define vstore_half4_rte _cl_vstore_half4_rte -#define vloada_half4_rte _cl_vloada_half4_rte -#define vstorea_half4_rte _cl_vstorea_half4_rte -#define vload_half4_rtz _cl_vload_half4_rtz -#define vstore_half4_rtz _cl_vstore_half4_rtz -#define vloada_half4_rtz _cl_vloada_half4_rtz -#define vstorea_half4_rtz _cl_vstorea_half4_rtz -#define vload_half4_rtp _cl_vload_half4_rtp -#define vstore_half4_rtp _cl_vstore_half4_rtp -#define vloada_half4_rtp _cl_vloada_half4_rtp -#define vstorea_half4_rtp _cl_vstorea_half4_rtp -#define vload_half4_rtn _cl_vload_half4_rtn -#define vstore_half4_rtn _cl_vstore_half4_rtn -#define vloada_half4_rtn _cl_vloada_half4_rtn -#define vstorea_half4_rtn _cl_vstorea_half4_rtn -#define convert_char4 _cl_convert_char4 -#define convert_uchar4 _cl_convert_uchar4 -#define convert_short4 _cl_convert_short4 -#define convert_ushort4 _cl_convert_ushort4 -#define convert_int4 _cl_convert_int4 -#define convert_uint4 _cl_convert_uint4 -#define convert_long4 _cl_convert_long4 -#define convert_ulong4 _cl_convert_ulong4 -#define convert_float4 _cl_convert_float4 -#define convert_double4 _cl_convert_double4 -#define convert_char4_rte _cl_convert_char4_rte -#define convert_uchar4_rte _cl_convert_uchar4_rte -#define convert_short4_rte _cl_convert_short4_rte -#define convert_ushort4_rte _cl_convert_ushort4_rte -#define convert_int4_rte _cl_convert_int4_rte -#define convert_uint4_rte _cl_convert_uint4_rte -#define convert_long4_rte _cl_convert_long4_rte -#define convert_ulong4_rte _cl_convert_ulong4_rte -#define convert_float4_rte _cl_convert_float4_rte -#define convert_double4_rte _cl_convert_double4_rte -#define convert_char4_rtz _cl_convert_char4_rtz -#define convert_uchar4_rtz _cl_convert_uchar4_rtz -#define convert_short4_rtz _cl_convert_short4_rtz -#define convert_ushort4_rtz _cl_convert_ushort4_rtz -#define convert_int4_rtz _cl_convert_int4_rtz -#define convert_uint4_rtz _cl_convert_uint4_rtz -#define convert_long4_rtz _cl_convert_long4_rtz -#define convert_ulong4_rtz _cl_convert_ulong4_rtz -#define convert_float4_rtz _cl_convert_float4_rtz -#define convert_double4_rtz _cl_convert_double4_rtz -#define convert_char4_rtp _cl_convert_char4_rtp -#define convert_uchar4_rtp _cl_convert_uchar4_rtp -#define convert_short4_rtp _cl_convert_short4_rtp -#define convert_ushort4_rtp _cl_convert_ushort4_rtp -#define convert_int4_rtp _cl_convert_int4_rtp -#define convert_uint4_rtp _cl_convert_uint4_rtp -#define convert_long4_rtp _cl_convert_long4_rtp -#define convert_ulong4_rtp _cl_convert_ulong4_rtp -#define convert_float4_rtp _cl_convert_float4_rtp -#define convert_double4_rtp _cl_convert_double4_rtp -#define convert_char4_rtn _cl_convert_char4_rtn -#define convert_uchar4_rtn _cl_convert_uchar4_rtn -#define convert_short4_rtn _cl_convert_short4_rtn -#define convert_ushort4_rtn _cl_convert_ushort4_rtn -#define convert_int4_rtn _cl_convert_int4_rtn -#define convert_uint4_rtn _cl_convert_uint4_rtn -#define convert_long4_rtn _cl_convert_long4_rtn -#define convert_ulong4_rtn _cl_convert_ulong4_rtn -#define convert_float4_rtn _cl_convert_float4_rtn -#define convert_double4_rtn _cl_convert_double4_rtn -#define convert_char4_sat _cl_convert_char4_sat -#define convert_uchar4_sat _cl_convert_uchar4_sat -#define convert_short4_sat _cl_convert_short4_sat -#define convert_ushort4_sat _cl_convert_ushort4_sat -#define convert_int4_sat _cl_convert_int4_sat -#define convert_uint4_sat _cl_convert_uint4_sat -#define convert_long4_sat _cl_convert_long4_sat -#define convert_ulong4_sat _cl_convert_ulong4_sat -#define convert_float4_sat _cl_convert_float4_sat -#define convert_double4_sat _cl_convert_double4_sat -#define convert_char4_sat_rte _cl_convert_char4_sat_rte -#define convert_uchar4_sat_rte _cl_convert_uchar4_sat_rte -#define convert_short4_sat_rte _cl_convert_short4_sat_rte -#define convert_ushort4_sat_rte _cl_convert_ushort4_sat_rte -#define convert_int4_sat_rte _cl_convert_int4_sat_rte -#define convert_uint4_sat_rte _cl_convert_uint4_sat_rte -#define convert_long4_sat_rte _cl_convert_long4_sat_rte -#define convert_ulong4_sat_rte _cl_convert_ulong4_sat_rte -#define convert_float4_sat_rte _cl_convert_float4_sat_rte -#define convert_double4_sat_rte _cl_convert_double4_sat_rte -#define convert_char4_sat_rtz _cl_convert_char4_sat_rtz -#define convert_uchar4_sat_rtz _cl_convert_uchar4_sat_rtz -#define convert_short4_sat_rtz _cl_convert_short4_sat_rtz -#define convert_ushort4_sat_rtz _cl_convert_ushort4_sat_rtz -#define convert_int4_sat_rtz _cl_convert_int4_sat_rtz -#define convert_uint4_sat_rtz _cl_convert_uint4_sat_rtz -#define convert_long4_sat_rtz _cl_convert_long4_sat_rtz -#define convert_ulong4_sat_rtz _cl_convert_ulong4_sat_rtz -#define convert_float4_sat_rtz _cl_convert_float4_sat_rtz -#define convert_double4_sat_rtz _cl_convert_double4_sat_rtz -#define convert_char4_sat_rtp _cl_convert_char4_sat_rtp -#define convert_uchar4_sat_rtp _cl_convert_uchar4_sat_rtp -#define convert_short4_sat_rtp _cl_convert_short4_sat_rtp -#define convert_ushort4_sat_rtp _cl_convert_ushort4_sat_rtp -#define convert_int4_sat_rtp _cl_convert_int4_sat_rtp -#define convert_uint4_sat_rtp _cl_convert_uint4_sat_rtp -#define convert_long4_sat_rtp _cl_convert_long4_sat_rtp -#define convert_ulong4_sat_rtp _cl_convert_ulong4_sat_rtp -#define convert_float4_sat_rtp _cl_convert_float4_sat_rtp -#define convert_double4_sat_rtp _cl_convert_double4_sat_rtp -#define convert_char4_sat_rtn _cl_convert_char4_sat_rtn -#define convert_uchar4_sat_rtn _cl_convert_uchar4_sat_rtn -#define convert_short4_sat_rtn _cl_convert_short4_sat_rtn -#define convert_ushort4_sat_rtn _cl_convert_ushort4_sat_rtn -#define convert_int4_sat_rtn _cl_convert_int4_sat_rtn -#define convert_uint4_sat_rtn _cl_convert_uint4_sat_rtn -#define convert_long4_sat_rtn _cl_convert_long4_sat_rtn -#define convert_ulong4_sat_rtn _cl_convert_ulong4_sat_rtn -#define convert_float4_sat_rtn _cl_convert_float4_sat_rtn -#define convert_double4_sat_rtn _cl_convert_double4_sat_rtn - -#define vload8 _cl_vload8 -#define vstore8 _cl_vstore8 -#define vload_half8 _cl_vload_half8 -#define vstore_half8 _cl_vstore_half8 -#define vloada_half8 _cl_vloada_half8 -#define vstorea_half8 _cl_vstorea_half8 -#define vload_half8_rte _cl_vload_half8_rte -#define vstore_half8_rte _cl_vstore_half8_rte -#define vloada_half8_rte _cl_vloada_half8_rte -#define vstorea_half8_rte _cl_vstorea_half8_rte -#define vload_half8_rtz _cl_vload_half8_rtz -#define vstore_half8_rtz _cl_vstore_half8_rtz -#define vloada_half8_rtz _cl_vloada_half8_rtz -#define vstorea_half8_rtz _cl_vstorea_half8_rtz -#define vload_half8_rtp _cl_vload_half8_rtp -#define vstore_half8_rtp _cl_vstore_half8_rtp -#define vloada_half8_rtp _cl_vloada_half8_rtp -#define vstorea_half8_rtp _cl_vstorea_half8_rtp -#define vload_half8_rtn _cl_vload_half8_rtn -#define vstore_half8_rtn _cl_vstore_half8_rtn -#define vloada_half8_rtn _cl_vloada_half8_rtn -#define vstorea_half8_rtn _cl_vstorea_half8_rtn -#define convert_char8 _cl_convert_char8 -#define convert_uchar8 _cl_convert_uchar8 -#define convert_short8 _cl_convert_short8 -#define convert_ushort8 _cl_convert_ushort8 -#define convert_int8 _cl_convert_int8 -#define convert_uint8 _cl_convert_uint8 -#define convert_long8 _cl_convert_long8 -#define convert_ulong8 _cl_convert_ulong8 -#define convert_float8 _cl_convert_float8 -#define convert_double8 _cl_convert_double8 -#define convert_char8_rte _cl_convert_char8_rte -#define convert_uchar8_rte _cl_convert_uchar8_rte -#define convert_short8_rte _cl_convert_short8_rte -#define convert_ushort8_rte _cl_convert_ushort8_rte -#define convert_int8_rte _cl_convert_int8_rte -#define convert_uint8_rte _cl_convert_uint8_rte -#define convert_long8_rte _cl_convert_long8_rte -#define convert_ulong8_rte _cl_convert_ulong8_rte -#define convert_float8_rte _cl_convert_float8_rte -#define convert_double8_rte _cl_convert_double8_rte -#define convert_char8_rtz _cl_convert_char8_rtz -#define convert_uchar8_rtz _cl_convert_uchar8_rtz -#define convert_short8_rtz _cl_convert_short8_rtz -#define convert_ushort8_rtz _cl_convert_ushort8_rtz -#define convert_int8_rtz _cl_convert_int8_rtz -#define convert_uint8_rtz _cl_convert_uint8_rtz -#define convert_long8_rtz _cl_convert_long8_rtz -#define convert_ulong8_rtz _cl_convert_ulong8_rtz -#define convert_float8_rtz _cl_convert_float8_rtz -#define convert_double8_rtz _cl_convert_double8_rtz -#define convert_char8_rtp _cl_convert_char8_rtp -#define convert_uchar8_rtp _cl_convert_uchar8_rtp -#define convert_short8_rtp _cl_convert_short8_rtp -#define convert_ushort8_rtp _cl_convert_ushort8_rtp -#define convert_int8_rtp _cl_convert_int8_rtp -#define convert_uint8_rtp _cl_convert_uint8_rtp -#define convert_long8_rtp _cl_convert_long8_rtp -#define convert_ulong8_rtp _cl_convert_ulong8_rtp -#define convert_float8_rtp _cl_convert_float8_rtp -#define convert_double8_rtp _cl_convert_double8_rtp -#define convert_char8_rtn _cl_convert_char8_rtn -#define convert_uchar8_rtn _cl_convert_uchar8_rtn -#define convert_short8_rtn _cl_convert_short8_rtn -#define convert_ushort8_rtn _cl_convert_ushort8_rtn -#define convert_int8_rtn _cl_convert_int8_rtn -#define convert_uint8_rtn _cl_convert_uint8_rtn -#define convert_long8_rtn _cl_convert_long8_rtn -#define convert_ulong8_rtn _cl_convert_ulong8_rtn -#define convert_float8_rtn _cl_convert_float8_rtn -#define convert_double8_rtn _cl_convert_double8_rtn -#define convert_char8_sat _cl_convert_char8_sat -#define convert_uchar8_sat _cl_convert_uchar8_sat -#define convert_short8_sat _cl_convert_short8_sat -#define convert_ushort8_sat _cl_convert_ushort8_sat -#define convert_int8_sat _cl_convert_int8_sat -#define convert_uint8_sat _cl_convert_uint8_sat -#define convert_long8_sat _cl_convert_long8_sat -#define convert_ulong8_sat _cl_convert_ulong8_sat -#define convert_float8_sat _cl_convert_float8_sat -#define convert_double8_sat _cl_convert_double8_sat -#define convert_char8_sat_rte _cl_convert_char8_sat_rte -#define convert_uchar8_sat_rte _cl_convert_uchar8_sat_rte -#define convert_short8_sat_rte _cl_convert_short8_sat_rte -#define convert_ushort8_sat_rte _cl_convert_ushort8_sat_rte -#define convert_int8_sat_rte _cl_convert_int8_sat_rte -#define convert_uint8_sat_rte _cl_convert_uint8_sat_rte -#define convert_long8_sat_rte _cl_convert_long8_sat_rte -#define convert_ulong8_sat_rte _cl_convert_ulong8_sat_rte -#define convert_float8_sat_rte _cl_convert_float8_sat_rte -#define convert_double8_sat_rte _cl_convert_double8_sat_rte -#define convert_char8_sat_rtz _cl_convert_char8_sat_rtz -#define convert_uchar8_sat_rtz _cl_convert_uchar8_sat_rtz -#define convert_short8_sat_rtz _cl_convert_short8_sat_rtz -#define convert_ushort8_sat_rtz _cl_convert_ushort8_sat_rtz -#define convert_int8_sat_rtz _cl_convert_int8_sat_rtz -#define convert_uint8_sat_rtz _cl_convert_uint8_sat_rtz -#define convert_long8_sat_rtz _cl_convert_long8_sat_rtz -#define convert_ulong8_sat_rtz _cl_convert_ulong8_sat_rtz -#define convert_float8_sat_rtz _cl_convert_float8_sat_rtz -#define convert_double8_sat_rtz _cl_convert_double8_sat_rtz -#define convert_char8_sat_rtp _cl_convert_char8_sat_rtp -#define convert_uchar8_sat_rtp _cl_convert_uchar8_sat_rtp -#define convert_short8_sat_rtp _cl_convert_short8_sat_rtp -#define convert_ushort8_sat_rtp _cl_convert_ushort8_sat_rtp -#define convert_int8_sat_rtp _cl_convert_int8_sat_rtp -#define convert_uint8_sat_rtp _cl_convert_uint8_sat_rtp -#define convert_long8_sat_rtp _cl_convert_long8_sat_rtp -#define convert_ulong8_sat_rtp _cl_convert_ulong8_sat_rtp -#define convert_float8_sat_rtp _cl_convert_float8_sat_rtp -#define convert_double8_sat_rtp _cl_convert_double8_sat_rtp -#define convert_char8_sat_rtn _cl_convert_char8_sat_rtn -#define convert_uchar8_sat_rtn _cl_convert_uchar8_sat_rtn -#define convert_short8_sat_rtn _cl_convert_short8_sat_rtn -#define convert_ushort8_sat_rtn _cl_convert_ushort8_sat_rtn -#define convert_int8_sat_rtn _cl_convert_int8_sat_rtn -#define convert_uint8_sat_rtn _cl_convert_uint8_sat_rtn -#define convert_long8_sat_rtn _cl_convert_long8_sat_rtn -#define convert_ulong8_sat_rtn _cl_convert_ulong8_sat_rtn -#define convert_float8_sat_rtn _cl_convert_float8_sat_rtn -#define convert_double8_sat_rtn _cl_convert_double8_sat_rtn - -#define vload16 _cl_vload16 -#define vstore16 _cl_vstore16 -#define vload_half16 _cl_vload_half16 -#define vstore_half16 _cl_vstore_half16 -#define vloada_half16 _cl_vloada_half16 -#define vstorea_half16 _cl_vstorea_half16 -#define vload_half16_rte _cl_vload_half16_rte -#define vstore_half16_rte _cl_vstore_half16_rte -#define vloada_half16_rte _cl_vloada_half16_rte -#define vstorea_half16_rte _cl_vstorea_half16_rte -#define vload_half16_rtz _cl_vload_half16_rtz -#define vstore_half16_rtz _cl_vstore_half16_rtz -#define vloada_half16_rtz _cl_vloada_half16_rtz -#define vstorea_half16_rtz _cl_vstorea_half16_rtz -#define vload_half16_rtp _cl_vload_half16_rtp -#define vstore_half16_rtp _cl_vstore_half16_rtp -#define vloada_half16_rtp _cl_vloada_half16_rtp -#define vstorea_half16_rtp _cl_vstorea_half16_rtp -#define vload_half16_rtn _cl_vload_half16_rtn -#define vstore_half16_rtn _cl_vstore_half16_rtn -#define vloada_half16_rtn _cl_vloada_half16_rtn -#define vstorea_half16_rtn _cl_vstorea_half16_rtn -#define convert_char16 _cl_convert_char16 -#define convert_uchar16 _cl_convert_uchar16 -#define convert_short16 _cl_convert_short16 -#define convert_ushort16 _cl_convert_ushort16 -#define convert_int16 _cl_convert_int16 -#define convert_uint16 _cl_convert_uint16 -#define convert_long16 _cl_convert_long16 -#define convert_ulong16 _cl_convert_ulong16 -#define convert_float16 _cl_convert_float16 -#define convert_double16 _cl_convert_double16 -#define convert_char16_rte _cl_convert_char16_rte -#define convert_uchar16_rte _cl_convert_uchar16_rte -#define convert_short16_rte _cl_convert_short16_rte -#define convert_ushort16_rte _cl_convert_ushort16_rte -#define convert_int16_rte _cl_convert_int16_rte -#define convert_uint16_rte _cl_convert_uint16_rte -#define convert_long16_rte _cl_convert_long16_rte -#define convert_ulong16_rte _cl_convert_ulong16_rte -#define convert_float16_rte _cl_convert_float16_rte -#define convert_double16_rte _cl_convert_double16_rte -#define convert_char16_rtz _cl_convert_char16_rtz -#define convert_uchar16_rtz _cl_convert_uchar16_rtz -#define convert_short16_rtz _cl_convert_short16_rtz -#define convert_ushort16_rtz _cl_convert_ushort16_rtz -#define convert_int16_rtz _cl_convert_int16_rtz -#define convert_uint16_rtz _cl_convert_uint16_rtz -#define convert_long16_rtz _cl_convert_long16_rtz -#define convert_ulong16_rtz _cl_convert_ulong16_rtz -#define convert_float16_rtz _cl_convert_float16_rtz -#define convert_double16_rtz _cl_convert_double16_rtz -#define convert_char16_rtp _cl_convert_char16_rtp -#define convert_uchar16_rtp _cl_convert_uchar16_rtp -#define convert_short16_rtp _cl_convert_short16_rtp -#define convert_ushort16_rtp _cl_convert_ushort16_rtp -#define convert_int16_rtp _cl_convert_int16_rtp -#define convert_uint16_rtp _cl_convert_uint16_rtp -#define convert_long16_rtp _cl_convert_long16_rtp -#define convert_ulong16_rtp _cl_convert_ulong16_rtp -#define convert_float16_rtp _cl_convert_float16_rtp -#define convert_double16_rtp _cl_convert_double16_rtp -#define convert_char16_rtn _cl_convert_char16_rtn -#define convert_uchar16_rtn _cl_convert_uchar16_rtn -#define convert_short16_rtn _cl_convert_short16_rtn -#define convert_ushort16_rtn _cl_convert_ushort16_rtn -#define convert_int16_rtn _cl_convert_int16_rtn -#define convert_uint16_rtn _cl_convert_uint16_rtn -#define convert_long16_rtn _cl_convert_long16_rtn -#define convert_ulong16_rtn _cl_convert_ulong16_rtn -#define convert_float16_rtn _cl_convert_float16_rtn -#define convert_double16_rtn _cl_convert_double16_rtn -#define convert_char16_sat _cl_convert_char16_sat -#define convert_uchar16_sat _cl_convert_uchar16_sat -#define convert_short16_sat _cl_convert_short16_sat -#define convert_ushort16_sat _cl_convert_ushort16_sat -#define convert_int16_sat _cl_convert_int16_sat -#define convert_uint16_sat _cl_convert_uint16_sat -#define convert_long16_sat _cl_convert_long16_sat -#define convert_ulong16_sat _cl_convert_ulong16_sat -#define convert_float16_sat _cl_convert_float16_sat -#define convert_double16_sat _cl_convert_double16_sat -#define convert_char16_sat_rte _cl_convert_char16_sat_rte -#define convert_uchar16_sat_rte _cl_convert_uchar16_sat_rte -#define convert_short16_sat_rte _cl_convert_short16_sat_rte -#define convert_ushort16_sat_rte _cl_convert_ushort16_sat_rte -#define convert_int16_sat_rte _cl_convert_int16_sat_rte -#define convert_uint16_sat_rte _cl_convert_uint16_sat_rte -#define convert_long16_sat_rte _cl_convert_long16_sat_rte -#define convert_ulong16_sat_rte _cl_convert_ulong16_sat_rte -#define convert_float16_sat_rte _cl_convert_float16_sat_rte -#define convert_double16_sat_rte _cl_convert_double16_sat_rte -#define convert_char16_sat_rtz _cl_convert_char16_sat_rtz -#define convert_uchar16_sat_rtz _cl_convert_uchar16_sat_rtz -#define convert_short16_sat_rtz _cl_convert_short16_sat_rtz -#define convert_ushort16_sat_rtz _cl_convert_ushort16_sat_rtz -#define convert_int16_sat_rtz _cl_convert_int16_sat_rtz -#define convert_uint16_sat_rtz _cl_convert_uint16_sat_rtz -#define convert_long16_sat_rtz _cl_convert_long16_sat_rtz -#define convert_ulong16_sat_rtz _cl_convert_ulong16_sat_rtz -#define convert_float16_sat_rtz _cl_convert_float16_sat_rtz -#define convert_double16_sat_rtz _cl_convert_double16_sat_rtz -#define convert_char16_sat_rtp _cl_convert_char16_sat_rtp -#define convert_uchar16_sat_rtp _cl_convert_uchar16_sat_rtp -#define convert_short16_sat_rtp _cl_convert_short16_sat_rtp -#define convert_ushort16_sat_rtp _cl_convert_ushort16_sat_rtp -#define convert_int16_sat_rtp _cl_convert_int16_sat_rtp -#define convert_uint16_sat_rtp _cl_convert_uint16_sat_rtp -#define convert_long16_sat_rtp _cl_convert_long16_sat_rtp -#define convert_ulong16_sat_rtp _cl_convert_ulong16_sat_rtp -#define convert_float16_sat_rtp _cl_convert_float16_sat_rtp -#define convert_double16_sat_rtp _cl_convert_double16_sat_rtp -#define convert_char16_sat_rtn _cl_convert_char16_sat_rtn -#define convert_uchar16_sat_rtn _cl_convert_uchar16_sat_rtn -#define convert_short16_sat_rtn _cl_convert_short16_sat_rtn -#define convert_ushort16_sat_rtn _cl_convert_ushort16_sat_rtn -#define convert_int16_sat_rtn _cl_convert_int16_sat_rtn -#define convert_uint16_sat_rtn _cl_convert_uint16_sat_rtn -#define convert_long16_sat_rtn _cl_convert_long16_sat_rtn -#define convert_ulong16_sat_rtn _cl_convert_ulong16_sat_rtn -#define convert_float16_sat_rtn _cl_convert_float16_sat_rtn -#define convert_double16_sat_rtn _cl_convert_double16_sat_rtn - -#define convert_half _cl_convert_half -#define convert_half_rte _cl_convert_half_rte -#define convert_half_rtz _cl_convert_half_rtz -#define convert_half_rtp _cl_convert_half_rtp -#define convert_half_rtn _cl_convert_half_rtn -#define convert_half_sat _cl_convert_half._sat -#define convert_half_sat_rte _cl_convert_half_sat_rte -#define convert_half_sat_rtz _cl_convert_half_sat_rtz -#define convert_half_sat_rtp _cl_convert_half_sat_rtp -#define convert_half_sat_rtn _cl_convert_half_sat_rtn - -#define convert_half2 _cl_convert_half2 -#define convert_half2_rte _cl_convert_half2_rte -#define convert_half2_rtz _cl_convert_half2_rtz -#define convert_half2_rtp _cl_convert_half2_rtp -#define convert_half2_rtn _cl_convert_half2_rtn -#define convert_half2_sat _cl_convert_half2._sat -#define convert_half2_sat_rte _cl_convert_half2_sat_rte -#define convert_half2_sat_rtz _cl_convert_half2_sat_rtz -#define convert_half2_sat_rtp _cl_convert_half2_sat_rtp -#define convert_half2_sat_rtn _cl_convert_half2_sat_rtn - -#define convert_half3 _cl_convert_half3 -#define convert_half3_rte _cl_convert_half3_rte -#define convert_half3_rtz _cl_convert_half3_rtz -#define convert_half3_rtp _cl_convert_half3_rtp -#define convert_half3_rtn _cl_convert_half3_rtn -#define convert_half3_sat _cl_convert_half3._sat -#define convert_half3_sat_rte _cl_convert_half3_sat_rte -#define convert_half3_sat_rtz _cl_convert_half3_sat_rtz -#define convert_half3_sat_rtp _cl_convert_half3_sat_rtp -#define convert_half3_sat_rtn _cl_convert_half3_sat_rtn - -#define convert_half4 _cl_convert_half4 -#define convert_half4_rte _cl_convert_half4_rte -#define convert_half4_rtz _cl_convert_half4_rtz -#define convert_half4_rtp _cl_convert_half4_rtp -#define convert_half4_rtn _cl_convert_half4_rtn -#define convert_half4_sat _cl_convert_half4._sat -#define convert_half4_sat_rte _cl_convert_half4_sat_rte -#define convert_half4_sat_rtz _cl_convert_half4_sat_rtz -#define convert_half4_sat_rtp _cl_convert_half4_sat_rtp -#define convert_half4_sat_rtn _cl_convert_half4_sat_rtn - -#define convert_half8 _cl_convert_half8 -#define convert_half8_rte _cl_convert_half8_rte -#define convert_half8_rtz _cl_convert_half8_rtz -#define convert_half8_rtp _cl_convert_half8_rtp -#define convert_half8_rtn _cl_convert_half8_rtn -#define convert_half8_sat _cl_convert_half8._sat -#define convert_half8_sat_rte _cl_convert_half8_sat_rte -#define convert_half8_sat_rtz _cl_convert_half8_sat_rtz -#define convert_half8_sat_rtp _cl_convert_half8_sat_rtp -#define convert_half8_sat_rtn _cl_convert_half8_sat_rtn - -#define convert_half16 _cl_convert_half16 -#define convert_half16_rte _cl_convert_half16_rte -#define convert_half16_rtz _cl_convert_half16_rtz -#define convert_half16_rtp _cl_convert_half16_rtp -#define convert_half16_rtn _cl_convert_half16_rtn -#define convert_half16_sat _cl_convert_half16._sat -#define convert_half16_sat_rte _cl_convert_half16_sat_rte -#define convert_half16_sat_rtz _cl_convert_half16_sat_rtz -#define convert_half16_sat_rtp _cl_convert_half16_sat_rtp -#define convert_half16_sat_rtn _cl_convert_half16_sat_rtn - - -#define atomic_add _cl_atomic_add -#define atomic_sub _cl_atomic_sub -#define atomic_xchg _cl_atomic_xchg -#define atomic_inc _cl_atomic_inc -#define atomic_dec _cl_atomic_dec -#define atomic_cmpxchg _cl_atomic_cmpxchg -#define atomic_min _cl_atomic_min -#define atomic_max _cl_atomic_max -#define atomic_and _cl_atomic_and -#define atomic_or _cl_atomic_or -#define atomic_xor _cl_atomic_xor - -#define atom_add _cl_atom_add -#define atom_sub _cl_atom_sub -#define atom_xchg _cl_atom_xchg -#define atom_inc _cl_atom_inc -#define atom_dec _cl_atom_dec -#define atom_cmpxchg _cl_atom_cmpxchg -#define atom_min _cl_atom_min -#define atom_max _cl_atom_max -#define atom_and _cl_atom_and -#define atom_or _cl_atom_or -#define atom_xor _cl_atom_xor - -#define atomic_init _cl_atomic_init -#define atomic_flag_test_and_set_explicit _cl_atomic_flag_test_and_set_explicit -#define atomic_flag_test_and_set _cl_atomic_flag_test_and_set -#define atomic_flag_clear_explicit _cl_atomic_flag_clear_explicit -#define atomic_flag_clear _cl_atomic_flag_clear -#define atomic_store_explicit _cl_atomic_store_explicit -#define atomic_store _cl_atomic_store -#define atomic_load_explicit _cl_atomic_load_explicit -#define atomic_load _cl_atomic_load -#define atomic_exchange_explicit _cl_atomic_exchange_explicit -#define atomic_exchange _cl_atomic_exchange -#define atomic_compare_exchange_strong_explicit _cl_atomic_compare_exchange_strong_explicit -#define atomic_compare_exchange_strong _cl_atomic_compare_exchange_strong -#define atomic_compare_exchange_weak_explicit _cl_atomic_compare_exchange_weak_explicit -#define atomic_compare_exchange_weak _cl_atomic_compare_exchange_weak -#define atomic_fetch_add_explicit _cl_atomic_fetch_add_explicit -#define atomic_fetch_add _cl_atomic_fetch_add -#define atomic_fetch_sub_explicit _cl_atomic_fetch_sub_explicit -#define atomic_fetch_sub _cl_atomic_fetch_sub -#define atomic_fetch_or_explicit _cl_atomic_fetch_or_explicit -#define atomic_fetch_or _cl_atomic_fetch_or -#define atomic_fetch_xor_explicit _cl_atomic_fetch_xor_explicit -#define atomic_fetch_xor _cl_atomic_fetch_xor -#define atomic_fetch_and_explicit _cl_atomic_fetch_and_explicit -#define atomic_fetch_and _cl_atomic_fetch_and -#define atomic_fetch_min_explicit _cl_atomic_fetch_min_explicit -#define atomic_fetch_min _cl_atomic_fetch_min -#define atomic_fetch_max_explicit _cl_atomic_fetch_max_explicit -#define atomic_fetch_max _cl_atomic_fetch_max - -#define read_mem_fence _cl_read_mem_fence -#define write_mem_fence _cl_write_mem_fence -#define mem_fence _cl_mem_fence -#define work_group_barrier _cl_work_group_barrier -#define atomic_work_item_fence _cl_atomic_work_item_fence -#define wait_group_events _cl_wait_group_events - -#define get_image_array_size _cl_get_image_array_size -#define get_image_channel_data_type _cl_get_image_channel_data_type -#define get_image_channel_order _cl_get_image_channel_order -#define get_image_dim _cl_get_image_dim -#define get_image_depth _cl_get_image_depth -#define get_image_height _cl_get_image_height -#define get_image_width _cl_get_image_width -#define read_imageui _cl_read_imageui -#define read_imagei _cl_read_imagei -#define read_imagef _cl_read_imagef -#define read_imageh _cl_read_imageh -#define write_imageui _cl_write_imageui -#define write_imagei _cl_write_imagei -#define write_imagef _cl_write_imagef -#define write_imageh _cl_write_imageh - -#define get_sub_group_size _cl_get_sub_group_size -#define get_max_sub_group_size _cl_get_max_sub_group_size -#define get_num_sub_groups _cl_get_num_sub_groups -#define get_enqueued_num_sub_groups _cl_get_enqueued_num_sub_groups -#define get_sub_group_id _cl_get_sub_group_id -#define get_sub_group_local_id _cl_get_sub_group_local_id -#define sub_group_ballot _cl_sub_group_ballot -#define sub_group_broadcast _cl_sub_group_broadcast -#define sub_group_barrier _cl_sub_group_barrier -#define sub_group_any _cl_sub_group_any -#define sub_group_all _cl_sub_group_all -#define sub_group_reduce_add _cl_sub_group_reduce_add -#define sub_group_reduce_min _cl_sub_group_reduce_min -#define sub_group_reduce_max _cl_sub_group_reduce_max -#define sub_group_shuffle _cl_sub_group_shuffle -#define sub_group_shuffle_xor _cl_sub_group_shuffle_xor -#define sub_group_shuffle_up _cl_sub_group_shuffle_up -#define sub_group_shuffle_down _cl_sub_group_shuffle_down -#define intel_sub_group_shuffle _cl_intel_sub_group_shuffle -#define intel_sub_group_shuffle_xor _cl_intel_sub_group_shuffle_xor -#define intel_sub_group_shuffle_up _cl_intel_sub_group_shuffle_up -#define intel_sub_group_shuffle_down _cl_intel_sub_group_shuffle_down -#define sub_group_scan_inclusive_add _cl_sub_group_scan_inclusive_add -#define sub_group_scan_inclusive_min _cl_sub_group_scan_inclusive_min -#define sub_group_scan_inclusive_max _cl_sub_group_scan_inclusive_max -#define sub_group_scan_exclusive_add _cl_sub_group_scan_exclusive_add -#define sub_group_scan_exclusive_min _cl_sub_group_scan_exclusive_min -#define sub_group_scan_exclusive_max _cl_sub_group_scan_exclusive_max - -#define intel_sub_group_block_read _cl_intel_sub_group_block_read -#define intel_sub_group_block_read2 _cl_intel_sub_group_block_read2 -#define intel_sub_group_block_read4 _cl_intel_sub_group_block_read4 -#define intel_sub_group_block_read8 _cl_intel_sub_group_block_read8 -#define intel_sub_group_block_read_uc _cl_intel_sub_group_block_read_uc -#define intel_sub_group_block_read_uc2 _cl_intel_sub_group_block_read_uc2 -#define intel_sub_group_block_read_uc4 _cl_intel_sub_group_block_read_uc4 -#define intel_sub_group_block_read_uc8 _cl_intel_sub_group_block_read_uc8 -#define intel_sub_group_block_read_uc16 _cl_intel_sub_group_block_read_uc16 -#define intel_sub_group_block_read_us _cl_intel_sub_group_block_read_us -#define intel_sub_group_block_read_us2 _cl_intel_sub_group_block_read_us2 -#define intel_sub_group_block_read_us4 _cl_intel_sub_group_block_read_us4 -#define intel_sub_group_block_read_us8 _cl_intel_sub_group_block_read_us8 -#define intel_sub_group_block_read_ui _cl_intel_sub_group_block_read_ui -#define intel_sub_group_block_read_ui2 _cl_intel_sub_group_block_read_ui2 -#define intel_sub_group_block_read_ui4 _cl_intel_sub_group_block_read_ui4 -#define intel_sub_group_block_read_ui8 _cl_intel_sub_group_block_read_ui8 - -#define intel_sub_group_block_write _cl_intel_sub_group_block_write -#define intel_sub_group_block_write2 _cl_intel_sub_group_block_write2 -#define intel_sub_group_block_write4 _cl_intel_sub_group_block_write4 -#define intel_sub_group_block_write8 _cl_intel_sub_group_block_write8 -#define intel_sub_group_block_write_uc _cl_intel_sub_group_block_write_uc -#define intel_sub_group_block_write_uc2 _cl_intel_sub_group_block_write_uc2 -#define intel_sub_group_block_write_uc4 _cl_intel_sub_group_block_write_uc4 -#define intel_sub_group_block_write_uc8 _cl_intel_sub_group_block_write_uc8 -#define intel_sub_group_block_write_uc16 _cl_intel_sub_group_block_write_uc16 -#define intel_sub_group_block_write_us _cl_intel_sub_group_block_write_us -#define intel_sub_group_block_write_us2 _cl_intel_sub_group_block_write_us2 -#define intel_sub_group_block_write_us4 _cl_intel_sub_group_block_write_us4 -#define intel_sub_group_block_write_us8 _cl_intel_sub_group_block_write_us8 -#define intel_sub_group_block_write_ui _cl_intel_sub_group_block_write_ui -#define intel_sub_group_block_write_ui2 _cl_intel_sub_group_block_write_ui2 -#define intel_sub_group_block_write_ui4 _cl_intel_sub_group_block_write_ui4 -#define intel_sub_group_block_write_ui8 _cl_intel_sub_group_block_write_ui8 - -#define bitfield_insert _cl_bitfield_insert -#define bitfield_extract_signed _cl_bitfield_extract_signed -#define bitfield_extract_unsigned _cl_bitfield_extract_unsigned - -#define dot _cl_dot -#define dot_acc_sat _cl_dot_acc_sat -#define dot_4x8packed_uu_uint _cl_dot_4x8packed_uu_uint -#define dot_4x8packed_ss_int _cl_dot_4x8packed_ss_int -#define dot_4x8packed_us_int _cl_dot_4x8packed_us_int -#define dot_4x8packed_su_int _cl_dot_4x8packed_su_int -#define dot_acc_sat_4x8packed_uu_uint _cl_dot_acc_sat_4x8packed_uu_uint -#define dot_acc_sat_4x8packed_su_int _cl_dot_acc_sat_4x8packed_su_int -#define dot_acc_sat_4x8packed_us_int _cl_dot_acc_sat_4x8packed_us_int -#define dot_acc_sat_4x8packed_ss_int _cl_dot_acc_sat_4x8packed_ss_int - -#define clock_read_device _cl_clock_read_device -#define clock_read_work_group _cl_clock_read_work_group -#define clock_read_sub_group _cl_clock_read_sub_group -#define clock_read_hilo_device _cl_clock_read_hilo_device -#define clock_read_hilo_work_group _cl_clock_read_hilo_work_group -#define clock_read_hilo_sub_group _cl_clock_read_hilo_sub_group - -#endif diff --git a/drivers/pocl-gen7/share/pocl/include/_clang_opencl.h b/drivers/pocl-gen7/share/pocl/include/_clang_opencl.h deleted file mode 100644 index 3c0c885..0000000 --- a/drivers/pocl-gen7/share/pocl/include/_clang_opencl.h +++ /dev/null @@ -1,770 +0,0 @@ -/* This file adds declarations missing from opencl-c.h. - - Copyright (c) 2011-2017 Pekka Jääskeläinen / TUT - 2024 Pekka Jääskeläinen / Intel Finland Oy - Copyright (c) 2017 Michal Babej / Tampere University of Technology - - Permission is hereby granted, free of charge, to any person obtaining a copy - of this software and associated documentation files (the "Software"), to - deal in the Software without restriction, including without limitation the - rights to use, copy, modify, merge, publish, distribute, sublicense, and/or - sell copies of the Software, and to permit persons to whom the Software is - furnished to do so, subject to the following conditions: - - The above copyright notice and this permission notice shall be included in - all copies or substantial portions of the Software. - - THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR - IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, - FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE - AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER - LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING - FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS - IN THE SOFTWARE. -*/ - -#ifndef _CLANG_OPENCL_H -#define _CLANG_OPENCL_H - -#ifndef SKIP_HEADER_INCLUDE -/* Use the declarations shipped with Clang. */ -#ifndef _OPENCL_H_ -/* Check for _OPENCL_H already here because the kernel compiler loads the - header beforehand, but cannot find the file due to include paths not - set up. */ -#include "opencl-c.h" -#endif -#endif - -/* We can include this header directly (to patch up opencl-c.h without - including _kernel.h, thus need to define the attribute macros here. */ -#ifndef _CL_OVERLOADABLE - -#if __has_attribute(__overloadable__) -# define _CL_OVERLOADABLE __attribute__((__overloadable__)) -#else -# define _CL_OVERLOADABLE -#endif - -#endif - -#ifndef _CL_READNONE - -#if __has_attribute(__const__) -# define _CL_READNONE __attribute__((__const__)) -#else -# define _CL_READNONE -#endif - -#endif - -#ifndef _CL_CONV - -#if __has_attribute(__convergent__) -# define _CL_CONV __attribute__((__convergent__)) -#else -# define _CL_CONV -#endif - -#endif - -/* Some of the geometric builtins are defined only up to 4 vectors, but we - implement them all: */ -#ifdef cl_khr_fp16 -#pragma OPENCL EXTENSION cl_khr_fp16 : enable -half _CL_OVERLOADABLE _CL_READNONE length (half8 p); -half _CL_OVERLOADABLE _CL_READNONE length (half16 p); - -half _CL_OVERLOADABLE _CL_READNONE fast_length (half8 p); -half _CL_OVERLOADABLE _CL_READNONE fast_length (half16 p); - -half8 _CL_OVERLOADABLE _CL_READNONE normalize (half8 p); -half16 _CL_OVERLOADABLE _CL_READNONE normalize (half16 p); - -half8 _CL_OVERLOADABLE _CL_READNONE fast_normalize (half8 p); -half16 _CL_OVERLOADABLE _CL_READNONE fast_normalize (half16 p); - -half _CL_OVERLOADABLE _CL_READNONE dot (half8 p0, half8 p1); -half _CL_OVERLOADABLE _CL_READNONE dot (half16 p0, half16 p1); -#endif - -float _CL_OVERLOADABLE _CL_READNONE length (float8 p); -float _CL_OVERLOADABLE _CL_READNONE length (float16 p); - -float _CL_OVERLOADABLE _CL_READNONE fast_length (float8 p); -float _CL_OVERLOADABLE _CL_READNONE fast_length (float16 p); - -float8 _CL_OVERLOADABLE _CL_READNONE normalize (float8 p); -float16 _CL_OVERLOADABLE _CL_READNONE normalize (float16 p); - -float8 _CL_OVERLOADABLE _CL_READNONE fast_normalize (float8 p); -float16 _CL_OVERLOADABLE _CL_READNONE fast_normalize (float16 p); - -float _CL_OVERLOADABLE _CL_READNONE dot (float8 p0, float8 p1); -float _CL_OVERLOADABLE _CL_READNONE dot (float16 p0, float16 p1); - -#ifdef cl_khr_fp64 -#pragma OPENCL EXTENSION cl_khr_fp64 : enable - -double _CL_OVERLOADABLE _CL_READNONE length (double8 p); -double _CL_OVERLOADABLE _CL_READNONE length (double16 p); - -double _CL_OVERLOADABLE _CL_READNONE fast_length (double p); -double _CL_OVERLOADABLE _CL_READNONE fast_length (double2 p); -double _CL_OVERLOADABLE _CL_READNONE fast_length (double3 p); -double _CL_OVERLOADABLE _CL_READNONE fast_length (double4 p); -double _CL_OVERLOADABLE _CL_READNONE fast_length (double8 p); -double _CL_OVERLOADABLE _CL_READNONE fast_length (double16 p); - -double8 _CL_OVERLOADABLE _CL_READNONE normalize (double8 p); -double16 _CL_OVERLOADABLE _CL_READNONE normalize (double16 p); - -double8 _CL_OVERLOADABLE _CL_READNONE fast_normalize (double8 p); -double16 _CL_OVERLOADABLE _CL_READNONE fast_normalize (double16 p); - -double _CL_OVERLOADABLE _CL_READNONE dot (double8 p0, double8 p1); -double _CL_OVERLOADABLE _CL_READNONE dot (double16 p0, double16 p1); - -#endif - -#if defined(cl_khr_kernel_clock) - -#if defined(__opencl_c_kernel_clock_scope_device) -ulong _CL_OVERLOADABLE _CL_CONV clock_read_device(void); -uint2 _CL_OVERLOADABLE _CL_CONV clock_read_hilo_device(void); -#endif // __opencl_c_kernel_clock_scope_device - -#if defined(__opencl_c_kernel_clock_scope_work_group) -ulong _CL_OVERLOADABLE _CL_CONV clock_read_work_group(void); -uint2 _CL_OVERLOADABLE _CL_CONV clock_read_hilo_work_group(void); -#endif // __opencl_c_kernel_clock_scope_work_group - -#if defined(__opencl_c_kernel_clock_scope_sub_group) -ulong _CL_OVERLOADABLE _CL_CONV clock_read_sub_group(void); -uint2 _CL_OVERLOADABLE _CL_CONV clock_read_hilo_sub_group(void); -#endif // __opencl_c_kernel_clock_scope_sub_group - -#endif // cl_khr_kernel_clock - -/**************************************************************************/ - -#if defined(cl_intel_subgroups_char) -/* The char version is missing from opencl-c.h */ -char _CL_OVERLOADABLE _CL_CONV -intel_sub_group_broadcast (char, uint sub_group_local_id); -char2 _CL_OVERLOADABLE _CL_CONV -intel_sub_group_broadcast (char2, uint sub_group_local_id); -char3 _CL_OVERLOADABLE _CL_CONV -intel_sub_group_broadcast (char3, uint sub_group_local_id); -char4 _CL_OVERLOADABLE _CL_CONV -intel_sub_group_broadcast (char4, uint sub_group_local_id); -char8 _CL_OVERLOADABLE _CL_CONV -intel_sub_group_broadcast (char8, uint sub_group_local_id); - -uchar _CL_OVERLOADABLE _CL_CONV -intel_sub_group_broadcast (uchar, uint sub_group_local_id); -uchar2 _CL_OVERLOADABLE _CL_CONV -intel_sub_group_broadcast (uchar2, uint sub_group_local_id); -uchar3 _CL_OVERLOADABLE _CL_CONV -intel_sub_group_broadcast (uchar3, uint sub_group_local_id); -uchar4 _CL_OVERLOADABLE _CL_CONV -intel_sub_group_broadcast (uchar4, uint sub_group_local_id); -uchar8 _CL_OVERLOADABLE _CL_CONV -intel_sub_group_broadcast (uchar8, uint sub_group_local_id); - -char _CL_OVERLOADABLE _CL_CONV intel_sub_group_shuffle (char, uint); -char2 _CL_OVERLOADABLE _CL_CONV intel_sub_group_shuffle (char2, uint); -char3 _CL_OVERLOADABLE _CL_CONV intel_sub_group_shuffle (char3, uint); -char4 _CL_OVERLOADABLE _CL_CONV intel_sub_group_shuffle (char4, uint); -char8 _CL_OVERLOADABLE _CL_CONV intel_sub_group_shuffle (char8, uint); -char16 _CL_OVERLOADABLE _CL_CONV intel_sub_group_shuffle (char16, uint); - -uchar _CL_OVERLOADABLE _CL_CONV intel_sub_group_shuffle (uchar, uint); -uchar2 _CL_OVERLOADABLE _CL_CONV intel_sub_group_shuffle (uchar2, uint); -uchar3 _CL_OVERLOADABLE _CL_CONV intel_sub_group_shuffle (uchar3, uint); -uchar4 _CL_OVERLOADABLE _CL_CONV intel_sub_group_shuffle (uchar4, uint); -uchar8 _CL_OVERLOADABLE _CL_CONV intel_sub_group_shuffle (uchar8, uint); -uchar16 _CL_OVERLOADABLE _CL_CONV intel_sub_group_shuffle (uchar16, uint); - -char _CL_OVERLOADABLE _CL_CONV intel_sub_group_shuffle_down (char cur, - char next, - uint); -char2 _CL_OVERLOADABLE _CL_CONV intel_sub_group_shuffle_down (char2 cur, - char2 next, - uint); -char3 _CL_OVERLOADABLE _CL_CONV intel_sub_group_shuffle_down (char3 cur, - char3 next, - uint); -char4 _CL_OVERLOADABLE _CL_CONV intel_sub_group_shuffle_down (char4 cur, - char4 next, - uint); -char8 _CL_OVERLOADABLE _CL_CONV intel_sub_group_shuffle_down (char8 cur, - char8 next, - uint); -char16 _CL_OVERLOADABLE _CL_CONV intel_sub_group_shuffle_down (char16 cur, - char16 next, - uint); - -uchar _CL_OVERLOADABLE _CL_CONV intel_sub_group_shuffle_down (uchar cur, - uchar next, - uint); -uchar2 _CL_OVERLOADABLE _CL_CONV intel_sub_group_shuffle_down (uchar2 cur, - uchar2 next, - uint); -uchar3 _CL_OVERLOADABLE _CL_CONV intel_sub_group_shuffle_down (uchar3 cur, - uchar3 next, - uint); -uchar4 _CL_OVERLOADABLE _CL_CONV intel_sub_group_shuffle_down (uchar4 cur, - uchar4 next, - uint); -uchar8 _CL_OVERLOADABLE _CL_CONV intel_sub_group_shuffle_down (uchar8 cur, - uchar8 next, - uint); -uchar16 _CL_OVERLOADABLE _CL_CONV -intel_sub_group_shuffle_down (uchar16 cur, uchar16 next, uint); - -char _CL_OVERLOADABLE _CL_CONV intel_sub_group_shuffle_up (char cur, - char next, - uint); -char2 _CL_OVERLOADABLE _CL_CONV intel_sub_group_shuffle_up (char2 cur, - char2 next, - uint); -char3 _CL_OVERLOADABLE _CL_CONV intel_sub_group_shuffle_up (char3 cur, - char3 next, - uint); -char4 _CL_OVERLOADABLE _CL_CONV intel_sub_group_shuffle_up (char4 cur, - char4 next, - uint); -char8 _CL_OVERLOADABLE _CL_CONV intel_sub_group_shuffle_up (char8 cur, - char8 next, - uint); -char16 _CL_OVERLOADABLE _CL_CONV intel_sub_group_shuffle_up (char16 cur, - char16 next, - uint); - -uchar _CL_OVERLOADABLE _CL_CONV intel_sub_group_shuffle_up (uchar cur, - uchar next, - uint); -uchar2 _CL_OVERLOADABLE _CL_CONV intel_sub_group_shuffle_up (uchar2 cur, - uchar2 next, - uint); -uchar3 _CL_OVERLOADABLE _CL_CONV intel_sub_group_shuffle_up (uchar3 cur, - uchar3 next, - uint); -uchar4 _CL_OVERLOADABLE _CL_CONV intel_sub_group_shuffle_up (uchar4 cur, - uchar4 next, - uint); -uchar8 _CL_OVERLOADABLE _CL_CONV intel_sub_group_shuffle_up (uchar8 cur, - uchar8 next, - uint); -uchar16 _CL_OVERLOADABLE _CL_CONV intel_sub_group_shuffle_up (uchar16 cur, - uchar16 next, - uint); - -char _CL_OVERLOADABLE _CL_CONV intel_sub_group_shuffle_xor (char, uint); -char2 _CL_OVERLOADABLE _CL_CONV intel_sub_group_shuffle_xor (char2, uint); -char3 _CL_OVERLOADABLE _CL_CONV intel_sub_group_shuffle_xor (char3, uint); -char4 _CL_OVERLOADABLE _CL_CONV intel_sub_group_shuffle_xor (char4, uint); -char8 _CL_OVERLOADABLE _CL_CONV intel_sub_group_shuffle_xor (char8, uint); -char16 _CL_OVERLOADABLE _CL_CONV intel_sub_group_shuffle_xor (char16, - uint); - -uchar _CL_OVERLOADABLE _CL_CONV intel_sub_group_shuffle_xor (uchar, uint); -uchar2 _CL_OVERLOADABLE _CL_CONV intel_sub_group_shuffle_xor (uchar2, - uint); -uchar3 _CL_OVERLOADABLE _CL_CONV intel_sub_group_shuffle_xor (uchar3, - uint); -uchar4 _CL_OVERLOADABLE _CL_CONV intel_sub_group_shuffle_xor (uchar4, - uint); -uchar8 _CL_OVERLOADABLE _CL_CONV intel_sub_group_shuffle_xor (uchar8, - uint); -uchar16 _CL_OVERLOADABLE _CL_CONV intel_sub_group_shuffle_xor (uchar16, - uint); - -char _CL_OVERLOADABLE _CL_CONV intel_sub_group_reduce_add (char x); -uchar _CL_OVERLOADABLE _CL_CONV intel_sub_group_reduce_add (uchar x); -char _CL_OVERLOADABLE _CL_CONV intel_sub_group_reduce_min (char x); -uchar _CL_OVERLOADABLE _CL_CONV intel_sub_group_reduce_min (uchar x); -char _CL_OVERLOADABLE _CL_CONV intel_sub_group_reduce_max (char x); -uchar _CL_OVERLOADABLE _CL_CONV intel_sub_group_reduce_max (uchar x); - -char _CL_OVERLOADABLE _CL_CONV intel_sub_group_scan_exclusive_add (char x); -uchar _CL_OVERLOADABLE _CL_CONV -intel_sub_group_scan_exclusive_add (uchar x); -char _CL_OVERLOADABLE _CL_CONV intel_sub_group_scan_exclusive_min (char x); -uchar _CL_OVERLOADABLE _CL_CONV -intel_sub_group_scan_exclusive_min (uchar x); -char _CL_OVERLOADABLE _CL_CONV intel_sub_group_scan_exclusive_max (char x); -uchar _CL_OVERLOADABLE _CL_CONV -intel_sub_group_scan_exclusive_max (uchar x); - -char _CL_OVERLOADABLE _CL_CONV intel_sub_group_scan_inclusive_add (char x); -uchar _CL_OVERLOADABLE _CL_CONV -intel_sub_group_scan_inclusive_add (uchar x); -char _CL_OVERLOADABLE _CL_CONV intel_sub_group_scan_inclusive_min (char x); -uchar _CL_OVERLOADABLE _CL_CONV -intel_sub_group_scan_inclusive_min (uchar x); -char _CL_OVERLOADABLE _CL_CONV intel_sub_group_scan_inclusive_max (char x); -uchar _CL_OVERLOADABLE _CL_CONV -intel_sub_group_scan_inclusive_max (uchar x); - -#if defined(__opencl_c_images) -uchar _CL_OVERLOADABLE _CL_CONV -intel_sub_group_block_read_uc (read_only image2d_t, int2); -uchar2 _CL_OVERLOADABLE _CL_CONV -intel_sub_group_block_read_uc2 (read_only image2d_t, int2); -uchar4 _CL_OVERLOADABLE _CL_CONV -intel_sub_group_block_read_uc4 (read_only image2d_t, int2); -uchar8 _CL_OVERLOADABLE _CL_CONV -intel_sub_group_block_read_uc8 (read_only image2d_t, int2); -uchar16 _CL_OVERLOADABLE _CL_CONV -intel_sub_group_block_read_uc16 (read_only image2d_t, int2); - -#if defined(__opencl_c_read_write_images) -uchar _CL_OVERLOADABLE _CL_CONV -intel_sub_group_block_read_uc (read_write image2d_t, int2); -uchar2 _CL_OVERLOADABLE _CL_CONV -intel_sub_group_block_read_uc2 (read_write image2d_t, int2); -uchar4 _CL_OVERLOADABLE _CL_CONV -intel_sub_group_block_read_uc4 (read_write image2d_t, int2); -uchar8 _CL_OVERLOADABLE _CL_CONV -intel_sub_group_block_read_uc8 (read_write image2d_t, int2); -uchar16 _CL_OVERLOADABLE _CL_CONV -intel_sub_group_block_read_uc16 (read_write image2d_t, int2); -#endif // defined(__opencl_c_read_write_images) -#endif // defined(__opencl_c_images) - -uchar _CL_OVERLOADABLE _CL_CONV -intel_sub_group_block_read_uc (const global uchar *p); -uchar2 _CL_OVERLOADABLE _CL_CONV -intel_sub_group_block_read_uc2 (const global uchar *p); -uchar4 _CL_OVERLOADABLE _CL_CONV -intel_sub_group_block_read_uc4 (const global uchar *p); -uchar8 _CL_OVERLOADABLE _CL_CONV -intel_sub_group_block_read_uc8 (const global uchar *p); -uchar16 _CL_OVERLOADABLE _CL_CONV -intel_sub_group_block_read_uc16 (const global uchar *p); - -uchar _CL_OVERLOADABLE _CL_CONV -intel_sub_group_block_read_uc (const local uchar *p); -uchar2 _CL_OVERLOADABLE _CL_CONV -intel_sub_group_block_read_uc2 (const local uchar *p); -uchar4 _CL_OVERLOADABLE _CL_CONV -intel_sub_group_block_read_uc4 (const local uchar *p); -uchar8 _CL_OVERLOADABLE _CL_CONV -intel_sub_group_block_read_uc8 (const local uchar *p); -uchar16 _CL_OVERLOADABLE _CL_CONV -intel_sub_group_block_read_uc16 (const local uchar *p); - -void _CL_OVERLOADABLE _CL_CONV intel_sub_group_block_write_uc (global uchar *p, - uchar data); -void _CL_OVERLOADABLE _CL_CONV intel_sub_group_block_write_uc2 (global uchar *p, - uchar2 data); -void _CL_OVERLOADABLE _CL_CONV intel_sub_group_block_write_uc4 (global uchar *p, - uchar4 data); -void _CL_OVERLOADABLE _CL_CONV intel_sub_group_block_write_uc8 (global uchar *p, - uchar8 data); -void _CL_OVERLOADABLE _CL_CONV intel_sub_group_block_write_uc16 (global uchar *p, - uchar16 data); - -void _CL_OVERLOADABLE _CL_CONV intel_sub_group_block_write_uc (local uchar *p, - uchar data); -void _CL_OVERLOADABLE _CL_CONV intel_sub_group_block_write_uc2 (local uchar *p, - uchar2 data); -void _CL_OVERLOADABLE _CL_CONV intel_sub_group_block_write_uc4 (local uchar *p, - uchar4 data); -void _CL_OVERLOADABLE _CL_CONV intel_sub_group_block_write_uc8 (local uchar *p, - uchar8 data); -void _CL_OVERLOADABLE _CL_CONV intel_sub_group_block_write_uc16 (local uchar *p, - uchar16 data); - -#if defined(__opencl_c_images) -void _CL_OVERLOADABLE _CL_CONV -intel_sub_group_block_write_uc (write_only image2d_t, int2, uchar); -void _CL_OVERLOADABLE _CL_CONV -intel_sub_group_block_write_uc2 (write_only image2d_t, int2, uchar2); -void _CL_OVERLOADABLE _CL_CONV -intel_sub_group_block_write_uc4 (write_only image2d_t, int2, uchar4); -void _CL_OVERLOADABLE _CL_CONV -intel_sub_group_block_write_uc8 (write_only image2d_t, int2, uchar8); -void _CL_OVERLOADABLE _CL_CONV -intel_sub_group_block_write_uc16 (write_only image2d_t, int2, uchar16); - -#if defined(__opencl_c_read_write_images) -void _CL_OVERLOADABLE _CL_CONV -intel_sub_group_block_write_uc (read_write image2d_t, int2, uchar); -void _CL_OVERLOADABLE _CL_CONV -intel_sub_group_block_write_uc2 (read_write image2d_t, int2, uchar2); -void _CL_OVERLOADABLE _CL_CONV -intel_sub_group_block_write_uc4 (read_write image2d_t, int2, uchar4); -void _CL_OVERLOADABLE _CL_CONV -intel_sub_group_block_write_uc8 (read_write image2d_t, int2, uchar8); -void _CL_OVERLOADABLE _CL_CONV -intel_sub_group_block_write_uc16 (read_write image2d_t, int2, uchar16); -#endif // defined(__opencl_c_read_write_images) -#endif // defined(__opencl_c_images) - -#endif // cl_intel_subgroups_char - -/**************************************************************************/ - -#if defined(cl_intel_subgroups_short) -/* The short version is missing from opencl-c.h */ -short _CL_OVERLOADABLE _CL_CONV -intel_sub_group_broadcast (short, uint sub_group_local_id); -short2 _CL_OVERLOADABLE _CL_CONV -intel_sub_group_broadcast (short2, uint sub_group_local_id); -short3 _CL_OVERLOADABLE _CL_CONV -intel_sub_group_broadcast (short3, uint sub_group_local_id); -short4 _CL_OVERLOADABLE _CL_CONV -intel_sub_group_broadcast (short4, uint sub_group_local_id); -short8 _CL_OVERLOADABLE _CL_CONV -intel_sub_group_broadcast (short8, uint sub_group_local_id); - -ushort _CL_OVERLOADABLE _CL_CONV -intel_sub_group_broadcast (ushort, uint sub_group_local_id); -ushort2 _CL_OVERLOADABLE _CL_CONV -intel_sub_group_broadcast (ushort2, uint sub_group_local_id); -ushort3 _CL_OVERLOADABLE _CL_CONV -intel_sub_group_broadcast (ushort3, uint sub_group_local_id); -ushort4 _CL_OVERLOADABLE _CL_CONV -intel_sub_group_broadcast (ushort4, uint sub_group_local_id); -ushort8 _CL_OVERLOADABLE _CL_CONV -intel_sub_group_broadcast (ushort8, uint sub_group_local_id); - -short _CL_OVERLOADABLE _CL_CONV intel_sub_group_shuffle (short, uint); -short2 _CL_OVERLOADABLE _CL_CONV intel_sub_group_shuffle (short2, uint); -short3 _CL_OVERLOADABLE _CL_CONV intel_sub_group_shuffle (short3, uint); -short4 _CL_OVERLOADABLE _CL_CONV intel_sub_group_shuffle (short4, uint); -short8 _CL_OVERLOADABLE _CL_CONV intel_sub_group_shuffle (short8, uint); -short16 _CL_OVERLOADABLE _CL_CONV intel_sub_group_shuffle (short16, uint); - -ushort _CL_OVERLOADABLE _CL_CONV intel_sub_group_shuffle (ushort, uint); -ushort2 _CL_OVERLOADABLE _CL_CONV intel_sub_group_shuffle (ushort2, uint); -ushort3 _CL_OVERLOADABLE _CL_CONV intel_sub_group_shuffle (ushort3, uint); -ushort4 _CL_OVERLOADABLE _CL_CONV intel_sub_group_shuffle (ushort4, uint); -ushort8 _CL_OVERLOADABLE _CL_CONV intel_sub_group_shuffle (ushort8, uint); -ushort16 _CL_OVERLOADABLE _CL_CONV intel_sub_group_shuffle (ushort16, uint); - -short _CL_OVERLOADABLE _CL_CONV intel_sub_group_shuffle_down (short cur, - short next, - uint); -short2 _CL_OVERLOADABLE _CL_CONV intel_sub_group_shuffle_down (short2 cur, - short2 next, - uint); -short3 _CL_OVERLOADABLE _CL_CONV intel_sub_group_shuffle_down (short3 cur, - short3 next, - uint); -short4 _CL_OVERLOADABLE _CL_CONV intel_sub_group_shuffle_down (short4 cur, - short4 next, - uint); -short8 _CL_OVERLOADABLE _CL_CONV intel_sub_group_shuffle_down (short8 cur, - short8 next, - uint); -short16 _CL_OVERLOADABLE _CL_CONV intel_sub_group_shuffle_down (short16 cur, - short16 next, - uint); - -ushort _CL_OVERLOADABLE _CL_CONV intel_sub_group_shuffle_down (ushort cur, - ushort next, - uint); -ushort2 _CL_OVERLOADABLE _CL_CONV intel_sub_group_shuffle_down (ushort2 cur, - ushort2 next, - uint); -ushort3 _CL_OVERLOADABLE _CL_CONV intel_sub_group_shuffle_down (ushort3 cur, - ushort3 next, - uint); -ushort4 _CL_OVERLOADABLE _CL_CONV intel_sub_group_shuffle_down (ushort4 cur, - ushort4 next, - uint); -ushort8 _CL_OVERLOADABLE _CL_CONV intel_sub_group_shuffle_down (ushort8 cur, - ushort8 next, - uint); -ushort16 _CL_OVERLOADABLE _CL_CONV -intel_sub_group_shuffle_down (ushort16 cur, ushort16 next, uint); - -short _CL_OVERLOADABLE _CL_CONV intel_sub_group_shuffle_up (short cur, - short next, - uint); -short2 _CL_OVERLOADABLE _CL_CONV intel_sub_group_shuffle_up (short2 cur, - short2 next, - uint); -short3 _CL_OVERLOADABLE _CL_CONV intel_sub_group_shuffle_up (short3 cur, - short3 next, - uint); -short4 _CL_OVERLOADABLE _CL_CONV intel_sub_group_shuffle_up (short4 cur, - short4 next, - uint); -short8 _CL_OVERLOADABLE _CL_CONV intel_sub_group_shuffle_up (short8 cur, - short8 next, - uint); -short16 _CL_OVERLOADABLE _CL_CONV intel_sub_group_shuffle_up (short16 cur, - short16 next, - uint); - -ushort _CL_OVERLOADABLE _CL_CONV intel_sub_group_shuffle_up (ushort cur, - ushort next, - uint); -ushort2 _CL_OVERLOADABLE _CL_CONV intel_sub_group_shuffle_up (ushort2 cur, - ushort2 next, - uint); -ushort3 _CL_OVERLOADABLE _CL_CONV intel_sub_group_shuffle_up (ushort3 cur, - ushort3 next, - uint); -ushort4 _CL_OVERLOADABLE _CL_CONV intel_sub_group_shuffle_up (ushort4 cur, - ushort4 next, - uint); -ushort8 _CL_OVERLOADABLE _CL_CONV intel_sub_group_shuffle_up (ushort8 cur, - ushort8 next, - uint); -ushort16 _CL_OVERLOADABLE _CL_CONV intel_sub_group_shuffle_up (ushort16 cur, - ushort16 next, - uint); - -short _CL_OVERLOADABLE _CL_CONV intel_sub_group_shuffle_xor (short, uint); -short2 _CL_OVERLOADABLE _CL_CONV intel_sub_group_shuffle_xor (short2, uint); -short3 _CL_OVERLOADABLE _CL_CONV intel_sub_group_shuffle_xor (short3, uint); -short4 _CL_OVERLOADABLE _CL_CONV intel_sub_group_shuffle_xor (short4, uint); -short8 _CL_OVERLOADABLE _CL_CONV intel_sub_group_shuffle_xor (short8, uint); -short16 _CL_OVERLOADABLE _CL_CONV intel_sub_group_shuffle_xor (short16, - uint); - -ushort _CL_OVERLOADABLE _CL_CONV intel_sub_group_shuffle_xor (ushort, uint); -ushort2 _CL_OVERLOADABLE _CL_CONV intel_sub_group_shuffle_xor (ushort2, - uint); -ushort3 _CL_OVERLOADABLE _CL_CONV intel_sub_group_shuffle_xor (ushort3, - uint); -ushort4 _CL_OVERLOADABLE _CL_CONV intel_sub_group_shuffle_xor (ushort4, - uint); -ushort8 _CL_OVERLOADABLE _CL_CONV intel_sub_group_shuffle_xor (ushort8, - uint); -ushort16 _CL_OVERLOADABLE _CL_CONV intel_sub_group_shuffle_xor (ushort16, - uint); - -short _CL_OVERLOADABLE _CL_CONV intel_sub_group_reduce_add (short x); -ushort _CL_OVERLOADABLE _CL_CONV intel_sub_group_reduce_add (ushort x); -short _CL_OVERLOADABLE _CL_CONV intel_sub_group_reduce_min (short x); -ushort _CL_OVERLOADABLE _CL_CONV intel_sub_group_reduce_min (ushort x); -short _CL_OVERLOADABLE _CL_CONV intel_sub_group_reduce_max (short x); -ushort _CL_OVERLOADABLE _CL_CONV intel_sub_group_reduce_max (ushort x); - -short _CL_OVERLOADABLE _CL_CONV intel_sub_group_scan_exclusive_add (short x); -ushort _CL_OVERLOADABLE _CL_CONV -intel_sub_group_scan_exclusive_add (ushort x); -short _CL_OVERLOADABLE _CL_CONV intel_sub_group_scan_exclusive_min (short x); -ushort _CL_OVERLOADABLE _CL_CONV -intel_sub_group_scan_exclusive_min (ushort x); -short _CL_OVERLOADABLE _CL_CONV intel_sub_group_scan_exclusive_max (short x); -ushort _CL_OVERLOADABLE _CL_CONV -intel_sub_group_scan_exclusive_max (ushort x); - -short _CL_OVERLOADABLE _CL_CONV intel_sub_group_scan_inclusive_add (short x); -ushort _CL_OVERLOADABLE _CL_CONV -intel_sub_group_scan_inclusive_add (ushort x); -short _CL_OVERLOADABLE _CL_CONV intel_sub_group_scan_inclusive_min (short x); -ushort _CL_OVERLOADABLE _CL_CONV -intel_sub_group_scan_inclusive_min (ushort x); -short _CL_OVERLOADABLE _CL_CONV intel_sub_group_scan_inclusive_max (short x); -ushort _CL_OVERLOADABLE _CL_CONV -intel_sub_group_scan_inclusive_max (ushort x); - -#if defined(__opencl_c_images) -ushort _CL_OVERLOADABLE _CL_CONV -intel_sub_group_block_read_us (read_only image2d_t, int2); -ushort2 _CL_OVERLOADABLE _CL_CONV -intel_sub_group_block_read_us2 (read_only image2d_t, int2); -ushort4 _CL_OVERLOADABLE _CL_CONV -intel_sub_group_block_read_us4 (read_only image2d_t, int2); -ushort8 _CL_OVERLOADABLE _CL_CONV -intel_sub_group_block_read_us8 (read_only image2d_t, int2); -ushort16 _CL_OVERLOADABLE _CL_CONV -intel_sub_group_block_read_us16 (read_only image2d_t, int2); - -#if defined(__opencl_c_read_write_images) -ushort _CL_OVERLOADABLE _CL_CONV -intel_sub_group_block_read_us (read_write image2d_t, int2); -ushort2 _CL_OVERLOADABLE _CL_CONV -intel_sub_group_block_read_us2 (read_write image2d_t, int2); -ushort4 _CL_OVERLOADABLE _CL_CONV -intel_sub_group_block_read_us4 (read_write image2d_t, int2); -ushort8 _CL_OVERLOADABLE _CL_CONV -intel_sub_group_block_read_us8 (read_write image2d_t, int2); -ushort16 _CL_OVERLOADABLE _CL_CONV -intel_sub_group_block_read_us16 (read_write image2d_t, int2); -#endif // defined(__opencl_c_read_write_images) -#endif // defined(__opencl_c_images) - -ushort _CL_OVERLOADABLE _CL_CONV -intel_sub_group_block_read_us (const global ushort *p); -ushort2 _CL_OVERLOADABLE _CL_CONV -intel_sub_group_block_read_us2 (const global ushort *p); -ushort4 _CL_OVERLOADABLE _CL_CONV -intel_sub_group_block_read_us4 (const global ushort *p); -ushort8 _CL_OVERLOADABLE _CL_CONV -intel_sub_group_block_read_us8 (const global ushort *p); -ushort16 _CL_OVERLOADABLE _CL_CONV -intel_sub_group_block_read_us16 (const global ushort *p); - -ushort _CL_OVERLOADABLE _CL_CONV -intel_sub_group_block_read_us (const local ushort *p); -ushort2 _CL_OVERLOADABLE _CL_CONV -intel_sub_group_block_read_us2 (const local ushort *p); -ushort4 _CL_OVERLOADABLE _CL_CONV -intel_sub_group_block_read_us4 (const local ushort *p); -ushort8 _CL_OVERLOADABLE _CL_CONV -intel_sub_group_block_read_us8 (const local ushort *p); -ushort16 _CL_OVERLOADABLE _CL_CONV -intel_sub_group_block_read_us16 (const local ushort *p); - -void _CL_OVERLOADABLE _CL_CONV intel_sub_group_block_write_us (global ushort *p, - ushort data); -void _CL_OVERLOADABLE _CL_CONV intel_sub_group_block_write_us2 (global ushort *p, - ushort2 data); -void _CL_OVERLOADABLE _CL_CONV intel_sub_group_block_write_us4 (global ushort *p, - ushort4 data); -void _CL_OVERLOADABLE _CL_CONV intel_sub_group_block_write_us8 (global ushort *p, - ushort8 data); -void _CL_OVERLOADABLE _CL_CONV intel_sub_group_block_write_us16 (global ushort *p, - ushort16 data); - -void _CL_OVERLOADABLE _CL_CONV intel_sub_group_block_write_us (local ushort *p, - ushort data); -void _CL_OVERLOADABLE _CL_CONV intel_sub_group_block_write_us2 (local ushort *p, - ushort2 data); -void _CL_OVERLOADABLE _CL_CONV intel_sub_group_block_write_us4 (local ushort *p, - ushort4 data); -void _CL_OVERLOADABLE _CL_CONV intel_sub_group_block_write_us8 (local ushort *p, - ushort8 data); -void _CL_OVERLOADABLE _CL_CONV intel_sub_group_block_write_us16 (local ushort *p, - ushort16 data); - -#if defined(__opencl_c_images) -void _CL_OVERLOADABLE _CL_CONV -intel_sub_group_block_write_us (write_only image2d_t, int2, ushort); -void _CL_OVERLOADABLE _CL_CONV -intel_sub_group_block_write_us2 (write_only image2d_t, int2, ushort2); -void _CL_OVERLOADABLE _CL_CONV -intel_sub_group_block_write_us4 (write_only image2d_t, int2, ushort4); -void _CL_OVERLOADABLE _CL_CONV -intel_sub_group_block_write_us8 (write_only image2d_t, int2, ushort8); -void _CL_OVERLOADABLE _CL_CONV -intel_sub_group_block_write_us16 (write_only image2d_t, int2, ushort16); - -#if defined(__opencl_c_read_write_images) -void _CL_OVERLOADABLE _CL_CONV -intel_sub_group_block_write_us (read_write image2d_t, int2, ushort); -void _CL_OVERLOADABLE _CL_CONV -intel_sub_group_block_write_us2 (read_write image2d_t, int2, ushort2); -void _CL_OVERLOADABLE _CL_CONV -intel_sub_group_block_write_us4 (read_write image2d_t, int2, ushort4); -void _CL_OVERLOADABLE _CL_CONV -intel_sub_group_block_write_us8 (read_write image2d_t, int2, ushort8); -void _CL_OVERLOADABLE _CL_CONV -intel_sub_group_block_write_us16 (read_write image2d_t, int2, ushort16); -#endif // defined(__opencl_c_read_write_images) -#endif // defined(__opencl_c_images) - -#endif // cl_intel_subgroups_short - -/**************************************************************************/ - -#if defined(cl_intel_subgroups_long) - -#if defined(__opencl_c_images) -ulong _CL_OVERLOADABLE _CL_CONV -intel_sub_group_block_read_ul (read_only image2d_t, int2); -ulong2 _CL_OVERLOADABLE _CL_CONV -intel_sub_group_block_read_ul2 (read_only image2d_t, int2); -ulong4 _CL_OVERLOADABLE _CL_CONV -intel_sub_group_block_read_ul4 (read_only image2d_t, int2); -ulong8 _CL_OVERLOADABLE _CL_CONV -intel_sub_group_block_read_ul8 (read_only image2d_t, int2); - -#if defined(__opencl_c_read_write_images) -ulong _CL_OVERLOADABLE _CL_CONV -intel_sub_group_block_read_ul (read_write image2d_t, int2); -ulong2 _CL_OVERLOADABLE _CL_CONV -intel_sub_group_block_read_ul2 (read_write image2d_t, int2); -ulong4 _CL_OVERLOADABLE _CL_CONV -intel_sub_group_block_read_ul4 (read_write image2d_t, int2); -ulong8 _CL_OVERLOADABLE _CL_CONV -intel_sub_group_block_read_ul8 (read_write image2d_t, int2); -#endif // defined(__opencl_c_read_write_images) -#endif // defined(__opencl_c_images) - -ulong _CL_OVERLOADABLE _CL_CONV -intel_sub_group_block_read_ul (const global ulong *p); -ulong2 _CL_OVERLOADABLE _CL_CONV -intel_sub_group_block_read_ul2 (const global ulong *p); -ulong4 _CL_OVERLOADABLE _CL_CONV -intel_sub_group_block_read_ul4 (const global ulong *p); -ulong8 _CL_OVERLOADABLE _CL_CONV -intel_sub_group_block_read_ul8 (const global ulong *p); - -ulong _CL_OVERLOADABLE _CL_CONV -intel_sub_group_block_read_ul (const local ulong *p); -ulong2 _CL_OVERLOADABLE _CL_CONV -intel_sub_group_block_read_ul2 (const local ulong *p); -ulong4 _CL_OVERLOADABLE _CL_CONV -intel_sub_group_block_read_ul4 (const local ulong *p); -ulong8 _CL_OVERLOADABLE _CL_CONV -intel_sub_group_block_read_ul8 (const local ulong *p); - -void _CL_OVERLOADABLE _CL_CONV intel_sub_group_block_write_ul (global ulong *p, - ulong data); -void _CL_OVERLOADABLE _CL_CONV intel_sub_group_block_write_ul2 (global ulong *p, - ulong2 data); -void _CL_OVERLOADABLE _CL_CONV intel_sub_group_block_write_ul4 (global ulong *p, - ulong4 data); -void _CL_OVERLOADABLE _CL_CONV intel_sub_group_block_write_ul8 (global ulong *p, - ulong8 data); - -void _CL_OVERLOADABLE _CL_CONV intel_sub_group_block_write_ul (local ulong *p, - ulong data); -void _CL_OVERLOADABLE _CL_CONV intel_sub_group_block_write_ul2 (local ulong *p, - ulong2 data); -void _CL_OVERLOADABLE _CL_CONV intel_sub_group_block_write_ul4 (local ulong *p, - ulong4 data); -void _CL_OVERLOADABLE _CL_CONV intel_sub_group_block_write_ul8 (local ulong *p, - ulong8 data); - -#if defined(__opencl_c_images) -void _CL_OVERLOADABLE _CL_CONV -intel_sub_group_block_write_ul (write_only image2d_t, int2, ulong); -void _CL_OVERLOADABLE _CL_CONV -intel_sub_group_block_write_ul2 (write_only image2d_t, int2, ulong2); -void _CL_OVERLOADABLE _CL_CONV -intel_sub_group_block_write_ul4 (write_only image2d_t, int2, ulong4); -void _CL_OVERLOADABLE _CL_CONV -intel_sub_group_block_write_ul8 (write_only image2d_t, int2, ulong8); - -#if defined(__opencl_c_read_write_images) -void _CL_OVERLOADABLE _CL_CONV -intel_sub_group_block_write_ul (read_write image2d_t, int2, ulong); -void _CL_OVERLOADABLE _CL_CONV -intel_sub_group_block_write_ul2 (read_write image2d_t, int2, ulong2); -void _CL_OVERLOADABLE _CL_CONV -intel_sub_group_block_write_ul4 (read_write image2d_t, int2, ulong4); -void _CL_OVERLOADABLE _CL_CONV -intel_sub_group_block_write_ul8 (read_write image2d_t, int2, ulong8); -#endif // defined(__opencl_c_read_write_images) -#endif // defined(__opencl_c_images) - -#endif // cl_intel_subgroups_long - -/**************************************************************************/ - -#ifdef cl_intel_split_work_group_barrier -void _CL_OVERLOADABLE -intel_work_group_barrier_arrive (cl_mem_fence_flags flags); -void _CL_OVERLOADABLE intel_work_group_barrier_wait (cl_mem_fence_flags flags); -// For OpenCL C 2.0 or newer: -#if defined(__OPENCL_CPP_VERSION__) || (__OPENCL_C_VERSION__ >= CL_VERSION_2_0) -void _CL_OVERLOADABLE -intel_work_group_barrier_arrive (cl_mem_fence_flags flags, memory_scope scope); -void _CL_OVERLOADABLE intel_work_group_barrier_wait (cl_mem_fence_flags flags, - memory_scope scope); -#endif -#endif // cl_intel_split_work_group_barrier - -#endif diff --git a/drivers/pocl-gen7/share/pocl/include/_enable_all_exts.h b/drivers/pocl-gen7/share/pocl/include/_enable_all_exts.h deleted file mode 100644 index 64957e6..0000000 --- a/drivers/pocl-gen7/share/pocl/include/_enable_all_exts.h +++ /dev/null @@ -1,53 +0,0 @@ -/* Enable all extensions known to pocl, which a device supports. - * This is required at the start of include/_kernel.h for prototypes, - * then at kernel lib compilation phase (because _kernel.h disables - * everything at the end). - */ - -/* OpenCL 1.0-only extensions */ - -#if (__OPENCL_C_VERSION__ < 110) - -#ifdef cl_khr_global_int32_base_atomics -# pragma OPENCL EXTENSION cl_khr_global_int32_base_atomics : enable -#endif - -#ifdef cl_khr_global_int32_extended_atomics -# pragma OPENCL EXTENSION cl_khr_global_int32_extended_atomics : enable -#endif - -#ifdef cl_khr_local_int32_base_atomics -# pragma OPENCL EXTENSION cl_khr_local_int32_base_atomics : enable -#endif - -#ifdef cl_khr_local_int32_extended_atomics -# pragma OPENCL EXTENSION cl_khr_local_int32_extended_atomics : enable -#endif - -#ifdef cl_khr_byte_addressable_store -# pragma OPENCL EXTENSION cl_khr_byte_addressable_store : enable -#endif - -#endif - - -/* all versions */ -#ifdef cl_khr_fp16 -# pragma OPENCL EXTENSION cl_khr_fp16: enable -#endif - -#ifdef cl_khr_fp64 -# pragma OPENCL EXTENSION cl_khr_fp64: enable -#endif - -#ifdef cl_khr_int64_base_atomics -# pragma OPENCL EXTENSION cl_khr_int64_base_atomics : enable -#endif - -#ifdef cl_khr_int64_extended_atomics -# pragma OPENCL EXTENSION cl_khr_int64_extended_atomics : enable -#endif - -#ifdef cl_khr_3d_image_writes -# pragma OPENCL EXTENSION cl_khr_3d_image_writes : enable -#endif diff --git a/drivers/pocl-gen7/share/pocl/include/_kernel.h b/drivers/pocl-gen7/share/pocl/include/_kernel.h deleted file mode 100644 index 62f8f33..0000000 --- a/drivers/pocl-gen7/share/pocl/include/_kernel.h +++ /dev/null @@ -1,179 +0,0 @@ -/* pocl/_kernel.h - OpenCL types and runtime library - functions declarations. This should be included only from OpenCL C files. - - Copyright (c) 2011 Universidad Rey Juan Carlos - Copyright (c) 2011-2017 Pekka Jääskeläinen / TUT - Copyright (c) 2011-2013 Erik Schnetter - Perimeter Institute for Theoretical Physics - - Permission is hereby granted, free of charge, to any person obtaining a copy - of this software and associated documentation files (the "Software"), to deal - in the Software without restriction, including without limitation the rights - to use, copy, modify, merge, publish, distribute, sublicense, and/or sell - copies of the Software, and to permit persons to whom the Software is - furnished to do so, subject to the following conditions: - - The above copyright notice and this permission notice shall be included in - all copies or substantial portions of the Software. - - THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR - IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, - FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE - AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER - LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, - OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN - THE SOFTWARE. -*/ - -/* If the -cl-std build option is not specified, the highest OpenCL C 1.x - * language version supported by each device is used as the version of - * OpenCL C when compiling the program for each device. - */ -#ifndef __OPENCL_C_VERSION__ -#define __OPENCL_C_VERSION__ 120 -#endif - -#if (__OPENCL_C_VERSION__ > 99) -#define CL_VERSION_1_0 100 -#endif - -#if (__OPENCL_C_VERSION__ > 109) -#define CL_VERSION_1_1 110 -#endif - -#if (__OPENCL_C_VERSION__ > 119) -#define CL_VERSION_1_2 120 -#endif - -#if (__OPENCL_C_VERSION__ > 199) -#define CL_VERSION_2_0 200 -#endif - -#include "_enable_all_exts.h" - -#include "_builtin_renames.h" - -/* Define some feature test macros to help write generic code. These are used - * mostly in _pocl_opencl.h header + some .cl files in kernel library */ - -#ifdef cl_khr_int64 -# define __IF_INT64(x) x -#else -# define __IF_INT64(x) -#endif -#ifdef cl_khr_fp16 -# define __IF_FP16(x) x -#else -# define __IF_FP16(x) -#endif -#ifdef cl_khr_fp64 -# define __IF_FP64(x) x -#else -# define __IF_FP64(x) -#endif -#ifdef cl_khr_int64_base_atomics -#define __IF_BA64(x) x -#else -#define __IF_BA64(x) -#endif -#ifdef cl_khr_int64_extended_atomics -#define __IF_EA64(x) x -#else -#define __IF_EA64(x) -#endif - -/****************************************************************************/ - -/* Function/type attributes supported by Clang/SPIR */ -#if __has_attribute(__always_inline__) -# define _CL_ALWAYSINLINE __attribute__((__always_inline__)) -#else -# define _CL_ALWAYSINLINE -#endif -#if __has_attribute(__noinline__) -# define _CL_NOINLINE __attribute__((__noinline__)) -#else -# define _CL_NOINLINE -#endif -#if __has_attribute(__overloadable__) -# define _CL_OVERLOADABLE __attribute__((__overloadable__)) -#else -# define _CL_OVERLOADABLE -#endif -#if __has_attribute(__pure__) -# define _CL_READONLY __attribute__((__pure__)) -#else -# define _CL_READONLY -#endif -#if __has_attribute(__const__) -# define _CL_READNONE __attribute__((__const__)) -#else -# define _CL_READNONE -#endif -#if __has_attribute(convergent) -# define _CL_CONVERGENT __attribute__((convergent)) -#else -# define _CL_CONVERGENT -#endif - -/****************************************************************************/ - -/* A static assert statement to catch inconsistencies at build time */ -#if __has_extension(__c_static_assert__) -# define _CL_STATIC_ASSERT(_t, _x) _Static_assert(_x, #_t) -#else -# define _CL_STATIC_ASSERT(_t, _x) typedef int __cl_ai##_t[(x) ? 1 : -1]; -#endif - -/****************************************************************************/ - -#define IMG_RO_AQ __read_only -#define IMG_WO_AQ __write_only - -#ifdef __opencl_c_read_write_images -#define CLANG_HAS_RW_IMAGES -#define IMG_RW_AQ __read_write -#else -#undef CLANG_HAS_RW_IMAGES -#define IMG_RW_AQ __RW_IMAGES_UNSUPPORTED_BEFORE_CL_20 -#endif - -/****************************************************************************/ -/* use Clang opencl header for definitions. */ - -#ifdef POCL_DEVICE_ADDRESS_BITS - -/* If we wish to override the Clang set __SIZE_TYPE__ for this target, - let's do it here so the opencl-c.h sets size_t to the wanted type. */ - -#ifdef __SIZE_TYPE__ -#undef __SIZE_TYPE__ -#endif - -#if POCL_DEVICE_ADDRESS_BITS == 32 -#define __SIZE_TYPE__ uint -#elif POCL_DEVICE_ADDRESS_BITS == 64 -#define __SIZE_TYPE__ ulong -#else -#error Unsupported POCL_DEVICE_ADDRESS_BITS value. -#endif - -#endif - -#include "_clang_opencl.h" - -/****************************************************************************/ - -/* GNU's libm seems to use INT_MIN here while the Clang's header uses - INT_MAX. Both are allowed by the OpenCL specs, but we want them to - be unified to avoid failing tests. */ -#undef FP_ILOGBNAN -#undef FP_ILOGB0 -#define FP_ILOGB0 INT_MIN -#define FP_ILOGBNAN INT_MAX - -/****************************************************************************/ - -#include "pocl_image_types.h" - -#pragma OPENCL EXTENSION all : disable diff --git a/drivers/pocl-gen7/share/pocl/include/_kernel_c.h b/drivers/pocl-gen7/share/pocl/include/_kernel_c.h deleted file mode 100644 index 807a75d..0000000 --- a/drivers/pocl-gen7/share/pocl/include/_kernel_c.h +++ /dev/null @@ -1,199 +0,0 @@ -/* pocl/_kernel_c.h - C compatible OpenCL types and runtime library - functions declarations for kernel builtin implementations using C. - - Copyright (c) 2011 Universidad Rey Juan Carlos - Copyright (c) 2011-2017 Pekka Jääskeläinen / TUT - Copyright (c) 2011-2013 Erik Schnetter - Perimeter Institute for Theoretical Physics - - Permission is hereby granted, free of charge, to any person obtaining a copy - of this software and associated documentation files (the "Software"), to deal - in the Software without restriction, including without limitation the rights - to use, copy, modify, merge, publish, distribute, sublicense, and/or sell - copies of the Software, and to permit persons to whom the Software is - furnished to do so, subject to the following conditions: - - The above copyright notice and this permission notice shall be included in - all copies or substantial portions of the Software. - - THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR - IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, - FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE - AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER - LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, - OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN - THE SOFTWARE. -*/ -/** - * Header that can be implemented in C compiled implementations of - * built-in functions to introduce the OpenCL C compatible types etc. - */ -#ifndef _KERNEL_C_H -#define _KERNEL_C_H - -#include "pocl_types.h" - -/* cannot include "_builtin_renames.h" because it overrides some C/C++ macros, - but we need the prefixed functions in the builtin library */ -#define POCL_BUILTIN_PREFIX(FUNC) _cl_##FUNC - -#include "_kernel_constants.h" - -/* Function/type attributes supported by Clang/SPIR */ -#if __has_attribute(__always_inline__) -# define _CL_ALWAYSINLINE __attribute__((__always_inline__)) -#else -# define _CL_ALWAYSINLINE -#endif -#if __has_attribute(__noinline__) -# define _CL_NOINLINE __attribute__((__noinline__)) -#else -# define _CL_NOINLINE -#endif -#if __has_attribute(__overloadable__) -# define _CL_OVERLOADABLE __attribute__((__overloadable__)) -#else -# define _CL_OVERLOADABLE -#endif -#if __has_attribute(__pure__) -# define _CL_READONLY __attribute__((__pure__)) -#else -# define _CL_READONLY -#endif -#if __has_attribute(__const__) -# define _CL_READNONE __attribute__((__const__)) -#else -# define _CL_READNONE -#endif -#if __has_attribute(convergent) -# define _CL_CONVERGENT __attribute__((convergent)) -#else -# define _CL_CONVERGENT -#endif -#if __has_attribute(optnone) -#define _CL_OPTNONE __attribute__ ((optnone)) -#else -#define _CL_OPTNONE -#endif - -typedef char char2 __attribute__((__ext_vector_type__(2))); -typedef char char3 __attribute__((__ext_vector_type__(3))); -typedef char char4 __attribute__((__ext_vector_type__(4))); -typedef char char8 __attribute__((__ext_vector_type__(8))); -typedef char char16 __attribute__((__ext_vector_type__(16))); - -typedef uchar uchar2 __attribute__((__ext_vector_type__(2))); -typedef uchar uchar3 __attribute__((__ext_vector_type__(3))); -typedef uchar uchar4 __attribute__((__ext_vector_type__(4))); -typedef uchar uchar8 __attribute__((__ext_vector_type__(8))); -typedef uchar uchar16 __attribute__((__ext_vector_type__(16))); - -typedef short short2 __attribute__((__ext_vector_type__(2))); -typedef short short3 __attribute__((__ext_vector_type__(3))); -typedef short short4 __attribute__((__ext_vector_type__(4))); -typedef short short8 __attribute__((__ext_vector_type__(8))); -typedef short short16 __attribute__((__ext_vector_type__(16))); - -typedef ushort ushort2 __attribute__((__ext_vector_type__(2))); -typedef ushort ushort3 __attribute__((__ext_vector_type__(3))); -typedef ushort ushort4 __attribute__((__ext_vector_type__(4))); -typedef ushort ushort8 __attribute__((__ext_vector_type__(8))); -typedef ushort ushort16 __attribute__((__ext_vector_type__(16))); - -typedef int int2 __attribute__((__ext_vector_type__(2))); -typedef int int3 __attribute__((__ext_vector_type__(3))); -typedef int int4 __attribute__((__ext_vector_type__(4))); -typedef int int8 __attribute__((__ext_vector_type__(8))); -typedef int int16 __attribute__((__ext_vector_type__(16))); - -typedef uint uint2 __attribute__((__ext_vector_type__(2))); -typedef uint uint3 __attribute__((__ext_vector_type__(3))); -typedef uint uint4 __attribute__((__ext_vector_type__(4))); -typedef uint uint8 __attribute__((__ext_vector_type__(8))); -typedef uint uint16 __attribute__((__ext_vector_type__(16))); - -#if defined(__CBUILD__) && defined(cl_khr_fp16) - -#ifdef _HAS_FLOAT16_TYPE -typedef _Float16 half; -#else -typedef __fp16 half; -#endif - -typedef half half2 __attribute__((__ext_vector_type__(2))); -typedef half half3 __attribute__((__ext_vector_type__(3))); -typedef half half4 __attribute__((__ext_vector_type__(4))); -typedef half half8 __attribute__((__ext_vector_type__(8))); -typedef half half16 __attribute__((__ext_vector_type__(16))); -#endif - -typedef float float2 __attribute__((__ext_vector_type__(2))); -typedef float float3 __attribute__((__ext_vector_type__(3))); -typedef float float4 __attribute__((__ext_vector_type__(4))); -typedef float float8 __attribute__((__ext_vector_type__(8))); -typedef float float16 __attribute__((__ext_vector_type__(16))); - -#ifdef cl_khr_fp64 -# ifndef __CBUILD__ -# pragma OPENCL EXTENSION cl_khr_fp64 : enable -# endif -typedef double double2 __attribute__((__ext_vector_type__(2))); -typedef double double3 __attribute__((__ext_vector_type__(3))); -typedef double double4 __attribute__((__ext_vector_type__(4))); -typedef double double8 __attribute__((__ext_vector_type__(8))); -typedef double double16 __attribute__((__ext_vector_type__(16))); -#endif - -#ifdef cl_khr_int64 -typedef long long2 __attribute__((__ext_vector_type__(2))); -typedef long long3 __attribute__((__ext_vector_type__(3))); -typedef long long4 __attribute__((__ext_vector_type__(4))); -typedef long long8 __attribute__((__ext_vector_type__(8))); -typedef long long16 __attribute__((__ext_vector_type__(16))); - -typedef ulong ulong2 __attribute__((__ext_vector_type__(2))); -typedef ulong ulong3 __attribute__((__ext_vector_type__(3))); -typedef ulong ulong4 __attribute__((__ext_vector_type__(4))); -typedef ulong ulong8 __attribute__((__ext_vector_type__(8))); -typedef ulong ulong16 __attribute__((__ext_vector_type__(16))); -#endif - -#if defined(__TCE__) - -#define POCL_ADDRESS_SPACE_PRIVATE 0 -#define POCL_ADDRESS_SPACE_GLOBAL 1 -#define POCL_ADDRESS_SPACE_LOCAL 3 -#define POCL_ADDRESS_SPACE_CONSTANT 2 -#define POCL_ADDRESS_SPACE_GENERIC 6 - -#endif - -typedef uint cl_mem_fence_flags; - -/* Integer Constants */ - -#if defined(__CBUILD__) - -#define CHAR_BIT 8 -#define CHAR_MAX SCHAR_MAX -#define CHAR_MIN SCHAR_MIN -#define INT_MAX 2147483647 -#define INT_MIN (-2147483647 - 1) -#ifdef cl_khr_int64 -#define LONG_MAX 0x7fffffffffffffffL -#define LONG_MIN (-0x7fffffffffffffffL - 1) -#endif -#define SCHAR_MAX 127 -#define SCHAR_MIN (-127 - 1) -#define SHRT_MAX 32767 -#define SHRT_MIN (-32767 - 1) -#define UCHAR_MAX 255 -#define USHRT_MAX 65535 -#define UINT_MAX 0xffffffff -#ifdef cl_khr_int64 -#define ULONG_MAX 0xffffffffffffffffUL -#endif - -#endif /* __CBUILD__ */ - -#endif diff --git a/drivers/pocl-gen7/share/pocl/include/_kernel_constants.h b/drivers/pocl-gen7/share/pocl/include/_kernel_constants.h deleted file mode 100644 index e45ebdb..0000000 --- a/drivers/pocl-gen7/share/pocl/include/_kernel_constants.h +++ /dev/null @@ -1,93 +0,0 @@ -/* pocl/_kernel_constants.h - C compatible OpenCL types and runtime library - constants declarations. - - Copyright (c) 2011 Universidad Rey Juan Carlos - Copyright (c) 2011-2013 Pekka Jääskeläinen / TUT - Copyright (c) 2011-2013 Erik Schnetter - Perimeter Institute for Theoretical Physics - - Permission is hereby granted, free of charge, to any person obtaining a copy - of this software and associated documentation files (the "Software"), to deal - in the Software without restriction, including without limitation the rights - to use, copy, modify, merge, publish, distribute, sublicense, and/or sell - copies of the Software, and to permit persons to whom the Software is - furnished to do so, subject to the following conditions: - - The above copyright notice and this permission notice shall be included in - all copies or substantial portions of the Software. - - THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR - IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, - FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE - AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER - LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, - OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN - THE SOFTWARE. -*/ -/** - * Header that can be implemented in C compiled implementations of - * built-in functions to introduce the OpenCL C compatible constants. - */ -#ifndef _KERNEL_CONSTANTS_H -#define _KERNEL_CONSTANTS_H - -/* clang's header defines these */ -#ifndef _OPENCL_H_ - -/* cl_channel_order */ -#define CLK_R 0x10B0 -#define CLK_A 0x10B1 -#define CLK_RG 0x10B2 -#define CLK_RA 0x10B3 -#define CLK_RGB 0x10B4 -#define CLK_RGBA 0x10B5 -#define CLK_BGRA 0x10B6 -#define CLK_ARGB 0x10B7 -#define CLK_INTENSITY 0x10B8 -#define CLK_LUMINANCE 0x10B9 -#define CLK_Rx 0x10BA -#define CLK_RGx 0x10BB -#define CLK_RGBx 0x10BC -#define CLK_DEPTH 0x10BD -#define CLK_DEPTH_STENCIL 0x10BE - -/* cl_channel_type */ -#define CLK_SNORM_INT8 0x10D0 -#define CLK_SNORM_INT16 0x10D1 -#define CLK_UNORM_INT8 0x10D2 -#define CLK_UNORM_INT16 0x10D3 -#define CLK_UNORM_SHORT_565 0x10D4 -#define CLK_UNORM_SHORT_555 0x10D5 -#define CLK_UNORM_INT_101010 0x10D6 -#define CLK_SIGNED_INT8 0x10D7 -#define CLK_SIGNED_INT16 0x10D8 -#define CLK_SIGNED_INT32 0x10D9 -#define CLK_UNSIGNED_INT8 0x10DA -#define CLK_UNSIGNED_INT16 0x10DB -#define CLK_UNSIGNED_INT32 0x10DC -#define CLK_HALF_FLOAT 0x10DD -#define CLK_FLOAT 0x10DE -#define CLK_UNORM_INT24 0x10DF - -/* cl_addressing _mode */ -#define CLK_ADDRESS_NONE 0x00 -#define CLK_ADDRESS_CLAMP_TO_EDGE 0x02 -#define CLK_ADDRESS_CLAMP 0x04 -#define CLK_ADDRESS_REPEAT 0x06 -#define CLK_ADDRESS_MIRRORED_REPEAT 0x08 - -/* cl_sampler_info */ -#define CLK_NORMALIZED_COORDS_FALSE 0x00 -#define CLK_NORMALIZED_COORDS_TRUE 0x01 - -/* filter_mode */ -#define CLK_FILTER_NEAREST 0x10 -#define CLK_FILTER_LINEAR 0x20 - -/* barrier() flags */ -#define CLK_LOCAL_MEM_FENCE 0x01 -#define CLK_GLOBAL_MEM_FENCE 0x02 - -#endif - -#endif diff --git a/drivers/pocl-gen7/share/pocl/include/opencl-c-base.h b/drivers/pocl-gen7/share/pocl/include/opencl-c-base.h deleted file mode 100644 index 68daf0b..0000000 --- a/drivers/pocl-gen7/share/pocl/include/opencl-c-base.h +++ /dev/null @@ -1,830 +0,0 @@ -//===----- opencl-c-base.h - OpenCL C language base definitions -----------===// -// -// 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 -// -//===----------------------------------------------------------------------===// - -#ifndef _OPENCL_BASE_H_ -#define _OPENCL_BASE_H_ - -// Define extension macros - -#if (defined(__OPENCL_CPP_VERSION__) || __OPENCL_C_VERSION__ >= 200) -// For SPIR and SPIR-V all extensions are supported. -#if defined(__SPIR__) || defined(__SPIRV__) -#define cl_khr_subgroup_extended_types 1 -#define cl_khr_subgroup_non_uniform_vote 1 -#define cl_khr_subgroup_ballot 1 -#define cl_khr_subgroup_non_uniform_arithmetic 1 -#define cl_khr_subgroup_shuffle 1 -#define cl_khr_subgroup_shuffle_relative 1 -#define cl_khr_subgroup_clustered_reduce 1 -#define cl_khr_subgroup_rotate 1 -#define cl_khr_extended_bit_ops 1 -#define cl_khr_integer_dot_product 1 -#define __opencl_c_integer_dot_product_input_4x8bit 1 -#define __opencl_c_integer_dot_product_input_4x8bit_packed 1 -#define cl_ext_float_atomics 1 -#ifdef cl_khr_fp16 -#define __opencl_c_ext_fp16_global_atomic_load_store 1 -#define __opencl_c_ext_fp16_local_atomic_load_store 1 -#define __opencl_c_ext_fp16_global_atomic_add 1 -#define __opencl_c_ext_fp16_local_atomic_add 1 -#define __opencl_c_ext_fp16_global_atomic_min_max 1 -#define __opencl_c_ext_fp16_local_atomic_min_max 1 -#endif -#ifdef cl_khr_fp64 -#define __opencl_c_ext_fp64_global_atomic_add 1 -#define __opencl_c_ext_fp64_local_atomic_add 1 -#define __opencl_c_ext_fp64_global_atomic_min_max 1 -#define __opencl_c_ext_fp64_local_atomic_min_max 1 -#endif -#define __opencl_c_ext_fp32_global_atomic_add 1 -#define __opencl_c_ext_fp32_local_atomic_add 1 -#define __opencl_c_ext_fp32_global_atomic_min_max 1 -#define __opencl_c_ext_fp32_local_atomic_min_max 1 - -#endif // defined(__SPIR__) || defined(__SPIRV__) -#endif // (defined(__OPENCL_CPP_VERSION__) || __OPENCL_C_VERSION__ >= 200) - -// Define feature macros for OpenCL C 2.0 -#if (__OPENCL_CPP_VERSION__ == 100 || __OPENCL_C_VERSION__ == 200) -#define __opencl_c_pipes 1 -#define __opencl_c_generic_address_space 1 -#define __opencl_c_work_group_collective_functions 1 -#define __opencl_c_atomic_order_acq_rel 1 -#define __opencl_c_atomic_order_seq_cst 1 -#define __opencl_c_atomic_scope_device 1 -#define __opencl_c_atomic_scope_all_devices 1 -#define __opencl_c_device_enqueue 1 -#define __opencl_c_read_write_images 1 -#define __opencl_c_program_scope_global_variables 1 -#define __opencl_c_images 1 -#endif - -// Define header-only feature macros for OpenCL C 3.0. -#if (__OPENCL_CPP_VERSION__ == 202100 || __OPENCL_C_VERSION__ == 300) -// For the SPIR and SPIR-V target all features are supported. -#if defined(__SPIR__) || defined(__SPIRV__) -#define __opencl_c_work_group_collective_functions 1 -#define __opencl_c_atomic_order_seq_cst 1 -#define __opencl_c_atomic_scope_device 1 -#define __opencl_c_atomic_scope_all_devices 1 -#define __opencl_c_read_write_images 1 -#endif // defined(__SPIR__) - -// Undefine any feature macros that have been explicitly disabled using -// an __undef_ macro. -#ifdef __undef___opencl_c_work_group_collective_functions -#undef __opencl_c_work_group_collective_functions -#endif -#ifdef __undef___opencl_c_atomic_order_seq_cst -#undef __opencl_c_atomic_order_seq_cst -#endif -#ifdef __undef___opencl_c_atomic_scope_device -#undef __opencl_c_atomic_scope_device -#endif -#ifdef __undef___opencl_c_atomic_scope_all_devices -#undef __opencl_c_atomic_scope_all_devices -#endif -#ifdef __undef___opencl_c_read_write_images -#undef __opencl_c_read_write_images -#endif - -#endif // (__OPENCL_CPP_VERSION__ == 202100 || __OPENCL_C_VERSION__ == 300) - -#if !defined(__opencl_c_generic_address_space) -// Internal feature macro to provide named (global, local, private) address -// space overloads for builtin functions that take a pointer argument. -#define __opencl_c_named_address_space_builtins 1 -#endif // !defined(__opencl_c_generic_address_space) - -#if defined(cl_intel_subgroups) || defined(cl_khr_subgroups) || defined(__opencl_c_subgroups) -// Internal feature macro to provide subgroup builtins. -#define __opencl_subgroup_builtins 1 -#endif - -// built-in scalar data types: - -/** - * An unsigned 8-bit integer. - */ -typedef unsigned char uchar; - -/** - * An unsigned 16-bit integer. - */ -typedef unsigned short ushort; - -/** - * An unsigned 32-bit integer. - */ -typedef unsigned int uint; - -/** - * An unsigned 64-bit integer. - */ -typedef unsigned long ulong; - -/** - * The unsigned integer type of the result of the sizeof operator. This - * is a 32-bit unsigned integer if CL_DEVICE_ADDRESS_BITS - * defined in table 4.3 is 32-bits and is a 64-bit unsigned integer if - * CL_DEVICE_ADDRESS_BITS is 64-bits. - */ -typedef __SIZE_TYPE__ size_t; - -/** - * A signed integer type that is the result of subtracting two pointers. - * This is a 32-bit signed integer if CL_DEVICE_ADDRESS_BITS - * defined in table 4.3 is 32-bits and is a 64-bit signed integer if - * CL_DEVICE_ADDRESS_BITS is 64-bits. - */ -typedef __PTRDIFF_TYPE__ ptrdiff_t; - -/** - * A signed integer type with the property that any valid pointer to - * void can be converted to this type, then converted back to pointer - * to void, and the result will compare equal to the original pointer. - */ -typedef __INTPTR_TYPE__ intptr_t; - -/** - * An unsigned integer type with the property that any valid pointer to - * void can be converted to this type, then converted back to pointer - * to void, and the result will compare equal to the original pointer. - */ -typedef __UINTPTR_TYPE__ uintptr_t; - -// built-in vector data types: -typedef char char2 __attribute__((ext_vector_type(2))) __attribute__((aligned(2))); -typedef char char3 __attribute__((ext_vector_type(3))) __attribute__((aligned(4))); -typedef char char4 __attribute__((ext_vector_type(4))) __attribute__((aligned(4))); -typedef char char8 __attribute__((ext_vector_type(8))) __attribute__((aligned(8))); -typedef char char16 __attribute__((ext_vector_type(16))) __attribute__((aligned(16))); - -typedef uchar uchar2 __attribute__((ext_vector_type(2))) __attribute__((aligned(2))); -typedef uchar uchar3 __attribute__((ext_vector_type(3))) __attribute__((aligned(4))); -typedef uchar uchar4 __attribute__((ext_vector_type(4))) __attribute__((aligned(4))); -typedef uchar uchar8 __attribute__((ext_vector_type(8))) __attribute__((aligned(8))); -typedef uchar uchar16 __attribute__((ext_vector_type(16))) __attribute__((aligned(16))); - -typedef short short2 __attribute__((ext_vector_type(2))) __attribute__((aligned(4))); -typedef short short3 __attribute__((ext_vector_type(3))) __attribute__((aligned(8))); -typedef short short4 __attribute__((ext_vector_type(4))) __attribute__((aligned(8))); -typedef short short8 __attribute__((ext_vector_type(8))) __attribute__((aligned(16))); -typedef short short16 __attribute__((ext_vector_type(16))) __attribute__((aligned(32))); - -typedef ushort ushort2 __attribute__((ext_vector_type(2))) __attribute__((aligned(4))); -typedef ushort ushort3 __attribute__((ext_vector_type(3))) __attribute__((aligned(8))); -typedef ushort ushort4 __attribute__((ext_vector_type(4))) __attribute__((aligned(8))); -typedef ushort ushort8 __attribute__((ext_vector_type(8))) __attribute__((aligned(16))); -typedef ushort ushort16 __attribute__((ext_vector_type(16))) __attribute__((aligned(32))); - -typedef int int2 __attribute__((ext_vector_type(2))) __attribute__((aligned(8))); -typedef int int3 __attribute__((ext_vector_type(3))) __attribute__((aligned(16))); -typedef int int4 __attribute__((ext_vector_type(4))) __attribute__((aligned(16))); -typedef int int8 __attribute__((ext_vector_type(8))) __attribute__((aligned(32))); -typedef int int16 __attribute__((ext_vector_type(16))) __attribute__((aligned(64))); - -typedef uint uint2 __attribute__((ext_vector_type(2))) __attribute__((aligned(8))); -typedef uint uint3 __attribute__((ext_vector_type(3))) __attribute__((aligned(16))); -typedef uint uint4 __attribute__((ext_vector_type(4))) __attribute__((aligned(16))); -typedef uint uint8 __attribute__((ext_vector_type(8))) __attribute__((aligned(32))); -typedef uint uint16 __attribute__((ext_vector_type(16))) __attribute__((aligned(64))); - -typedef long long2 __attribute__((ext_vector_type(2))) __attribute__((aligned(16))); -typedef long long3 __attribute__((ext_vector_type(3))) __attribute__((aligned(32))); -typedef long long4 __attribute__((ext_vector_type(4))) __attribute__((aligned(32))); -typedef long long8 __attribute__((ext_vector_type(8))) __attribute__((aligned(64))); -typedef long long16 __attribute__((ext_vector_type(16))) __attribute__((aligned(128))); - -typedef ulong ulong2 __attribute__((ext_vector_type(2))) __attribute__((aligned(16))); -typedef ulong ulong3 __attribute__((ext_vector_type(3))) __attribute__((aligned(32))); -typedef ulong ulong4 __attribute__((ext_vector_type(4))) __attribute__((aligned(32))); -typedef ulong ulong8 __attribute__((ext_vector_type(8))) __attribute__((aligned(64))); -typedef ulong ulong16 __attribute__((ext_vector_type(16))) __attribute__((aligned(128))); - -typedef float float2 __attribute__((ext_vector_type(2))) __attribute__((aligned(8))); -typedef float float3 __attribute__((ext_vector_type(3))) __attribute__((aligned(16))); -typedef float float4 __attribute__((ext_vector_type(4))) __attribute__((aligned(16))); -typedef float float8 __attribute__((ext_vector_type(8))) __attribute__((aligned(32))); -typedef float float16 __attribute__((ext_vector_type(16))) __attribute__((aligned(64))); - -#ifdef cl_khr_fp16 -#pragma OPENCL EXTENSION cl_khr_fp16 : enable -typedef half half2 __attribute__((ext_vector_type(2))) __attribute__((aligned(4))); -typedef half half3 __attribute__((ext_vector_type(3))) __attribute__((aligned(8))); -typedef half half4 __attribute__((ext_vector_type(4))) __attribute__((aligned(8))); -typedef half half8 __attribute__((ext_vector_type(8))) __attribute__((aligned(16))); -typedef half half16 __attribute__((ext_vector_type(16))) __attribute__((aligned(32))); -#endif -#ifdef cl_khr_fp64 -#if __OPENCL_C_VERSION__ < CL_VERSION_1_2 -#pragma OPENCL EXTENSION cl_khr_fp64 : enable -#endif -typedef double double2 __attribute__((ext_vector_type(2))) __attribute__((aligned(16))); -typedef double double3 __attribute__((ext_vector_type(3))) __attribute__((aligned(32))); -typedef double double4 __attribute__((ext_vector_type(4))) __attribute__((aligned(32))); -typedef double double8 __attribute__((ext_vector_type(8))) __attribute__((aligned(64))); -typedef double double16 __attribute__((ext_vector_type(16))) __attribute__((aligned(128))); -#endif - - -// An internal alias for half, for use by OpenCLBuiltins.td. -#define __half half - -#if defined(__OPENCL_CPP_VERSION__) -#define NULL nullptr -#elif defined(__OPENCL_C_VERSION__) -#define NULL ((void*)0) -#endif - -/** - * Value of maximum non-infinite single-precision floating-point - * number. - */ -#define MAXFLOAT 0x1.fffffep127f - -/** - * A positive float constant expression. HUGE_VALF evaluates - * to +infinity. Used as an error value returned by the built-in - * math functions. - */ -#define HUGE_VALF (__builtin_huge_valf()) - -/** - * A positive double constant expression. HUGE_VAL evaluates - * to +infinity. Used as an error value returned by the built-in - * math functions. - */ -#define HUGE_VAL (__builtin_huge_val()) - -/** - * A constant expression of type float representing positive or - * unsigned infinity. - */ -#define INFINITY (__builtin_inff()) - -/** - * A constant expression of type float representing a quiet NaN. - */ -#define NAN as_float(INT_MAX) - -#define FP_ILOGB0 INT_MIN -#define FP_ILOGBNAN INT_MAX - -#define FLT_DIG 6 -#define FLT_MANT_DIG 24 -#define FLT_MAX_10_EXP +38 -#define FLT_MAX_EXP +128 -#define FLT_MIN_10_EXP -37 -#define FLT_MIN_EXP -125 -#define FLT_RADIX 2 -#define FLT_MAX 0x1.fffffep127f -#define FLT_MIN 0x1.0p-126f -#define FLT_EPSILON 0x1.0p-23f - -#define M_E_F 2.71828182845904523536028747135266250f -#define M_LOG2E_F 1.44269504088896340735992468100189214f -#define M_LOG10E_F 0.434294481903251827651128918916605082f -#define M_LN2_F 0.693147180559945309417232121458176568f -#define M_LN10_F 2.30258509299404568401799145468436421f -#define M_PI_F 3.14159265358979323846264338327950288f -#define M_PI_2_F 1.57079632679489661923132169163975144f -#define M_PI_4_F 0.785398163397448309615660845819875721f -#define M_1_PI_F 0.318309886183790671537767526745028724f -#define M_2_PI_F 0.636619772367581343075535053490057448f -#define M_2_SQRTPI_F 1.12837916709551257389615890312154517f -#define M_SQRT2_F 1.41421356237309504880168872420969808f -#define M_SQRT1_2_F 0.707106781186547524400844362104849039f - -#define DBL_DIG 15 -#define DBL_MANT_DIG 53 -#define DBL_MAX_10_EXP +308 -#define DBL_MAX_EXP +1024 -#define DBL_MIN_10_EXP -307 -#define DBL_MIN_EXP -1021 -#define DBL_RADIX 2 -#define DBL_MAX 0x1.fffffffffffffp1023 -#define DBL_MIN 0x1.0p-1022 -#define DBL_EPSILON 0x1.0p-52 - -#define M_E 0x1.5bf0a8b145769p+1 -#define M_LOG2E 0x1.71547652b82fep+0 -#define M_LOG10E 0x1.bcb7b1526e50ep-2 -#define M_LN2 0x1.62e42fefa39efp-1 -#define M_LN10 0x1.26bb1bbb55516p+1 -#define M_PI 0x1.921fb54442d18p+1 -#define M_PI_2 0x1.921fb54442d18p+0 -#define M_PI_4 0x1.921fb54442d18p-1 -#define M_1_PI 0x1.45f306dc9c883p-2 -#define M_2_PI 0x1.45f306dc9c883p-1 -#define M_2_SQRTPI 0x1.20dd750429b6dp+0 -#define M_SQRT2 0x1.6a09e667f3bcdp+0 -#define M_SQRT1_2 0x1.6a09e667f3bcdp-1 - -#ifdef cl_khr_fp16 - -#define HALF_DIG 3 -#define HALF_MANT_DIG 11 -#define HALF_MAX_10_EXP +4 -#define HALF_MAX_EXP +16 -#define HALF_MIN_10_EXP -4 -#define HALF_MIN_EXP -13 -#define HALF_RADIX 2 -#define HALF_MAX ((0x1.ffcp15h)) -#define HALF_MIN ((0x1.0p-14h)) -#define HALF_EPSILON ((0x1.0p-10h)) - -#define M_E_H 2.71828182845904523536028747135266250h -#define M_LOG2E_H 1.44269504088896340735992468100189214h -#define M_LOG10E_H 0.434294481903251827651128918916605082h -#define M_LN2_H 0.693147180559945309417232121458176568h -#define M_LN10_H 2.30258509299404568401799145468436421h -#define M_PI_H 3.14159265358979323846264338327950288h -#define M_PI_2_H 1.57079632679489661923132169163975144h -#define M_PI_4_H 0.785398163397448309615660845819875721h -#define M_1_PI_H 0.318309886183790671537767526745028724h -#define M_2_PI_H 0.636619772367581343075535053490057448h -#define M_2_SQRTPI_H 1.12837916709551257389615890312154517h -#define M_SQRT2_H 1.41421356237309504880168872420969808h -#define M_SQRT1_2_H 0.707106781186547524400844362104849039h - -#endif //cl_khr_fp16 - -#define CHAR_BIT 8 -#define SCHAR_MAX 127 -#define SCHAR_MIN (-128) -#define UCHAR_MAX 255 -#define CHAR_MAX SCHAR_MAX -#define CHAR_MIN SCHAR_MIN -#define USHRT_MAX 65535 -#define SHRT_MAX 32767 -#define SHRT_MIN (-32768) -#define UINT_MAX 0xffffffff -#define INT_MAX 2147483647 -#define INT_MIN (-2147483647-1) -#define ULONG_MAX 0xffffffffffffffffUL -#define LONG_MAX 0x7fffffffffffffffL -#define LONG_MIN (-0x7fffffffffffffffL-1) - -// OpenCL v1.1 s6.11.8, v1.2 s6.12.8, v2.0 s6.13.8 - Synchronization Functions - -// Flag type and values for barrier, mem_fence, read_mem_fence, write_mem_fence -typedef uint cl_mem_fence_flags; - -/** - * Queue a memory fence to ensure correct - * ordering of memory operations to local memory - */ -#define CLK_LOCAL_MEM_FENCE 0x01 - -/** - * Queue a memory fence to ensure correct - * ordering of memory operations to global memory - */ -#define CLK_GLOBAL_MEM_FENCE 0x02 - -#if defined(__OPENCL_CPP_VERSION__) || (__OPENCL_C_VERSION__ >= CL_VERSION_2_0) - -typedef enum memory_scope { - memory_scope_work_item = __OPENCL_MEMORY_SCOPE_WORK_ITEM, - memory_scope_work_group = __OPENCL_MEMORY_SCOPE_WORK_GROUP, - memory_scope_device = __OPENCL_MEMORY_SCOPE_DEVICE, -#if defined(__opencl_c_atomic_scope_all_devices) - memory_scope_all_svm_devices = __OPENCL_MEMORY_SCOPE_ALL_SVM_DEVICES, -#if (__OPENCL_C_VERSION__ >= CL_VERSION_3_0 || __OPENCL_CPP_VERSION__ >= 202100) - memory_scope_all_devices = memory_scope_all_svm_devices, -#endif // (__OPENCL_C_VERSION__ >= CL_VERSION_3_0 || __OPENCL_CPP_VERSION__ >= 202100) -#endif // defined(__opencl_c_atomic_scope_all_devices) -/** - * Subgroups have different requirements on forward progress, so just test - * all the relevant macros. - * CL 3.0 sub-groups "they are not guaranteed to make independent forward progress" - * KHR subgroups "Subgroups within a workgroup are independent, make forward progress with respect to each other" - */ -#if defined(cl_intel_subgroups) || defined(cl_khr_subgroups) || defined(__opencl_c_subgroups) - memory_scope_sub_group = __OPENCL_MEMORY_SCOPE_SUB_GROUP -#endif -} memory_scope; - -/** - * Queue a memory fence to ensure correct ordering of memory - * operations between work-items of a work-group to - * image memory. - */ -#define CLK_IMAGE_MEM_FENCE 0x04 - -#ifndef ATOMIC_VAR_INIT -#define ATOMIC_VAR_INIT(x) (x) -#endif //ATOMIC_VAR_INIT -#define ATOMIC_FLAG_INIT 0 - -// enum values aligned with what clang uses in EmitAtomicExpr() -typedef enum memory_order -{ - memory_order_relaxed = __ATOMIC_RELAXED, - memory_order_acquire = __ATOMIC_ACQUIRE, - memory_order_release = __ATOMIC_RELEASE, - memory_order_acq_rel = __ATOMIC_ACQ_REL, -#if defined(__opencl_c_atomic_order_seq_cst) - memory_order_seq_cst = __ATOMIC_SEQ_CST -#endif -} memory_order; - -#endif // defined(__OPENCL_CPP_VERSION__) || (__OPENCL_C_VERSION__ >= CL_VERSION_2_0) - -// OpenCL v1.1 s6.11.3, v1.2 s6.12.14, v2.0 s6.13.14 - Image Read and Write Functions - -// These values need to match the runtime equivalent -// -// Addressing Mode. -// -#define CLK_ADDRESS_NONE 0 -#define CLK_ADDRESS_CLAMP_TO_EDGE 2 -#define CLK_ADDRESS_CLAMP 4 -#define CLK_ADDRESS_REPEAT 6 -#define CLK_ADDRESS_MIRRORED_REPEAT 8 - -// -// Coordination Normalization -// -#define CLK_NORMALIZED_COORDS_FALSE 0 -#define CLK_NORMALIZED_COORDS_TRUE 1 - -// -// Filtering Mode. -// -#define CLK_FILTER_NEAREST 0x10 -#define CLK_FILTER_LINEAR 0x20 - -#ifdef cl_khr_gl_msaa_sharing -#pragma OPENCL EXTENSION cl_khr_gl_msaa_sharing : enable -#endif //cl_khr_gl_msaa_sharing - -// -// Channel Datatype. -// -#define CLK_SNORM_INT8 0x10D0 -#define CLK_SNORM_INT16 0x10D1 -#define CLK_UNORM_INT8 0x10D2 -#define CLK_UNORM_INT16 0x10D3 -#define CLK_UNORM_SHORT_565 0x10D4 -#define CLK_UNORM_SHORT_555 0x10D5 -#define CLK_UNORM_INT_101010 0x10D6 -#define CLK_SIGNED_INT8 0x10D7 -#define CLK_SIGNED_INT16 0x10D8 -#define CLK_SIGNED_INT32 0x10D9 -#define CLK_UNSIGNED_INT8 0x10DA -#define CLK_UNSIGNED_INT16 0x10DB -#define CLK_UNSIGNED_INT32 0x10DC -#define CLK_HALF_FLOAT 0x10DD -#define CLK_FLOAT 0x10DE -#define CLK_UNORM_INT24 0x10DF -#if __OPENCL_C_VERSION__ >= CL_VERSION_3_0 -#define CLK_UNORM_INT_101010_2 0x10E0 -#endif // __OPENCL_C_VERSION__ >= CL_VERSION_3_0 - -// Channel order, numbering must be aligned with cl_channel_order in cl.h -// -#define CLK_R 0x10B0 -#define CLK_A 0x10B1 -#define CLK_RG 0x10B2 -#define CLK_RA 0x10B3 -#define CLK_RGB 0x10B4 -#define CLK_RGBA 0x10B5 -#define CLK_BGRA 0x10B6 -#define CLK_ARGB 0x10B7 -#define CLK_INTENSITY 0x10B8 -#define CLK_LUMINANCE 0x10B9 -#define CLK_Rx 0x10BA -#define CLK_RGx 0x10BB -#define CLK_RGBx 0x10BC -#define CLK_DEPTH 0x10BD -#define CLK_DEPTH_STENCIL 0x10BE -#if __OPENCL_C_VERSION__ >= CL_VERSION_2_0 -#define CLK_sRGB 0x10BF -#define CLK_sRGBx 0x10C0 -#define CLK_sRGBA 0x10C1 -#define CLK_sBGRA 0x10C2 -#define CLK_ABGR 0x10C3 -#endif //__OPENCL_C_VERSION__ >= CL_VERSION_2_0 - -// OpenCL v2.0 s6.13.16 - Pipe Functions -#if defined(__OPENCL_CPP_VERSION__) || (__OPENCL_C_VERSION__ >= CL_VERSION_2_0) -#define CLK_NULL_RESERVE_ID (__builtin_astype(((void*)(__SIZE_MAX__)), reserve_id_t)) - -// OpenCL v2.0 s6.13.17 - Enqueue Kernels -#define CL_COMPLETE 0x0 -#define CL_RUNNING 0x1 -#define CL_SUBMITTED 0x2 -#define CL_QUEUED 0x3 - -#define CLK_SUCCESS 0 -#define CLK_ENQUEUE_FAILURE -101 -#define CLK_INVALID_QUEUE -102 -#define CLK_INVALID_NDRANGE -160 -#define CLK_INVALID_EVENT_WAIT_LIST -57 -#define CLK_DEVICE_QUEUE_FULL -161 -#define CLK_INVALID_ARG_SIZE -51 -#define CLK_EVENT_ALLOCATION_FAILURE -100 -#define CLK_OUT_OF_RESOURCES -5 - -#define CLK_NULL_QUEUE 0 -#define CLK_NULL_EVENT (__builtin_astype(((__SIZE_MAX__)), clk_event_t)) - -// execution model related definitions -#define CLK_ENQUEUE_FLAGS_NO_WAIT 0x0 -#define CLK_ENQUEUE_FLAGS_WAIT_KERNEL 0x1 -#define CLK_ENQUEUE_FLAGS_WAIT_WORK_GROUP 0x2 - -typedef int kernel_enqueue_flags_t; -typedef int clk_profiling_info; - -// Profiling info name (see capture_event_profiling_info) -#define CLK_PROFILING_COMMAND_EXEC_TIME 0x1 - -#define MAX_WORK_DIM 3 - -#ifdef __opencl_c_device_enqueue -typedef struct { - unsigned int workDimension; - size_t globalWorkOffset[MAX_WORK_DIM]; - size_t globalWorkSize[MAX_WORK_DIM]; - size_t localWorkSize[MAX_WORK_DIM]; -} ndrange_t; -#endif // __opencl_c_device_enqueue - -#endif // defined(__OPENCL_CPP_VERSION__) || (__OPENCL_C_VERSION__ >= CL_VERSION_2_0) - -/** - * OpenCL v1.1/1.2/2.0 s6.2.4.2 - as_type operators - * Reinterprets a data type as another data type of the same size - */ -#define as_char(x) __builtin_astype((x), char) -#define as_char2(x) __builtin_astype((x), char2) -#define as_char3(x) __builtin_astype((x), char3) -#define as_char4(x) __builtin_astype((x), char4) -#define as_char8(x) __builtin_astype((x), char8) -#define as_char16(x) __builtin_astype((x), char16) - -#define as_uchar(x) __builtin_astype((x), uchar) -#define as_uchar2(x) __builtin_astype((x), uchar2) -#define as_uchar3(x) __builtin_astype((x), uchar3) -#define as_uchar4(x) __builtin_astype((x), uchar4) -#define as_uchar8(x) __builtin_astype((x), uchar8) -#define as_uchar16(x) __builtin_astype((x), uchar16) - -#define as_short(x) __builtin_astype((x), short) -#define as_short2(x) __builtin_astype((x), short2) -#define as_short3(x) __builtin_astype((x), short3) -#define as_short4(x) __builtin_astype((x), short4) -#define as_short8(x) __builtin_astype((x), short8) -#define as_short16(x) __builtin_astype((x), short16) - -#define as_ushort(x) __builtin_astype((x), ushort) -#define as_ushort2(x) __builtin_astype((x), ushort2) -#define as_ushort3(x) __builtin_astype((x), ushort3) -#define as_ushort4(x) __builtin_astype((x), ushort4) -#define as_ushort8(x) __builtin_astype((x), ushort8) -#define as_ushort16(x) __builtin_astype((x), ushort16) - -#define as_int(x) __builtin_astype((x), int) -#define as_int2(x) __builtin_astype((x), int2) -#define as_int3(x) __builtin_astype((x), int3) -#define as_int4(x) __builtin_astype((x), int4) -#define as_int8(x) __builtin_astype((x), int8) -#define as_int16(x) __builtin_astype((x), int16) - -#define as_uint(x) __builtin_astype((x), uint) -#define as_uint2(x) __builtin_astype((x), uint2) -#define as_uint3(x) __builtin_astype((x), uint3) -#define as_uint4(x) __builtin_astype((x), uint4) -#define as_uint8(x) __builtin_astype((x), uint8) -#define as_uint16(x) __builtin_astype((x), uint16) - -#define as_long(x) __builtin_astype((x), long) -#define as_long2(x) __builtin_astype((x), long2) -#define as_long3(x) __builtin_astype((x), long3) -#define as_long4(x) __builtin_astype((x), long4) -#define as_long8(x) __builtin_astype((x), long8) -#define as_long16(x) __builtin_astype((x), long16) - -#define as_ulong(x) __builtin_astype((x), ulong) -#define as_ulong2(x) __builtin_astype((x), ulong2) -#define as_ulong3(x) __builtin_astype((x), ulong3) -#define as_ulong4(x) __builtin_astype((x), ulong4) -#define as_ulong8(x) __builtin_astype((x), ulong8) -#define as_ulong16(x) __builtin_astype((x), ulong16) - -#define as_float(x) __builtin_astype((x), float) -#define as_float2(x) __builtin_astype((x), float2) -#define as_float3(x) __builtin_astype((x), float3) -#define as_float4(x) __builtin_astype((x), float4) -#define as_float8(x) __builtin_astype((x), float8) -#define as_float16(x) __builtin_astype((x), float16) - -#ifdef cl_khr_fp64 -#define as_double(x) __builtin_astype((x), double) -#define as_double2(x) __builtin_astype((x), double2) -#define as_double3(x) __builtin_astype((x), double3) -#define as_double4(x) __builtin_astype((x), double4) -#define as_double8(x) __builtin_astype((x), double8) -#define as_double16(x) __builtin_astype((x), double16) -#endif // cl_khr_fp64 - -#ifdef cl_khr_fp16 -#define as_half(x) __builtin_astype((x), half) -#define as_half2(x) __builtin_astype((x), half2) -#define as_half3(x) __builtin_astype((x), half3) -#define as_half4(x) __builtin_astype((x), half4) -#define as_half8(x) __builtin_astype((x), half8) -#define as_half16(x) __builtin_astype((x), half16) -#endif // cl_khr_fp16 - -#define as_size_t(x) __builtin_astype((x), size_t) -#define as_ptrdiff_t(x) __builtin_astype((x), ptrdiff_t) -#define as_intptr_t(x) __builtin_astype((x), intptr_t) -#define as_uintptr_t(x) __builtin_astype((x), uintptr_t) - -// C++ for OpenCL - __remove_address_space -#if defined(__OPENCL_CPP_VERSION__) -template struct __remove_address_space { using type = _Tp; }; -#if defined(__opencl_c_generic_address_space) -template struct __remove_address_space<__generic _Tp> { - using type = _Tp; -}; -#endif -template struct __remove_address_space<__global _Tp> { - using type = _Tp; -}; -template struct __remove_address_space<__private _Tp> { - using type = _Tp; -}; -template struct __remove_address_space<__local _Tp> { - using type = _Tp; -}; -template struct __remove_address_space<__constant _Tp> { - using type = _Tp; -}; -#endif - -// OpenCL v1.1 s6.9, v1.2/2.0 s6.10 - Function qualifiers - -#define __kernel_exec(X, typen) __kernel \ - __attribute__((work_group_size_hint(X, 1, 1))) \ - __attribute__((vec_type_hint(typen))) - -#define kernel_exec(X, typen) __kernel \ - __attribute__((work_group_size_hint(X, 1, 1))) \ - __attribute__((vec_type_hint(typen))) - -#if defined(__OPENCL_CPP_VERSION__) || (__OPENCL_C_VERSION__ >= CL_VERSION_1_2) -// OpenCL v1.2 s6.12.13, v2.0 s6.13.13 - printf - -int printf(__constant const char* st, ...) __attribute__((format(printf, 1, 2))); -#endif - -#ifdef cl_intel_device_side_avc_motion_estimation - -#define CLK_AVC_ME_MAJOR_16x16_INTEL 0x0 -#define CLK_AVC_ME_MAJOR_16x8_INTEL 0x1 -#define CLK_AVC_ME_MAJOR_8x16_INTEL 0x2 -#define CLK_AVC_ME_MAJOR_8x8_INTEL 0x3 - -#define CLK_AVC_ME_MINOR_8x8_INTEL 0x0 -#define CLK_AVC_ME_MINOR_8x4_INTEL 0x1 -#define CLK_AVC_ME_MINOR_4x8_INTEL 0x2 -#define CLK_AVC_ME_MINOR_4x4_INTEL 0x3 - -#define CLK_AVC_ME_MAJOR_FORWARD_INTEL 0x0 -#define CLK_AVC_ME_MAJOR_BACKWARD_INTEL 0x1 -#define CLK_AVC_ME_MAJOR_BIDIRECTIONAL_INTEL 0x2 - -#define CLK_AVC_ME_PARTITION_MASK_ALL_INTEL 0x0 -#define CLK_AVC_ME_PARTITION_MASK_16x16_INTEL 0x7E -#define CLK_AVC_ME_PARTITION_MASK_16x8_INTEL 0x7D -#define CLK_AVC_ME_PARTITION_MASK_8x16_INTEL 0x7B -#define CLK_AVC_ME_PARTITION_MASK_8x8_INTEL 0x77 -#define CLK_AVC_ME_PARTITION_MASK_8x4_INTEL 0x6F -#define CLK_AVC_ME_PARTITION_MASK_4x8_INTEL 0x5F -#define CLK_AVC_ME_PARTITION_MASK_4x4_INTEL 0x3F - -#define CLK_AVC_ME_SLICE_TYPE_PRED_INTEL 0x0 -#define CLK_AVC_ME_SLICE_TYPE_BPRED_INTEL 0x1 -#define CLK_AVC_ME_SLICE_TYPE_INTRA_INTEL 0x2 - -#define CLK_AVC_ME_SEARCH_WINDOW_EXHAUSTIVE_INTEL 0x0 -#define CLK_AVC_ME_SEARCH_WINDOW_SMALL_INTEL 0x1 -#define CLK_AVC_ME_SEARCH_WINDOW_TINY_INTEL 0x2 -#define CLK_AVC_ME_SEARCH_WINDOW_EXTRA_TINY_INTEL 0x3 -#define CLK_AVC_ME_SEARCH_WINDOW_DIAMOND_INTEL 0x4 -#define CLK_AVC_ME_SEARCH_WINDOW_LARGE_DIAMOND_INTEL 0x5 -#define CLK_AVC_ME_SEARCH_WINDOW_RESERVED0_INTEL 0x6 -#define CLK_AVC_ME_SEARCH_WINDOW_RESERVED1_INTEL 0x7 -#define CLK_AVC_ME_SEARCH_WINDOW_CUSTOM_INTEL 0x8 - -#define CLK_AVC_ME_SAD_ADJUST_MODE_NONE_INTEL 0x0 -#define CLK_AVC_ME_SAD_ADJUST_MODE_HAAR_INTEL 0x2 - -#define CLK_AVC_ME_SUBPIXEL_MODE_INTEGER_INTEL 0x0 -#define CLK_AVC_ME_SUBPIXEL_MODE_HPEL_INTEL 0x1 -#define CLK_AVC_ME_SUBPIXEL_MODE_QPEL_INTEL 0x3 - -#define CLK_AVC_ME_COST_PRECISION_QPEL_INTEL 0x0 -#define CLK_AVC_ME_COST_PRECISION_HPEL_INTEL 0x1 -#define CLK_AVC_ME_COST_PRECISION_PEL_INTEL 0x2 -#define CLK_AVC_ME_COST_PRECISION_DPEL_INTEL 0x3 - -#define CLK_AVC_ME_BIDIR_WEIGHT_QUARTER_INTEL 0x10 -#define CLK_AVC_ME_BIDIR_WEIGHT_THIRD_INTEL 0x15 -#define CLK_AVC_ME_BIDIR_WEIGHT_HALF_INTEL 0x20 -#define CLK_AVC_ME_BIDIR_WEIGHT_TWO_THIRD_INTEL 0x2B -#define CLK_AVC_ME_BIDIR_WEIGHT_THREE_QUARTER_INTEL 0x30 - -#define CLK_AVC_ME_BORDER_REACHED_LEFT_INTEL 0x0 -#define CLK_AVC_ME_BORDER_REACHED_RIGHT_INTEL 0x2 -#define CLK_AVC_ME_BORDER_REACHED_TOP_INTEL 0x4 -#define CLK_AVC_ME_BORDER_REACHED_BOTTOM_INTEL 0x8 - -#define CLK_AVC_ME_INTRA_16x16_INTEL 0x0 -#define CLK_AVC_ME_INTRA_8x8_INTEL 0x1 -#define CLK_AVC_ME_INTRA_4x4_INTEL 0x2 - -#define CLK_AVC_ME_SKIP_BLOCK_PARTITION_16x16_INTEL 0x0 -#define CLK_AVC_ME_SKIP_BLOCK_PARTITION_8x8_INTEL 0x4000 - -#define CLK_AVC_ME_SKIP_BLOCK_16x16_FORWARD_ENABLE_INTEL (0x1 << 24) -#define CLK_AVC_ME_SKIP_BLOCK_16x16_BACKWARD_ENABLE_INTEL (0x2 << 24) -#define CLK_AVC_ME_SKIP_BLOCK_16x16_DUAL_ENABLE_INTEL (0x3 << 24) -#define CLK_AVC_ME_SKIP_BLOCK_8x8_FORWARD_ENABLE_INTEL (0x55 << 24) -#define CLK_AVC_ME_SKIP_BLOCK_8x8_BACKWARD_ENABLE_INTEL (0xAA << 24) -#define CLK_AVC_ME_SKIP_BLOCK_8x8_DUAL_ENABLE_INTEL (0xFF << 24) -#define CLK_AVC_ME_SKIP_BLOCK_8x8_0_FORWARD_ENABLE_INTEL (0x1 << 24) -#define CLK_AVC_ME_SKIP_BLOCK_8x8_0_BACKWARD_ENABLE_INTEL (0x2 << 24) -#define CLK_AVC_ME_SKIP_BLOCK_8x8_1_FORWARD_ENABLE_INTEL (0x1 << 26) -#define CLK_AVC_ME_SKIP_BLOCK_8x8_1_BACKWARD_ENABLE_INTEL (0x2 << 26) -#define CLK_AVC_ME_SKIP_BLOCK_8x8_2_FORWARD_ENABLE_INTEL (0x1 << 28) -#define CLK_AVC_ME_SKIP_BLOCK_8x8_2_BACKWARD_ENABLE_INTEL (0x2 << 28) -#define CLK_AVC_ME_SKIP_BLOCK_8x8_3_FORWARD_ENABLE_INTEL (0x1 << 30) -#define CLK_AVC_ME_SKIP_BLOCK_8x8_3_BACKWARD_ENABLE_INTEL (0x2 << 30) - -#define CLK_AVC_ME_BLOCK_BASED_SKIP_4x4_INTEL 0x00 -#define CLK_AVC_ME_BLOCK_BASED_SKIP_8x8_INTEL 0x80 - -#define CLK_AVC_ME_INTRA_LUMA_PARTITION_MASK_ALL_INTEL 0x0 -#define CLK_AVC_ME_INTRA_LUMA_PARTITION_MASK_16x16_INTEL 0x6 -#define CLK_AVC_ME_INTRA_LUMA_PARTITION_MASK_8x8_INTEL 0x5 -#define CLK_AVC_ME_INTRA_LUMA_PARTITION_MASK_4x4_INTEL 0x3 - -#define CLK_AVC_ME_INTRA_NEIGHBOR_LEFT_MASK_ENABLE_INTEL 0x60 -#define CLK_AVC_ME_INTRA_NEIGHBOR_UPPER_MASK_ENABLE_INTEL 0x10 -#define CLK_AVC_ME_INTRA_NEIGHBOR_UPPER_RIGHT_MASK_ENABLE_INTEL 0x8 -#define CLK_AVC_ME_INTRA_NEIGHBOR_UPPER_LEFT_MASK_ENABLE_INTEL 0x4 - -#define CLK_AVC_ME_LUMA_PREDICTOR_MODE_VERTICAL_INTEL 0x0 -#define CLK_AVC_ME_LUMA_PREDICTOR_MODE_HORIZONTAL_INTEL 0x1 -#define CLK_AVC_ME_LUMA_PREDICTOR_MODE_DC_INTEL 0x2 -#define CLK_AVC_ME_LUMA_PREDICTOR_MODE_DIAGONAL_DOWN_LEFT_INTEL 0x3 -#define CLK_AVC_ME_LUMA_PREDICTOR_MODE_DIAGONAL_DOWN_RIGHT_INTEL 0x4 -#define CLK_AVC_ME_LUMA_PREDICTOR_MODE_PLANE_INTEL 0x4 -#define CLK_AVC_ME_LUMA_PREDICTOR_MODE_VERTICAL_RIGHT_INTEL 0x5 -#define CLK_AVC_ME_LUMA_PREDICTOR_MODE_HORIZONTAL_DOWN_INTEL 0x6 -#define CLK_AVC_ME_LUMA_PREDICTOR_MODE_VERTICAL_LEFT_INTEL 0x7 -#define CLK_AVC_ME_LUMA_PREDICTOR_MODE_HORIZONTAL_UP_INTEL 0x8 -#define CLK_AVC_ME_CHROMA_PREDICTOR_MODE_DC_INTEL 0x0 -#define CLK_AVC_ME_CHROMA_PREDICTOR_MODE_HORIZONTAL_INTEL 0x1 -#define CLK_AVC_ME_CHROMA_PREDICTOR_MODE_VERTICAL_INTEL 0x2 -#define CLK_AVC_ME_CHROMA_PREDICTOR_MODE_PLANE_INTEL 0x3 - -#define CLK_AVC_ME_FRAME_FORWARD_INTEL 0x1 -#define CLK_AVC_ME_FRAME_BACKWARD_INTEL 0x2 -#define CLK_AVC_ME_FRAME_DUAL_INTEL 0x3 - -#define CLK_AVC_ME_INTERLACED_SCAN_TOP_FIELD_INTEL 0x0 -#define CLK_AVC_ME_INTERLACED_SCAN_BOTTOM_FIELD_INTEL 0x1 - -#define CLK_AVC_ME_INITIALIZE_INTEL 0x0 - -#define CLK_AVC_IME_PAYLOAD_INITIALIZE_INTEL 0x0 -#define CLK_AVC_REF_PAYLOAD_INITIALIZE_INTEL 0x0 -#define CLK_AVC_SIC_PAYLOAD_INITIALIZE_INTEL 0x0 - -#define CLK_AVC_IME_RESULT_INITIALIZE_INTEL 0x0 -#define CLK_AVC_REF_RESULT_INITIALIZE_INTEL 0x0 -#define CLK_AVC_SIC_RESULT_INITIALIZE_INTEL 0x0 - -#define CLK_AVC_IME_RESULT_SINGLE_REFERENCE_STREAMOUT_INITIALIZE_INTEL 0x0 -#define CLK_AVC_IME_RESULT_SINGLE_REFERENCE_STREAMIN_INITIALIZE_INTEL 0x0 -#define CLK_AVC_IME_RESULT_DUAL_REFERENCE_STREAMOUT_INITIALIZE_INTEL 0x0 -#define CLK_AVC_IME_RESULT_DUAL_REFERENCE_STREAMIN_INITIALIZE_INTEL 0x0 - -#endif // cl_intel_device_side_avc_motion_estimation - -// Disable any extensions we may have enabled previously. -#pragma OPENCL EXTENSION all : disable - -#endif //_OPENCL_BASE_H_ diff --git a/drivers/pocl-gen7/share/pocl/include/opencl-c.h b/drivers/pocl-gen7/share/pocl/include/opencl-c.h deleted file mode 100644 index 8479596..0000000 --- a/drivers/pocl-gen7/share/pocl/include/opencl-c.h +++ /dev/null @@ -1,18375 +0,0 @@ -//===--- opencl-c.h - OpenCL C language builtin function header -----------===// -// -// 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 -// -//===----------------------------------------------------------------------===// - -#ifndef _OPENCL_H_ -#define _OPENCL_H_ - -#ifndef SKIP_HEADER_INCLUDE -#include "opencl-c-base.h" -#endif - -#if defined(__opencl_c_images) -#ifndef cl_khr_depth_images -#define cl_khr_depth_images -#endif //cl_khr_depth_images -#endif //defined(__opencl_c_images) - -#if __OPENCL_C_VERSION__ < CL_VERSION_2_0 -#ifdef cl_khr_3d_image_writes -#pragma OPENCL EXTENSION cl_khr_3d_image_writes : enable -#endif //cl_khr_3d_image_writes -#endif //__OPENCL_C_VERSION__ < CL_VERSION_2_0 - -#if (defined(__OPENCL_CPP_VERSION__) || \ - (__OPENCL_C_VERSION__ >= CL_VERSION_1_2)) && \ - (defined(__SPIR__) || defined(__SPIRV__)) -#pragma OPENCL EXTENSION cl_intel_planar_yuv : begin -#pragma OPENCL EXTENSION cl_intel_planar_yuv : end -#endif // (defined(__OPENCL_CPP_VERSION__) || - // (__OPENCL_C_VERSION__ >= CL_VERSION_1_2)) && - // (defined(__SPIR__) || defined(__SPIRV__)) - -#define __ovld __attribute__((overloadable)) -#define __conv __attribute__((convergent)) - -// Optimizations -#define __purefn __attribute__((pure)) -#define __cnfn __attribute__((const)) - - -// OpenCL v1.1/1.2/2.0 s6.2.3 - Explicit conversions - -char __ovld __cnfn convert_char_rte(char); -char __ovld __cnfn convert_char_sat_rte(char); -char __ovld __cnfn convert_char_rtz(char); -char __ovld __cnfn convert_char_sat_rtz(char); -char __ovld __cnfn convert_char_rtp(char); -char __ovld __cnfn convert_char_sat_rtp(char); -char __ovld __cnfn convert_char_rtn(char); -char __ovld __cnfn convert_char_sat_rtn(char); -char __ovld __cnfn convert_char(char); -char __ovld __cnfn convert_char_sat(char); -char __ovld __cnfn convert_char_rte(uchar); -char __ovld __cnfn convert_char_sat_rte(uchar); -char __ovld __cnfn convert_char_rtz(uchar); -char __ovld __cnfn convert_char_sat_rtz(uchar); -char __ovld __cnfn convert_char_rtp(uchar); -char __ovld __cnfn convert_char_sat_rtp(uchar); -char __ovld __cnfn convert_char_rtn(uchar); -char __ovld __cnfn convert_char_sat_rtn(uchar); -char __ovld __cnfn convert_char(uchar); -char __ovld __cnfn convert_char_sat(uchar); -char __ovld __cnfn convert_char_rte(short); -char __ovld __cnfn convert_char_sat_rte(short); -char __ovld __cnfn convert_char_rtz(short); -char __ovld __cnfn convert_char_sat_rtz(short); -char __ovld __cnfn convert_char_rtp(short); -char __ovld __cnfn convert_char_sat_rtp(short); -char __ovld __cnfn convert_char_rtn(short); -char __ovld __cnfn convert_char_sat_rtn(short); -char __ovld __cnfn convert_char(short); -char __ovld __cnfn convert_char_sat(short); -char __ovld __cnfn convert_char_rte(ushort); -char __ovld __cnfn convert_char_sat_rte(ushort); -char __ovld __cnfn convert_char_rtz(ushort); -char __ovld __cnfn convert_char_sat_rtz(ushort); -char __ovld __cnfn convert_char_rtp(ushort); -char __ovld __cnfn convert_char_sat_rtp(ushort); -char __ovld __cnfn convert_char_rtn(ushort); -char __ovld __cnfn convert_char_sat_rtn(ushort); -char __ovld __cnfn convert_char(ushort); -char __ovld __cnfn convert_char_sat(ushort); -char __ovld __cnfn convert_char_rte(int); -char __ovld __cnfn convert_char_sat_rte(int); -char __ovld __cnfn convert_char_rtz(int); -char __ovld __cnfn convert_char_sat_rtz(int); -char __ovld __cnfn convert_char_rtp(int); -char __ovld __cnfn convert_char_sat_rtp(int); -char __ovld __cnfn convert_char_rtn(int); -char __ovld __cnfn convert_char_sat_rtn(int); -char __ovld __cnfn convert_char(int); -char __ovld __cnfn convert_char_sat(int); -char __ovld __cnfn convert_char_rte(uint); -char __ovld __cnfn convert_char_sat_rte(uint); -char __ovld __cnfn convert_char_rtz(uint); -char __ovld __cnfn convert_char_sat_rtz(uint); -char __ovld __cnfn convert_char_rtp(uint); -char __ovld __cnfn convert_char_sat_rtp(uint); -char __ovld __cnfn convert_char_rtn(uint); -char __ovld __cnfn convert_char_sat_rtn(uint); -char __ovld __cnfn convert_char(uint); -char __ovld __cnfn convert_char_sat(uint); -char __ovld __cnfn convert_char_rte(long); -char __ovld __cnfn convert_char_sat_rte(long); -char __ovld __cnfn convert_char_rtz(long); -char __ovld __cnfn convert_char_sat_rtz(long); -char __ovld __cnfn convert_char_rtp(long); -char __ovld __cnfn convert_char_sat_rtp(long); -char __ovld __cnfn convert_char_rtn(long); -char __ovld __cnfn convert_char_sat_rtn(long); -char __ovld __cnfn convert_char(long); -char __ovld __cnfn convert_char_sat(long); -char __ovld __cnfn convert_char_rte(ulong); -char __ovld __cnfn convert_char_sat_rte(ulong); -char __ovld __cnfn convert_char_rtz(ulong); -char __ovld __cnfn convert_char_sat_rtz(ulong); -char __ovld __cnfn convert_char_rtp(ulong); -char __ovld __cnfn convert_char_sat_rtp(ulong); -char __ovld __cnfn convert_char_rtn(ulong); -char __ovld __cnfn convert_char_sat_rtn(ulong); -char __ovld __cnfn convert_char(ulong); -char __ovld __cnfn convert_char_sat(ulong); -char __ovld __cnfn convert_char_rte(float); -char __ovld __cnfn convert_char_sat_rte(float); -char __ovld __cnfn convert_char_rtz(float); -char __ovld __cnfn convert_char_sat_rtz(float); -char __ovld __cnfn convert_char_rtp(float); -char __ovld __cnfn convert_char_sat_rtp(float); -char __ovld __cnfn convert_char_rtn(float); -char __ovld __cnfn convert_char_sat_rtn(float); -char __ovld __cnfn convert_char(float); -char __ovld __cnfn convert_char_sat(float); -uchar __ovld __cnfn convert_uchar_rte(char); -uchar __ovld __cnfn convert_uchar_sat_rte(char); -uchar __ovld __cnfn convert_uchar_rtz(char); -uchar __ovld __cnfn convert_uchar_sat_rtz(char); -uchar __ovld __cnfn convert_uchar_rtp(char); -uchar __ovld __cnfn convert_uchar_sat_rtp(char); -uchar __ovld __cnfn convert_uchar_rtn(char); -uchar __ovld __cnfn convert_uchar_sat_rtn(char); -uchar __ovld __cnfn convert_uchar(char); -uchar __ovld __cnfn convert_uchar_sat(char); -uchar __ovld __cnfn convert_uchar_rte(uchar); -uchar __ovld __cnfn convert_uchar_sat_rte(uchar); -uchar __ovld __cnfn convert_uchar_rtz(uchar); -uchar __ovld __cnfn convert_uchar_sat_rtz(uchar); -uchar __ovld __cnfn convert_uchar_rtp(uchar); -uchar __ovld __cnfn convert_uchar_sat_rtp(uchar); -uchar __ovld __cnfn convert_uchar_rtn(uchar); -uchar __ovld __cnfn convert_uchar_sat_rtn(uchar); -uchar __ovld __cnfn convert_uchar(uchar); -uchar __ovld __cnfn convert_uchar_sat(uchar); -uchar __ovld __cnfn convert_uchar_rte(short); -uchar __ovld __cnfn convert_uchar_sat_rte(short); -uchar __ovld __cnfn convert_uchar_rtz(short); -uchar __ovld __cnfn convert_uchar_sat_rtz(short); -uchar __ovld __cnfn convert_uchar_rtp(short); -uchar __ovld __cnfn convert_uchar_sat_rtp(short); -uchar __ovld __cnfn convert_uchar_rtn(short); -uchar __ovld __cnfn convert_uchar_sat_rtn(short); -uchar __ovld __cnfn convert_uchar(short); -uchar __ovld __cnfn convert_uchar_sat(short); -uchar __ovld __cnfn convert_uchar_rte(ushort); -uchar __ovld __cnfn convert_uchar_sat_rte(ushort); -uchar __ovld __cnfn convert_uchar_rtz(ushort); -uchar __ovld __cnfn convert_uchar_sat_rtz(ushort); -uchar __ovld __cnfn convert_uchar_rtp(ushort); -uchar __ovld __cnfn convert_uchar_sat_rtp(ushort); -uchar __ovld __cnfn convert_uchar_rtn(ushort); -uchar __ovld __cnfn convert_uchar_sat_rtn(ushort); -uchar __ovld __cnfn convert_uchar(ushort); -uchar __ovld __cnfn convert_uchar_sat(ushort); -uchar __ovld __cnfn convert_uchar_rte(int); -uchar __ovld __cnfn convert_uchar_sat_rte(int); -uchar __ovld __cnfn convert_uchar_rtz(int); -uchar __ovld __cnfn convert_uchar_sat_rtz(int); -uchar __ovld __cnfn convert_uchar_rtp(int); -uchar __ovld __cnfn convert_uchar_sat_rtp(int); -uchar __ovld __cnfn convert_uchar_rtn(int); -uchar __ovld __cnfn convert_uchar_sat_rtn(int); -uchar __ovld __cnfn convert_uchar(int); -uchar __ovld __cnfn convert_uchar_sat(int); -uchar __ovld __cnfn convert_uchar_rte(uint); -uchar __ovld __cnfn convert_uchar_sat_rte(uint); -uchar __ovld __cnfn convert_uchar_rtz(uint); -uchar __ovld __cnfn convert_uchar_sat_rtz(uint); -uchar __ovld __cnfn convert_uchar_rtp(uint); -uchar __ovld __cnfn convert_uchar_sat_rtp(uint); -uchar __ovld __cnfn convert_uchar_rtn(uint); -uchar __ovld __cnfn convert_uchar_sat_rtn(uint); -uchar __ovld __cnfn convert_uchar(uint); -uchar __ovld __cnfn convert_uchar_sat(uint); -uchar __ovld __cnfn convert_uchar_rte(long); -uchar __ovld __cnfn convert_uchar_sat_rte(long); -uchar __ovld __cnfn convert_uchar_rtz(long); -uchar __ovld __cnfn convert_uchar_sat_rtz(long); -uchar __ovld __cnfn convert_uchar_rtp(long); -uchar __ovld __cnfn convert_uchar_sat_rtp(long); -uchar __ovld __cnfn convert_uchar_rtn(long); -uchar __ovld __cnfn convert_uchar_sat_rtn(long); -uchar __ovld __cnfn convert_uchar(long); -uchar __ovld __cnfn convert_uchar_sat(long); -uchar __ovld __cnfn convert_uchar_rte(ulong); -uchar __ovld __cnfn convert_uchar_sat_rte(ulong); -uchar __ovld __cnfn convert_uchar_rtz(ulong); -uchar __ovld __cnfn convert_uchar_sat_rtz(ulong); -uchar __ovld __cnfn convert_uchar_rtp(ulong); -uchar __ovld __cnfn convert_uchar_sat_rtp(ulong); -uchar __ovld __cnfn convert_uchar_rtn(ulong); -uchar __ovld __cnfn convert_uchar_sat_rtn(ulong); -uchar __ovld __cnfn convert_uchar(ulong); -uchar __ovld __cnfn convert_uchar_sat(ulong); -uchar __ovld __cnfn convert_uchar_rte(float); -uchar __ovld __cnfn convert_uchar_sat_rte(float); -uchar __ovld __cnfn convert_uchar_rtz(float); -uchar __ovld __cnfn convert_uchar_sat_rtz(float); -uchar __ovld __cnfn convert_uchar_rtp(float); -uchar __ovld __cnfn convert_uchar_sat_rtp(float); -uchar __ovld __cnfn convert_uchar_rtn(float); -uchar __ovld __cnfn convert_uchar_sat_rtn(float); -uchar __ovld __cnfn convert_uchar(float); -uchar __ovld __cnfn convert_uchar_sat(float); - -short __ovld __cnfn convert_short_rte(char); -short __ovld __cnfn convert_short_sat_rte(char); -short __ovld __cnfn convert_short_rtz(char); -short __ovld __cnfn convert_short_sat_rtz(char); -short __ovld __cnfn convert_short_rtp(char); -short __ovld __cnfn convert_short_sat_rtp(char); -short __ovld __cnfn convert_short_rtn(char); -short __ovld __cnfn convert_short_sat_rtn(char); -short __ovld __cnfn convert_short(char); -short __ovld __cnfn convert_short_sat(char); -short __ovld __cnfn convert_short_rte(uchar); -short __ovld __cnfn convert_short_sat_rte(uchar); -short __ovld __cnfn convert_short_rtz(uchar); -short __ovld __cnfn convert_short_sat_rtz(uchar); -short __ovld __cnfn convert_short_rtp(uchar); -short __ovld __cnfn convert_short_sat_rtp(uchar); -short __ovld __cnfn convert_short_rtn(uchar); -short __ovld __cnfn convert_short_sat_rtn(uchar); -short __ovld __cnfn convert_short(uchar); -short __ovld __cnfn convert_short_sat(uchar); -short __ovld __cnfn convert_short_rte(short); -short __ovld __cnfn convert_short_sat_rte(short); -short __ovld __cnfn convert_short_rtz(short); -short __ovld __cnfn convert_short_sat_rtz(short); -short __ovld __cnfn convert_short_rtp(short); -short __ovld __cnfn convert_short_sat_rtp(short); -short __ovld __cnfn convert_short_rtn(short); -short __ovld __cnfn convert_short_sat_rtn(short); -short __ovld __cnfn convert_short(short); -short __ovld __cnfn convert_short_sat(short); -short __ovld __cnfn convert_short_rte(ushort); -short __ovld __cnfn convert_short_sat_rte(ushort); -short __ovld __cnfn convert_short_rtz(ushort); -short __ovld __cnfn convert_short_sat_rtz(ushort); -short __ovld __cnfn convert_short_rtp(ushort); -short __ovld __cnfn convert_short_sat_rtp(ushort); -short __ovld __cnfn convert_short_rtn(ushort); -short __ovld __cnfn convert_short_sat_rtn(ushort); -short __ovld __cnfn convert_short(ushort); -short __ovld __cnfn convert_short_sat(ushort); -short __ovld __cnfn convert_short_rte(int); -short __ovld __cnfn convert_short_sat_rte(int); -short __ovld __cnfn convert_short_rtz(int); -short __ovld __cnfn convert_short_sat_rtz(int); -short __ovld __cnfn convert_short_rtp(int); -short __ovld __cnfn convert_short_sat_rtp(int); -short __ovld __cnfn convert_short_rtn(int); -short __ovld __cnfn convert_short_sat_rtn(int); -short __ovld __cnfn convert_short(int); -short __ovld __cnfn convert_short_sat(int); -short __ovld __cnfn convert_short_rte(uint); -short __ovld __cnfn convert_short_sat_rte(uint); -short __ovld __cnfn convert_short_rtz(uint); -short __ovld __cnfn convert_short_sat_rtz(uint); -short __ovld __cnfn convert_short_rtp(uint); -short __ovld __cnfn convert_short_sat_rtp(uint); -short __ovld __cnfn convert_short_rtn(uint); -short __ovld __cnfn convert_short_sat_rtn(uint); -short __ovld __cnfn convert_short(uint); -short __ovld __cnfn convert_short_sat(uint); -short __ovld __cnfn convert_short_rte(long); -short __ovld __cnfn convert_short_sat_rte(long); -short __ovld __cnfn convert_short_rtz(long); -short __ovld __cnfn convert_short_sat_rtz(long); -short __ovld __cnfn convert_short_rtp(long); -short __ovld __cnfn convert_short_sat_rtp(long); -short __ovld __cnfn convert_short_rtn(long); -short __ovld __cnfn convert_short_sat_rtn(long); -short __ovld __cnfn convert_short(long); -short __ovld __cnfn convert_short_sat(long); -short __ovld __cnfn convert_short_rte(ulong); -short __ovld __cnfn convert_short_sat_rte(ulong); -short __ovld __cnfn convert_short_rtz(ulong); -short __ovld __cnfn convert_short_sat_rtz(ulong); -short __ovld __cnfn convert_short_rtp(ulong); -short __ovld __cnfn convert_short_sat_rtp(ulong); -short __ovld __cnfn convert_short_rtn(ulong); -short __ovld __cnfn convert_short_sat_rtn(ulong); -short __ovld __cnfn convert_short(ulong); -short __ovld __cnfn convert_short_sat(ulong); -short __ovld __cnfn convert_short_rte(float); -short __ovld __cnfn convert_short_sat_rte(float); -short __ovld __cnfn convert_short_rtz(float); -short __ovld __cnfn convert_short_sat_rtz(float); -short __ovld __cnfn convert_short_rtp(float); -short __ovld __cnfn convert_short_sat_rtp(float); -short __ovld __cnfn convert_short_rtn(float); -short __ovld __cnfn convert_short_sat_rtn(float); -short __ovld __cnfn convert_short(float); -short __ovld __cnfn convert_short_sat(float); -ushort __ovld __cnfn convert_ushort_rte(char); -ushort __ovld __cnfn convert_ushort_sat_rte(char); -ushort __ovld __cnfn convert_ushort_rtz(char); -ushort __ovld __cnfn convert_ushort_sat_rtz(char); -ushort __ovld __cnfn convert_ushort_rtp(char); -ushort __ovld __cnfn convert_ushort_sat_rtp(char); -ushort __ovld __cnfn convert_ushort_rtn(char); -ushort __ovld __cnfn convert_ushort_sat_rtn(char); -ushort __ovld __cnfn convert_ushort(char); -ushort __ovld __cnfn convert_ushort_sat(char); -ushort __ovld __cnfn convert_ushort_rte(uchar); -ushort __ovld __cnfn convert_ushort_sat_rte(uchar); -ushort __ovld __cnfn convert_ushort_rtz(uchar); -ushort __ovld __cnfn convert_ushort_sat_rtz(uchar); -ushort __ovld __cnfn convert_ushort_rtp(uchar); -ushort __ovld __cnfn convert_ushort_sat_rtp(uchar); -ushort __ovld __cnfn convert_ushort_rtn(uchar); -ushort __ovld __cnfn convert_ushort_sat_rtn(uchar); -ushort __ovld __cnfn convert_ushort(uchar); -ushort __ovld __cnfn convert_ushort_sat(uchar); -ushort __ovld __cnfn convert_ushort_rte(short); -ushort __ovld __cnfn convert_ushort_sat_rte(short); -ushort __ovld __cnfn convert_ushort_rtz(short); -ushort __ovld __cnfn convert_ushort_sat_rtz(short); -ushort __ovld __cnfn convert_ushort_rtp(short); -ushort __ovld __cnfn convert_ushort_sat_rtp(short); -ushort __ovld __cnfn convert_ushort_rtn(short); -ushort __ovld __cnfn convert_ushort_sat_rtn(short); -ushort __ovld __cnfn convert_ushort(short); -ushort __ovld __cnfn convert_ushort_sat(short); -ushort __ovld __cnfn convert_ushort_rte(ushort); -ushort __ovld __cnfn convert_ushort_sat_rte(ushort); -ushort __ovld __cnfn convert_ushort_rtz(ushort); -ushort __ovld __cnfn convert_ushort_sat_rtz(ushort); -ushort __ovld __cnfn convert_ushort_rtp(ushort); -ushort __ovld __cnfn convert_ushort_sat_rtp(ushort); -ushort __ovld __cnfn convert_ushort_rtn(ushort); -ushort __ovld __cnfn convert_ushort_sat_rtn(ushort); -ushort __ovld __cnfn convert_ushort(ushort); -ushort __ovld __cnfn convert_ushort_sat(ushort); -ushort __ovld __cnfn convert_ushort_rte(int); -ushort __ovld __cnfn convert_ushort_sat_rte(int); -ushort __ovld __cnfn convert_ushort_rtz(int); -ushort __ovld __cnfn convert_ushort_sat_rtz(int); -ushort __ovld __cnfn convert_ushort_rtp(int); -ushort __ovld __cnfn convert_ushort_sat_rtp(int); -ushort __ovld __cnfn convert_ushort_rtn(int); -ushort __ovld __cnfn convert_ushort_sat_rtn(int); -ushort __ovld __cnfn convert_ushort(int); -ushort __ovld __cnfn convert_ushort_sat(int); -ushort __ovld __cnfn convert_ushort_rte(uint); -ushort __ovld __cnfn convert_ushort_sat_rte(uint); -ushort __ovld __cnfn convert_ushort_rtz(uint); -ushort __ovld __cnfn convert_ushort_sat_rtz(uint); -ushort __ovld __cnfn convert_ushort_rtp(uint); -ushort __ovld __cnfn convert_ushort_sat_rtp(uint); -ushort __ovld __cnfn convert_ushort_rtn(uint); -ushort __ovld __cnfn convert_ushort_sat_rtn(uint); -ushort __ovld __cnfn convert_ushort(uint); -ushort __ovld __cnfn convert_ushort_sat(uint); -ushort __ovld __cnfn convert_ushort_rte(long); -ushort __ovld __cnfn convert_ushort_sat_rte(long); -ushort __ovld __cnfn convert_ushort_rtz(long); -ushort __ovld __cnfn convert_ushort_sat_rtz(long); -ushort __ovld __cnfn convert_ushort_rtp(long); -ushort __ovld __cnfn convert_ushort_sat_rtp(long); -ushort __ovld __cnfn convert_ushort_rtn(long); -ushort __ovld __cnfn convert_ushort_sat_rtn(long); -ushort __ovld __cnfn convert_ushort(long); -ushort __ovld __cnfn convert_ushort_sat(long); -ushort __ovld __cnfn convert_ushort_rte(ulong); -ushort __ovld __cnfn convert_ushort_sat_rte(ulong); -ushort __ovld __cnfn convert_ushort_rtz(ulong); -ushort __ovld __cnfn convert_ushort_sat_rtz(ulong); -ushort __ovld __cnfn convert_ushort_rtp(ulong); -ushort __ovld __cnfn convert_ushort_sat_rtp(ulong); -ushort __ovld __cnfn convert_ushort_rtn(ulong); -ushort __ovld __cnfn convert_ushort_sat_rtn(ulong); -ushort __ovld __cnfn convert_ushort(ulong); -ushort __ovld __cnfn convert_ushort_sat(ulong); -ushort __ovld __cnfn convert_ushort_rte(float); -ushort __ovld __cnfn convert_ushort_sat_rte(float); -ushort __ovld __cnfn convert_ushort_rtz(float); -ushort __ovld __cnfn convert_ushort_sat_rtz(float); -ushort __ovld __cnfn convert_ushort_rtp(float); -ushort __ovld __cnfn convert_ushort_sat_rtp(float); -ushort __ovld __cnfn convert_ushort_rtn(float); -ushort __ovld __cnfn convert_ushort_sat_rtn(float); -ushort __ovld __cnfn convert_ushort(float); -ushort __ovld __cnfn convert_ushort_sat(float); -int __ovld __cnfn convert_int_rte(char); -int __ovld __cnfn convert_int_sat_rte(char); -int __ovld __cnfn convert_int_rtz(char); -int __ovld __cnfn convert_int_sat_rtz(char); -int __ovld __cnfn convert_int_rtp(char); -int __ovld __cnfn convert_int_sat_rtp(char); -int __ovld __cnfn convert_int_rtn(char); -int __ovld __cnfn convert_int_sat_rtn(char); -int __ovld __cnfn convert_int(char); -int __ovld __cnfn convert_int_sat(char); -int __ovld __cnfn convert_int_rte(uchar); -int __ovld __cnfn convert_int_sat_rte(uchar); -int __ovld __cnfn convert_int_rtz(uchar); -int __ovld __cnfn convert_int_sat_rtz(uchar); -int __ovld __cnfn convert_int_rtp(uchar); -int __ovld __cnfn convert_int_sat_rtp(uchar); -int __ovld __cnfn convert_int_rtn(uchar); -int __ovld __cnfn convert_int_sat_rtn(uchar); -int __ovld __cnfn convert_int(uchar); -int __ovld __cnfn convert_int_sat(uchar); -int __ovld __cnfn convert_int_rte(short); -int __ovld __cnfn convert_int_sat_rte(short); -int __ovld __cnfn convert_int_rtz(short); -int __ovld __cnfn convert_int_sat_rtz(short); -int __ovld __cnfn convert_int_rtp(short); -int __ovld __cnfn convert_int_sat_rtp(short); -int __ovld __cnfn convert_int_rtn(short); -int __ovld __cnfn convert_int_sat_rtn(short); -int __ovld __cnfn convert_int(short); -int __ovld __cnfn convert_int_sat(short); -int __ovld __cnfn convert_int_rte(ushort); -int __ovld __cnfn convert_int_sat_rte(ushort); -int __ovld __cnfn convert_int_rtz(ushort); -int __ovld __cnfn convert_int_sat_rtz(ushort); -int __ovld __cnfn convert_int_rtp(ushort); -int __ovld __cnfn convert_int_sat_rtp(ushort); -int __ovld __cnfn convert_int_rtn(ushort); -int __ovld __cnfn convert_int_sat_rtn(ushort); -int __ovld __cnfn convert_int(ushort); -int __ovld __cnfn convert_int_sat(ushort); -int __ovld __cnfn convert_int_rte(int); -int __ovld __cnfn convert_int_sat_rte(int); -int __ovld __cnfn convert_int_rtz(int); -int __ovld __cnfn convert_int_sat_rtz(int); -int __ovld __cnfn convert_int_rtp(int); -int __ovld __cnfn convert_int_sat_rtp(int); -int __ovld __cnfn convert_int_rtn(int); -int __ovld __cnfn convert_int_sat_rtn(int); -int __ovld __cnfn convert_int(int); -int __ovld __cnfn convert_int_sat(int); -int __ovld __cnfn convert_int_rte(uint); -int __ovld __cnfn convert_int_sat_rte(uint); -int __ovld __cnfn convert_int_rtz(uint); -int __ovld __cnfn convert_int_sat_rtz(uint); -int __ovld __cnfn convert_int_rtp(uint); -int __ovld __cnfn convert_int_sat_rtp(uint); -int __ovld __cnfn convert_int_rtn(uint); -int __ovld __cnfn convert_int_sat_rtn(uint); -int __ovld __cnfn convert_int(uint); -int __ovld __cnfn convert_int_sat(uint); -int __ovld __cnfn convert_int_rte(long); -int __ovld __cnfn convert_int_sat_rte(long); -int __ovld __cnfn convert_int_rtz(long); -int __ovld __cnfn convert_int_sat_rtz(long); -int __ovld __cnfn convert_int_rtp(long); -int __ovld __cnfn convert_int_sat_rtp(long); -int __ovld __cnfn convert_int_rtn(long); -int __ovld __cnfn convert_int_sat_rtn(long); -int __ovld __cnfn convert_int(long); -int __ovld __cnfn convert_int_sat(long); -int __ovld __cnfn convert_int_rte(ulong); -int __ovld __cnfn convert_int_sat_rte(ulong); -int __ovld __cnfn convert_int_rtz(ulong); -int __ovld __cnfn convert_int_sat_rtz(ulong); -int __ovld __cnfn convert_int_rtp(ulong); -int __ovld __cnfn convert_int_sat_rtp(ulong); -int __ovld __cnfn convert_int_rtn(ulong); -int __ovld __cnfn convert_int_sat_rtn(ulong); -int __ovld __cnfn convert_int(ulong); -int __ovld __cnfn convert_int_sat(ulong); -int __ovld __cnfn convert_int_rte(float); -int __ovld __cnfn convert_int_sat_rte(float); -int __ovld __cnfn convert_int_rtz(float); -int __ovld __cnfn convert_int_sat_rtz(float); -int __ovld __cnfn convert_int_rtp(float); -int __ovld __cnfn convert_int_sat_rtp(float); -int __ovld __cnfn convert_int_rtn(float); -int __ovld __cnfn convert_int_sat_rtn(float); -int __ovld __cnfn convert_int(float); -int __ovld __cnfn convert_int_sat(float); -uint __ovld __cnfn convert_uint_rte(char); -uint __ovld __cnfn convert_uint_sat_rte(char); -uint __ovld __cnfn convert_uint_rtz(char); -uint __ovld __cnfn convert_uint_sat_rtz(char); -uint __ovld __cnfn convert_uint_rtp(char); -uint __ovld __cnfn convert_uint_sat_rtp(char); -uint __ovld __cnfn convert_uint_rtn(char); -uint __ovld __cnfn convert_uint_sat_rtn(char); -uint __ovld __cnfn convert_uint(char); -uint __ovld __cnfn convert_uint_sat(char); -uint __ovld __cnfn convert_uint_rte(uchar); -uint __ovld __cnfn convert_uint_sat_rte(uchar); -uint __ovld __cnfn convert_uint_rtz(uchar); -uint __ovld __cnfn convert_uint_sat_rtz(uchar); -uint __ovld __cnfn convert_uint_rtp(uchar); -uint __ovld __cnfn convert_uint_sat_rtp(uchar); -uint __ovld __cnfn convert_uint_rtn(uchar); -uint __ovld __cnfn convert_uint_sat_rtn(uchar); -uint __ovld __cnfn convert_uint(uchar); -uint __ovld __cnfn convert_uint_sat(uchar); -uint __ovld __cnfn convert_uint_rte(short); -uint __ovld __cnfn convert_uint_sat_rte(short); -uint __ovld __cnfn convert_uint_rtz(short); -uint __ovld __cnfn convert_uint_sat_rtz(short); -uint __ovld __cnfn convert_uint_rtp(short); -uint __ovld __cnfn convert_uint_sat_rtp(short); -uint __ovld __cnfn convert_uint_rtn(short); -uint __ovld __cnfn convert_uint_sat_rtn(short); -uint __ovld __cnfn convert_uint(short); -uint __ovld __cnfn convert_uint_sat(short); -uint __ovld __cnfn convert_uint_rte(ushort); -uint __ovld __cnfn convert_uint_sat_rte(ushort); -uint __ovld __cnfn convert_uint_rtz(ushort); -uint __ovld __cnfn convert_uint_sat_rtz(ushort); -uint __ovld __cnfn convert_uint_rtp(ushort); -uint __ovld __cnfn convert_uint_sat_rtp(ushort); -uint __ovld __cnfn convert_uint_rtn(ushort); -uint __ovld __cnfn convert_uint_sat_rtn(ushort); -uint __ovld __cnfn convert_uint(ushort); -uint __ovld __cnfn convert_uint_sat(ushort); -uint __ovld __cnfn convert_uint_rte(int); -uint __ovld __cnfn convert_uint_sat_rte(int); -uint __ovld __cnfn convert_uint_rtz(int); -uint __ovld __cnfn convert_uint_sat_rtz(int); -uint __ovld __cnfn convert_uint_rtp(int); -uint __ovld __cnfn convert_uint_sat_rtp(int); -uint __ovld __cnfn convert_uint_rtn(int); -uint __ovld __cnfn convert_uint_sat_rtn(int); -uint __ovld __cnfn convert_uint(int); -uint __ovld __cnfn convert_uint_sat(int); -uint __ovld __cnfn convert_uint_rte(uint); -uint __ovld __cnfn convert_uint_sat_rte(uint); -uint __ovld __cnfn convert_uint_rtz(uint); -uint __ovld __cnfn convert_uint_sat_rtz(uint); -uint __ovld __cnfn convert_uint_rtp(uint); -uint __ovld __cnfn convert_uint_sat_rtp(uint); -uint __ovld __cnfn convert_uint_rtn(uint); -uint __ovld __cnfn convert_uint_sat_rtn(uint); -uint __ovld __cnfn convert_uint(uint); -uint __ovld __cnfn convert_uint_sat(uint); -uint __ovld __cnfn convert_uint_rte(long); -uint __ovld __cnfn convert_uint_sat_rte(long); -uint __ovld __cnfn convert_uint_rtz(long); -uint __ovld __cnfn convert_uint_sat_rtz(long); -uint __ovld __cnfn convert_uint_rtp(long); -uint __ovld __cnfn convert_uint_sat_rtp(long); -uint __ovld __cnfn convert_uint_rtn(long); -uint __ovld __cnfn convert_uint_sat_rtn(long); -uint __ovld __cnfn convert_uint(long); -uint __ovld __cnfn convert_uint_sat(long); -uint __ovld __cnfn convert_uint_rte(ulong); -uint __ovld __cnfn convert_uint_sat_rte(ulong); -uint __ovld __cnfn convert_uint_rtz(ulong); -uint __ovld __cnfn convert_uint_sat_rtz(ulong); -uint __ovld __cnfn convert_uint_rtp(ulong); -uint __ovld __cnfn convert_uint_sat_rtp(ulong); -uint __ovld __cnfn convert_uint_rtn(ulong); -uint __ovld __cnfn convert_uint_sat_rtn(ulong); -uint __ovld __cnfn convert_uint(ulong); -uint __ovld __cnfn convert_uint_sat(ulong); -uint __ovld __cnfn convert_uint_rte(float); -uint __ovld __cnfn convert_uint_sat_rte(float); -uint __ovld __cnfn convert_uint_rtz(float); -uint __ovld __cnfn convert_uint_sat_rtz(float); -uint __ovld __cnfn convert_uint_rtp(float); -uint __ovld __cnfn convert_uint_sat_rtp(float); -uint __ovld __cnfn convert_uint_rtn(float); -uint __ovld __cnfn convert_uint_sat_rtn(float); -uint __ovld __cnfn convert_uint(float); -uint __ovld __cnfn convert_uint_sat(float); -long __ovld __cnfn convert_long_rte(char); -long __ovld __cnfn convert_long_sat_rte(char); -long __ovld __cnfn convert_long_rtz(char); -long __ovld __cnfn convert_long_sat_rtz(char); -long __ovld __cnfn convert_long_rtp(char); -long __ovld __cnfn convert_long_sat_rtp(char); -long __ovld __cnfn convert_long_rtn(char); -long __ovld __cnfn convert_long_sat_rtn(char); -long __ovld __cnfn convert_long(char); -long __ovld __cnfn convert_long_sat(char); -long __ovld __cnfn convert_long_rte(uchar); -long __ovld __cnfn convert_long_sat_rte(uchar); -long __ovld __cnfn convert_long_rtz(uchar); -long __ovld __cnfn convert_long_sat_rtz(uchar); -long __ovld __cnfn convert_long_rtp(uchar); -long __ovld __cnfn convert_long_sat_rtp(uchar); -long __ovld __cnfn convert_long_rtn(uchar); -long __ovld __cnfn convert_long_sat_rtn(uchar); -long __ovld __cnfn convert_long(uchar); -long __ovld __cnfn convert_long_sat(uchar); -long __ovld __cnfn convert_long_rte(short); -long __ovld __cnfn convert_long_sat_rte(short); -long __ovld __cnfn convert_long_rtz(short); -long __ovld __cnfn convert_long_sat_rtz(short); -long __ovld __cnfn convert_long_rtp(short); -long __ovld __cnfn convert_long_sat_rtp(short); -long __ovld __cnfn convert_long_rtn(short); -long __ovld __cnfn convert_long_sat_rtn(short); -long __ovld __cnfn convert_long(short); -long __ovld __cnfn convert_long_sat(short); -long __ovld __cnfn convert_long_rte(ushort); -long __ovld __cnfn convert_long_sat_rte(ushort); -long __ovld __cnfn convert_long_rtz(ushort); -long __ovld __cnfn convert_long_sat_rtz(ushort); -long __ovld __cnfn convert_long_rtp(ushort); -long __ovld __cnfn convert_long_sat_rtp(ushort); -long __ovld __cnfn convert_long_rtn(ushort); -long __ovld __cnfn convert_long_sat_rtn(ushort); -long __ovld __cnfn convert_long(ushort); -long __ovld __cnfn convert_long_sat(ushort); -long __ovld __cnfn convert_long_rte(int); -long __ovld __cnfn convert_long_sat_rte(int); -long __ovld __cnfn convert_long_rtz(int); -long __ovld __cnfn convert_long_sat_rtz(int); -long __ovld __cnfn convert_long_rtp(int); -long __ovld __cnfn convert_long_sat_rtp(int); -long __ovld __cnfn convert_long_rtn(int); -long __ovld __cnfn convert_long_sat_rtn(int); -long __ovld __cnfn convert_long(int); -long __ovld __cnfn convert_long_sat(int); -long __ovld __cnfn convert_long_rte(uint); -long __ovld __cnfn convert_long_sat_rte(uint); -long __ovld __cnfn convert_long_rtz(uint); -long __ovld __cnfn convert_long_sat_rtz(uint); -long __ovld __cnfn convert_long_rtp(uint); -long __ovld __cnfn convert_long_sat_rtp(uint); -long __ovld __cnfn convert_long_rtn(uint); -long __ovld __cnfn convert_long_sat_rtn(uint); -long __ovld __cnfn convert_long(uint); -long __ovld __cnfn convert_long_sat(uint); -long __ovld __cnfn convert_long_rte(long); -long __ovld __cnfn convert_long_sat_rte(long); -long __ovld __cnfn convert_long_rtz(long); -long __ovld __cnfn convert_long_sat_rtz(long); -long __ovld __cnfn convert_long_rtp(long); -long __ovld __cnfn convert_long_sat_rtp(long); -long __ovld __cnfn convert_long_rtn(long); -long __ovld __cnfn convert_long_sat_rtn(long); -long __ovld __cnfn convert_long(long); -long __ovld __cnfn convert_long_sat(long); -long __ovld __cnfn convert_long_rte(ulong); -long __ovld __cnfn convert_long_sat_rte(ulong); -long __ovld __cnfn convert_long_rtz(ulong); -long __ovld __cnfn convert_long_sat_rtz(ulong); -long __ovld __cnfn convert_long_rtp(ulong); -long __ovld __cnfn convert_long_sat_rtp(ulong); -long __ovld __cnfn convert_long_rtn(ulong); -long __ovld __cnfn convert_long_sat_rtn(ulong); -long __ovld __cnfn convert_long(ulong); -long __ovld __cnfn convert_long_sat(ulong); -long __ovld __cnfn convert_long_rte(float); -long __ovld __cnfn convert_long_sat_rte(float); -long __ovld __cnfn convert_long_rtz(float); -long __ovld __cnfn convert_long_sat_rtz(float); -long __ovld __cnfn convert_long_rtp(float); -long __ovld __cnfn convert_long_sat_rtp(float); -long __ovld __cnfn convert_long_rtn(float); -long __ovld __cnfn convert_long_sat_rtn(float); -long __ovld __cnfn convert_long(float); -long __ovld __cnfn convert_long_sat(float); -ulong __ovld __cnfn convert_ulong_rte(char); -ulong __ovld __cnfn convert_ulong_sat_rte(char); -ulong __ovld __cnfn convert_ulong_rtz(char); -ulong __ovld __cnfn convert_ulong_sat_rtz(char); -ulong __ovld __cnfn convert_ulong_rtp(char); -ulong __ovld __cnfn convert_ulong_sat_rtp(char); -ulong __ovld __cnfn convert_ulong_rtn(char); -ulong __ovld __cnfn convert_ulong_sat_rtn(char); -ulong __ovld __cnfn convert_ulong(char); -ulong __ovld __cnfn convert_ulong_sat(char); -ulong __ovld __cnfn convert_ulong_rte(uchar); -ulong __ovld __cnfn convert_ulong_sat_rte(uchar); -ulong __ovld __cnfn convert_ulong_rtz(uchar); -ulong __ovld __cnfn convert_ulong_sat_rtz(uchar); -ulong __ovld __cnfn convert_ulong_rtp(uchar); -ulong __ovld __cnfn convert_ulong_sat_rtp(uchar); -ulong __ovld __cnfn convert_ulong_rtn(uchar); -ulong __ovld __cnfn convert_ulong_sat_rtn(uchar); -ulong __ovld __cnfn convert_ulong(uchar); -ulong __ovld __cnfn convert_ulong_sat(uchar); -ulong __ovld __cnfn convert_ulong_rte(short); -ulong __ovld __cnfn convert_ulong_sat_rte(short); -ulong __ovld __cnfn convert_ulong_rtz(short); -ulong __ovld __cnfn convert_ulong_sat_rtz(short); -ulong __ovld __cnfn convert_ulong_rtp(short); -ulong __ovld __cnfn convert_ulong_sat_rtp(short); -ulong __ovld __cnfn convert_ulong_rtn(short); -ulong __ovld __cnfn convert_ulong_sat_rtn(short); -ulong __ovld __cnfn convert_ulong(short); -ulong __ovld __cnfn convert_ulong_sat(short); -ulong __ovld __cnfn convert_ulong_rte(ushort); -ulong __ovld __cnfn convert_ulong_sat_rte(ushort); -ulong __ovld __cnfn convert_ulong_rtz(ushort); -ulong __ovld __cnfn convert_ulong_sat_rtz(ushort); -ulong __ovld __cnfn convert_ulong_rtp(ushort); -ulong __ovld __cnfn convert_ulong_sat_rtp(ushort); -ulong __ovld __cnfn convert_ulong_rtn(ushort); -ulong __ovld __cnfn convert_ulong_sat_rtn(ushort); -ulong __ovld __cnfn convert_ulong(ushort); -ulong __ovld __cnfn convert_ulong_sat(ushort); -ulong __ovld __cnfn convert_ulong_rte(int); -ulong __ovld __cnfn convert_ulong_sat_rte(int); -ulong __ovld __cnfn convert_ulong_rtz(int); -ulong __ovld __cnfn convert_ulong_sat_rtz(int); -ulong __ovld __cnfn convert_ulong_rtp(int); -ulong __ovld __cnfn convert_ulong_sat_rtp(int); -ulong __ovld __cnfn convert_ulong_rtn(int); -ulong __ovld __cnfn convert_ulong_sat_rtn(int); -ulong __ovld __cnfn convert_ulong(int); -ulong __ovld __cnfn convert_ulong_sat(int); -ulong __ovld __cnfn convert_ulong_rte(uint); -ulong __ovld __cnfn convert_ulong_sat_rte(uint); -ulong __ovld __cnfn convert_ulong_rtz(uint); -ulong __ovld __cnfn convert_ulong_sat_rtz(uint); -ulong __ovld __cnfn convert_ulong_rtp(uint); -ulong __ovld __cnfn convert_ulong_sat_rtp(uint); -ulong __ovld __cnfn convert_ulong_rtn(uint); -ulong __ovld __cnfn convert_ulong_sat_rtn(uint); -ulong __ovld __cnfn convert_ulong(uint); -ulong __ovld __cnfn convert_ulong_sat(uint); -ulong __ovld __cnfn convert_ulong_rte(long); -ulong __ovld __cnfn convert_ulong_sat_rte(long); -ulong __ovld __cnfn convert_ulong_rtz(long); -ulong __ovld __cnfn convert_ulong_sat_rtz(long); -ulong __ovld __cnfn convert_ulong_rtp(long); -ulong __ovld __cnfn convert_ulong_sat_rtp(long); -ulong __ovld __cnfn convert_ulong_rtn(long); -ulong __ovld __cnfn convert_ulong_sat_rtn(long); -ulong __ovld __cnfn convert_ulong(long); -ulong __ovld __cnfn convert_ulong_sat(long); -ulong __ovld __cnfn convert_ulong_rte(ulong); -ulong __ovld __cnfn convert_ulong_sat_rte(ulong); -ulong __ovld __cnfn convert_ulong_rtz(ulong); -ulong __ovld __cnfn convert_ulong_sat_rtz(ulong); -ulong __ovld __cnfn convert_ulong_rtp(ulong); -ulong __ovld __cnfn convert_ulong_sat_rtp(ulong); -ulong __ovld __cnfn convert_ulong_rtn(ulong); -ulong __ovld __cnfn convert_ulong_sat_rtn(ulong); -ulong __ovld __cnfn convert_ulong(ulong); -ulong __ovld __cnfn convert_ulong_sat(ulong); -ulong __ovld __cnfn convert_ulong_rte(float); -ulong __ovld __cnfn convert_ulong_sat_rte(float); -ulong __ovld __cnfn convert_ulong_rtz(float); -ulong __ovld __cnfn convert_ulong_sat_rtz(float); -ulong __ovld __cnfn convert_ulong_rtp(float); -ulong __ovld __cnfn convert_ulong_sat_rtp(float); -ulong __ovld __cnfn convert_ulong_rtn(float); -ulong __ovld __cnfn convert_ulong_sat_rtn(float); -ulong __ovld __cnfn convert_ulong(float); -ulong __ovld __cnfn convert_ulong_sat(float); -float __ovld __cnfn convert_float_rte(char); -float __ovld __cnfn convert_float_rtz(char); -float __ovld __cnfn convert_float_rtp(char); -float __ovld __cnfn convert_float_rtn(char); -float __ovld __cnfn convert_float(char); -float __ovld __cnfn convert_float_rte(uchar); -float __ovld __cnfn convert_float_rtz(uchar); -float __ovld __cnfn convert_float_rtp(uchar); -float __ovld __cnfn convert_float_rtn(uchar); -float __ovld __cnfn convert_float(uchar); -float __ovld __cnfn convert_float_rte(short); -float __ovld __cnfn convert_float_rtz(short); -float __ovld __cnfn convert_float_rtp(short); -float __ovld __cnfn convert_float_rtn(short); -float __ovld __cnfn convert_float(short); -float __ovld __cnfn convert_float_rte(ushort); -float __ovld __cnfn convert_float_rtz(ushort); -float __ovld __cnfn convert_float_rtp(ushort); -float __ovld __cnfn convert_float_rtn(ushort); -float __ovld __cnfn convert_float(ushort); -float __ovld __cnfn convert_float_rte(int); -float __ovld __cnfn convert_float_rtz(int); -float __ovld __cnfn convert_float_rtp(int); -float __ovld __cnfn convert_float_rtn(int); -float __ovld __cnfn convert_float(int); -float __ovld __cnfn convert_float_rte(uint); -float __ovld __cnfn convert_float_rtz(uint); -float __ovld __cnfn convert_float_rtp(uint); -float __ovld __cnfn convert_float_rtn(uint); -float __ovld __cnfn convert_float(uint); -float __ovld __cnfn convert_float_rte(long); -float __ovld __cnfn convert_float_rtz(long); -float __ovld __cnfn convert_float_rtp(long); -float __ovld __cnfn convert_float_rtn(long); -float __ovld __cnfn convert_float(long); -float __ovld __cnfn convert_float_rte(ulong); -float __ovld __cnfn convert_float_rtz(ulong); -float __ovld __cnfn convert_float_rtp(ulong); -float __ovld __cnfn convert_float_rtn(ulong); -float __ovld __cnfn convert_float(ulong); -float __ovld __cnfn convert_float_rte(float); -float __ovld __cnfn convert_float_rtz(float); -float __ovld __cnfn convert_float_rtp(float); -float __ovld __cnfn convert_float_rtn(float); -float __ovld __cnfn convert_float(float); -char2 __ovld __cnfn convert_char2_rte(char2); -char2 __ovld __cnfn convert_char2_sat_rte(char2); -char2 __ovld __cnfn convert_char2_rtz(char2); -char2 __ovld __cnfn convert_char2_sat_rtz(char2); -char2 __ovld __cnfn convert_char2_rtp(char2); -char2 __ovld __cnfn convert_char2_sat_rtp(char2); -char2 __ovld __cnfn convert_char2_rtn(char2); -char2 __ovld __cnfn convert_char2_sat_rtn(char2); -char2 __ovld __cnfn convert_char2(char2); -char2 __ovld __cnfn convert_char2_sat(char2); -char2 __ovld __cnfn convert_char2_rte(uchar2); -char2 __ovld __cnfn convert_char2_sat_rte(uchar2); -char2 __ovld __cnfn convert_char2_rtz(uchar2); -char2 __ovld __cnfn convert_char2_sat_rtz(uchar2); -char2 __ovld __cnfn convert_char2_rtp(uchar2); -char2 __ovld __cnfn convert_char2_sat_rtp(uchar2); -char2 __ovld __cnfn convert_char2_rtn(uchar2); -char2 __ovld __cnfn convert_char2_sat_rtn(uchar2); -char2 __ovld __cnfn convert_char2(uchar2); -char2 __ovld __cnfn convert_char2_sat(uchar2); -char2 __ovld __cnfn convert_char2_rte(short2); -char2 __ovld __cnfn convert_char2_sat_rte(short2); -char2 __ovld __cnfn convert_char2_rtz(short2); -char2 __ovld __cnfn convert_char2_sat_rtz(short2); -char2 __ovld __cnfn convert_char2_rtp(short2); -char2 __ovld __cnfn convert_char2_sat_rtp(short2); -char2 __ovld __cnfn convert_char2_rtn(short2); -char2 __ovld __cnfn convert_char2_sat_rtn(short2); -char2 __ovld __cnfn convert_char2(short2); -char2 __ovld __cnfn convert_char2_sat(short2); -char2 __ovld __cnfn convert_char2_rte(ushort2); -char2 __ovld __cnfn convert_char2_sat_rte(ushort2); -char2 __ovld __cnfn convert_char2_rtz(ushort2); -char2 __ovld __cnfn convert_char2_sat_rtz(ushort2); -char2 __ovld __cnfn convert_char2_rtp(ushort2); -char2 __ovld __cnfn convert_char2_sat_rtp(ushort2); -char2 __ovld __cnfn convert_char2_rtn(ushort2); -char2 __ovld __cnfn convert_char2_sat_rtn(ushort2); -char2 __ovld __cnfn convert_char2(ushort2); -char2 __ovld __cnfn convert_char2_sat(ushort2); -char2 __ovld __cnfn convert_char2_rte(int2); -char2 __ovld __cnfn convert_char2_sat_rte(int2); -char2 __ovld __cnfn convert_char2_rtz(int2); -char2 __ovld __cnfn convert_char2_sat_rtz(int2); -char2 __ovld __cnfn convert_char2_rtp(int2); -char2 __ovld __cnfn convert_char2_sat_rtp(int2); -char2 __ovld __cnfn convert_char2_rtn(int2); -char2 __ovld __cnfn convert_char2_sat_rtn(int2); -char2 __ovld __cnfn convert_char2(int2); -char2 __ovld __cnfn convert_char2_sat(int2); -char2 __ovld __cnfn convert_char2_rte(uint2); -char2 __ovld __cnfn convert_char2_sat_rte(uint2); -char2 __ovld __cnfn convert_char2_rtz(uint2); -char2 __ovld __cnfn convert_char2_sat_rtz(uint2); -char2 __ovld __cnfn convert_char2_rtp(uint2); -char2 __ovld __cnfn convert_char2_sat_rtp(uint2); -char2 __ovld __cnfn convert_char2_rtn(uint2); -char2 __ovld __cnfn convert_char2_sat_rtn(uint2); -char2 __ovld __cnfn convert_char2(uint2); -char2 __ovld __cnfn convert_char2_sat(uint2); -char2 __ovld __cnfn convert_char2_rte(long2); -char2 __ovld __cnfn convert_char2_sat_rte(long2); -char2 __ovld __cnfn convert_char2_rtz(long2); -char2 __ovld __cnfn convert_char2_sat_rtz(long2); -char2 __ovld __cnfn convert_char2_rtp(long2); -char2 __ovld __cnfn convert_char2_sat_rtp(long2); -char2 __ovld __cnfn convert_char2_rtn(long2); -char2 __ovld __cnfn convert_char2_sat_rtn(long2); -char2 __ovld __cnfn convert_char2(long2); -char2 __ovld __cnfn convert_char2_sat(long2); -char2 __ovld __cnfn convert_char2_rte(ulong2); -char2 __ovld __cnfn convert_char2_sat_rte(ulong2); -char2 __ovld __cnfn convert_char2_rtz(ulong2); -char2 __ovld __cnfn convert_char2_sat_rtz(ulong2); -char2 __ovld __cnfn convert_char2_rtp(ulong2); -char2 __ovld __cnfn convert_char2_sat_rtp(ulong2); -char2 __ovld __cnfn convert_char2_rtn(ulong2); -char2 __ovld __cnfn convert_char2_sat_rtn(ulong2); -char2 __ovld __cnfn convert_char2(ulong2); -char2 __ovld __cnfn convert_char2_sat(ulong2); -char2 __ovld __cnfn convert_char2_rte(float2); -char2 __ovld __cnfn convert_char2_sat_rte(float2); -char2 __ovld __cnfn convert_char2_rtz(float2); -char2 __ovld __cnfn convert_char2_sat_rtz(float2); -char2 __ovld __cnfn convert_char2_rtp(float2); -char2 __ovld __cnfn convert_char2_sat_rtp(float2); -char2 __ovld __cnfn convert_char2_rtn(float2); -char2 __ovld __cnfn convert_char2_sat_rtn(float2); -char2 __ovld __cnfn convert_char2(float2); -char2 __ovld __cnfn convert_char2_sat(float2); -uchar2 __ovld __cnfn convert_uchar2_rte(char2); -uchar2 __ovld __cnfn convert_uchar2_sat_rte(char2); -uchar2 __ovld __cnfn convert_uchar2_rtz(char2); -uchar2 __ovld __cnfn convert_uchar2_sat_rtz(char2); -uchar2 __ovld __cnfn convert_uchar2_rtp(char2); -uchar2 __ovld __cnfn convert_uchar2_sat_rtp(char2); -uchar2 __ovld __cnfn convert_uchar2_rtn(char2); -uchar2 __ovld __cnfn convert_uchar2_sat_rtn(char2); -uchar2 __ovld __cnfn convert_uchar2(char2); -uchar2 __ovld __cnfn convert_uchar2_sat(char2); -uchar2 __ovld __cnfn convert_uchar2_rte(uchar2); -uchar2 __ovld __cnfn convert_uchar2_sat_rte(uchar2); -uchar2 __ovld __cnfn convert_uchar2_rtz(uchar2); -uchar2 __ovld __cnfn convert_uchar2_sat_rtz(uchar2); -uchar2 __ovld __cnfn convert_uchar2_rtp(uchar2); -uchar2 __ovld __cnfn convert_uchar2_sat_rtp(uchar2); -uchar2 __ovld __cnfn convert_uchar2_rtn(uchar2); -uchar2 __ovld __cnfn convert_uchar2_sat_rtn(uchar2); -uchar2 __ovld __cnfn convert_uchar2(uchar2); -uchar2 __ovld __cnfn convert_uchar2_sat(uchar2); -uchar2 __ovld __cnfn convert_uchar2_rte(short2); -uchar2 __ovld __cnfn convert_uchar2_sat_rte(short2); -uchar2 __ovld __cnfn convert_uchar2_rtz(short2); -uchar2 __ovld __cnfn convert_uchar2_sat_rtz(short2); -uchar2 __ovld __cnfn convert_uchar2_rtp(short2); -uchar2 __ovld __cnfn convert_uchar2_sat_rtp(short2); -uchar2 __ovld __cnfn convert_uchar2_rtn(short2); -uchar2 __ovld __cnfn convert_uchar2_sat_rtn(short2); -uchar2 __ovld __cnfn convert_uchar2(short2); -uchar2 __ovld __cnfn convert_uchar2_sat(short2); -uchar2 __ovld __cnfn convert_uchar2_rte(ushort2); -uchar2 __ovld __cnfn convert_uchar2_sat_rte(ushort2); -uchar2 __ovld __cnfn convert_uchar2_rtz(ushort2); -uchar2 __ovld __cnfn convert_uchar2_sat_rtz(ushort2); -uchar2 __ovld __cnfn convert_uchar2_rtp(ushort2); -uchar2 __ovld __cnfn convert_uchar2_sat_rtp(ushort2); -uchar2 __ovld __cnfn convert_uchar2_rtn(ushort2); -uchar2 __ovld __cnfn convert_uchar2_sat_rtn(ushort2); -uchar2 __ovld __cnfn convert_uchar2(ushort2); -uchar2 __ovld __cnfn convert_uchar2_sat(ushort2); -uchar2 __ovld __cnfn convert_uchar2_rte(int2); -uchar2 __ovld __cnfn convert_uchar2_sat_rte(int2); -uchar2 __ovld __cnfn convert_uchar2_rtz(int2); -uchar2 __ovld __cnfn convert_uchar2_sat_rtz(int2); -uchar2 __ovld __cnfn convert_uchar2_rtp(int2); -uchar2 __ovld __cnfn convert_uchar2_sat_rtp(int2); -uchar2 __ovld __cnfn convert_uchar2_rtn(int2); -uchar2 __ovld __cnfn convert_uchar2_sat_rtn(int2); -uchar2 __ovld __cnfn convert_uchar2(int2); -uchar2 __ovld __cnfn convert_uchar2_sat(int2); -uchar2 __ovld __cnfn convert_uchar2_rte(uint2); -uchar2 __ovld __cnfn convert_uchar2_sat_rte(uint2); -uchar2 __ovld __cnfn convert_uchar2_rtz(uint2); -uchar2 __ovld __cnfn convert_uchar2_sat_rtz(uint2); -uchar2 __ovld __cnfn convert_uchar2_rtp(uint2); -uchar2 __ovld __cnfn convert_uchar2_sat_rtp(uint2); -uchar2 __ovld __cnfn convert_uchar2_rtn(uint2); -uchar2 __ovld __cnfn convert_uchar2_sat_rtn(uint2); -uchar2 __ovld __cnfn convert_uchar2(uint2); -uchar2 __ovld __cnfn convert_uchar2_sat(uint2); -uchar2 __ovld __cnfn convert_uchar2_rte(long2); -uchar2 __ovld __cnfn convert_uchar2_sat_rte(long2); -uchar2 __ovld __cnfn convert_uchar2_rtz(long2); -uchar2 __ovld __cnfn convert_uchar2_sat_rtz(long2); -uchar2 __ovld __cnfn convert_uchar2_rtp(long2); -uchar2 __ovld __cnfn convert_uchar2_sat_rtp(long2); -uchar2 __ovld __cnfn convert_uchar2_rtn(long2); -uchar2 __ovld __cnfn convert_uchar2_sat_rtn(long2); -uchar2 __ovld __cnfn convert_uchar2(long2); -uchar2 __ovld __cnfn convert_uchar2_sat(long2); -uchar2 __ovld __cnfn convert_uchar2_rte(ulong2); -uchar2 __ovld __cnfn convert_uchar2_sat_rte(ulong2); -uchar2 __ovld __cnfn convert_uchar2_rtz(ulong2); -uchar2 __ovld __cnfn convert_uchar2_sat_rtz(ulong2); -uchar2 __ovld __cnfn convert_uchar2_rtp(ulong2); -uchar2 __ovld __cnfn convert_uchar2_sat_rtp(ulong2); -uchar2 __ovld __cnfn convert_uchar2_rtn(ulong2); -uchar2 __ovld __cnfn convert_uchar2_sat_rtn(ulong2); -uchar2 __ovld __cnfn convert_uchar2(ulong2); -uchar2 __ovld __cnfn convert_uchar2_sat(ulong2); -uchar2 __ovld __cnfn convert_uchar2_rte(float2); -uchar2 __ovld __cnfn convert_uchar2_sat_rte(float2); -uchar2 __ovld __cnfn convert_uchar2_rtz(float2); -uchar2 __ovld __cnfn convert_uchar2_sat_rtz(float2); -uchar2 __ovld __cnfn convert_uchar2_rtp(float2); -uchar2 __ovld __cnfn convert_uchar2_sat_rtp(float2); -uchar2 __ovld __cnfn convert_uchar2_rtn(float2); -uchar2 __ovld __cnfn convert_uchar2_sat_rtn(float2); -uchar2 __ovld __cnfn convert_uchar2(float2); -uchar2 __ovld __cnfn convert_uchar2_sat(float2); -short2 __ovld __cnfn convert_short2_rte(char2); -short2 __ovld __cnfn convert_short2_sat_rte(char2); -short2 __ovld __cnfn convert_short2_rtz(char2); -short2 __ovld __cnfn convert_short2_sat_rtz(char2); -short2 __ovld __cnfn convert_short2_rtp(char2); -short2 __ovld __cnfn convert_short2_sat_rtp(char2); -short2 __ovld __cnfn convert_short2_rtn(char2); -short2 __ovld __cnfn convert_short2_sat_rtn(char2); -short2 __ovld __cnfn convert_short2(char2); -short2 __ovld __cnfn convert_short2_sat(char2); -short2 __ovld __cnfn convert_short2_rte(uchar2); -short2 __ovld __cnfn convert_short2_sat_rte(uchar2); -short2 __ovld __cnfn convert_short2_rtz(uchar2); -short2 __ovld __cnfn convert_short2_sat_rtz(uchar2); -short2 __ovld __cnfn convert_short2_rtp(uchar2); -short2 __ovld __cnfn convert_short2_sat_rtp(uchar2); -short2 __ovld __cnfn convert_short2_rtn(uchar2); -short2 __ovld __cnfn convert_short2_sat_rtn(uchar2); -short2 __ovld __cnfn convert_short2(uchar2); -short2 __ovld __cnfn convert_short2_sat(uchar2); -short2 __ovld __cnfn convert_short2_rte(short2); -short2 __ovld __cnfn convert_short2_sat_rte(short2); -short2 __ovld __cnfn convert_short2_rtz(short2); -short2 __ovld __cnfn convert_short2_sat_rtz(short2); -short2 __ovld __cnfn convert_short2_rtp(short2); -short2 __ovld __cnfn convert_short2_sat_rtp(short2); -short2 __ovld __cnfn convert_short2_rtn(short2); -short2 __ovld __cnfn convert_short2_sat_rtn(short2); -short2 __ovld __cnfn convert_short2(short2); -short2 __ovld __cnfn convert_short2_sat(short2); -short2 __ovld __cnfn convert_short2_rte(ushort2); -short2 __ovld __cnfn convert_short2_sat_rte(ushort2); -short2 __ovld __cnfn convert_short2_rtz(ushort2); -short2 __ovld __cnfn convert_short2_sat_rtz(ushort2); -short2 __ovld __cnfn convert_short2_rtp(ushort2); -short2 __ovld __cnfn convert_short2_sat_rtp(ushort2); -short2 __ovld __cnfn convert_short2_rtn(ushort2); -short2 __ovld __cnfn convert_short2_sat_rtn(ushort2); -short2 __ovld __cnfn convert_short2(ushort2); -short2 __ovld __cnfn convert_short2_sat(ushort2); -short2 __ovld __cnfn convert_short2_rte(int2); -short2 __ovld __cnfn convert_short2_sat_rte(int2); -short2 __ovld __cnfn convert_short2_rtz(int2); -short2 __ovld __cnfn convert_short2_sat_rtz(int2); -short2 __ovld __cnfn convert_short2_rtp(int2); -short2 __ovld __cnfn convert_short2_sat_rtp(int2); -short2 __ovld __cnfn convert_short2_rtn(int2); -short2 __ovld __cnfn convert_short2_sat_rtn(int2); -short2 __ovld __cnfn convert_short2(int2); -short2 __ovld __cnfn convert_short2_sat(int2); -short2 __ovld __cnfn convert_short2_rte(uint2); -short2 __ovld __cnfn convert_short2_sat_rte(uint2); -short2 __ovld __cnfn convert_short2_rtz(uint2); -short2 __ovld __cnfn convert_short2_sat_rtz(uint2); -short2 __ovld __cnfn convert_short2_rtp(uint2); -short2 __ovld __cnfn convert_short2_sat_rtp(uint2); -short2 __ovld __cnfn convert_short2_rtn(uint2); -short2 __ovld __cnfn convert_short2_sat_rtn(uint2); -short2 __ovld __cnfn convert_short2(uint2); -short2 __ovld __cnfn convert_short2_sat(uint2); -short2 __ovld __cnfn convert_short2_rte(long2); -short2 __ovld __cnfn convert_short2_sat_rte(long2); -short2 __ovld __cnfn convert_short2_rtz(long2); -short2 __ovld __cnfn convert_short2_sat_rtz(long2); -short2 __ovld __cnfn convert_short2_rtp(long2); -short2 __ovld __cnfn convert_short2_sat_rtp(long2); -short2 __ovld __cnfn convert_short2_rtn(long2); -short2 __ovld __cnfn convert_short2_sat_rtn(long2); -short2 __ovld __cnfn convert_short2(long2); -short2 __ovld __cnfn convert_short2_sat(long2); -short2 __ovld __cnfn convert_short2_rte(ulong2); -short2 __ovld __cnfn convert_short2_sat_rte(ulong2); -short2 __ovld __cnfn convert_short2_rtz(ulong2); -short2 __ovld __cnfn convert_short2_sat_rtz(ulong2); -short2 __ovld __cnfn convert_short2_rtp(ulong2); -short2 __ovld __cnfn convert_short2_sat_rtp(ulong2); -short2 __ovld __cnfn convert_short2_rtn(ulong2); -short2 __ovld __cnfn convert_short2_sat_rtn(ulong2); -short2 __ovld __cnfn convert_short2(ulong2); -short2 __ovld __cnfn convert_short2_sat(ulong2); -short2 __ovld __cnfn convert_short2_rte(float2); -short2 __ovld __cnfn convert_short2_sat_rte(float2); -short2 __ovld __cnfn convert_short2_rtz(float2); -short2 __ovld __cnfn convert_short2_sat_rtz(float2); -short2 __ovld __cnfn convert_short2_rtp(float2); -short2 __ovld __cnfn convert_short2_sat_rtp(float2); -short2 __ovld __cnfn convert_short2_rtn(float2); -short2 __ovld __cnfn convert_short2_sat_rtn(float2); -short2 __ovld __cnfn convert_short2(float2); -short2 __ovld __cnfn convert_short2_sat(float2); -ushort2 __ovld __cnfn convert_ushort2_rte(char2); -ushort2 __ovld __cnfn convert_ushort2_sat_rte(char2); -ushort2 __ovld __cnfn convert_ushort2_rtz(char2); -ushort2 __ovld __cnfn convert_ushort2_sat_rtz(char2); -ushort2 __ovld __cnfn convert_ushort2_rtp(char2); -ushort2 __ovld __cnfn convert_ushort2_sat_rtp(char2); -ushort2 __ovld __cnfn convert_ushort2_rtn(char2); -ushort2 __ovld __cnfn convert_ushort2_sat_rtn(char2); -ushort2 __ovld __cnfn convert_ushort2(char2); -ushort2 __ovld __cnfn convert_ushort2_sat(char2); -ushort2 __ovld __cnfn convert_ushort2_rte(uchar2); -ushort2 __ovld __cnfn convert_ushort2_sat_rte(uchar2); -ushort2 __ovld __cnfn convert_ushort2_rtz(uchar2); -ushort2 __ovld __cnfn convert_ushort2_sat_rtz(uchar2); -ushort2 __ovld __cnfn convert_ushort2_rtp(uchar2); -ushort2 __ovld __cnfn convert_ushort2_sat_rtp(uchar2); -ushort2 __ovld __cnfn convert_ushort2_rtn(uchar2); -ushort2 __ovld __cnfn convert_ushort2_sat_rtn(uchar2); -ushort2 __ovld __cnfn convert_ushort2(uchar2); -ushort2 __ovld __cnfn convert_ushort2_sat(uchar2); -ushort2 __ovld __cnfn convert_ushort2_rte(short2); -ushort2 __ovld __cnfn convert_ushort2_sat_rte(short2); -ushort2 __ovld __cnfn convert_ushort2_rtz(short2); -ushort2 __ovld __cnfn convert_ushort2_sat_rtz(short2); -ushort2 __ovld __cnfn convert_ushort2_rtp(short2); -ushort2 __ovld __cnfn convert_ushort2_sat_rtp(short2); -ushort2 __ovld __cnfn convert_ushort2_rtn(short2); -ushort2 __ovld __cnfn convert_ushort2_sat_rtn(short2); -ushort2 __ovld __cnfn convert_ushort2(short2); -ushort2 __ovld __cnfn convert_ushort2_sat(short2); -ushort2 __ovld __cnfn convert_ushort2_rte(ushort2); -ushort2 __ovld __cnfn convert_ushort2_sat_rte(ushort2); -ushort2 __ovld __cnfn convert_ushort2_rtz(ushort2); -ushort2 __ovld __cnfn convert_ushort2_sat_rtz(ushort2); -ushort2 __ovld __cnfn convert_ushort2_rtp(ushort2); -ushort2 __ovld __cnfn convert_ushort2_sat_rtp(ushort2); -ushort2 __ovld __cnfn convert_ushort2_rtn(ushort2); -ushort2 __ovld __cnfn convert_ushort2_sat_rtn(ushort2); -ushort2 __ovld __cnfn convert_ushort2(ushort2); -ushort2 __ovld __cnfn convert_ushort2_sat(ushort2); -ushort2 __ovld __cnfn convert_ushort2_rte(int2); -ushort2 __ovld __cnfn convert_ushort2_sat_rte(int2); -ushort2 __ovld __cnfn convert_ushort2_rtz(int2); -ushort2 __ovld __cnfn convert_ushort2_sat_rtz(int2); -ushort2 __ovld __cnfn convert_ushort2_rtp(int2); -ushort2 __ovld __cnfn convert_ushort2_sat_rtp(int2); -ushort2 __ovld __cnfn convert_ushort2_rtn(int2); -ushort2 __ovld __cnfn convert_ushort2_sat_rtn(int2); -ushort2 __ovld __cnfn convert_ushort2(int2); -ushort2 __ovld __cnfn convert_ushort2_sat(int2); -ushort2 __ovld __cnfn convert_ushort2_rte(uint2); -ushort2 __ovld __cnfn convert_ushort2_sat_rte(uint2); -ushort2 __ovld __cnfn convert_ushort2_rtz(uint2); -ushort2 __ovld __cnfn convert_ushort2_sat_rtz(uint2); -ushort2 __ovld __cnfn convert_ushort2_rtp(uint2); -ushort2 __ovld __cnfn convert_ushort2_sat_rtp(uint2); -ushort2 __ovld __cnfn convert_ushort2_rtn(uint2); -ushort2 __ovld __cnfn convert_ushort2_sat_rtn(uint2); -ushort2 __ovld __cnfn convert_ushort2(uint2); -ushort2 __ovld __cnfn convert_ushort2_sat(uint2); -ushort2 __ovld __cnfn convert_ushort2_rte(long2); -ushort2 __ovld __cnfn convert_ushort2_sat_rte(long2); -ushort2 __ovld __cnfn convert_ushort2_rtz(long2); -ushort2 __ovld __cnfn convert_ushort2_sat_rtz(long2); -ushort2 __ovld __cnfn convert_ushort2_rtp(long2); -ushort2 __ovld __cnfn convert_ushort2_sat_rtp(long2); -ushort2 __ovld __cnfn convert_ushort2_rtn(long2); -ushort2 __ovld __cnfn convert_ushort2_sat_rtn(long2); -ushort2 __ovld __cnfn convert_ushort2(long2); -ushort2 __ovld __cnfn convert_ushort2_sat(long2); -ushort2 __ovld __cnfn convert_ushort2_rte(ulong2); -ushort2 __ovld __cnfn convert_ushort2_sat_rte(ulong2); -ushort2 __ovld __cnfn convert_ushort2_rtz(ulong2); -ushort2 __ovld __cnfn convert_ushort2_sat_rtz(ulong2); -ushort2 __ovld __cnfn convert_ushort2_rtp(ulong2); -ushort2 __ovld __cnfn convert_ushort2_sat_rtp(ulong2); -ushort2 __ovld __cnfn convert_ushort2_rtn(ulong2); -ushort2 __ovld __cnfn convert_ushort2_sat_rtn(ulong2); -ushort2 __ovld __cnfn convert_ushort2(ulong2); -ushort2 __ovld __cnfn convert_ushort2_sat(ulong2); -ushort2 __ovld __cnfn convert_ushort2_rte(float2); -ushort2 __ovld __cnfn convert_ushort2_sat_rte(float2); -ushort2 __ovld __cnfn convert_ushort2_rtz(float2); -ushort2 __ovld __cnfn convert_ushort2_sat_rtz(float2); -ushort2 __ovld __cnfn convert_ushort2_rtp(float2); -ushort2 __ovld __cnfn convert_ushort2_sat_rtp(float2); -ushort2 __ovld __cnfn convert_ushort2_rtn(float2); -ushort2 __ovld __cnfn convert_ushort2_sat_rtn(float2); -ushort2 __ovld __cnfn convert_ushort2(float2); -ushort2 __ovld __cnfn convert_ushort2_sat(float2); -int2 __ovld __cnfn convert_int2_rte(char2); -int2 __ovld __cnfn convert_int2_sat_rte(char2); -int2 __ovld __cnfn convert_int2_rtz(char2); -int2 __ovld __cnfn convert_int2_sat_rtz(char2); -int2 __ovld __cnfn convert_int2_rtp(char2); -int2 __ovld __cnfn convert_int2_sat_rtp(char2); -int2 __ovld __cnfn convert_int2_rtn(char2); -int2 __ovld __cnfn convert_int2_sat_rtn(char2); -int2 __ovld __cnfn convert_int2(char2); -int2 __ovld __cnfn convert_int2_sat(char2); -int2 __ovld __cnfn convert_int2_rte(uchar2); -int2 __ovld __cnfn convert_int2_sat_rte(uchar2); -int2 __ovld __cnfn convert_int2_rtz(uchar2); -int2 __ovld __cnfn convert_int2_sat_rtz(uchar2); -int2 __ovld __cnfn convert_int2_rtp(uchar2); -int2 __ovld __cnfn convert_int2_sat_rtp(uchar2); -int2 __ovld __cnfn convert_int2_rtn(uchar2); -int2 __ovld __cnfn convert_int2_sat_rtn(uchar2); -int2 __ovld __cnfn convert_int2(uchar2); -int2 __ovld __cnfn convert_int2_sat(uchar2); -int2 __ovld __cnfn convert_int2_rte(short2); -int2 __ovld __cnfn convert_int2_sat_rte(short2); -int2 __ovld __cnfn convert_int2_rtz(short2); -int2 __ovld __cnfn convert_int2_sat_rtz(short2); -int2 __ovld __cnfn convert_int2_rtp(short2); -int2 __ovld __cnfn convert_int2_sat_rtp(short2); -int2 __ovld __cnfn convert_int2_rtn(short2); -int2 __ovld __cnfn convert_int2_sat_rtn(short2); -int2 __ovld __cnfn convert_int2(short2); -int2 __ovld __cnfn convert_int2_sat(short2); -int2 __ovld __cnfn convert_int2_rte(ushort2); -int2 __ovld __cnfn convert_int2_sat_rte(ushort2); -int2 __ovld __cnfn convert_int2_rtz(ushort2); -int2 __ovld __cnfn convert_int2_sat_rtz(ushort2); -int2 __ovld __cnfn convert_int2_rtp(ushort2); -int2 __ovld __cnfn convert_int2_sat_rtp(ushort2); -int2 __ovld __cnfn convert_int2_rtn(ushort2); -int2 __ovld __cnfn convert_int2_sat_rtn(ushort2); -int2 __ovld __cnfn convert_int2(ushort2); -int2 __ovld __cnfn convert_int2_sat(ushort2); -int2 __ovld __cnfn convert_int2_rte(int2); -int2 __ovld __cnfn convert_int2_sat_rte(int2); -int2 __ovld __cnfn convert_int2_rtz(int2); -int2 __ovld __cnfn convert_int2_sat_rtz(int2); -int2 __ovld __cnfn convert_int2_rtp(int2); -int2 __ovld __cnfn convert_int2_sat_rtp(int2); -int2 __ovld __cnfn convert_int2_rtn(int2); -int2 __ovld __cnfn convert_int2_sat_rtn(int2); -int2 __ovld __cnfn convert_int2(int2); -int2 __ovld __cnfn convert_int2_sat(int2); -int2 __ovld __cnfn convert_int2_rte(uint2); -int2 __ovld __cnfn convert_int2_sat_rte(uint2); -int2 __ovld __cnfn convert_int2_rtz(uint2); -int2 __ovld __cnfn convert_int2_sat_rtz(uint2); -int2 __ovld __cnfn convert_int2_rtp(uint2); -int2 __ovld __cnfn convert_int2_sat_rtp(uint2); -int2 __ovld __cnfn convert_int2_rtn(uint2); -int2 __ovld __cnfn convert_int2_sat_rtn(uint2); -int2 __ovld __cnfn convert_int2(uint2); -int2 __ovld __cnfn convert_int2_sat(uint2); -int2 __ovld __cnfn convert_int2_rte(long2); -int2 __ovld __cnfn convert_int2_sat_rte(long2); -int2 __ovld __cnfn convert_int2_rtz(long2); -int2 __ovld __cnfn convert_int2_sat_rtz(long2); -int2 __ovld __cnfn convert_int2_rtp(long2); -int2 __ovld __cnfn convert_int2_sat_rtp(long2); -int2 __ovld __cnfn convert_int2_rtn(long2); -int2 __ovld __cnfn convert_int2_sat_rtn(long2); -int2 __ovld __cnfn convert_int2(long2); -int2 __ovld __cnfn convert_int2_sat(long2); -int2 __ovld __cnfn convert_int2_rte(ulong2); -int2 __ovld __cnfn convert_int2_sat_rte(ulong2); -int2 __ovld __cnfn convert_int2_rtz(ulong2); -int2 __ovld __cnfn convert_int2_sat_rtz(ulong2); -int2 __ovld __cnfn convert_int2_rtp(ulong2); -int2 __ovld __cnfn convert_int2_sat_rtp(ulong2); -int2 __ovld __cnfn convert_int2_rtn(ulong2); -int2 __ovld __cnfn convert_int2_sat_rtn(ulong2); -int2 __ovld __cnfn convert_int2(ulong2); -int2 __ovld __cnfn convert_int2_sat(ulong2); -int2 __ovld __cnfn convert_int2_rte(float2); -int2 __ovld __cnfn convert_int2_sat_rte(float2); -int2 __ovld __cnfn convert_int2_rtz(float2); -int2 __ovld __cnfn convert_int2_sat_rtz(float2); -int2 __ovld __cnfn convert_int2_rtp(float2); -int2 __ovld __cnfn convert_int2_sat_rtp(float2); -int2 __ovld __cnfn convert_int2_rtn(float2); -int2 __ovld __cnfn convert_int2_sat_rtn(float2); -int2 __ovld __cnfn convert_int2(float2); -int2 __ovld __cnfn convert_int2_sat(float2); -uint2 __ovld __cnfn convert_uint2_rte(char2); -uint2 __ovld __cnfn convert_uint2_sat_rte(char2); -uint2 __ovld __cnfn convert_uint2_rtz(char2); -uint2 __ovld __cnfn convert_uint2_sat_rtz(char2); -uint2 __ovld __cnfn convert_uint2_rtp(char2); -uint2 __ovld __cnfn convert_uint2_sat_rtp(char2); -uint2 __ovld __cnfn convert_uint2_rtn(char2); -uint2 __ovld __cnfn convert_uint2_sat_rtn(char2); -uint2 __ovld __cnfn convert_uint2(char2); -uint2 __ovld __cnfn convert_uint2_sat(char2); -uint2 __ovld __cnfn convert_uint2_rte(uchar2); -uint2 __ovld __cnfn convert_uint2_sat_rte(uchar2); -uint2 __ovld __cnfn convert_uint2_rtz(uchar2); -uint2 __ovld __cnfn convert_uint2_sat_rtz(uchar2); -uint2 __ovld __cnfn convert_uint2_rtp(uchar2); -uint2 __ovld __cnfn convert_uint2_sat_rtp(uchar2); -uint2 __ovld __cnfn convert_uint2_rtn(uchar2); -uint2 __ovld __cnfn convert_uint2_sat_rtn(uchar2); -uint2 __ovld __cnfn convert_uint2(uchar2); -uint2 __ovld __cnfn convert_uint2_sat(uchar2); -uint2 __ovld __cnfn convert_uint2_rte(short2); -uint2 __ovld __cnfn convert_uint2_sat_rte(short2); -uint2 __ovld __cnfn convert_uint2_rtz(short2); -uint2 __ovld __cnfn convert_uint2_sat_rtz(short2); -uint2 __ovld __cnfn convert_uint2_rtp(short2); -uint2 __ovld __cnfn convert_uint2_sat_rtp(short2); -uint2 __ovld __cnfn convert_uint2_rtn(short2); -uint2 __ovld __cnfn convert_uint2_sat_rtn(short2); -uint2 __ovld __cnfn convert_uint2(short2); -uint2 __ovld __cnfn convert_uint2_sat(short2); -uint2 __ovld __cnfn convert_uint2_rte(ushort2); -uint2 __ovld __cnfn convert_uint2_sat_rte(ushort2); -uint2 __ovld __cnfn convert_uint2_rtz(ushort2); -uint2 __ovld __cnfn convert_uint2_sat_rtz(ushort2); -uint2 __ovld __cnfn convert_uint2_rtp(ushort2); -uint2 __ovld __cnfn convert_uint2_sat_rtp(ushort2); -uint2 __ovld __cnfn convert_uint2_rtn(ushort2); -uint2 __ovld __cnfn convert_uint2_sat_rtn(ushort2); -uint2 __ovld __cnfn convert_uint2(ushort2); -uint2 __ovld __cnfn convert_uint2_sat(ushort2); -uint2 __ovld __cnfn convert_uint2_rte(int2); -uint2 __ovld __cnfn convert_uint2_sat_rte(int2); -uint2 __ovld __cnfn convert_uint2_rtz(int2); -uint2 __ovld __cnfn convert_uint2_sat_rtz(int2); -uint2 __ovld __cnfn convert_uint2_rtp(int2); -uint2 __ovld __cnfn convert_uint2_sat_rtp(int2); -uint2 __ovld __cnfn convert_uint2_rtn(int2); -uint2 __ovld __cnfn convert_uint2_sat_rtn(int2); -uint2 __ovld __cnfn convert_uint2(int2); -uint2 __ovld __cnfn convert_uint2_sat(int2); -uint2 __ovld __cnfn convert_uint2_rte(uint2); -uint2 __ovld __cnfn convert_uint2_sat_rte(uint2); -uint2 __ovld __cnfn convert_uint2_rtz(uint2); -uint2 __ovld __cnfn convert_uint2_sat_rtz(uint2); -uint2 __ovld __cnfn convert_uint2_rtp(uint2); -uint2 __ovld __cnfn convert_uint2_sat_rtp(uint2); -uint2 __ovld __cnfn convert_uint2_rtn(uint2); -uint2 __ovld __cnfn convert_uint2_sat_rtn(uint2); -uint2 __ovld __cnfn convert_uint2(uint2); -uint2 __ovld __cnfn convert_uint2_sat(uint2); -uint2 __ovld __cnfn convert_uint2_rte(long2); -uint2 __ovld __cnfn convert_uint2_sat_rte(long2); -uint2 __ovld __cnfn convert_uint2_rtz(long2); -uint2 __ovld __cnfn convert_uint2_sat_rtz(long2); -uint2 __ovld __cnfn convert_uint2_rtp(long2); -uint2 __ovld __cnfn convert_uint2_sat_rtp(long2); -uint2 __ovld __cnfn convert_uint2_rtn(long2); -uint2 __ovld __cnfn convert_uint2_sat_rtn(long2); -uint2 __ovld __cnfn convert_uint2(long2); -uint2 __ovld __cnfn convert_uint2_sat(long2); -uint2 __ovld __cnfn convert_uint2_rte(ulong2); -uint2 __ovld __cnfn convert_uint2_sat_rte(ulong2); -uint2 __ovld __cnfn convert_uint2_rtz(ulong2); -uint2 __ovld __cnfn convert_uint2_sat_rtz(ulong2); -uint2 __ovld __cnfn convert_uint2_rtp(ulong2); -uint2 __ovld __cnfn convert_uint2_sat_rtp(ulong2); -uint2 __ovld __cnfn convert_uint2_rtn(ulong2); -uint2 __ovld __cnfn convert_uint2_sat_rtn(ulong2); -uint2 __ovld __cnfn convert_uint2(ulong2); -uint2 __ovld __cnfn convert_uint2_sat(ulong2); -uint2 __ovld __cnfn convert_uint2_rte(float2); -uint2 __ovld __cnfn convert_uint2_sat_rte(float2); -uint2 __ovld __cnfn convert_uint2_rtz(float2); -uint2 __ovld __cnfn convert_uint2_sat_rtz(float2); -uint2 __ovld __cnfn convert_uint2_rtp(float2); -uint2 __ovld __cnfn convert_uint2_sat_rtp(float2); -uint2 __ovld __cnfn convert_uint2_rtn(float2); -uint2 __ovld __cnfn convert_uint2_sat_rtn(float2); -uint2 __ovld __cnfn convert_uint2(float2); -uint2 __ovld __cnfn convert_uint2_sat(float2); -long2 __ovld __cnfn convert_long2_rte(char2); -long2 __ovld __cnfn convert_long2_sat_rte(char2); -long2 __ovld __cnfn convert_long2_rtz(char2); -long2 __ovld __cnfn convert_long2_sat_rtz(char2); -long2 __ovld __cnfn convert_long2_rtp(char2); -long2 __ovld __cnfn convert_long2_sat_rtp(char2); -long2 __ovld __cnfn convert_long2_rtn(char2); -long2 __ovld __cnfn convert_long2_sat_rtn(char2); -long2 __ovld __cnfn convert_long2(char2); -long2 __ovld __cnfn convert_long2_sat(char2); -long2 __ovld __cnfn convert_long2_rte(uchar2); -long2 __ovld __cnfn convert_long2_sat_rte(uchar2); -long2 __ovld __cnfn convert_long2_rtz(uchar2); -long2 __ovld __cnfn convert_long2_sat_rtz(uchar2); -long2 __ovld __cnfn convert_long2_rtp(uchar2); -long2 __ovld __cnfn convert_long2_sat_rtp(uchar2); -long2 __ovld __cnfn convert_long2_rtn(uchar2); -long2 __ovld __cnfn convert_long2_sat_rtn(uchar2); -long2 __ovld __cnfn convert_long2(uchar2); -long2 __ovld __cnfn convert_long2_sat(uchar2); -long2 __ovld __cnfn convert_long2_rte(short2); -long2 __ovld __cnfn convert_long2_sat_rte(short2); -long2 __ovld __cnfn convert_long2_rtz(short2); -long2 __ovld __cnfn convert_long2_sat_rtz(short2); -long2 __ovld __cnfn convert_long2_rtp(short2); -long2 __ovld __cnfn convert_long2_sat_rtp(short2); -long2 __ovld __cnfn convert_long2_rtn(short2); -long2 __ovld __cnfn convert_long2_sat_rtn(short2); -long2 __ovld __cnfn convert_long2(short2); -long2 __ovld __cnfn convert_long2_sat(short2); -long2 __ovld __cnfn convert_long2_rte(ushort2); -long2 __ovld __cnfn convert_long2_sat_rte(ushort2); -long2 __ovld __cnfn convert_long2_rtz(ushort2); -long2 __ovld __cnfn convert_long2_sat_rtz(ushort2); -long2 __ovld __cnfn convert_long2_rtp(ushort2); -long2 __ovld __cnfn convert_long2_sat_rtp(ushort2); -long2 __ovld __cnfn convert_long2_rtn(ushort2); -long2 __ovld __cnfn convert_long2_sat_rtn(ushort2); -long2 __ovld __cnfn convert_long2(ushort2); -long2 __ovld __cnfn convert_long2_sat(ushort2); -long2 __ovld __cnfn convert_long2_rte(int2); -long2 __ovld __cnfn convert_long2_sat_rte(int2); -long2 __ovld __cnfn convert_long2_rtz(int2); -long2 __ovld __cnfn convert_long2_sat_rtz(int2); -long2 __ovld __cnfn convert_long2_rtp(int2); -long2 __ovld __cnfn convert_long2_sat_rtp(int2); -long2 __ovld __cnfn convert_long2_rtn(int2); -long2 __ovld __cnfn convert_long2_sat_rtn(int2); -long2 __ovld __cnfn convert_long2(int2); -long2 __ovld __cnfn convert_long2_sat(int2); -long2 __ovld __cnfn convert_long2_rte(uint2); -long2 __ovld __cnfn convert_long2_sat_rte(uint2); -long2 __ovld __cnfn convert_long2_rtz(uint2); -long2 __ovld __cnfn convert_long2_sat_rtz(uint2); -long2 __ovld __cnfn convert_long2_rtp(uint2); -long2 __ovld __cnfn convert_long2_sat_rtp(uint2); -long2 __ovld __cnfn convert_long2_rtn(uint2); -long2 __ovld __cnfn convert_long2_sat_rtn(uint2); -long2 __ovld __cnfn convert_long2(uint2); -long2 __ovld __cnfn convert_long2_sat(uint2); -long2 __ovld __cnfn convert_long2_rte(long2); -long2 __ovld __cnfn convert_long2_sat_rte(long2); -long2 __ovld __cnfn convert_long2_rtz(long2); -long2 __ovld __cnfn convert_long2_sat_rtz(long2); -long2 __ovld __cnfn convert_long2_rtp(long2); -long2 __ovld __cnfn convert_long2_sat_rtp(long2); -long2 __ovld __cnfn convert_long2_rtn(long2); -long2 __ovld __cnfn convert_long2_sat_rtn(long2); -long2 __ovld __cnfn convert_long2(long2); -long2 __ovld __cnfn convert_long2_sat(long2); -long2 __ovld __cnfn convert_long2_rte(ulong2); -long2 __ovld __cnfn convert_long2_sat_rte(ulong2); -long2 __ovld __cnfn convert_long2_rtz(ulong2); -long2 __ovld __cnfn convert_long2_sat_rtz(ulong2); -long2 __ovld __cnfn convert_long2_rtp(ulong2); -long2 __ovld __cnfn convert_long2_sat_rtp(ulong2); -long2 __ovld __cnfn convert_long2_rtn(ulong2); -long2 __ovld __cnfn convert_long2_sat_rtn(ulong2); -long2 __ovld __cnfn convert_long2(ulong2); -long2 __ovld __cnfn convert_long2_sat(ulong2); -long2 __ovld __cnfn convert_long2_rte(float2); -long2 __ovld __cnfn convert_long2_sat_rte(float2); -long2 __ovld __cnfn convert_long2_rtz(float2); -long2 __ovld __cnfn convert_long2_sat_rtz(float2); -long2 __ovld __cnfn convert_long2_rtp(float2); -long2 __ovld __cnfn convert_long2_sat_rtp(float2); -long2 __ovld __cnfn convert_long2_rtn(float2); -long2 __ovld __cnfn convert_long2_sat_rtn(float2); -long2 __ovld __cnfn convert_long2(float2); -long2 __ovld __cnfn convert_long2_sat(float2); -ulong2 __ovld __cnfn convert_ulong2_rte(char2); -ulong2 __ovld __cnfn convert_ulong2_sat_rte(char2); -ulong2 __ovld __cnfn convert_ulong2_rtz(char2); -ulong2 __ovld __cnfn convert_ulong2_sat_rtz(char2); -ulong2 __ovld __cnfn convert_ulong2_rtp(char2); -ulong2 __ovld __cnfn convert_ulong2_sat_rtp(char2); -ulong2 __ovld __cnfn convert_ulong2_rtn(char2); -ulong2 __ovld __cnfn convert_ulong2_sat_rtn(char2); -ulong2 __ovld __cnfn convert_ulong2(char2); -ulong2 __ovld __cnfn convert_ulong2_sat(char2); -ulong2 __ovld __cnfn convert_ulong2_rte(uchar2); -ulong2 __ovld __cnfn convert_ulong2_sat_rte(uchar2); -ulong2 __ovld __cnfn convert_ulong2_rtz(uchar2); -ulong2 __ovld __cnfn convert_ulong2_sat_rtz(uchar2); -ulong2 __ovld __cnfn convert_ulong2_rtp(uchar2); -ulong2 __ovld __cnfn convert_ulong2_sat_rtp(uchar2); -ulong2 __ovld __cnfn convert_ulong2_rtn(uchar2); -ulong2 __ovld __cnfn convert_ulong2_sat_rtn(uchar2); -ulong2 __ovld __cnfn convert_ulong2(uchar2); -ulong2 __ovld __cnfn convert_ulong2_sat(uchar2); -ulong2 __ovld __cnfn convert_ulong2_rte(short2); -ulong2 __ovld __cnfn convert_ulong2_sat_rte(short2); -ulong2 __ovld __cnfn convert_ulong2_rtz(short2); -ulong2 __ovld __cnfn convert_ulong2_sat_rtz(short2); -ulong2 __ovld __cnfn convert_ulong2_rtp(short2); -ulong2 __ovld __cnfn convert_ulong2_sat_rtp(short2); -ulong2 __ovld __cnfn convert_ulong2_rtn(short2); -ulong2 __ovld __cnfn convert_ulong2_sat_rtn(short2); -ulong2 __ovld __cnfn convert_ulong2(short2); -ulong2 __ovld __cnfn convert_ulong2_sat(short2); -ulong2 __ovld __cnfn convert_ulong2_rte(ushort2); -ulong2 __ovld __cnfn convert_ulong2_sat_rte(ushort2); -ulong2 __ovld __cnfn convert_ulong2_rtz(ushort2); -ulong2 __ovld __cnfn convert_ulong2_sat_rtz(ushort2); -ulong2 __ovld __cnfn convert_ulong2_rtp(ushort2); -ulong2 __ovld __cnfn convert_ulong2_sat_rtp(ushort2); -ulong2 __ovld __cnfn convert_ulong2_rtn(ushort2); -ulong2 __ovld __cnfn convert_ulong2_sat_rtn(ushort2); -ulong2 __ovld __cnfn convert_ulong2(ushort2); -ulong2 __ovld __cnfn convert_ulong2_sat(ushort2); -ulong2 __ovld __cnfn convert_ulong2_rte(int2); -ulong2 __ovld __cnfn convert_ulong2_sat_rte(int2); -ulong2 __ovld __cnfn convert_ulong2_rtz(int2); -ulong2 __ovld __cnfn convert_ulong2_sat_rtz(int2); -ulong2 __ovld __cnfn convert_ulong2_rtp(int2); -ulong2 __ovld __cnfn convert_ulong2_sat_rtp(int2); -ulong2 __ovld __cnfn convert_ulong2_rtn(int2); -ulong2 __ovld __cnfn convert_ulong2_sat_rtn(int2); -ulong2 __ovld __cnfn convert_ulong2(int2); -ulong2 __ovld __cnfn convert_ulong2_sat(int2); -ulong2 __ovld __cnfn convert_ulong2_rte(uint2); -ulong2 __ovld __cnfn convert_ulong2_sat_rte(uint2); -ulong2 __ovld __cnfn convert_ulong2_rtz(uint2); -ulong2 __ovld __cnfn convert_ulong2_sat_rtz(uint2); -ulong2 __ovld __cnfn convert_ulong2_rtp(uint2); -ulong2 __ovld __cnfn convert_ulong2_sat_rtp(uint2); -ulong2 __ovld __cnfn convert_ulong2_rtn(uint2); -ulong2 __ovld __cnfn convert_ulong2_sat_rtn(uint2); -ulong2 __ovld __cnfn convert_ulong2(uint2); -ulong2 __ovld __cnfn convert_ulong2_sat(uint2); -ulong2 __ovld __cnfn convert_ulong2_rte(long2); -ulong2 __ovld __cnfn convert_ulong2_sat_rte(long2); -ulong2 __ovld __cnfn convert_ulong2_rtz(long2); -ulong2 __ovld __cnfn convert_ulong2_sat_rtz(long2); -ulong2 __ovld __cnfn convert_ulong2_rtp(long2); -ulong2 __ovld __cnfn convert_ulong2_sat_rtp(long2); -ulong2 __ovld __cnfn convert_ulong2_rtn(long2); -ulong2 __ovld __cnfn convert_ulong2_sat_rtn(long2); -ulong2 __ovld __cnfn convert_ulong2(long2); -ulong2 __ovld __cnfn convert_ulong2_sat(long2); -ulong2 __ovld __cnfn convert_ulong2_rte(ulong2); -ulong2 __ovld __cnfn convert_ulong2_sat_rte(ulong2); -ulong2 __ovld __cnfn convert_ulong2_rtz(ulong2); -ulong2 __ovld __cnfn convert_ulong2_sat_rtz(ulong2); -ulong2 __ovld __cnfn convert_ulong2_rtp(ulong2); -ulong2 __ovld __cnfn convert_ulong2_sat_rtp(ulong2); -ulong2 __ovld __cnfn convert_ulong2_rtn(ulong2); -ulong2 __ovld __cnfn convert_ulong2_sat_rtn(ulong2); -ulong2 __ovld __cnfn convert_ulong2(ulong2); -ulong2 __ovld __cnfn convert_ulong2_sat(ulong2); -ulong2 __ovld __cnfn convert_ulong2_rte(float2); -ulong2 __ovld __cnfn convert_ulong2_sat_rte(float2); -ulong2 __ovld __cnfn convert_ulong2_rtz(float2); -ulong2 __ovld __cnfn convert_ulong2_sat_rtz(float2); -ulong2 __ovld __cnfn convert_ulong2_rtp(float2); -ulong2 __ovld __cnfn convert_ulong2_sat_rtp(float2); -ulong2 __ovld __cnfn convert_ulong2_rtn(float2); -ulong2 __ovld __cnfn convert_ulong2_sat_rtn(float2); -ulong2 __ovld __cnfn convert_ulong2(float2); -ulong2 __ovld __cnfn convert_ulong2_sat(float2); -float2 __ovld __cnfn convert_float2_rte(char2); -float2 __ovld __cnfn convert_float2_rtz(char2); -float2 __ovld __cnfn convert_float2_rtp(char2); -float2 __ovld __cnfn convert_float2_rtn(char2); -float2 __ovld __cnfn convert_float2(char2); -float2 __ovld __cnfn convert_float2_rte(uchar2); -float2 __ovld __cnfn convert_float2_rtz(uchar2); -float2 __ovld __cnfn convert_float2_rtp(uchar2); -float2 __ovld __cnfn convert_float2_rtn(uchar2); -float2 __ovld __cnfn convert_float2(uchar2); -float2 __ovld __cnfn convert_float2_rte(short2); -float2 __ovld __cnfn convert_float2_rtz(short2); -float2 __ovld __cnfn convert_float2_rtp(short2); -float2 __ovld __cnfn convert_float2_rtn(short2); -float2 __ovld __cnfn convert_float2(short2); -float2 __ovld __cnfn convert_float2_rte(ushort2); -float2 __ovld __cnfn convert_float2_rtz(ushort2); -float2 __ovld __cnfn convert_float2_rtp(ushort2); -float2 __ovld __cnfn convert_float2_rtn(ushort2); -float2 __ovld __cnfn convert_float2(ushort2); -float2 __ovld __cnfn convert_float2_rte(int2); -float2 __ovld __cnfn convert_float2_rtz(int2); -float2 __ovld __cnfn convert_float2_rtp(int2); -float2 __ovld __cnfn convert_float2_rtn(int2); -float2 __ovld __cnfn convert_float2(int2); -float2 __ovld __cnfn convert_float2_rte(uint2); -float2 __ovld __cnfn convert_float2_rtz(uint2); -float2 __ovld __cnfn convert_float2_rtp(uint2); -float2 __ovld __cnfn convert_float2_rtn(uint2); -float2 __ovld __cnfn convert_float2(uint2); -float2 __ovld __cnfn convert_float2_rte(long2); -float2 __ovld __cnfn convert_float2_rtz(long2); -float2 __ovld __cnfn convert_float2_rtp(long2); -float2 __ovld __cnfn convert_float2_rtn(long2); -float2 __ovld __cnfn convert_float2(long2); -float2 __ovld __cnfn convert_float2_rte(ulong2); -float2 __ovld __cnfn convert_float2_rtz(ulong2); -float2 __ovld __cnfn convert_float2_rtp(ulong2); -float2 __ovld __cnfn convert_float2_rtn(ulong2); -float2 __ovld __cnfn convert_float2(ulong2); -float2 __ovld __cnfn convert_float2_rte(float2); -float2 __ovld __cnfn convert_float2_rtz(float2); -float2 __ovld __cnfn convert_float2_rtp(float2); -float2 __ovld __cnfn convert_float2_rtn(float2); -float2 __ovld __cnfn convert_float2(float2); -char3 __ovld __cnfn convert_char3_rte(char3); -char3 __ovld __cnfn convert_char3_sat_rte(char3); -char3 __ovld __cnfn convert_char3_rtz(char3); -char3 __ovld __cnfn convert_char3_sat_rtz(char3); -char3 __ovld __cnfn convert_char3_rtp(char3); -char3 __ovld __cnfn convert_char3_sat_rtp(char3); -char3 __ovld __cnfn convert_char3_rtn(char3); -char3 __ovld __cnfn convert_char3_sat_rtn(char3); -char3 __ovld __cnfn convert_char3(char3); -char3 __ovld __cnfn convert_char3_sat(char3); -char3 __ovld __cnfn convert_char3_rte(uchar3); -char3 __ovld __cnfn convert_char3_sat_rte(uchar3); -char3 __ovld __cnfn convert_char3_rtz(uchar3); -char3 __ovld __cnfn convert_char3_sat_rtz(uchar3); -char3 __ovld __cnfn convert_char3_rtp(uchar3); -char3 __ovld __cnfn convert_char3_sat_rtp(uchar3); -char3 __ovld __cnfn convert_char3_rtn(uchar3); -char3 __ovld __cnfn convert_char3_sat_rtn(uchar3); -char3 __ovld __cnfn convert_char3(uchar3); -char3 __ovld __cnfn convert_char3_sat(uchar3); -char3 __ovld __cnfn convert_char3_rte(short3); -char3 __ovld __cnfn convert_char3_sat_rte(short3); -char3 __ovld __cnfn convert_char3_rtz(short3); -char3 __ovld __cnfn convert_char3_sat_rtz(short3); -char3 __ovld __cnfn convert_char3_rtp(short3); -char3 __ovld __cnfn convert_char3_sat_rtp(short3); -char3 __ovld __cnfn convert_char3_rtn(short3); -char3 __ovld __cnfn convert_char3_sat_rtn(short3); -char3 __ovld __cnfn convert_char3(short3); -char3 __ovld __cnfn convert_char3_sat(short3); -char3 __ovld __cnfn convert_char3_rte(ushort3); -char3 __ovld __cnfn convert_char3_sat_rte(ushort3); -char3 __ovld __cnfn convert_char3_rtz(ushort3); -char3 __ovld __cnfn convert_char3_sat_rtz(ushort3); -char3 __ovld __cnfn convert_char3_rtp(ushort3); -char3 __ovld __cnfn convert_char3_sat_rtp(ushort3); -char3 __ovld __cnfn convert_char3_rtn(ushort3); -char3 __ovld __cnfn convert_char3_sat_rtn(ushort3); -char3 __ovld __cnfn convert_char3(ushort3); -char3 __ovld __cnfn convert_char3_sat(ushort3); -char3 __ovld __cnfn convert_char3_rte(int3); -char3 __ovld __cnfn convert_char3_sat_rte(int3); -char3 __ovld __cnfn convert_char3_rtz(int3); -char3 __ovld __cnfn convert_char3_sat_rtz(int3); -char3 __ovld __cnfn convert_char3_rtp(int3); -char3 __ovld __cnfn convert_char3_sat_rtp(int3); -char3 __ovld __cnfn convert_char3_rtn(int3); -char3 __ovld __cnfn convert_char3_sat_rtn(int3); -char3 __ovld __cnfn convert_char3(int3); -char3 __ovld __cnfn convert_char3_sat(int3); -char3 __ovld __cnfn convert_char3_rte(uint3); -char3 __ovld __cnfn convert_char3_sat_rte(uint3); -char3 __ovld __cnfn convert_char3_rtz(uint3); -char3 __ovld __cnfn convert_char3_sat_rtz(uint3); -char3 __ovld __cnfn convert_char3_rtp(uint3); -char3 __ovld __cnfn convert_char3_sat_rtp(uint3); -char3 __ovld __cnfn convert_char3_rtn(uint3); -char3 __ovld __cnfn convert_char3_sat_rtn(uint3); -char3 __ovld __cnfn convert_char3(uint3); -char3 __ovld __cnfn convert_char3_sat(uint3); -char3 __ovld __cnfn convert_char3_rte(long3); -char3 __ovld __cnfn convert_char3_sat_rte(long3); -char3 __ovld __cnfn convert_char3_rtz(long3); -char3 __ovld __cnfn convert_char3_sat_rtz(long3); -char3 __ovld __cnfn convert_char3_rtp(long3); -char3 __ovld __cnfn convert_char3_sat_rtp(long3); -char3 __ovld __cnfn convert_char3_rtn(long3); -char3 __ovld __cnfn convert_char3_sat_rtn(long3); -char3 __ovld __cnfn convert_char3(long3); -char3 __ovld __cnfn convert_char3_sat(long3); -char3 __ovld __cnfn convert_char3_rte(ulong3); -char3 __ovld __cnfn convert_char3_sat_rte(ulong3); -char3 __ovld __cnfn convert_char3_rtz(ulong3); -char3 __ovld __cnfn convert_char3_sat_rtz(ulong3); -char3 __ovld __cnfn convert_char3_rtp(ulong3); -char3 __ovld __cnfn convert_char3_sat_rtp(ulong3); -char3 __ovld __cnfn convert_char3_rtn(ulong3); -char3 __ovld __cnfn convert_char3_sat_rtn(ulong3); -char3 __ovld __cnfn convert_char3(ulong3); -char3 __ovld __cnfn convert_char3_sat(ulong3); -char3 __ovld __cnfn convert_char3_rte(float3); -char3 __ovld __cnfn convert_char3_sat_rte(float3); -char3 __ovld __cnfn convert_char3_rtz(float3); -char3 __ovld __cnfn convert_char3_sat_rtz(float3); -char3 __ovld __cnfn convert_char3_rtp(float3); -char3 __ovld __cnfn convert_char3_sat_rtp(float3); -char3 __ovld __cnfn convert_char3_rtn(float3); -char3 __ovld __cnfn convert_char3_sat_rtn(float3); -char3 __ovld __cnfn convert_char3(float3); -char3 __ovld __cnfn convert_char3_sat(float3); -uchar3 __ovld __cnfn convert_uchar3_rte(char3); -uchar3 __ovld __cnfn convert_uchar3_sat_rte(char3); -uchar3 __ovld __cnfn convert_uchar3_rtz(char3); -uchar3 __ovld __cnfn convert_uchar3_sat_rtz(char3); -uchar3 __ovld __cnfn convert_uchar3_rtp(char3); -uchar3 __ovld __cnfn convert_uchar3_sat_rtp(char3); -uchar3 __ovld __cnfn convert_uchar3_rtn(char3); -uchar3 __ovld __cnfn convert_uchar3_sat_rtn(char3); -uchar3 __ovld __cnfn convert_uchar3(char3); -uchar3 __ovld __cnfn convert_uchar3_sat(char3); -uchar3 __ovld __cnfn convert_uchar3_rte(uchar3); -uchar3 __ovld __cnfn convert_uchar3_sat_rte(uchar3); -uchar3 __ovld __cnfn convert_uchar3_rtz(uchar3); -uchar3 __ovld __cnfn convert_uchar3_sat_rtz(uchar3); -uchar3 __ovld __cnfn convert_uchar3_rtp(uchar3); -uchar3 __ovld __cnfn convert_uchar3_sat_rtp(uchar3); -uchar3 __ovld __cnfn convert_uchar3_rtn(uchar3); -uchar3 __ovld __cnfn convert_uchar3_sat_rtn(uchar3); -uchar3 __ovld __cnfn convert_uchar3(uchar3); -uchar3 __ovld __cnfn convert_uchar3_sat(uchar3); -uchar3 __ovld __cnfn convert_uchar3_rte(short3); -uchar3 __ovld __cnfn convert_uchar3_sat_rte(short3); -uchar3 __ovld __cnfn convert_uchar3_rtz(short3); -uchar3 __ovld __cnfn convert_uchar3_sat_rtz(short3); -uchar3 __ovld __cnfn convert_uchar3_rtp(short3); -uchar3 __ovld __cnfn convert_uchar3_sat_rtp(short3); -uchar3 __ovld __cnfn convert_uchar3_rtn(short3); -uchar3 __ovld __cnfn convert_uchar3_sat_rtn(short3); -uchar3 __ovld __cnfn convert_uchar3(short3); -uchar3 __ovld __cnfn convert_uchar3_sat(short3); -uchar3 __ovld __cnfn convert_uchar3_rte(ushort3); -uchar3 __ovld __cnfn convert_uchar3_sat_rte(ushort3); -uchar3 __ovld __cnfn convert_uchar3_rtz(ushort3); -uchar3 __ovld __cnfn convert_uchar3_sat_rtz(ushort3); -uchar3 __ovld __cnfn convert_uchar3_rtp(ushort3); -uchar3 __ovld __cnfn convert_uchar3_sat_rtp(ushort3); -uchar3 __ovld __cnfn convert_uchar3_rtn(ushort3); -uchar3 __ovld __cnfn convert_uchar3_sat_rtn(ushort3); -uchar3 __ovld __cnfn convert_uchar3(ushort3); -uchar3 __ovld __cnfn convert_uchar3_sat(ushort3); -uchar3 __ovld __cnfn convert_uchar3_rte(int3); -uchar3 __ovld __cnfn convert_uchar3_sat_rte(int3); -uchar3 __ovld __cnfn convert_uchar3_rtz(int3); -uchar3 __ovld __cnfn convert_uchar3_sat_rtz(int3); -uchar3 __ovld __cnfn convert_uchar3_rtp(int3); -uchar3 __ovld __cnfn convert_uchar3_sat_rtp(int3); -uchar3 __ovld __cnfn convert_uchar3_rtn(int3); -uchar3 __ovld __cnfn convert_uchar3_sat_rtn(int3); -uchar3 __ovld __cnfn convert_uchar3(int3); -uchar3 __ovld __cnfn convert_uchar3_sat(int3); -uchar3 __ovld __cnfn convert_uchar3_rte(uint3); -uchar3 __ovld __cnfn convert_uchar3_sat_rte(uint3); -uchar3 __ovld __cnfn convert_uchar3_rtz(uint3); -uchar3 __ovld __cnfn convert_uchar3_sat_rtz(uint3); -uchar3 __ovld __cnfn convert_uchar3_rtp(uint3); -uchar3 __ovld __cnfn convert_uchar3_sat_rtp(uint3); -uchar3 __ovld __cnfn convert_uchar3_rtn(uint3); -uchar3 __ovld __cnfn convert_uchar3_sat_rtn(uint3); -uchar3 __ovld __cnfn convert_uchar3(uint3); -uchar3 __ovld __cnfn convert_uchar3_sat(uint3); -uchar3 __ovld __cnfn convert_uchar3_rte(long3); -uchar3 __ovld __cnfn convert_uchar3_sat_rte(long3); -uchar3 __ovld __cnfn convert_uchar3_rtz(long3); -uchar3 __ovld __cnfn convert_uchar3_sat_rtz(long3); -uchar3 __ovld __cnfn convert_uchar3_rtp(long3); -uchar3 __ovld __cnfn convert_uchar3_sat_rtp(long3); -uchar3 __ovld __cnfn convert_uchar3_rtn(long3); -uchar3 __ovld __cnfn convert_uchar3_sat_rtn(long3); -uchar3 __ovld __cnfn convert_uchar3(long3); -uchar3 __ovld __cnfn convert_uchar3_sat(long3); -uchar3 __ovld __cnfn convert_uchar3_rte(ulong3); -uchar3 __ovld __cnfn convert_uchar3_sat_rte(ulong3); -uchar3 __ovld __cnfn convert_uchar3_rtz(ulong3); -uchar3 __ovld __cnfn convert_uchar3_sat_rtz(ulong3); -uchar3 __ovld __cnfn convert_uchar3_rtp(ulong3); -uchar3 __ovld __cnfn convert_uchar3_sat_rtp(ulong3); -uchar3 __ovld __cnfn convert_uchar3_rtn(ulong3); -uchar3 __ovld __cnfn convert_uchar3_sat_rtn(ulong3); -uchar3 __ovld __cnfn convert_uchar3(ulong3); -uchar3 __ovld __cnfn convert_uchar3_sat(ulong3); -uchar3 __ovld __cnfn convert_uchar3_rte(float3); -uchar3 __ovld __cnfn convert_uchar3_sat_rte(float3); -uchar3 __ovld __cnfn convert_uchar3_rtz(float3); -uchar3 __ovld __cnfn convert_uchar3_sat_rtz(float3); -uchar3 __ovld __cnfn convert_uchar3_rtp(float3); -uchar3 __ovld __cnfn convert_uchar3_sat_rtp(float3); -uchar3 __ovld __cnfn convert_uchar3_rtn(float3); -uchar3 __ovld __cnfn convert_uchar3_sat_rtn(float3); -uchar3 __ovld __cnfn convert_uchar3(float3); -uchar3 __ovld __cnfn convert_uchar3_sat(float3); -short3 __ovld __cnfn convert_short3_rte(char3); -short3 __ovld __cnfn convert_short3_sat_rte(char3); -short3 __ovld __cnfn convert_short3_rtz(char3); -short3 __ovld __cnfn convert_short3_sat_rtz(char3); -short3 __ovld __cnfn convert_short3_rtp(char3); -short3 __ovld __cnfn convert_short3_sat_rtp(char3); -short3 __ovld __cnfn convert_short3_rtn(char3); -short3 __ovld __cnfn convert_short3_sat_rtn(char3); -short3 __ovld __cnfn convert_short3(char3); -short3 __ovld __cnfn convert_short3_sat(char3); -short3 __ovld __cnfn convert_short3_rte(uchar3); -short3 __ovld __cnfn convert_short3_sat_rte(uchar3); -short3 __ovld __cnfn convert_short3_rtz(uchar3); -short3 __ovld __cnfn convert_short3_sat_rtz(uchar3); -short3 __ovld __cnfn convert_short3_rtp(uchar3); -short3 __ovld __cnfn convert_short3_sat_rtp(uchar3); -short3 __ovld __cnfn convert_short3_rtn(uchar3); -short3 __ovld __cnfn convert_short3_sat_rtn(uchar3); -short3 __ovld __cnfn convert_short3(uchar3); -short3 __ovld __cnfn convert_short3_sat(uchar3); -short3 __ovld __cnfn convert_short3_rte(short3); -short3 __ovld __cnfn convert_short3_sat_rte(short3); -short3 __ovld __cnfn convert_short3_rtz(short3); -short3 __ovld __cnfn convert_short3_sat_rtz(short3); -short3 __ovld __cnfn convert_short3_rtp(short3); -short3 __ovld __cnfn convert_short3_sat_rtp(short3); -short3 __ovld __cnfn convert_short3_rtn(short3); -short3 __ovld __cnfn convert_short3_sat_rtn(short3); -short3 __ovld __cnfn convert_short3(short3); -short3 __ovld __cnfn convert_short3_sat(short3); -short3 __ovld __cnfn convert_short3_rte(ushort3); -short3 __ovld __cnfn convert_short3_sat_rte(ushort3); -short3 __ovld __cnfn convert_short3_rtz(ushort3); -short3 __ovld __cnfn convert_short3_sat_rtz(ushort3); -short3 __ovld __cnfn convert_short3_rtp(ushort3); -short3 __ovld __cnfn convert_short3_sat_rtp(ushort3); -short3 __ovld __cnfn convert_short3_rtn(ushort3); -short3 __ovld __cnfn convert_short3_sat_rtn(ushort3); -short3 __ovld __cnfn convert_short3(ushort3); -short3 __ovld __cnfn convert_short3_sat(ushort3); -short3 __ovld __cnfn convert_short3_rte(int3); -short3 __ovld __cnfn convert_short3_sat_rte(int3); -short3 __ovld __cnfn convert_short3_rtz(int3); -short3 __ovld __cnfn convert_short3_sat_rtz(int3); -short3 __ovld __cnfn convert_short3_rtp(int3); -short3 __ovld __cnfn convert_short3_sat_rtp(int3); -short3 __ovld __cnfn convert_short3_rtn(int3); -short3 __ovld __cnfn convert_short3_sat_rtn(int3); -short3 __ovld __cnfn convert_short3(int3); -short3 __ovld __cnfn convert_short3_sat(int3); -short3 __ovld __cnfn convert_short3_rte(uint3); -short3 __ovld __cnfn convert_short3_sat_rte(uint3); -short3 __ovld __cnfn convert_short3_rtz(uint3); -short3 __ovld __cnfn convert_short3_sat_rtz(uint3); -short3 __ovld __cnfn convert_short3_rtp(uint3); -short3 __ovld __cnfn convert_short3_sat_rtp(uint3); -short3 __ovld __cnfn convert_short3_rtn(uint3); -short3 __ovld __cnfn convert_short3_sat_rtn(uint3); -short3 __ovld __cnfn convert_short3(uint3); -short3 __ovld __cnfn convert_short3_sat(uint3); -short3 __ovld __cnfn convert_short3_rte(long3); -short3 __ovld __cnfn convert_short3_sat_rte(long3); -short3 __ovld __cnfn convert_short3_rtz(long3); -short3 __ovld __cnfn convert_short3_sat_rtz(long3); -short3 __ovld __cnfn convert_short3_rtp(long3); -short3 __ovld __cnfn convert_short3_sat_rtp(long3); -short3 __ovld __cnfn convert_short3_rtn(long3); -short3 __ovld __cnfn convert_short3_sat_rtn(long3); -short3 __ovld __cnfn convert_short3(long3); -short3 __ovld __cnfn convert_short3_sat(long3); -short3 __ovld __cnfn convert_short3_rte(ulong3); -short3 __ovld __cnfn convert_short3_sat_rte(ulong3); -short3 __ovld __cnfn convert_short3_rtz(ulong3); -short3 __ovld __cnfn convert_short3_sat_rtz(ulong3); -short3 __ovld __cnfn convert_short3_rtp(ulong3); -short3 __ovld __cnfn convert_short3_sat_rtp(ulong3); -short3 __ovld __cnfn convert_short3_rtn(ulong3); -short3 __ovld __cnfn convert_short3_sat_rtn(ulong3); -short3 __ovld __cnfn convert_short3(ulong3); -short3 __ovld __cnfn convert_short3_sat(ulong3); -short3 __ovld __cnfn convert_short3_rte(float3); -short3 __ovld __cnfn convert_short3_sat_rte(float3); -short3 __ovld __cnfn convert_short3_rtz(float3); -short3 __ovld __cnfn convert_short3_sat_rtz(float3); -short3 __ovld __cnfn convert_short3_rtp(float3); -short3 __ovld __cnfn convert_short3_sat_rtp(float3); -short3 __ovld __cnfn convert_short3_rtn(float3); -short3 __ovld __cnfn convert_short3_sat_rtn(float3); -short3 __ovld __cnfn convert_short3(float3); -short3 __ovld __cnfn convert_short3_sat(float3); -ushort3 __ovld __cnfn convert_ushort3_rte(char3); -ushort3 __ovld __cnfn convert_ushort3_sat_rte(char3); -ushort3 __ovld __cnfn convert_ushort3_rtz(char3); -ushort3 __ovld __cnfn convert_ushort3_sat_rtz(char3); -ushort3 __ovld __cnfn convert_ushort3_rtp(char3); -ushort3 __ovld __cnfn convert_ushort3_sat_rtp(char3); -ushort3 __ovld __cnfn convert_ushort3_rtn(char3); -ushort3 __ovld __cnfn convert_ushort3_sat_rtn(char3); -ushort3 __ovld __cnfn convert_ushort3(char3); -ushort3 __ovld __cnfn convert_ushort3_sat(char3); -ushort3 __ovld __cnfn convert_ushort3_rte(uchar3); -ushort3 __ovld __cnfn convert_ushort3_sat_rte(uchar3); -ushort3 __ovld __cnfn convert_ushort3_rtz(uchar3); -ushort3 __ovld __cnfn convert_ushort3_sat_rtz(uchar3); -ushort3 __ovld __cnfn convert_ushort3_rtp(uchar3); -ushort3 __ovld __cnfn convert_ushort3_sat_rtp(uchar3); -ushort3 __ovld __cnfn convert_ushort3_rtn(uchar3); -ushort3 __ovld __cnfn convert_ushort3_sat_rtn(uchar3); -ushort3 __ovld __cnfn convert_ushort3(uchar3); -ushort3 __ovld __cnfn convert_ushort3_sat(uchar3); -ushort3 __ovld __cnfn convert_ushort3_rte(short3); -ushort3 __ovld __cnfn convert_ushort3_sat_rte(short3); -ushort3 __ovld __cnfn convert_ushort3_rtz(short3); -ushort3 __ovld __cnfn convert_ushort3_sat_rtz(short3); -ushort3 __ovld __cnfn convert_ushort3_rtp(short3); -ushort3 __ovld __cnfn convert_ushort3_sat_rtp(short3); -ushort3 __ovld __cnfn convert_ushort3_rtn(short3); -ushort3 __ovld __cnfn convert_ushort3_sat_rtn(short3); -ushort3 __ovld __cnfn convert_ushort3(short3); -ushort3 __ovld __cnfn convert_ushort3_sat(short3); -ushort3 __ovld __cnfn convert_ushort3_rte(ushort3); -ushort3 __ovld __cnfn convert_ushort3_sat_rte(ushort3); -ushort3 __ovld __cnfn convert_ushort3_rtz(ushort3); -ushort3 __ovld __cnfn convert_ushort3_sat_rtz(ushort3); -ushort3 __ovld __cnfn convert_ushort3_rtp(ushort3); -ushort3 __ovld __cnfn convert_ushort3_sat_rtp(ushort3); -ushort3 __ovld __cnfn convert_ushort3_rtn(ushort3); -ushort3 __ovld __cnfn convert_ushort3_sat_rtn(ushort3); -ushort3 __ovld __cnfn convert_ushort3(ushort3); -ushort3 __ovld __cnfn convert_ushort3_sat(ushort3); -ushort3 __ovld __cnfn convert_ushort3_rte(int3); -ushort3 __ovld __cnfn convert_ushort3_sat_rte(int3); -ushort3 __ovld __cnfn convert_ushort3_rtz(int3); -ushort3 __ovld __cnfn convert_ushort3_sat_rtz(int3); -ushort3 __ovld __cnfn convert_ushort3_rtp(int3); -ushort3 __ovld __cnfn convert_ushort3_sat_rtp(int3); -ushort3 __ovld __cnfn convert_ushort3_rtn(int3); -ushort3 __ovld __cnfn convert_ushort3_sat_rtn(int3); -ushort3 __ovld __cnfn convert_ushort3(int3); -ushort3 __ovld __cnfn convert_ushort3_sat(int3); -ushort3 __ovld __cnfn convert_ushort3_rte(uint3); -ushort3 __ovld __cnfn convert_ushort3_sat_rte(uint3); -ushort3 __ovld __cnfn convert_ushort3_rtz(uint3); -ushort3 __ovld __cnfn convert_ushort3_sat_rtz(uint3); -ushort3 __ovld __cnfn convert_ushort3_rtp(uint3); -ushort3 __ovld __cnfn convert_ushort3_sat_rtp(uint3); -ushort3 __ovld __cnfn convert_ushort3_rtn(uint3); -ushort3 __ovld __cnfn convert_ushort3_sat_rtn(uint3); -ushort3 __ovld __cnfn convert_ushort3(uint3); -ushort3 __ovld __cnfn convert_ushort3_sat(uint3); -ushort3 __ovld __cnfn convert_ushort3_rte(long3); -ushort3 __ovld __cnfn convert_ushort3_sat_rte(long3); -ushort3 __ovld __cnfn convert_ushort3_rtz(long3); -ushort3 __ovld __cnfn convert_ushort3_sat_rtz(long3); -ushort3 __ovld __cnfn convert_ushort3_rtp(long3); -ushort3 __ovld __cnfn convert_ushort3_sat_rtp(long3); -ushort3 __ovld __cnfn convert_ushort3_rtn(long3); -ushort3 __ovld __cnfn convert_ushort3_sat_rtn(long3); -ushort3 __ovld __cnfn convert_ushort3(long3); -ushort3 __ovld __cnfn convert_ushort3_sat(long3); -ushort3 __ovld __cnfn convert_ushort3_rte(ulong3); -ushort3 __ovld __cnfn convert_ushort3_sat_rte(ulong3); -ushort3 __ovld __cnfn convert_ushort3_rtz(ulong3); -ushort3 __ovld __cnfn convert_ushort3_sat_rtz(ulong3); -ushort3 __ovld __cnfn convert_ushort3_rtp(ulong3); -ushort3 __ovld __cnfn convert_ushort3_sat_rtp(ulong3); -ushort3 __ovld __cnfn convert_ushort3_rtn(ulong3); -ushort3 __ovld __cnfn convert_ushort3_sat_rtn(ulong3); -ushort3 __ovld __cnfn convert_ushort3(ulong3); -ushort3 __ovld __cnfn convert_ushort3_sat(ulong3); -ushort3 __ovld __cnfn convert_ushort3_rte(float3); -ushort3 __ovld __cnfn convert_ushort3_sat_rte(float3); -ushort3 __ovld __cnfn convert_ushort3_rtz(float3); -ushort3 __ovld __cnfn convert_ushort3_sat_rtz(float3); -ushort3 __ovld __cnfn convert_ushort3_rtp(float3); -ushort3 __ovld __cnfn convert_ushort3_sat_rtp(float3); -ushort3 __ovld __cnfn convert_ushort3_rtn(float3); -ushort3 __ovld __cnfn convert_ushort3_sat_rtn(float3); -ushort3 __ovld __cnfn convert_ushort3(float3); -ushort3 __ovld __cnfn convert_ushort3_sat(float3); -int3 __ovld __cnfn convert_int3_rte(char3); -int3 __ovld __cnfn convert_int3_sat_rte(char3); -int3 __ovld __cnfn convert_int3_rtz(char3); -int3 __ovld __cnfn convert_int3_sat_rtz(char3); -int3 __ovld __cnfn convert_int3_rtp(char3); -int3 __ovld __cnfn convert_int3_sat_rtp(char3); -int3 __ovld __cnfn convert_int3_rtn(char3); -int3 __ovld __cnfn convert_int3_sat_rtn(char3); -int3 __ovld __cnfn convert_int3(char3); -int3 __ovld __cnfn convert_int3_sat(char3); -int3 __ovld __cnfn convert_int3_rte(uchar3); -int3 __ovld __cnfn convert_int3_sat_rte(uchar3); -int3 __ovld __cnfn convert_int3_rtz(uchar3); -int3 __ovld __cnfn convert_int3_sat_rtz(uchar3); -int3 __ovld __cnfn convert_int3_rtp(uchar3); -int3 __ovld __cnfn convert_int3_sat_rtp(uchar3); -int3 __ovld __cnfn convert_int3_rtn(uchar3); -int3 __ovld __cnfn convert_int3_sat_rtn(uchar3); -int3 __ovld __cnfn convert_int3(uchar3); -int3 __ovld __cnfn convert_int3_sat(uchar3); -int3 __ovld __cnfn convert_int3_rte(short3); -int3 __ovld __cnfn convert_int3_sat_rte(short3); -int3 __ovld __cnfn convert_int3_rtz(short3); -int3 __ovld __cnfn convert_int3_sat_rtz(short3); -int3 __ovld __cnfn convert_int3_rtp(short3); -int3 __ovld __cnfn convert_int3_sat_rtp(short3); -int3 __ovld __cnfn convert_int3_rtn(short3); -int3 __ovld __cnfn convert_int3_sat_rtn(short3); -int3 __ovld __cnfn convert_int3(short3); -int3 __ovld __cnfn convert_int3_sat(short3); -int3 __ovld __cnfn convert_int3_rte(ushort3); -int3 __ovld __cnfn convert_int3_sat_rte(ushort3); -int3 __ovld __cnfn convert_int3_rtz(ushort3); -int3 __ovld __cnfn convert_int3_sat_rtz(ushort3); -int3 __ovld __cnfn convert_int3_rtp(ushort3); -int3 __ovld __cnfn convert_int3_sat_rtp(ushort3); -int3 __ovld __cnfn convert_int3_rtn(ushort3); -int3 __ovld __cnfn convert_int3_sat_rtn(ushort3); -int3 __ovld __cnfn convert_int3(ushort3); -int3 __ovld __cnfn convert_int3_sat(ushort3); -int3 __ovld __cnfn convert_int3_rte(int3); -int3 __ovld __cnfn convert_int3_sat_rte(int3); -int3 __ovld __cnfn convert_int3_rtz(int3); -int3 __ovld __cnfn convert_int3_sat_rtz(int3); -int3 __ovld __cnfn convert_int3_rtp(int3); -int3 __ovld __cnfn convert_int3_sat_rtp(int3); -int3 __ovld __cnfn convert_int3_rtn(int3); -int3 __ovld __cnfn convert_int3_sat_rtn(int3); -int3 __ovld __cnfn convert_int3(int3); -int3 __ovld __cnfn convert_int3_sat(int3); -int3 __ovld __cnfn convert_int3_rte(uint3); -int3 __ovld __cnfn convert_int3_sat_rte(uint3); -int3 __ovld __cnfn convert_int3_rtz(uint3); -int3 __ovld __cnfn convert_int3_sat_rtz(uint3); -int3 __ovld __cnfn convert_int3_rtp(uint3); -int3 __ovld __cnfn convert_int3_sat_rtp(uint3); -int3 __ovld __cnfn convert_int3_rtn(uint3); -int3 __ovld __cnfn convert_int3_sat_rtn(uint3); -int3 __ovld __cnfn convert_int3(uint3); -int3 __ovld __cnfn convert_int3_sat(uint3); -int3 __ovld __cnfn convert_int3_rte(long3); -int3 __ovld __cnfn convert_int3_sat_rte(long3); -int3 __ovld __cnfn convert_int3_rtz(long3); -int3 __ovld __cnfn convert_int3_sat_rtz(long3); -int3 __ovld __cnfn convert_int3_rtp(long3); -int3 __ovld __cnfn convert_int3_sat_rtp(long3); -int3 __ovld __cnfn convert_int3_rtn(long3); -int3 __ovld __cnfn convert_int3_sat_rtn(long3); -int3 __ovld __cnfn convert_int3(long3); -int3 __ovld __cnfn convert_int3_sat(long3); -int3 __ovld __cnfn convert_int3_rte(ulong3); -int3 __ovld __cnfn convert_int3_sat_rte(ulong3); -int3 __ovld __cnfn convert_int3_rtz(ulong3); -int3 __ovld __cnfn convert_int3_sat_rtz(ulong3); -int3 __ovld __cnfn convert_int3_rtp(ulong3); -int3 __ovld __cnfn convert_int3_sat_rtp(ulong3); -int3 __ovld __cnfn convert_int3_rtn(ulong3); -int3 __ovld __cnfn convert_int3_sat_rtn(ulong3); -int3 __ovld __cnfn convert_int3(ulong3); -int3 __ovld __cnfn convert_int3_sat(ulong3); -int3 __ovld __cnfn convert_int3_rte(float3); -int3 __ovld __cnfn convert_int3_sat_rte(float3); -int3 __ovld __cnfn convert_int3_rtz(float3); -int3 __ovld __cnfn convert_int3_sat_rtz(float3); -int3 __ovld __cnfn convert_int3_rtp(float3); -int3 __ovld __cnfn convert_int3_sat_rtp(float3); -int3 __ovld __cnfn convert_int3_rtn(float3); -int3 __ovld __cnfn convert_int3_sat_rtn(float3); -int3 __ovld __cnfn convert_int3(float3); -int3 __ovld __cnfn convert_int3_sat(float3); -uint3 __ovld __cnfn convert_uint3_rte(char3); -uint3 __ovld __cnfn convert_uint3_sat_rte(char3); -uint3 __ovld __cnfn convert_uint3_rtz(char3); -uint3 __ovld __cnfn convert_uint3_sat_rtz(char3); -uint3 __ovld __cnfn convert_uint3_rtp(char3); -uint3 __ovld __cnfn convert_uint3_sat_rtp(char3); -uint3 __ovld __cnfn convert_uint3_rtn(char3); -uint3 __ovld __cnfn convert_uint3_sat_rtn(char3); -uint3 __ovld __cnfn convert_uint3(char3); -uint3 __ovld __cnfn convert_uint3_sat(char3); -uint3 __ovld __cnfn convert_uint3_rte(uchar3); -uint3 __ovld __cnfn convert_uint3_sat_rte(uchar3); -uint3 __ovld __cnfn convert_uint3_rtz(uchar3); -uint3 __ovld __cnfn convert_uint3_sat_rtz(uchar3); -uint3 __ovld __cnfn convert_uint3_rtp(uchar3); -uint3 __ovld __cnfn convert_uint3_sat_rtp(uchar3); -uint3 __ovld __cnfn convert_uint3_rtn(uchar3); -uint3 __ovld __cnfn convert_uint3_sat_rtn(uchar3); -uint3 __ovld __cnfn convert_uint3(uchar3); -uint3 __ovld __cnfn convert_uint3_sat(uchar3); -uint3 __ovld __cnfn convert_uint3_rte(short3); -uint3 __ovld __cnfn convert_uint3_sat_rte(short3); -uint3 __ovld __cnfn convert_uint3_rtz(short3); -uint3 __ovld __cnfn convert_uint3_sat_rtz(short3); -uint3 __ovld __cnfn convert_uint3_rtp(short3); -uint3 __ovld __cnfn convert_uint3_sat_rtp(short3); -uint3 __ovld __cnfn convert_uint3_rtn(short3); -uint3 __ovld __cnfn convert_uint3_sat_rtn(short3); -uint3 __ovld __cnfn convert_uint3(short3); -uint3 __ovld __cnfn convert_uint3_sat(short3); -uint3 __ovld __cnfn convert_uint3_rte(ushort3); -uint3 __ovld __cnfn convert_uint3_sat_rte(ushort3); -uint3 __ovld __cnfn convert_uint3_rtz(ushort3); -uint3 __ovld __cnfn convert_uint3_sat_rtz(ushort3); -uint3 __ovld __cnfn convert_uint3_rtp(ushort3); -uint3 __ovld __cnfn convert_uint3_sat_rtp(ushort3); -uint3 __ovld __cnfn convert_uint3_rtn(ushort3); -uint3 __ovld __cnfn convert_uint3_sat_rtn(ushort3); -uint3 __ovld __cnfn convert_uint3(ushort3); -uint3 __ovld __cnfn convert_uint3_sat(ushort3); -uint3 __ovld __cnfn convert_uint3_rte(int3); -uint3 __ovld __cnfn convert_uint3_sat_rte(int3); -uint3 __ovld __cnfn convert_uint3_rtz(int3); -uint3 __ovld __cnfn convert_uint3_sat_rtz(int3); -uint3 __ovld __cnfn convert_uint3_rtp(int3); -uint3 __ovld __cnfn convert_uint3_sat_rtp(int3); -uint3 __ovld __cnfn convert_uint3_rtn(int3); -uint3 __ovld __cnfn convert_uint3_sat_rtn(int3); -uint3 __ovld __cnfn convert_uint3(int3); -uint3 __ovld __cnfn convert_uint3_sat(int3); -uint3 __ovld __cnfn convert_uint3_rte(uint3); -uint3 __ovld __cnfn convert_uint3_sat_rte(uint3); -uint3 __ovld __cnfn convert_uint3_rtz(uint3); -uint3 __ovld __cnfn convert_uint3_sat_rtz(uint3); -uint3 __ovld __cnfn convert_uint3_rtp(uint3); -uint3 __ovld __cnfn convert_uint3_sat_rtp(uint3); -uint3 __ovld __cnfn convert_uint3_rtn(uint3); -uint3 __ovld __cnfn convert_uint3_sat_rtn(uint3); -uint3 __ovld __cnfn convert_uint3(uint3); -uint3 __ovld __cnfn convert_uint3_sat(uint3); -uint3 __ovld __cnfn convert_uint3_rte(long3); -uint3 __ovld __cnfn convert_uint3_sat_rte(long3); -uint3 __ovld __cnfn convert_uint3_rtz(long3); -uint3 __ovld __cnfn convert_uint3_sat_rtz(long3); -uint3 __ovld __cnfn convert_uint3_rtp(long3); -uint3 __ovld __cnfn convert_uint3_sat_rtp(long3); -uint3 __ovld __cnfn convert_uint3_rtn(long3); -uint3 __ovld __cnfn convert_uint3_sat_rtn(long3); -uint3 __ovld __cnfn convert_uint3(long3); -uint3 __ovld __cnfn convert_uint3_sat(long3); -uint3 __ovld __cnfn convert_uint3_rte(ulong3); -uint3 __ovld __cnfn convert_uint3_sat_rte(ulong3); -uint3 __ovld __cnfn convert_uint3_rtz(ulong3); -uint3 __ovld __cnfn convert_uint3_sat_rtz(ulong3); -uint3 __ovld __cnfn convert_uint3_rtp(ulong3); -uint3 __ovld __cnfn convert_uint3_sat_rtp(ulong3); -uint3 __ovld __cnfn convert_uint3_rtn(ulong3); -uint3 __ovld __cnfn convert_uint3_sat_rtn(ulong3); -uint3 __ovld __cnfn convert_uint3(ulong3); -uint3 __ovld __cnfn convert_uint3_sat(ulong3); -uint3 __ovld __cnfn convert_uint3_rte(float3); -uint3 __ovld __cnfn convert_uint3_sat_rte(float3); -uint3 __ovld __cnfn convert_uint3_rtz(float3); -uint3 __ovld __cnfn convert_uint3_sat_rtz(float3); -uint3 __ovld __cnfn convert_uint3_rtp(float3); -uint3 __ovld __cnfn convert_uint3_sat_rtp(float3); -uint3 __ovld __cnfn convert_uint3_rtn(float3); -uint3 __ovld __cnfn convert_uint3_sat_rtn(float3); -uint3 __ovld __cnfn convert_uint3(float3); -uint3 __ovld __cnfn convert_uint3_sat(float3); -long3 __ovld __cnfn convert_long3_rte(char3); -long3 __ovld __cnfn convert_long3_sat_rte(char3); -long3 __ovld __cnfn convert_long3_rtz(char3); -long3 __ovld __cnfn convert_long3_sat_rtz(char3); -long3 __ovld __cnfn convert_long3_rtp(char3); -long3 __ovld __cnfn convert_long3_sat_rtp(char3); -long3 __ovld __cnfn convert_long3_rtn(char3); -long3 __ovld __cnfn convert_long3_sat_rtn(char3); -long3 __ovld __cnfn convert_long3(char3); -long3 __ovld __cnfn convert_long3_sat(char3); -long3 __ovld __cnfn convert_long3_rte(uchar3); -long3 __ovld __cnfn convert_long3_sat_rte(uchar3); -long3 __ovld __cnfn convert_long3_rtz(uchar3); -long3 __ovld __cnfn convert_long3_sat_rtz(uchar3); -long3 __ovld __cnfn convert_long3_rtp(uchar3); -long3 __ovld __cnfn convert_long3_sat_rtp(uchar3); -long3 __ovld __cnfn convert_long3_rtn(uchar3); -long3 __ovld __cnfn convert_long3_sat_rtn(uchar3); -long3 __ovld __cnfn convert_long3(uchar3); -long3 __ovld __cnfn convert_long3_sat(uchar3); -long3 __ovld __cnfn convert_long3_rte(short3); -long3 __ovld __cnfn convert_long3_sat_rte(short3); -long3 __ovld __cnfn convert_long3_rtz(short3); -long3 __ovld __cnfn convert_long3_sat_rtz(short3); -long3 __ovld __cnfn convert_long3_rtp(short3); -long3 __ovld __cnfn convert_long3_sat_rtp(short3); -long3 __ovld __cnfn convert_long3_rtn(short3); -long3 __ovld __cnfn convert_long3_sat_rtn(short3); -long3 __ovld __cnfn convert_long3(short3); -long3 __ovld __cnfn convert_long3_sat(short3); -long3 __ovld __cnfn convert_long3_rte(ushort3); -long3 __ovld __cnfn convert_long3_sat_rte(ushort3); -long3 __ovld __cnfn convert_long3_rtz(ushort3); -long3 __ovld __cnfn convert_long3_sat_rtz(ushort3); -long3 __ovld __cnfn convert_long3_rtp(ushort3); -long3 __ovld __cnfn convert_long3_sat_rtp(ushort3); -long3 __ovld __cnfn convert_long3_rtn(ushort3); -long3 __ovld __cnfn convert_long3_sat_rtn(ushort3); -long3 __ovld __cnfn convert_long3(ushort3); -long3 __ovld __cnfn convert_long3_sat(ushort3); -long3 __ovld __cnfn convert_long3_rte(int3); -long3 __ovld __cnfn convert_long3_sat_rte(int3); -long3 __ovld __cnfn convert_long3_rtz(int3); -long3 __ovld __cnfn convert_long3_sat_rtz(int3); -long3 __ovld __cnfn convert_long3_rtp(int3); -long3 __ovld __cnfn convert_long3_sat_rtp(int3); -long3 __ovld __cnfn convert_long3_rtn(int3); -long3 __ovld __cnfn convert_long3_sat_rtn(int3); -long3 __ovld __cnfn convert_long3(int3); -long3 __ovld __cnfn convert_long3_sat(int3); -long3 __ovld __cnfn convert_long3_rte(uint3); -long3 __ovld __cnfn convert_long3_sat_rte(uint3); -long3 __ovld __cnfn convert_long3_rtz(uint3); -long3 __ovld __cnfn convert_long3_sat_rtz(uint3); -long3 __ovld __cnfn convert_long3_rtp(uint3); -long3 __ovld __cnfn convert_long3_sat_rtp(uint3); -long3 __ovld __cnfn convert_long3_rtn(uint3); -long3 __ovld __cnfn convert_long3_sat_rtn(uint3); -long3 __ovld __cnfn convert_long3(uint3); -long3 __ovld __cnfn convert_long3_sat(uint3); -long3 __ovld __cnfn convert_long3_rte(long3); -long3 __ovld __cnfn convert_long3_sat_rte(long3); -long3 __ovld __cnfn convert_long3_rtz(long3); -long3 __ovld __cnfn convert_long3_sat_rtz(long3); -long3 __ovld __cnfn convert_long3_rtp(long3); -long3 __ovld __cnfn convert_long3_sat_rtp(long3); -long3 __ovld __cnfn convert_long3_rtn(long3); -long3 __ovld __cnfn convert_long3_sat_rtn(long3); -long3 __ovld __cnfn convert_long3(long3); -long3 __ovld __cnfn convert_long3_sat(long3); -long3 __ovld __cnfn convert_long3_rte(ulong3); -long3 __ovld __cnfn convert_long3_sat_rte(ulong3); -long3 __ovld __cnfn convert_long3_rtz(ulong3); -long3 __ovld __cnfn convert_long3_sat_rtz(ulong3); -long3 __ovld __cnfn convert_long3_rtp(ulong3); -long3 __ovld __cnfn convert_long3_sat_rtp(ulong3); -long3 __ovld __cnfn convert_long3_rtn(ulong3); -long3 __ovld __cnfn convert_long3_sat_rtn(ulong3); -long3 __ovld __cnfn convert_long3(ulong3); -long3 __ovld __cnfn convert_long3_sat(ulong3); -long3 __ovld __cnfn convert_long3_rte(float3); -long3 __ovld __cnfn convert_long3_sat_rte(float3); -long3 __ovld __cnfn convert_long3_rtz(float3); -long3 __ovld __cnfn convert_long3_sat_rtz(float3); -long3 __ovld __cnfn convert_long3_rtp(float3); -long3 __ovld __cnfn convert_long3_sat_rtp(float3); -long3 __ovld __cnfn convert_long3_rtn(float3); -long3 __ovld __cnfn convert_long3_sat_rtn(float3); -long3 __ovld __cnfn convert_long3(float3); -long3 __ovld __cnfn convert_long3_sat(float3); -ulong3 __ovld __cnfn convert_ulong3_rte(char3); -ulong3 __ovld __cnfn convert_ulong3_sat_rte(char3); -ulong3 __ovld __cnfn convert_ulong3_rtz(char3); -ulong3 __ovld __cnfn convert_ulong3_sat_rtz(char3); -ulong3 __ovld __cnfn convert_ulong3_rtp(char3); -ulong3 __ovld __cnfn convert_ulong3_sat_rtp(char3); -ulong3 __ovld __cnfn convert_ulong3_rtn(char3); -ulong3 __ovld __cnfn convert_ulong3_sat_rtn(char3); -ulong3 __ovld __cnfn convert_ulong3(char3); -ulong3 __ovld __cnfn convert_ulong3_sat(char3); -ulong3 __ovld __cnfn convert_ulong3_rte(uchar3); -ulong3 __ovld __cnfn convert_ulong3_sat_rte(uchar3); -ulong3 __ovld __cnfn convert_ulong3_rtz(uchar3); -ulong3 __ovld __cnfn convert_ulong3_sat_rtz(uchar3); -ulong3 __ovld __cnfn convert_ulong3_rtp(uchar3); -ulong3 __ovld __cnfn convert_ulong3_sat_rtp(uchar3); -ulong3 __ovld __cnfn convert_ulong3_rtn(uchar3); -ulong3 __ovld __cnfn convert_ulong3_sat_rtn(uchar3); -ulong3 __ovld __cnfn convert_ulong3(uchar3); -ulong3 __ovld __cnfn convert_ulong3_sat(uchar3); -ulong3 __ovld __cnfn convert_ulong3_rte(short3); -ulong3 __ovld __cnfn convert_ulong3_sat_rte(short3); -ulong3 __ovld __cnfn convert_ulong3_rtz(short3); -ulong3 __ovld __cnfn convert_ulong3_sat_rtz(short3); -ulong3 __ovld __cnfn convert_ulong3_rtp(short3); -ulong3 __ovld __cnfn convert_ulong3_sat_rtp(short3); -ulong3 __ovld __cnfn convert_ulong3_rtn(short3); -ulong3 __ovld __cnfn convert_ulong3_sat_rtn(short3); -ulong3 __ovld __cnfn convert_ulong3(short3); -ulong3 __ovld __cnfn convert_ulong3_sat(short3); -ulong3 __ovld __cnfn convert_ulong3_rte(ushort3); -ulong3 __ovld __cnfn convert_ulong3_sat_rte(ushort3); -ulong3 __ovld __cnfn convert_ulong3_rtz(ushort3); -ulong3 __ovld __cnfn convert_ulong3_sat_rtz(ushort3); -ulong3 __ovld __cnfn convert_ulong3_rtp(ushort3); -ulong3 __ovld __cnfn convert_ulong3_sat_rtp(ushort3); -ulong3 __ovld __cnfn convert_ulong3_rtn(ushort3); -ulong3 __ovld __cnfn convert_ulong3_sat_rtn(ushort3); -ulong3 __ovld __cnfn convert_ulong3(ushort3); -ulong3 __ovld __cnfn convert_ulong3_sat(ushort3); -ulong3 __ovld __cnfn convert_ulong3_rte(int3); -ulong3 __ovld __cnfn convert_ulong3_sat_rte(int3); -ulong3 __ovld __cnfn convert_ulong3_rtz(int3); -ulong3 __ovld __cnfn convert_ulong3_sat_rtz(int3); -ulong3 __ovld __cnfn convert_ulong3_rtp(int3); -ulong3 __ovld __cnfn convert_ulong3_sat_rtp(int3); -ulong3 __ovld __cnfn convert_ulong3_rtn(int3); -ulong3 __ovld __cnfn convert_ulong3_sat_rtn(int3); -ulong3 __ovld __cnfn convert_ulong3(int3); -ulong3 __ovld __cnfn convert_ulong3_sat(int3); -ulong3 __ovld __cnfn convert_ulong3_rte(uint3); -ulong3 __ovld __cnfn convert_ulong3_sat_rte(uint3); -ulong3 __ovld __cnfn convert_ulong3_rtz(uint3); -ulong3 __ovld __cnfn convert_ulong3_sat_rtz(uint3); -ulong3 __ovld __cnfn convert_ulong3_rtp(uint3); -ulong3 __ovld __cnfn convert_ulong3_sat_rtp(uint3); -ulong3 __ovld __cnfn convert_ulong3_rtn(uint3); -ulong3 __ovld __cnfn convert_ulong3_sat_rtn(uint3); -ulong3 __ovld __cnfn convert_ulong3(uint3); -ulong3 __ovld __cnfn convert_ulong3_sat(uint3); -ulong3 __ovld __cnfn convert_ulong3_rte(long3); -ulong3 __ovld __cnfn convert_ulong3_sat_rte(long3); -ulong3 __ovld __cnfn convert_ulong3_rtz(long3); -ulong3 __ovld __cnfn convert_ulong3_sat_rtz(long3); -ulong3 __ovld __cnfn convert_ulong3_rtp(long3); -ulong3 __ovld __cnfn convert_ulong3_sat_rtp(long3); -ulong3 __ovld __cnfn convert_ulong3_rtn(long3); -ulong3 __ovld __cnfn convert_ulong3_sat_rtn(long3); -ulong3 __ovld __cnfn convert_ulong3(long3); -ulong3 __ovld __cnfn convert_ulong3_sat(long3); -ulong3 __ovld __cnfn convert_ulong3_rte(ulong3); -ulong3 __ovld __cnfn convert_ulong3_sat_rte(ulong3); -ulong3 __ovld __cnfn convert_ulong3_rtz(ulong3); -ulong3 __ovld __cnfn convert_ulong3_sat_rtz(ulong3); -ulong3 __ovld __cnfn convert_ulong3_rtp(ulong3); -ulong3 __ovld __cnfn convert_ulong3_sat_rtp(ulong3); -ulong3 __ovld __cnfn convert_ulong3_rtn(ulong3); -ulong3 __ovld __cnfn convert_ulong3_sat_rtn(ulong3); -ulong3 __ovld __cnfn convert_ulong3(ulong3); -ulong3 __ovld __cnfn convert_ulong3_sat(ulong3); -ulong3 __ovld __cnfn convert_ulong3_rte(float3); -ulong3 __ovld __cnfn convert_ulong3_sat_rte(float3); -ulong3 __ovld __cnfn convert_ulong3_rtz(float3); -ulong3 __ovld __cnfn convert_ulong3_sat_rtz(float3); -ulong3 __ovld __cnfn convert_ulong3_rtp(float3); -ulong3 __ovld __cnfn convert_ulong3_sat_rtp(float3); -ulong3 __ovld __cnfn convert_ulong3_rtn(float3); -ulong3 __ovld __cnfn convert_ulong3_sat_rtn(float3); -ulong3 __ovld __cnfn convert_ulong3(float3); -ulong3 __ovld __cnfn convert_ulong3_sat(float3); -float3 __ovld __cnfn convert_float3_rte(char3); -float3 __ovld __cnfn convert_float3_rtz(char3); -float3 __ovld __cnfn convert_float3_rtp(char3); -float3 __ovld __cnfn convert_float3_rtn(char3); -float3 __ovld __cnfn convert_float3(char3); -float3 __ovld __cnfn convert_float3_rte(uchar3); -float3 __ovld __cnfn convert_float3_rtz(uchar3); -float3 __ovld __cnfn convert_float3_rtp(uchar3); -float3 __ovld __cnfn convert_float3_rtn(uchar3); -float3 __ovld __cnfn convert_float3(uchar3); -float3 __ovld __cnfn convert_float3_rte(short3); -float3 __ovld __cnfn convert_float3_rtz(short3); -float3 __ovld __cnfn convert_float3_rtp(short3); -float3 __ovld __cnfn convert_float3_rtn(short3); -float3 __ovld __cnfn convert_float3(short3); -float3 __ovld __cnfn convert_float3_rte(ushort3); -float3 __ovld __cnfn convert_float3_rtz(ushort3); -float3 __ovld __cnfn convert_float3_rtp(ushort3); -float3 __ovld __cnfn convert_float3_rtn(ushort3); -float3 __ovld __cnfn convert_float3(ushort3); -float3 __ovld __cnfn convert_float3_rte(int3); -float3 __ovld __cnfn convert_float3_rtz(int3); -float3 __ovld __cnfn convert_float3_rtp(int3); -float3 __ovld __cnfn convert_float3_rtn(int3); -float3 __ovld __cnfn convert_float3(int3); -float3 __ovld __cnfn convert_float3_rte(uint3); -float3 __ovld __cnfn convert_float3_rtz(uint3); -float3 __ovld __cnfn convert_float3_rtp(uint3); -float3 __ovld __cnfn convert_float3_rtn(uint3); -float3 __ovld __cnfn convert_float3(uint3); -float3 __ovld __cnfn convert_float3_rte(long3); -float3 __ovld __cnfn convert_float3_rtz(long3); -float3 __ovld __cnfn convert_float3_rtp(long3); -float3 __ovld __cnfn convert_float3_rtn(long3); -float3 __ovld __cnfn convert_float3(long3); -float3 __ovld __cnfn convert_float3_rte(ulong3); -float3 __ovld __cnfn convert_float3_rtz(ulong3); -float3 __ovld __cnfn convert_float3_rtp(ulong3); -float3 __ovld __cnfn convert_float3_rtn(ulong3); -float3 __ovld __cnfn convert_float3(ulong3); -float3 __ovld __cnfn convert_float3_rte(float3); -float3 __ovld __cnfn convert_float3_rtz(float3); -float3 __ovld __cnfn convert_float3_rtp(float3); -float3 __ovld __cnfn convert_float3_rtn(float3); -float3 __ovld __cnfn convert_float3(float3); -char4 __ovld __cnfn convert_char4_rte(char4); -char4 __ovld __cnfn convert_char4_sat_rte(char4); -char4 __ovld __cnfn convert_char4_rtz(char4); -char4 __ovld __cnfn convert_char4_sat_rtz(char4); -char4 __ovld __cnfn convert_char4_rtp(char4); -char4 __ovld __cnfn convert_char4_sat_rtp(char4); -char4 __ovld __cnfn convert_char4_rtn(char4); -char4 __ovld __cnfn convert_char4_sat_rtn(char4); -char4 __ovld __cnfn convert_char4(char4); -char4 __ovld __cnfn convert_char4_sat(char4); -char4 __ovld __cnfn convert_char4_rte(uchar4); -char4 __ovld __cnfn convert_char4_sat_rte(uchar4); -char4 __ovld __cnfn convert_char4_rtz(uchar4); -char4 __ovld __cnfn convert_char4_sat_rtz(uchar4); -char4 __ovld __cnfn convert_char4_rtp(uchar4); -char4 __ovld __cnfn convert_char4_sat_rtp(uchar4); -char4 __ovld __cnfn convert_char4_rtn(uchar4); -char4 __ovld __cnfn convert_char4_sat_rtn(uchar4); -char4 __ovld __cnfn convert_char4(uchar4); -char4 __ovld __cnfn convert_char4_sat(uchar4); -char4 __ovld __cnfn convert_char4_rte(short4); -char4 __ovld __cnfn convert_char4_sat_rte(short4); -char4 __ovld __cnfn convert_char4_rtz(short4); -char4 __ovld __cnfn convert_char4_sat_rtz(short4); -char4 __ovld __cnfn convert_char4_rtp(short4); -char4 __ovld __cnfn convert_char4_sat_rtp(short4); -char4 __ovld __cnfn convert_char4_rtn(short4); -char4 __ovld __cnfn convert_char4_sat_rtn(short4); -char4 __ovld __cnfn convert_char4(short4); -char4 __ovld __cnfn convert_char4_sat(short4); -char4 __ovld __cnfn convert_char4_rte(ushort4); -char4 __ovld __cnfn convert_char4_sat_rte(ushort4); -char4 __ovld __cnfn convert_char4_rtz(ushort4); -char4 __ovld __cnfn convert_char4_sat_rtz(ushort4); -char4 __ovld __cnfn convert_char4_rtp(ushort4); -char4 __ovld __cnfn convert_char4_sat_rtp(ushort4); -char4 __ovld __cnfn convert_char4_rtn(ushort4); -char4 __ovld __cnfn convert_char4_sat_rtn(ushort4); -char4 __ovld __cnfn convert_char4(ushort4); -char4 __ovld __cnfn convert_char4_sat(ushort4); -char4 __ovld __cnfn convert_char4_rte(int4); -char4 __ovld __cnfn convert_char4_sat_rte(int4); -char4 __ovld __cnfn convert_char4_rtz(int4); -char4 __ovld __cnfn convert_char4_sat_rtz(int4); -char4 __ovld __cnfn convert_char4_rtp(int4); -char4 __ovld __cnfn convert_char4_sat_rtp(int4); -char4 __ovld __cnfn convert_char4_rtn(int4); -char4 __ovld __cnfn convert_char4_sat_rtn(int4); -char4 __ovld __cnfn convert_char4(int4); -char4 __ovld __cnfn convert_char4_sat(int4); -char4 __ovld __cnfn convert_char4_rte(uint4); -char4 __ovld __cnfn convert_char4_sat_rte(uint4); -char4 __ovld __cnfn convert_char4_rtz(uint4); -char4 __ovld __cnfn convert_char4_sat_rtz(uint4); -char4 __ovld __cnfn convert_char4_rtp(uint4); -char4 __ovld __cnfn convert_char4_sat_rtp(uint4); -char4 __ovld __cnfn convert_char4_rtn(uint4); -char4 __ovld __cnfn convert_char4_sat_rtn(uint4); -char4 __ovld __cnfn convert_char4(uint4); -char4 __ovld __cnfn convert_char4_sat(uint4); -char4 __ovld __cnfn convert_char4_rte(long4); -char4 __ovld __cnfn convert_char4_sat_rte(long4); -char4 __ovld __cnfn convert_char4_rtz(long4); -char4 __ovld __cnfn convert_char4_sat_rtz(long4); -char4 __ovld __cnfn convert_char4_rtp(long4); -char4 __ovld __cnfn convert_char4_sat_rtp(long4); -char4 __ovld __cnfn convert_char4_rtn(long4); -char4 __ovld __cnfn convert_char4_sat_rtn(long4); -char4 __ovld __cnfn convert_char4(long4); -char4 __ovld __cnfn convert_char4_sat(long4); -char4 __ovld __cnfn convert_char4_rte(ulong4); -char4 __ovld __cnfn convert_char4_sat_rte(ulong4); -char4 __ovld __cnfn convert_char4_rtz(ulong4); -char4 __ovld __cnfn convert_char4_sat_rtz(ulong4); -char4 __ovld __cnfn convert_char4_rtp(ulong4); -char4 __ovld __cnfn convert_char4_sat_rtp(ulong4); -char4 __ovld __cnfn convert_char4_rtn(ulong4); -char4 __ovld __cnfn convert_char4_sat_rtn(ulong4); -char4 __ovld __cnfn convert_char4(ulong4); -char4 __ovld __cnfn convert_char4_sat(ulong4); -char4 __ovld __cnfn convert_char4_rte(float4); -char4 __ovld __cnfn convert_char4_sat_rte(float4); -char4 __ovld __cnfn convert_char4_rtz(float4); -char4 __ovld __cnfn convert_char4_sat_rtz(float4); -char4 __ovld __cnfn convert_char4_rtp(float4); -char4 __ovld __cnfn convert_char4_sat_rtp(float4); -char4 __ovld __cnfn convert_char4_rtn(float4); -char4 __ovld __cnfn convert_char4_sat_rtn(float4); -char4 __ovld __cnfn convert_char4(float4); -char4 __ovld __cnfn convert_char4_sat(float4); -uchar4 __ovld __cnfn convert_uchar4_rte(char4); -uchar4 __ovld __cnfn convert_uchar4_sat_rte(char4); -uchar4 __ovld __cnfn convert_uchar4_rtz(char4); -uchar4 __ovld __cnfn convert_uchar4_sat_rtz(char4); -uchar4 __ovld __cnfn convert_uchar4_rtp(char4); -uchar4 __ovld __cnfn convert_uchar4_sat_rtp(char4); -uchar4 __ovld __cnfn convert_uchar4_rtn(char4); -uchar4 __ovld __cnfn convert_uchar4_sat_rtn(char4); -uchar4 __ovld __cnfn convert_uchar4(char4); -uchar4 __ovld __cnfn convert_uchar4_sat(char4); -uchar4 __ovld __cnfn convert_uchar4_rte(uchar4); -uchar4 __ovld __cnfn convert_uchar4_sat_rte(uchar4); -uchar4 __ovld __cnfn convert_uchar4_rtz(uchar4); -uchar4 __ovld __cnfn convert_uchar4_sat_rtz(uchar4); -uchar4 __ovld __cnfn convert_uchar4_rtp(uchar4); -uchar4 __ovld __cnfn convert_uchar4_sat_rtp(uchar4); -uchar4 __ovld __cnfn convert_uchar4_rtn(uchar4); -uchar4 __ovld __cnfn convert_uchar4_sat_rtn(uchar4); -uchar4 __ovld __cnfn convert_uchar4(uchar4); -uchar4 __ovld __cnfn convert_uchar4_sat(uchar4); -uchar4 __ovld __cnfn convert_uchar4_rte(short4); -uchar4 __ovld __cnfn convert_uchar4_sat_rte(short4); -uchar4 __ovld __cnfn convert_uchar4_rtz(short4); -uchar4 __ovld __cnfn convert_uchar4_sat_rtz(short4); -uchar4 __ovld __cnfn convert_uchar4_rtp(short4); -uchar4 __ovld __cnfn convert_uchar4_sat_rtp(short4); -uchar4 __ovld __cnfn convert_uchar4_rtn(short4); -uchar4 __ovld __cnfn convert_uchar4_sat_rtn(short4); -uchar4 __ovld __cnfn convert_uchar4(short4); -uchar4 __ovld __cnfn convert_uchar4_sat(short4); -uchar4 __ovld __cnfn convert_uchar4_rte(ushort4); -uchar4 __ovld __cnfn convert_uchar4_sat_rte(ushort4); -uchar4 __ovld __cnfn convert_uchar4_rtz(ushort4); -uchar4 __ovld __cnfn convert_uchar4_sat_rtz(ushort4); -uchar4 __ovld __cnfn convert_uchar4_rtp(ushort4); -uchar4 __ovld __cnfn convert_uchar4_sat_rtp(ushort4); -uchar4 __ovld __cnfn convert_uchar4_rtn(ushort4); -uchar4 __ovld __cnfn convert_uchar4_sat_rtn(ushort4); -uchar4 __ovld __cnfn convert_uchar4(ushort4); -uchar4 __ovld __cnfn convert_uchar4_sat(ushort4); -uchar4 __ovld __cnfn convert_uchar4_rte(int4); -uchar4 __ovld __cnfn convert_uchar4_sat_rte(int4); -uchar4 __ovld __cnfn convert_uchar4_rtz(int4); -uchar4 __ovld __cnfn convert_uchar4_sat_rtz(int4); -uchar4 __ovld __cnfn convert_uchar4_rtp(int4); -uchar4 __ovld __cnfn convert_uchar4_sat_rtp(int4); -uchar4 __ovld __cnfn convert_uchar4_rtn(int4); -uchar4 __ovld __cnfn convert_uchar4_sat_rtn(int4); -uchar4 __ovld __cnfn convert_uchar4(int4); -uchar4 __ovld __cnfn convert_uchar4_sat(int4); -uchar4 __ovld __cnfn convert_uchar4_rte(uint4); -uchar4 __ovld __cnfn convert_uchar4_sat_rte(uint4); -uchar4 __ovld __cnfn convert_uchar4_rtz(uint4); -uchar4 __ovld __cnfn convert_uchar4_sat_rtz(uint4); -uchar4 __ovld __cnfn convert_uchar4_rtp(uint4); -uchar4 __ovld __cnfn convert_uchar4_sat_rtp(uint4); -uchar4 __ovld __cnfn convert_uchar4_rtn(uint4); -uchar4 __ovld __cnfn convert_uchar4_sat_rtn(uint4); -uchar4 __ovld __cnfn convert_uchar4(uint4); -uchar4 __ovld __cnfn convert_uchar4_sat(uint4); -uchar4 __ovld __cnfn convert_uchar4_rte(long4); -uchar4 __ovld __cnfn convert_uchar4_sat_rte(long4); -uchar4 __ovld __cnfn convert_uchar4_rtz(long4); -uchar4 __ovld __cnfn convert_uchar4_sat_rtz(long4); -uchar4 __ovld __cnfn convert_uchar4_rtp(long4); -uchar4 __ovld __cnfn convert_uchar4_sat_rtp(long4); -uchar4 __ovld __cnfn convert_uchar4_rtn(long4); -uchar4 __ovld __cnfn convert_uchar4_sat_rtn(long4); -uchar4 __ovld __cnfn convert_uchar4(long4); -uchar4 __ovld __cnfn convert_uchar4_sat(long4); -uchar4 __ovld __cnfn convert_uchar4_rte(ulong4); -uchar4 __ovld __cnfn convert_uchar4_sat_rte(ulong4); -uchar4 __ovld __cnfn convert_uchar4_rtz(ulong4); -uchar4 __ovld __cnfn convert_uchar4_sat_rtz(ulong4); -uchar4 __ovld __cnfn convert_uchar4_rtp(ulong4); -uchar4 __ovld __cnfn convert_uchar4_sat_rtp(ulong4); -uchar4 __ovld __cnfn convert_uchar4_rtn(ulong4); -uchar4 __ovld __cnfn convert_uchar4_sat_rtn(ulong4); -uchar4 __ovld __cnfn convert_uchar4(ulong4); -uchar4 __ovld __cnfn convert_uchar4_sat(ulong4); -uchar4 __ovld __cnfn convert_uchar4_rte(float4); -uchar4 __ovld __cnfn convert_uchar4_sat_rte(float4); -uchar4 __ovld __cnfn convert_uchar4_rtz(float4); -uchar4 __ovld __cnfn convert_uchar4_sat_rtz(float4); -uchar4 __ovld __cnfn convert_uchar4_rtp(float4); -uchar4 __ovld __cnfn convert_uchar4_sat_rtp(float4); -uchar4 __ovld __cnfn convert_uchar4_rtn(float4); -uchar4 __ovld __cnfn convert_uchar4_sat_rtn(float4); -uchar4 __ovld __cnfn convert_uchar4(float4); -uchar4 __ovld __cnfn convert_uchar4_sat(float4); -short4 __ovld __cnfn convert_short4_rte(char4); -short4 __ovld __cnfn convert_short4_sat_rte(char4); -short4 __ovld __cnfn convert_short4_rtz(char4); -short4 __ovld __cnfn convert_short4_sat_rtz(char4); -short4 __ovld __cnfn convert_short4_rtp(char4); -short4 __ovld __cnfn convert_short4_sat_rtp(char4); -short4 __ovld __cnfn convert_short4_rtn(char4); -short4 __ovld __cnfn convert_short4_sat_rtn(char4); -short4 __ovld __cnfn convert_short4(char4); -short4 __ovld __cnfn convert_short4_sat(char4); -short4 __ovld __cnfn convert_short4_rte(uchar4); -short4 __ovld __cnfn convert_short4_sat_rte(uchar4); -short4 __ovld __cnfn convert_short4_rtz(uchar4); -short4 __ovld __cnfn convert_short4_sat_rtz(uchar4); -short4 __ovld __cnfn convert_short4_rtp(uchar4); -short4 __ovld __cnfn convert_short4_sat_rtp(uchar4); -short4 __ovld __cnfn convert_short4_rtn(uchar4); -short4 __ovld __cnfn convert_short4_sat_rtn(uchar4); -short4 __ovld __cnfn convert_short4(uchar4); -short4 __ovld __cnfn convert_short4_sat(uchar4); -short4 __ovld __cnfn convert_short4_rte(short4); -short4 __ovld __cnfn convert_short4_sat_rte(short4); -short4 __ovld __cnfn convert_short4_rtz(short4); -short4 __ovld __cnfn convert_short4_sat_rtz(short4); -short4 __ovld __cnfn convert_short4_rtp(short4); -short4 __ovld __cnfn convert_short4_sat_rtp(short4); -short4 __ovld __cnfn convert_short4_rtn(short4); -short4 __ovld __cnfn convert_short4_sat_rtn(short4); -short4 __ovld __cnfn convert_short4(short4); -short4 __ovld __cnfn convert_short4_sat(short4); -short4 __ovld __cnfn convert_short4_rte(ushort4); -short4 __ovld __cnfn convert_short4_sat_rte(ushort4); -short4 __ovld __cnfn convert_short4_rtz(ushort4); -short4 __ovld __cnfn convert_short4_sat_rtz(ushort4); -short4 __ovld __cnfn convert_short4_rtp(ushort4); -short4 __ovld __cnfn convert_short4_sat_rtp(ushort4); -short4 __ovld __cnfn convert_short4_rtn(ushort4); -short4 __ovld __cnfn convert_short4_sat_rtn(ushort4); -short4 __ovld __cnfn convert_short4(ushort4); -short4 __ovld __cnfn convert_short4_sat(ushort4); -short4 __ovld __cnfn convert_short4_rte(int4); -short4 __ovld __cnfn convert_short4_sat_rte(int4); -short4 __ovld __cnfn convert_short4_rtz(int4); -short4 __ovld __cnfn convert_short4_sat_rtz(int4); -short4 __ovld __cnfn convert_short4_rtp(int4); -short4 __ovld __cnfn convert_short4_sat_rtp(int4); -short4 __ovld __cnfn convert_short4_rtn(int4); -short4 __ovld __cnfn convert_short4_sat_rtn(int4); -short4 __ovld __cnfn convert_short4(int4); -short4 __ovld __cnfn convert_short4_sat(int4); -short4 __ovld __cnfn convert_short4_rte(uint4); -short4 __ovld __cnfn convert_short4_sat_rte(uint4); -short4 __ovld __cnfn convert_short4_rtz(uint4); -short4 __ovld __cnfn convert_short4_sat_rtz(uint4); -short4 __ovld __cnfn convert_short4_rtp(uint4); -short4 __ovld __cnfn convert_short4_sat_rtp(uint4); -short4 __ovld __cnfn convert_short4_rtn(uint4); -short4 __ovld __cnfn convert_short4_sat_rtn(uint4); -short4 __ovld __cnfn convert_short4(uint4); -short4 __ovld __cnfn convert_short4_sat(uint4); -short4 __ovld __cnfn convert_short4_rte(long4); -short4 __ovld __cnfn convert_short4_sat_rte(long4); -short4 __ovld __cnfn convert_short4_rtz(long4); -short4 __ovld __cnfn convert_short4_sat_rtz(long4); -short4 __ovld __cnfn convert_short4_rtp(long4); -short4 __ovld __cnfn convert_short4_sat_rtp(long4); -short4 __ovld __cnfn convert_short4_rtn(long4); -short4 __ovld __cnfn convert_short4_sat_rtn(long4); -short4 __ovld __cnfn convert_short4(long4); -short4 __ovld __cnfn convert_short4_sat(long4); -short4 __ovld __cnfn convert_short4_rte(ulong4); -short4 __ovld __cnfn convert_short4_sat_rte(ulong4); -short4 __ovld __cnfn convert_short4_rtz(ulong4); -short4 __ovld __cnfn convert_short4_sat_rtz(ulong4); -short4 __ovld __cnfn convert_short4_rtp(ulong4); -short4 __ovld __cnfn convert_short4_sat_rtp(ulong4); -short4 __ovld __cnfn convert_short4_rtn(ulong4); -short4 __ovld __cnfn convert_short4_sat_rtn(ulong4); -short4 __ovld __cnfn convert_short4(ulong4); -short4 __ovld __cnfn convert_short4_sat(ulong4); -short4 __ovld __cnfn convert_short4_rte(float4); -short4 __ovld __cnfn convert_short4_sat_rte(float4); -short4 __ovld __cnfn convert_short4_rtz(float4); -short4 __ovld __cnfn convert_short4_sat_rtz(float4); -short4 __ovld __cnfn convert_short4_rtp(float4); -short4 __ovld __cnfn convert_short4_sat_rtp(float4); -short4 __ovld __cnfn convert_short4_rtn(float4); -short4 __ovld __cnfn convert_short4_sat_rtn(float4); -short4 __ovld __cnfn convert_short4(float4); -short4 __ovld __cnfn convert_short4_sat(float4); -ushort4 __ovld __cnfn convert_ushort4_rte(char4); -ushort4 __ovld __cnfn convert_ushort4_sat_rte(char4); -ushort4 __ovld __cnfn convert_ushort4_rtz(char4); -ushort4 __ovld __cnfn convert_ushort4_sat_rtz(char4); -ushort4 __ovld __cnfn convert_ushort4_rtp(char4); -ushort4 __ovld __cnfn convert_ushort4_sat_rtp(char4); -ushort4 __ovld __cnfn convert_ushort4_rtn(char4); -ushort4 __ovld __cnfn convert_ushort4_sat_rtn(char4); -ushort4 __ovld __cnfn convert_ushort4(char4); -ushort4 __ovld __cnfn convert_ushort4_sat(char4); -ushort4 __ovld __cnfn convert_ushort4_rte(uchar4); -ushort4 __ovld __cnfn convert_ushort4_sat_rte(uchar4); -ushort4 __ovld __cnfn convert_ushort4_rtz(uchar4); -ushort4 __ovld __cnfn convert_ushort4_sat_rtz(uchar4); -ushort4 __ovld __cnfn convert_ushort4_rtp(uchar4); -ushort4 __ovld __cnfn convert_ushort4_sat_rtp(uchar4); -ushort4 __ovld __cnfn convert_ushort4_rtn(uchar4); -ushort4 __ovld __cnfn convert_ushort4_sat_rtn(uchar4); -ushort4 __ovld __cnfn convert_ushort4(uchar4); -ushort4 __ovld __cnfn convert_ushort4_sat(uchar4); -ushort4 __ovld __cnfn convert_ushort4_rte(short4); -ushort4 __ovld __cnfn convert_ushort4_sat_rte(short4); -ushort4 __ovld __cnfn convert_ushort4_rtz(short4); -ushort4 __ovld __cnfn convert_ushort4_sat_rtz(short4); -ushort4 __ovld __cnfn convert_ushort4_rtp(short4); -ushort4 __ovld __cnfn convert_ushort4_sat_rtp(short4); -ushort4 __ovld __cnfn convert_ushort4_rtn(short4); -ushort4 __ovld __cnfn convert_ushort4_sat_rtn(short4); -ushort4 __ovld __cnfn convert_ushort4(short4); -ushort4 __ovld __cnfn convert_ushort4_sat(short4); -ushort4 __ovld __cnfn convert_ushort4_rte(ushort4); -ushort4 __ovld __cnfn convert_ushort4_sat_rte(ushort4); -ushort4 __ovld __cnfn convert_ushort4_rtz(ushort4); -ushort4 __ovld __cnfn convert_ushort4_sat_rtz(ushort4); -ushort4 __ovld __cnfn convert_ushort4_rtp(ushort4); -ushort4 __ovld __cnfn convert_ushort4_sat_rtp(ushort4); -ushort4 __ovld __cnfn convert_ushort4_rtn(ushort4); -ushort4 __ovld __cnfn convert_ushort4_sat_rtn(ushort4); -ushort4 __ovld __cnfn convert_ushort4(ushort4); -ushort4 __ovld __cnfn convert_ushort4_sat(ushort4); -ushort4 __ovld __cnfn convert_ushort4_rte(int4); -ushort4 __ovld __cnfn convert_ushort4_sat_rte(int4); -ushort4 __ovld __cnfn convert_ushort4_rtz(int4); -ushort4 __ovld __cnfn convert_ushort4_sat_rtz(int4); -ushort4 __ovld __cnfn convert_ushort4_rtp(int4); -ushort4 __ovld __cnfn convert_ushort4_sat_rtp(int4); -ushort4 __ovld __cnfn convert_ushort4_rtn(int4); -ushort4 __ovld __cnfn convert_ushort4_sat_rtn(int4); -ushort4 __ovld __cnfn convert_ushort4(int4); -ushort4 __ovld __cnfn convert_ushort4_sat(int4); -ushort4 __ovld __cnfn convert_ushort4_rte(uint4); -ushort4 __ovld __cnfn convert_ushort4_sat_rte(uint4); -ushort4 __ovld __cnfn convert_ushort4_rtz(uint4); -ushort4 __ovld __cnfn convert_ushort4_sat_rtz(uint4); -ushort4 __ovld __cnfn convert_ushort4_rtp(uint4); -ushort4 __ovld __cnfn convert_ushort4_sat_rtp(uint4); -ushort4 __ovld __cnfn convert_ushort4_rtn(uint4); -ushort4 __ovld __cnfn convert_ushort4_sat_rtn(uint4); -ushort4 __ovld __cnfn convert_ushort4(uint4); -ushort4 __ovld __cnfn convert_ushort4_sat(uint4); -ushort4 __ovld __cnfn convert_ushort4_rte(long4); -ushort4 __ovld __cnfn convert_ushort4_sat_rte(long4); -ushort4 __ovld __cnfn convert_ushort4_rtz(long4); -ushort4 __ovld __cnfn convert_ushort4_sat_rtz(long4); -ushort4 __ovld __cnfn convert_ushort4_rtp(long4); -ushort4 __ovld __cnfn convert_ushort4_sat_rtp(long4); -ushort4 __ovld __cnfn convert_ushort4_rtn(long4); -ushort4 __ovld __cnfn convert_ushort4_sat_rtn(long4); -ushort4 __ovld __cnfn convert_ushort4(long4); -ushort4 __ovld __cnfn convert_ushort4_sat(long4); -ushort4 __ovld __cnfn convert_ushort4_rte(ulong4); -ushort4 __ovld __cnfn convert_ushort4_sat_rte(ulong4); -ushort4 __ovld __cnfn convert_ushort4_rtz(ulong4); -ushort4 __ovld __cnfn convert_ushort4_sat_rtz(ulong4); -ushort4 __ovld __cnfn convert_ushort4_rtp(ulong4); -ushort4 __ovld __cnfn convert_ushort4_sat_rtp(ulong4); -ushort4 __ovld __cnfn convert_ushort4_rtn(ulong4); -ushort4 __ovld __cnfn convert_ushort4_sat_rtn(ulong4); -ushort4 __ovld __cnfn convert_ushort4(ulong4); -ushort4 __ovld __cnfn convert_ushort4_sat(ulong4); -ushort4 __ovld __cnfn convert_ushort4_rte(float4); -ushort4 __ovld __cnfn convert_ushort4_sat_rte(float4); -ushort4 __ovld __cnfn convert_ushort4_rtz(float4); -ushort4 __ovld __cnfn convert_ushort4_sat_rtz(float4); -ushort4 __ovld __cnfn convert_ushort4_rtp(float4); -ushort4 __ovld __cnfn convert_ushort4_sat_rtp(float4); -ushort4 __ovld __cnfn convert_ushort4_rtn(float4); -ushort4 __ovld __cnfn convert_ushort4_sat_rtn(float4); -ushort4 __ovld __cnfn convert_ushort4(float4); -ushort4 __ovld __cnfn convert_ushort4_sat(float4); -int4 __ovld __cnfn convert_int4_rte(char4); -int4 __ovld __cnfn convert_int4_sat_rte(char4); -int4 __ovld __cnfn convert_int4_rtz(char4); -int4 __ovld __cnfn convert_int4_sat_rtz(char4); -int4 __ovld __cnfn convert_int4_rtp(char4); -int4 __ovld __cnfn convert_int4_sat_rtp(char4); -int4 __ovld __cnfn convert_int4_rtn(char4); -int4 __ovld __cnfn convert_int4_sat_rtn(char4); -int4 __ovld __cnfn convert_int4(char4); -int4 __ovld __cnfn convert_int4_sat(char4); -int4 __ovld __cnfn convert_int4_rte(uchar4); -int4 __ovld __cnfn convert_int4_sat_rte(uchar4); -int4 __ovld __cnfn convert_int4_rtz(uchar4); -int4 __ovld __cnfn convert_int4_sat_rtz(uchar4); -int4 __ovld __cnfn convert_int4_rtp(uchar4); -int4 __ovld __cnfn convert_int4_sat_rtp(uchar4); -int4 __ovld __cnfn convert_int4_rtn(uchar4); -int4 __ovld __cnfn convert_int4_sat_rtn(uchar4); -int4 __ovld __cnfn convert_int4(uchar4); -int4 __ovld __cnfn convert_int4_sat(uchar4); -int4 __ovld __cnfn convert_int4_rte(short4); -int4 __ovld __cnfn convert_int4_sat_rte(short4); -int4 __ovld __cnfn convert_int4_rtz(short4); -int4 __ovld __cnfn convert_int4_sat_rtz(short4); -int4 __ovld __cnfn convert_int4_rtp(short4); -int4 __ovld __cnfn convert_int4_sat_rtp(short4); -int4 __ovld __cnfn convert_int4_rtn(short4); -int4 __ovld __cnfn convert_int4_sat_rtn(short4); -int4 __ovld __cnfn convert_int4(short4); -int4 __ovld __cnfn convert_int4_sat(short4); -int4 __ovld __cnfn convert_int4_rte(ushort4); -int4 __ovld __cnfn convert_int4_sat_rte(ushort4); -int4 __ovld __cnfn convert_int4_rtz(ushort4); -int4 __ovld __cnfn convert_int4_sat_rtz(ushort4); -int4 __ovld __cnfn convert_int4_rtp(ushort4); -int4 __ovld __cnfn convert_int4_sat_rtp(ushort4); -int4 __ovld __cnfn convert_int4_rtn(ushort4); -int4 __ovld __cnfn convert_int4_sat_rtn(ushort4); -int4 __ovld __cnfn convert_int4(ushort4); -int4 __ovld __cnfn convert_int4_sat(ushort4); -int4 __ovld __cnfn convert_int4_rte(int4); -int4 __ovld __cnfn convert_int4_sat_rte(int4); -int4 __ovld __cnfn convert_int4_rtz(int4); -int4 __ovld __cnfn convert_int4_sat_rtz(int4); -int4 __ovld __cnfn convert_int4_rtp(int4); -int4 __ovld __cnfn convert_int4_sat_rtp(int4); -int4 __ovld __cnfn convert_int4_rtn(int4); -int4 __ovld __cnfn convert_int4_sat_rtn(int4); -int4 __ovld __cnfn convert_int4(int4); -int4 __ovld __cnfn convert_int4_sat(int4); -int4 __ovld __cnfn convert_int4_rte(uint4); -int4 __ovld __cnfn convert_int4_sat_rte(uint4); -int4 __ovld __cnfn convert_int4_rtz(uint4); -int4 __ovld __cnfn convert_int4_sat_rtz(uint4); -int4 __ovld __cnfn convert_int4_rtp(uint4); -int4 __ovld __cnfn convert_int4_sat_rtp(uint4); -int4 __ovld __cnfn convert_int4_rtn(uint4); -int4 __ovld __cnfn convert_int4_sat_rtn(uint4); -int4 __ovld __cnfn convert_int4(uint4); -int4 __ovld __cnfn convert_int4_sat(uint4); -int4 __ovld __cnfn convert_int4_rte(long4); -int4 __ovld __cnfn convert_int4_sat_rte(long4); -int4 __ovld __cnfn convert_int4_rtz(long4); -int4 __ovld __cnfn convert_int4_sat_rtz(long4); -int4 __ovld __cnfn convert_int4_rtp(long4); -int4 __ovld __cnfn convert_int4_sat_rtp(long4); -int4 __ovld __cnfn convert_int4_rtn(long4); -int4 __ovld __cnfn convert_int4_sat_rtn(long4); -int4 __ovld __cnfn convert_int4(long4); -int4 __ovld __cnfn convert_int4_sat(long4); -int4 __ovld __cnfn convert_int4_rte(ulong4); -int4 __ovld __cnfn convert_int4_sat_rte(ulong4); -int4 __ovld __cnfn convert_int4_rtz(ulong4); -int4 __ovld __cnfn convert_int4_sat_rtz(ulong4); -int4 __ovld __cnfn convert_int4_rtp(ulong4); -int4 __ovld __cnfn convert_int4_sat_rtp(ulong4); -int4 __ovld __cnfn convert_int4_rtn(ulong4); -int4 __ovld __cnfn convert_int4_sat_rtn(ulong4); -int4 __ovld __cnfn convert_int4(ulong4); -int4 __ovld __cnfn convert_int4_sat(ulong4); -int4 __ovld __cnfn convert_int4_rte(float4); -int4 __ovld __cnfn convert_int4_sat_rte(float4); -int4 __ovld __cnfn convert_int4_rtz(float4); -int4 __ovld __cnfn convert_int4_sat_rtz(float4); -int4 __ovld __cnfn convert_int4_rtp(float4); -int4 __ovld __cnfn convert_int4_sat_rtp(float4); -int4 __ovld __cnfn convert_int4_rtn(float4); -int4 __ovld __cnfn convert_int4_sat_rtn(float4); -int4 __ovld __cnfn convert_int4(float4); -int4 __ovld __cnfn convert_int4_sat(float4); -uint4 __ovld __cnfn convert_uint4_rte(char4); -uint4 __ovld __cnfn convert_uint4_sat_rte(char4); -uint4 __ovld __cnfn convert_uint4_rtz(char4); -uint4 __ovld __cnfn convert_uint4_sat_rtz(char4); -uint4 __ovld __cnfn convert_uint4_rtp(char4); -uint4 __ovld __cnfn convert_uint4_sat_rtp(char4); -uint4 __ovld __cnfn convert_uint4_rtn(char4); -uint4 __ovld __cnfn convert_uint4_sat_rtn(char4); -uint4 __ovld __cnfn convert_uint4(char4); -uint4 __ovld __cnfn convert_uint4_sat(char4); -uint4 __ovld __cnfn convert_uint4_rte(uchar4); -uint4 __ovld __cnfn convert_uint4_sat_rte(uchar4); -uint4 __ovld __cnfn convert_uint4_rtz(uchar4); -uint4 __ovld __cnfn convert_uint4_sat_rtz(uchar4); -uint4 __ovld __cnfn convert_uint4_rtp(uchar4); -uint4 __ovld __cnfn convert_uint4_sat_rtp(uchar4); -uint4 __ovld __cnfn convert_uint4_rtn(uchar4); -uint4 __ovld __cnfn convert_uint4_sat_rtn(uchar4); -uint4 __ovld __cnfn convert_uint4(uchar4); -uint4 __ovld __cnfn convert_uint4_sat(uchar4); -uint4 __ovld __cnfn convert_uint4_rte(short4); -uint4 __ovld __cnfn convert_uint4_sat_rte(short4); -uint4 __ovld __cnfn convert_uint4_rtz(short4); -uint4 __ovld __cnfn convert_uint4_sat_rtz(short4); -uint4 __ovld __cnfn convert_uint4_rtp(short4); -uint4 __ovld __cnfn convert_uint4_sat_rtp(short4); -uint4 __ovld __cnfn convert_uint4_rtn(short4); -uint4 __ovld __cnfn convert_uint4_sat_rtn(short4); -uint4 __ovld __cnfn convert_uint4(short4); -uint4 __ovld __cnfn convert_uint4_sat(short4); -uint4 __ovld __cnfn convert_uint4_rte(ushort4); -uint4 __ovld __cnfn convert_uint4_sat_rte(ushort4); -uint4 __ovld __cnfn convert_uint4_rtz(ushort4); -uint4 __ovld __cnfn convert_uint4_sat_rtz(ushort4); -uint4 __ovld __cnfn convert_uint4_rtp(ushort4); -uint4 __ovld __cnfn convert_uint4_sat_rtp(ushort4); -uint4 __ovld __cnfn convert_uint4_rtn(ushort4); -uint4 __ovld __cnfn convert_uint4_sat_rtn(ushort4); -uint4 __ovld __cnfn convert_uint4(ushort4); -uint4 __ovld __cnfn convert_uint4_sat(ushort4); -uint4 __ovld __cnfn convert_uint4_rte(int4); -uint4 __ovld __cnfn convert_uint4_sat_rte(int4); -uint4 __ovld __cnfn convert_uint4_rtz(int4); -uint4 __ovld __cnfn convert_uint4_sat_rtz(int4); -uint4 __ovld __cnfn convert_uint4_rtp(int4); -uint4 __ovld __cnfn convert_uint4_sat_rtp(int4); -uint4 __ovld __cnfn convert_uint4_rtn(int4); -uint4 __ovld __cnfn convert_uint4_sat_rtn(int4); -uint4 __ovld __cnfn convert_uint4(int4); -uint4 __ovld __cnfn convert_uint4_sat(int4); -uint4 __ovld __cnfn convert_uint4_rte(uint4); -uint4 __ovld __cnfn convert_uint4_sat_rte(uint4); -uint4 __ovld __cnfn convert_uint4_rtz(uint4); -uint4 __ovld __cnfn convert_uint4_sat_rtz(uint4); -uint4 __ovld __cnfn convert_uint4_rtp(uint4); -uint4 __ovld __cnfn convert_uint4_sat_rtp(uint4); -uint4 __ovld __cnfn convert_uint4_rtn(uint4); -uint4 __ovld __cnfn convert_uint4_sat_rtn(uint4); -uint4 __ovld __cnfn convert_uint4(uint4); -uint4 __ovld __cnfn convert_uint4_sat(uint4); -uint4 __ovld __cnfn convert_uint4_rte(long4); -uint4 __ovld __cnfn convert_uint4_sat_rte(long4); -uint4 __ovld __cnfn convert_uint4_rtz(long4); -uint4 __ovld __cnfn convert_uint4_sat_rtz(long4); -uint4 __ovld __cnfn convert_uint4_rtp(long4); -uint4 __ovld __cnfn convert_uint4_sat_rtp(long4); -uint4 __ovld __cnfn convert_uint4_rtn(long4); -uint4 __ovld __cnfn convert_uint4_sat_rtn(long4); -uint4 __ovld __cnfn convert_uint4(long4); -uint4 __ovld __cnfn convert_uint4_sat(long4); -uint4 __ovld __cnfn convert_uint4_rte(ulong4); -uint4 __ovld __cnfn convert_uint4_sat_rte(ulong4); -uint4 __ovld __cnfn convert_uint4_rtz(ulong4); -uint4 __ovld __cnfn convert_uint4_sat_rtz(ulong4); -uint4 __ovld __cnfn convert_uint4_rtp(ulong4); -uint4 __ovld __cnfn convert_uint4_sat_rtp(ulong4); -uint4 __ovld __cnfn convert_uint4_rtn(ulong4); -uint4 __ovld __cnfn convert_uint4_sat_rtn(ulong4); -uint4 __ovld __cnfn convert_uint4(ulong4); -uint4 __ovld __cnfn convert_uint4_sat(ulong4); -uint4 __ovld __cnfn convert_uint4_rte(float4); -uint4 __ovld __cnfn convert_uint4_sat_rte(float4); -uint4 __ovld __cnfn convert_uint4_rtz(float4); -uint4 __ovld __cnfn convert_uint4_sat_rtz(float4); -uint4 __ovld __cnfn convert_uint4_rtp(float4); -uint4 __ovld __cnfn convert_uint4_sat_rtp(float4); -uint4 __ovld __cnfn convert_uint4_rtn(float4); -uint4 __ovld __cnfn convert_uint4_sat_rtn(float4); -uint4 __ovld __cnfn convert_uint4(float4); -uint4 __ovld __cnfn convert_uint4_sat(float4); -long4 __ovld __cnfn convert_long4_rte(char4); -long4 __ovld __cnfn convert_long4_sat_rte(char4); -long4 __ovld __cnfn convert_long4_rtz(char4); -long4 __ovld __cnfn convert_long4_sat_rtz(char4); -long4 __ovld __cnfn convert_long4_rtp(char4); -long4 __ovld __cnfn convert_long4_sat_rtp(char4); -long4 __ovld __cnfn convert_long4_rtn(char4); -long4 __ovld __cnfn convert_long4_sat_rtn(char4); -long4 __ovld __cnfn convert_long4(char4); -long4 __ovld __cnfn convert_long4_sat(char4); -long4 __ovld __cnfn convert_long4_rte(uchar4); -long4 __ovld __cnfn convert_long4_sat_rte(uchar4); -long4 __ovld __cnfn convert_long4_rtz(uchar4); -long4 __ovld __cnfn convert_long4_sat_rtz(uchar4); -long4 __ovld __cnfn convert_long4_rtp(uchar4); -long4 __ovld __cnfn convert_long4_sat_rtp(uchar4); -long4 __ovld __cnfn convert_long4_rtn(uchar4); -long4 __ovld __cnfn convert_long4_sat_rtn(uchar4); -long4 __ovld __cnfn convert_long4(uchar4); -long4 __ovld __cnfn convert_long4_sat(uchar4); -long4 __ovld __cnfn convert_long4_rte(short4); -long4 __ovld __cnfn convert_long4_sat_rte(short4); -long4 __ovld __cnfn convert_long4_rtz(short4); -long4 __ovld __cnfn convert_long4_sat_rtz(short4); -long4 __ovld __cnfn convert_long4_rtp(short4); -long4 __ovld __cnfn convert_long4_sat_rtp(short4); -long4 __ovld __cnfn convert_long4_rtn(short4); -long4 __ovld __cnfn convert_long4_sat_rtn(short4); -long4 __ovld __cnfn convert_long4(short4); -long4 __ovld __cnfn convert_long4_sat(short4); -long4 __ovld __cnfn convert_long4_rte(ushort4); -long4 __ovld __cnfn convert_long4_sat_rte(ushort4); -long4 __ovld __cnfn convert_long4_rtz(ushort4); -long4 __ovld __cnfn convert_long4_sat_rtz(ushort4); -long4 __ovld __cnfn convert_long4_rtp(ushort4); -long4 __ovld __cnfn convert_long4_sat_rtp(ushort4); -long4 __ovld __cnfn convert_long4_rtn(ushort4); -long4 __ovld __cnfn convert_long4_sat_rtn(ushort4); -long4 __ovld __cnfn convert_long4(ushort4); -long4 __ovld __cnfn convert_long4_sat(ushort4); -long4 __ovld __cnfn convert_long4_rte(int4); -long4 __ovld __cnfn convert_long4_sat_rte(int4); -long4 __ovld __cnfn convert_long4_rtz(int4); -long4 __ovld __cnfn convert_long4_sat_rtz(int4); -long4 __ovld __cnfn convert_long4_rtp(int4); -long4 __ovld __cnfn convert_long4_sat_rtp(int4); -long4 __ovld __cnfn convert_long4_rtn(int4); -long4 __ovld __cnfn convert_long4_sat_rtn(int4); -long4 __ovld __cnfn convert_long4(int4); -long4 __ovld __cnfn convert_long4_sat(int4); -long4 __ovld __cnfn convert_long4_rte(uint4); -long4 __ovld __cnfn convert_long4_sat_rte(uint4); -long4 __ovld __cnfn convert_long4_rtz(uint4); -long4 __ovld __cnfn convert_long4_sat_rtz(uint4); -long4 __ovld __cnfn convert_long4_rtp(uint4); -long4 __ovld __cnfn convert_long4_sat_rtp(uint4); -long4 __ovld __cnfn convert_long4_rtn(uint4); -long4 __ovld __cnfn convert_long4_sat_rtn(uint4); -long4 __ovld __cnfn convert_long4(uint4); -long4 __ovld __cnfn convert_long4_sat(uint4); -long4 __ovld __cnfn convert_long4_rte(long4); -long4 __ovld __cnfn convert_long4_sat_rte(long4); -long4 __ovld __cnfn convert_long4_rtz(long4); -long4 __ovld __cnfn convert_long4_sat_rtz(long4); -long4 __ovld __cnfn convert_long4_rtp(long4); -long4 __ovld __cnfn convert_long4_sat_rtp(long4); -long4 __ovld __cnfn convert_long4_rtn(long4); -long4 __ovld __cnfn convert_long4_sat_rtn(long4); -long4 __ovld __cnfn convert_long4(long4); -long4 __ovld __cnfn convert_long4_sat(long4); -long4 __ovld __cnfn convert_long4_rte(ulong4); -long4 __ovld __cnfn convert_long4_sat_rte(ulong4); -long4 __ovld __cnfn convert_long4_rtz(ulong4); -long4 __ovld __cnfn convert_long4_sat_rtz(ulong4); -long4 __ovld __cnfn convert_long4_rtp(ulong4); -long4 __ovld __cnfn convert_long4_sat_rtp(ulong4); -long4 __ovld __cnfn convert_long4_rtn(ulong4); -long4 __ovld __cnfn convert_long4_sat_rtn(ulong4); -long4 __ovld __cnfn convert_long4(ulong4); -long4 __ovld __cnfn convert_long4_sat(ulong4); -long4 __ovld __cnfn convert_long4_rte(float4); -long4 __ovld __cnfn convert_long4_sat_rte(float4); -long4 __ovld __cnfn convert_long4_rtz(float4); -long4 __ovld __cnfn convert_long4_sat_rtz(float4); -long4 __ovld __cnfn convert_long4_rtp(float4); -long4 __ovld __cnfn convert_long4_sat_rtp(float4); -long4 __ovld __cnfn convert_long4_rtn(float4); -long4 __ovld __cnfn convert_long4_sat_rtn(float4); -long4 __ovld __cnfn convert_long4(float4); -long4 __ovld __cnfn convert_long4_sat(float4); -ulong4 __ovld __cnfn convert_ulong4_rte(char4); -ulong4 __ovld __cnfn convert_ulong4_sat_rte(char4); -ulong4 __ovld __cnfn convert_ulong4_rtz(char4); -ulong4 __ovld __cnfn convert_ulong4_sat_rtz(char4); -ulong4 __ovld __cnfn convert_ulong4_rtp(char4); -ulong4 __ovld __cnfn convert_ulong4_sat_rtp(char4); -ulong4 __ovld __cnfn convert_ulong4_rtn(char4); -ulong4 __ovld __cnfn convert_ulong4_sat_rtn(char4); -ulong4 __ovld __cnfn convert_ulong4(char4); -ulong4 __ovld __cnfn convert_ulong4_sat(char4); -ulong4 __ovld __cnfn convert_ulong4_rte(uchar4); -ulong4 __ovld __cnfn convert_ulong4_sat_rte(uchar4); -ulong4 __ovld __cnfn convert_ulong4_rtz(uchar4); -ulong4 __ovld __cnfn convert_ulong4_sat_rtz(uchar4); -ulong4 __ovld __cnfn convert_ulong4_rtp(uchar4); -ulong4 __ovld __cnfn convert_ulong4_sat_rtp(uchar4); -ulong4 __ovld __cnfn convert_ulong4_rtn(uchar4); -ulong4 __ovld __cnfn convert_ulong4_sat_rtn(uchar4); -ulong4 __ovld __cnfn convert_ulong4(uchar4); -ulong4 __ovld __cnfn convert_ulong4_sat(uchar4); -ulong4 __ovld __cnfn convert_ulong4_rte(short4); -ulong4 __ovld __cnfn convert_ulong4_sat_rte(short4); -ulong4 __ovld __cnfn convert_ulong4_rtz(short4); -ulong4 __ovld __cnfn convert_ulong4_sat_rtz(short4); -ulong4 __ovld __cnfn convert_ulong4_rtp(short4); -ulong4 __ovld __cnfn convert_ulong4_sat_rtp(short4); -ulong4 __ovld __cnfn convert_ulong4_rtn(short4); -ulong4 __ovld __cnfn convert_ulong4_sat_rtn(short4); -ulong4 __ovld __cnfn convert_ulong4(short4); -ulong4 __ovld __cnfn convert_ulong4_sat(short4); -ulong4 __ovld __cnfn convert_ulong4_rte(ushort4); -ulong4 __ovld __cnfn convert_ulong4_sat_rte(ushort4); -ulong4 __ovld __cnfn convert_ulong4_rtz(ushort4); -ulong4 __ovld __cnfn convert_ulong4_sat_rtz(ushort4); -ulong4 __ovld __cnfn convert_ulong4_rtp(ushort4); -ulong4 __ovld __cnfn convert_ulong4_sat_rtp(ushort4); -ulong4 __ovld __cnfn convert_ulong4_rtn(ushort4); -ulong4 __ovld __cnfn convert_ulong4_sat_rtn(ushort4); -ulong4 __ovld __cnfn convert_ulong4(ushort4); -ulong4 __ovld __cnfn convert_ulong4_sat(ushort4); -ulong4 __ovld __cnfn convert_ulong4_rte(int4); -ulong4 __ovld __cnfn convert_ulong4_sat_rte(int4); -ulong4 __ovld __cnfn convert_ulong4_rtz(int4); -ulong4 __ovld __cnfn convert_ulong4_sat_rtz(int4); -ulong4 __ovld __cnfn convert_ulong4_rtp(int4); -ulong4 __ovld __cnfn convert_ulong4_sat_rtp(int4); -ulong4 __ovld __cnfn convert_ulong4_rtn(int4); -ulong4 __ovld __cnfn convert_ulong4_sat_rtn(int4); -ulong4 __ovld __cnfn convert_ulong4(int4); -ulong4 __ovld __cnfn convert_ulong4_sat(int4); -ulong4 __ovld __cnfn convert_ulong4_rte(uint4); -ulong4 __ovld __cnfn convert_ulong4_sat_rte(uint4); -ulong4 __ovld __cnfn convert_ulong4_rtz(uint4); -ulong4 __ovld __cnfn convert_ulong4_sat_rtz(uint4); -ulong4 __ovld __cnfn convert_ulong4_rtp(uint4); -ulong4 __ovld __cnfn convert_ulong4_sat_rtp(uint4); -ulong4 __ovld __cnfn convert_ulong4_rtn(uint4); -ulong4 __ovld __cnfn convert_ulong4_sat_rtn(uint4); -ulong4 __ovld __cnfn convert_ulong4(uint4); -ulong4 __ovld __cnfn convert_ulong4_sat(uint4); -ulong4 __ovld __cnfn convert_ulong4_rte(long4); -ulong4 __ovld __cnfn convert_ulong4_sat_rte(long4); -ulong4 __ovld __cnfn convert_ulong4_rtz(long4); -ulong4 __ovld __cnfn convert_ulong4_sat_rtz(long4); -ulong4 __ovld __cnfn convert_ulong4_rtp(long4); -ulong4 __ovld __cnfn convert_ulong4_sat_rtp(long4); -ulong4 __ovld __cnfn convert_ulong4_rtn(long4); -ulong4 __ovld __cnfn convert_ulong4_sat_rtn(long4); -ulong4 __ovld __cnfn convert_ulong4(long4); -ulong4 __ovld __cnfn convert_ulong4_sat(long4); -ulong4 __ovld __cnfn convert_ulong4_rte(ulong4); -ulong4 __ovld __cnfn convert_ulong4_sat_rte(ulong4); -ulong4 __ovld __cnfn convert_ulong4_rtz(ulong4); -ulong4 __ovld __cnfn convert_ulong4_sat_rtz(ulong4); -ulong4 __ovld __cnfn convert_ulong4_rtp(ulong4); -ulong4 __ovld __cnfn convert_ulong4_sat_rtp(ulong4); -ulong4 __ovld __cnfn convert_ulong4_rtn(ulong4); -ulong4 __ovld __cnfn convert_ulong4_sat_rtn(ulong4); -ulong4 __ovld __cnfn convert_ulong4(ulong4); -ulong4 __ovld __cnfn convert_ulong4_sat(ulong4); -ulong4 __ovld __cnfn convert_ulong4_rte(float4); -ulong4 __ovld __cnfn convert_ulong4_sat_rte(float4); -ulong4 __ovld __cnfn convert_ulong4_rtz(float4); -ulong4 __ovld __cnfn convert_ulong4_sat_rtz(float4); -ulong4 __ovld __cnfn convert_ulong4_rtp(float4); -ulong4 __ovld __cnfn convert_ulong4_sat_rtp(float4); -ulong4 __ovld __cnfn convert_ulong4_rtn(float4); -ulong4 __ovld __cnfn convert_ulong4_sat_rtn(float4); -ulong4 __ovld __cnfn convert_ulong4(float4); -ulong4 __ovld __cnfn convert_ulong4_sat(float4); -float4 __ovld __cnfn convert_float4_rte(char4); -float4 __ovld __cnfn convert_float4_rtz(char4); -float4 __ovld __cnfn convert_float4_rtp(char4); -float4 __ovld __cnfn convert_float4_rtn(char4); -float4 __ovld __cnfn convert_float4(char4); -float4 __ovld __cnfn convert_float4_rte(uchar4); -float4 __ovld __cnfn convert_float4_rtz(uchar4); -float4 __ovld __cnfn convert_float4_rtp(uchar4); -float4 __ovld __cnfn convert_float4_rtn(uchar4); -float4 __ovld __cnfn convert_float4(uchar4); -float4 __ovld __cnfn convert_float4_rte(short4); -float4 __ovld __cnfn convert_float4_rtz(short4); -float4 __ovld __cnfn convert_float4_rtp(short4); -float4 __ovld __cnfn convert_float4_rtn(short4); -float4 __ovld __cnfn convert_float4(short4); -float4 __ovld __cnfn convert_float4_rte(ushort4); -float4 __ovld __cnfn convert_float4_rtz(ushort4); -float4 __ovld __cnfn convert_float4_rtp(ushort4); -float4 __ovld __cnfn convert_float4_rtn(ushort4); -float4 __ovld __cnfn convert_float4(ushort4); -float4 __ovld __cnfn convert_float4_rte(int4); -float4 __ovld __cnfn convert_float4_rtz(int4); -float4 __ovld __cnfn convert_float4_rtp(int4); -float4 __ovld __cnfn convert_float4_rtn(int4); -float4 __ovld __cnfn convert_float4(int4); -float4 __ovld __cnfn convert_float4_rte(uint4); -float4 __ovld __cnfn convert_float4_rtz(uint4); -float4 __ovld __cnfn convert_float4_rtp(uint4); -float4 __ovld __cnfn convert_float4_rtn(uint4); -float4 __ovld __cnfn convert_float4(uint4); -float4 __ovld __cnfn convert_float4_rte(long4); -float4 __ovld __cnfn convert_float4_rtz(long4); -float4 __ovld __cnfn convert_float4_rtp(long4); -float4 __ovld __cnfn convert_float4_rtn(long4); -float4 __ovld __cnfn convert_float4(long4); -float4 __ovld __cnfn convert_float4_rte(ulong4); -float4 __ovld __cnfn convert_float4_rtz(ulong4); -float4 __ovld __cnfn convert_float4_rtp(ulong4); -float4 __ovld __cnfn convert_float4_rtn(ulong4); -float4 __ovld __cnfn convert_float4(ulong4); -float4 __ovld __cnfn convert_float4_rte(float4); -float4 __ovld __cnfn convert_float4_rtz(float4); -float4 __ovld __cnfn convert_float4_rtp(float4); -float4 __ovld __cnfn convert_float4_rtn(float4); -float4 __ovld __cnfn convert_float4(float4); -char8 __ovld __cnfn convert_char8_rte(char8); -char8 __ovld __cnfn convert_char8_sat_rte(char8); -char8 __ovld __cnfn convert_char8_rtz(char8); -char8 __ovld __cnfn convert_char8_sat_rtz(char8); -char8 __ovld __cnfn convert_char8_rtp(char8); -char8 __ovld __cnfn convert_char8_sat_rtp(char8); -char8 __ovld __cnfn convert_char8_rtn(char8); -char8 __ovld __cnfn convert_char8_sat_rtn(char8); -char8 __ovld __cnfn convert_char8(char8); -char8 __ovld __cnfn convert_char8_sat(char8); -char8 __ovld __cnfn convert_char8_rte(uchar8); -char8 __ovld __cnfn convert_char8_sat_rte(uchar8); -char8 __ovld __cnfn convert_char8_rtz(uchar8); -char8 __ovld __cnfn convert_char8_sat_rtz(uchar8); -char8 __ovld __cnfn convert_char8_rtp(uchar8); -char8 __ovld __cnfn convert_char8_sat_rtp(uchar8); -char8 __ovld __cnfn convert_char8_rtn(uchar8); -char8 __ovld __cnfn convert_char8_sat_rtn(uchar8); -char8 __ovld __cnfn convert_char8(uchar8); -char8 __ovld __cnfn convert_char8_sat(uchar8); -char8 __ovld __cnfn convert_char8_rte(short8); -char8 __ovld __cnfn convert_char8_sat_rte(short8); -char8 __ovld __cnfn convert_char8_rtz(short8); -char8 __ovld __cnfn convert_char8_sat_rtz(short8); -char8 __ovld __cnfn convert_char8_rtp(short8); -char8 __ovld __cnfn convert_char8_sat_rtp(short8); -char8 __ovld __cnfn convert_char8_rtn(short8); -char8 __ovld __cnfn convert_char8_sat_rtn(short8); -char8 __ovld __cnfn convert_char8(short8); -char8 __ovld __cnfn convert_char8_sat(short8); -char8 __ovld __cnfn convert_char8_rte(ushort8); -char8 __ovld __cnfn convert_char8_sat_rte(ushort8); -char8 __ovld __cnfn convert_char8_rtz(ushort8); -char8 __ovld __cnfn convert_char8_sat_rtz(ushort8); -char8 __ovld __cnfn convert_char8_rtp(ushort8); -char8 __ovld __cnfn convert_char8_sat_rtp(ushort8); -char8 __ovld __cnfn convert_char8_rtn(ushort8); -char8 __ovld __cnfn convert_char8_sat_rtn(ushort8); -char8 __ovld __cnfn convert_char8(ushort8); -char8 __ovld __cnfn convert_char8_sat(ushort8); -char8 __ovld __cnfn convert_char8_rte(int8); -char8 __ovld __cnfn convert_char8_sat_rte(int8); -char8 __ovld __cnfn convert_char8_rtz(int8); -char8 __ovld __cnfn convert_char8_sat_rtz(int8); -char8 __ovld __cnfn convert_char8_rtp(int8); -char8 __ovld __cnfn convert_char8_sat_rtp(int8); -char8 __ovld __cnfn convert_char8_rtn(int8); -char8 __ovld __cnfn convert_char8_sat_rtn(int8); -char8 __ovld __cnfn convert_char8(int8); -char8 __ovld __cnfn convert_char8_sat(int8); -char8 __ovld __cnfn convert_char8_rte(uint8); -char8 __ovld __cnfn convert_char8_sat_rte(uint8); -char8 __ovld __cnfn convert_char8_rtz(uint8); -char8 __ovld __cnfn convert_char8_sat_rtz(uint8); -char8 __ovld __cnfn convert_char8_rtp(uint8); -char8 __ovld __cnfn convert_char8_sat_rtp(uint8); -char8 __ovld __cnfn convert_char8_rtn(uint8); -char8 __ovld __cnfn convert_char8_sat_rtn(uint8); -char8 __ovld __cnfn convert_char8(uint8); -char8 __ovld __cnfn convert_char8_sat(uint8); -char8 __ovld __cnfn convert_char8_rte(long8); -char8 __ovld __cnfn convert_char8_sat_rte(long8); -char8 __ovld __cnfn convert_char8_rtz(long8); -char8 __ovld __cnfn convert_char8_sat_rtz(long8); -char8 __ovld __cnfn convert_char8_rtp(long8); -char8 __ovld __cnfn convert_char8_sat_rtp(long8); -char8 __ovld __cnfn convert_char8_rtn(long8); -char8 __ovld __cnfn convert_char8_sat_rtn(long8); -char8 __ovld __cnfn convert_char8(long8); -char8 __ovld __cnfn convert_char8_sat(long8); -char8 __ovld __cnfn convert_char8_rte(ulong8); -char8 __ovld __cnfn convert_char8_sat_rte(ulong8); -char8 __ovld __cnfn convert_char8_rtz(ulong8); -char8 __ovld __cnfn convert_char8_sat_rtz(ulong8); -char8 __ovld __cnfn convert_char8_rtp(ulong8); -char8 __ovld __cnfn convert_char8_sat_rtp(ulong8); -char8 __ovld __cnfn convert_char8_rtn(ulong8); -char8 __ovld __cnfn convert_char8_sat_rtn(ulong8); -char8 __ovld __cnfn convert_char8(ulong8); -char8 __ovld __cnfn convert_char8_sat(ulong8); -char8 __ovld __cnfn convert_char8_rte(float8); -char8 __ovld __cnfn convert_char8_sat_rte(float8); -char8 __ovld __cnfn convert_char8_rtz(float8); -char8 __ovld __cnfn convert_char8_sat_rtz(float8); -char8 __ovld __cnfn convert_char8_rtp(float8); -char8 __ovld __cnfn convert_char8_sat_rtp(float8); -char8 __ovld __cnfn convert_char8_rtn(float8); -char8 __ovld __cnfn convert_char8_sat_rtn(float8); -char8 __ovld __cnfn convert_char8(float8); -char8 __ovld __cnfn convert_char8_sat(float8); -uchar8 __ovld __cnfn convert_uchar8_rte(char8); -uchar8 __ovld __cnfn convert_uchar8_sat_rte(char8); -uchar8 __ovld __cnfn convert_uchar8_rtz(char8); -uchar8 __ovld __cnfn convert_uchar8_sat_rtz(char8); -uchar8 __ovld __cnfn convert_uchar8_rtp(char8); -uchar8 __ovld __cnfn convert_uchar8_sat_rtp(char8); -uchar8 __ovld __cnfn convert_uchar8_rtn(char8); -uchar8 __ovld __cnfn convert_uchar8_sat_rtn(char8); -uchar8 __ovld __cnfn convert_uchar8(char8); -uchar8 __ovld __cnfn convert_uchar8_sat(char8); -uchar8 __ovld __cnfn convert_uchar8_rte(uchar8); -uchar8 __ovld __cnfn convert_uchar8_sat_rte(uchar8); -uchar8 __ovld __cnfn convert_uchar8_rtz(uchar8); -uchar8 __ovld __cnfn convert_uchar8_sat_rtz(uchar8); -uchar8 __ovld __cnfn convert_uchar8_rtp(uchar8); -uchar8 __ovld __cnfn convert_uchar8_sat_rtp(uchar8); -uchar8 __ovld __cnfn convert_uchar8_rtn(uchar8); -uchar8 __ovld __cnfn convert_uchar8_sat_rtn(uchar8); -uchar8 __ovld __cnfn convert_uchar8(uchar8); -uchar8 __ovld __cnfn convert_uchar8_sat(uchar8); -uchar8 __ovld __cnfn convert_uchar8_rte(short8); -uchar8 __ovld __cnfn convert_uchar8_sat_rte(short8); -uchar8 __ovld __cnfn convert_uchar8_rtz(short8); -uchar8 __ovld __cnfn convert_uchar8_sat_rtz(short8); -uchar8 __ovld __cnfn convert_uchar8_rtp(short8); -uchar8 __ovld __cnfn convert_uchar8_sat_rtp(short8); -uchar8 __ovld __cnfn convert_uchar8_rtn(short8); -uchar8 __ovld __cnfn convert_uchar8_sat_rtn(short8); -uchar8 __ovld __cnfn convert_uchar8(short8); -uchar8 __ovld __cnfn convert_uchar8_sat(short8); -uchar8 __ovld __cnfn convert_uchar8_rte(ushort8); -uchar8 __ovld __cnfn convert_uchar8_sat_rte(ushort8); -uchar8 __ovld __cnfn convert_uchar8_rtz(ushort8); -uchar8 __ovld __cnfn convert_uchar8_sat_rtz(ushort8); -uchar8 __ovld __cnfn convert_uchar8_rtp(ushort8); -uchar8 __ovld __cnfn convert_uchar8_sat_rtp(ushort8); -uchar8 __ovld __cnfn convert_uchar8_rtn(ushort8); -uchar8 __ovld __cnfn convert_uchar8_sat_rtn(ushort8); -uchar8 __ovld __cnfn convert_uchar8(ushort8); -uchar8 __ovld __cnfn convert_uchar8_sat(ushort8); -uchar8 __ovld __cnfn convert_uchar8_rte(int8); -uchar8 __ovld __cnfn convert_uchar8_sat_rte(int8); -uchar8 __ovld __cnfn convert_uchar8_rtz(int8); -uchar8 __ovld __cnfn convert_uchar8_sat_rtz(int8); -uchar8 __ovld __cnfn convert_uchar8_rtp(int8); -uchar8 __ovld __cnfn convert_uchar8_sat_rtp(int8); -uchar8 __ovld __cnfn convert_uchar8_rtn(int8); -uchar8 __ovld __cnfn convert_uchar8_sat_rtn(int8); -uchar8 __ovld __cnfn convert_uchar8(int8); -uchar8 __ovld __cnfn convert_uchar8_sat(int8); -uchar8 __ovld __cnfn convert_uchar8_rte(uint8); -uchar8 __ovld __cnfn convert_uchar8_sat_rte(uint8); -uchar8 __ovld __cnfn convert_uchar8_rtz(uint8); -uchar8 __ovld __cnfn convert_uchar8_sat_rtz(uint8); -uchar8 __ovld __cnfn convert_uchar8_rtp(uint8); -uchar8 __ovld __cnfn convert_uchar8_sat_rtp(uint8); -uchar8 __ovld __cnfn convert_uchar8_rtn(uint8); -uchar8 __ovld __cnfn convert_uchar8_sat_rtn(uint8); -uchar8 __ovld __cnfn convert_uchar8(uint8); -uchar8 __ovld __cnfn convert_uchar8_sat(uint8); -uchar8 __ovld __cnfn convert_uchar8_rte(long8); -uchar8 __ovld __cnfn convert_uchar8_sat_rte(long8); -uchar8 __ovld __cnfn convert_uchar8_rtz(long8); -uchar8 __ovld __cnfn convert_uchar8_sat_rtz(long8); -uchar8 __ovld __cnfn convert_uchar8_rtp(long8); -uchar8 __ovld __cnfn convert_uchar8_sat_rtp(long8); -uchar8 __ovld __cnfn convert_uchar8_rtn(long8); -uchar8 __ovld __cnfn convert_uchar8_sat_rtn(long8); -uchar8 __ovld __cnfn convert_uchar8(long8); -uchar8 __ovld __cnfn convert_uchar8_sat(long8); -uchar8 __ovld __cnfn convert_uchar8_rte(ulong8); -uchar8 __ovld __cnfn convert_uchar8_sat_rte(ulong8); -uchar8 __ovld __cnfn convert_uchar8_rtz(ulong8); -uchar8 __ovld __cnfn convert_uchar8_sat_rtz(ulong8); -uchar8 __ovld __cnfn convert_uchar8_rtp(ulong8); -uchar8 __ovld __cnfn convert_uchar8_sat_rtp(ulong8); -uchar8 __ovld __cnfn convert_uchar8_rtn(ulong8); -uchar8 __ovld __cnfn convert_uchar8_sat_rtn(ulong8); -uchar8 __ovld __cnfn convert_uchar8(ulong8); -uchar8 __ovld __cnfn convert_uchar8_sat(ulong8); -uchar8 __ovld __cnfn convert_uchar8_rte(float8); -uchar8 __ovld __cnfn convert_uchar8_sat_rte(float8); -uchar8 __ovld __cnfn convert_uchar8_rtz(float8); -uchar8 __ovld __cnfn convert_uchar8_sat_rtz(float8); -uchar8 __ovld __cnfn convert_uchar8_rtp(float8); -uchar8 __ovld __cnfn convert_uchar8_sat_rtp(float8); -uchar8 __ovld __cnfn convert_uchar8_rtn(float8); -uchar8 __ovld __cnfn convert_uchar8_sat_rtn(float8); -uchar8 __ovld __cnfn convert_uchar8(float8); -uchar8 __ovld __cnfn convert_uchar8_sat(float8); -short8 __ovld __cnfn convert_short8_rte(char8); -short8 __ovld __cnfn convert_short8_sat_rte(char8); -short8 __ovld __cnfn convert_short8_rtz(char8); -short8 __ovld __cnfn convert_short8_sat_rtz(char8); -short8 __ovld __cnfn convert_short8_rtp(char8); -short8 __ovld __cnfn convert_short8_sat_rtp(char8); -short8 __ovld __cnfn convert_short8_rtn(char8); -short8 __ovld __cnfn convert_short8_sat_rtn(char8); -short8 __ovld __cnfn convert_short8(char8); -short8 __ovld __cnfn convert_short8_sat(char8); -short8 __ovld __cnfn convert_short8_rte(uchar8); -short8 __ovld __cnfn convert_short8_sat_rte(uchar8); -short8 __ovld __cnfn convert_short8_rtz(uchar8); -short8 __ovld __cnfn convert_short8_sat_rtz(uchar8); -short8 __ovld __cnfn convert_short8_rtp(uchar8); -short8 __ovld __cnfn convert_short8_sat_rtp(uchar8); -short8 __ovld __cnfn convert_short8_rtn(uchar8); -short8 __ovld __cnfn convert_short8_sat_rtn(uchar8); -short8 __ovld __cnfn convert_short8(uchar8); -short8 __ovld __cnfn convert_short8_sat(uchar8); -short8 __ovld __cnfn convert_short8_rte(short8); -short8 __ovld __cnfn convert_short8_sat_rte(short8); -short8 __ovld __cnfn convert_short8_rtz(short8); -short8 __ovld __cnfn convert_short8_sat_rtz(short8); -short8 __ovld __cnfn convert_short8_rtp(short8); -short8 __ovld __cnfn convert_short8_sat_rtp(short8); -short8 __ovld __cnfn convert_short8_rtn(short8); -short8 __ovld __cnfn convert_short8_sat_rtn(short8); -short8 __ovld __cnfn convert_short8(short8); -short8 __ovld __cnfn convert_short8_sat(short8); -short8 __ovld __cnfn convert_short8_rte(ushort8); -short8 __ovld __cnfn convert_short8_sat_rte(ushort8); -short8 __ovld __cnfn convert_short8_rtz(ushort8); -short8 __ovld __cnfn convert_short8_sat_rtz(ushort8); -short8 __ovld __cnfn convert_short8_rtp(ushort8); -short8 __ovld __cnfn convert_short8_sat_rtp(ushort8); -short8 __ovld __cnfn convert_short8_rtn(ushort8); -short8 __ovld __cnfn convert_short8_sat_rtn(ushort8); -short8 __ovld __cnfn convert_short8(ushort8); -short8 __ovld __cnfn convert_short8_sat(ushort8); -short8 __ovld __cnfn convert_short8_rte(int8); -short8 __ovld __cnfn convert_short8_sat_rte(int8); -short8 __ovld __cnfn convert_short8_rtz(int8); -short8 __ovld __cnfn convert_short8_sat_rtz(int8); -short8 __ovld __cnfn convert_short8_rtp(int8); -short8 __ovld __cnfn convert_short8_sat_rtp(int8); -short8 __ovld __cnfn convert_short8_rtn(int8); -short8 __ovld __cnfn convert_short8_sat_rtn(int8); -short8 __ovld __cnfn convert_short8(int8); -short8 __ovld __cnfn convert_short8_sat(int8); -short8 __ovld __cnfn convert_short8_rte(uint8); -short8 __ovld __cnfn convert_short8_sat_rte(uint8); -short8 __ovld __cnfn convert_short8_rtz(uint8); -short8 __ovld __cnfn convert_short8_sat_rtz(uint8); -short8 __ovld __cnfn convert_short8_rtp(uint8); -short8 __ovld __cnfn convert_short8_sat_rtp(uint8); -short8 __ovld __cnfn convert_short8_rtn(uint8); -short8 __ovld __cnfn convert_short8_sat_rtn(uint8); -short8 __ovld __cnfn convert_short8(uint8); -short8 __ovld __cnfn convert_short8_sat(uint8); -short8 __ovld __cnfn convert_short8_rte(long8); -short8 __ovld __cnfn convert_short8_sat_rte(long8); -short8 __ovld __cnfn convert_short8_rtz(long8); -short8 __ovld __cnfn convert_short8_sat_rtz(long8); -short8 __ovld __cnfn convert_short8_rtp(long8); -short8 __ovld __cnfn convert_short8_sat_rtp(long8); -short8 __ovld __cnfn convert_short8_rtn(long8); -short8 __ovld __cnfn convert_short8_sat_rtn(long8); -short8 __ovld __cnfn convert_short8(long8); -short8 __ovld __cnfn convert_short8_sat(long8); -short8 __ovld __cnfn convert_short8_rte(ulong8); -short8 __ovld __cnfn convert_short8_sat_rte(ulong8); -short8 __ovld __cnfn convert_short8_rtz(ulong8); -short8 __ovld __cnfn convert_short8_sat_rtz(ulong8); -short8 __ovld __cnfn convert_short8_rtp(ulong8); -short8 __ovld __cnfn convert_short8_sat_rtp(ulong8); -short8 __ovld __cnfn convert_short8_rtn(ulong8); -short8 __ovld __cnfn convert_short8_sat_rtn(ulong8); -short8 __ovld __cnfn convert_short8(ulong8); -short8 __ovld __cnfn convert_short8_sat(ulong8); -short8 __ovld __cnfn convert_short8_rte(float8); -short8 __ovld __cnfn convert_short8_sat_rte(float8); -short8 __ovld __cnfn convert_short8_rtz(float8); -short8 __ovld __cnfn convert_short8_sat_rtz(float8); -short8 __ovld __cnfn convert_short8_rtp(float8); -short8 __ovld __cnfn convert_short8_sat_rtp(float8); -short8 __ovld __cnfn convert_short8_rtn(float8); -short8 __ovld __cnfn convert_short8_sat_rtn(float8); -short8 __ovld __cnfn convert_short8(float8); -short8 __ovld __cnfn convert_short8_sat(float8); -ushort8 __ovld __cnfn convert_ushort8_rte(char8); -ushort8 __ovld __cnfn convert_ushort8_sat_rte(char8); -ushort8 __ovld __cnfn convert_ushort8_rtz(char8); -ushort8 __ovld __cnfn convert_ushort8_sat_rtz(char8); -ushort8 __ovld __cnfn convert_ushort8_rtp(char8); -ushort8 __ovld __cnfn convert_ushort8_sat_rtp(char8); -ushort8 __ovld __cnfn convert_ushort8_rtn(char8); -ushort8 __ovld __cnfn convert_ushort8_sat_rtn(char8); -ushort8 __ovld __cnfn convert_ushort8(char8); -ushort8 __ovld __cnfn convert_ushort8_sat(char8); -ushort8 __ovld __cnfn convert_ushort8_rte(uchar8); -ushort8 __ovld __cnfn convert_ushort8_sat_rte(uchar8); -ushort8 __ovld __cnfn convert_ushort8_rtz(uchar8); -ushort8 __ovld __cnfn convert_ushort8_sat_rtz(uchar8); -ushort8 __ovld __cnfn convert_ushort8_rtp(uchar8); -ushort8 __ovld __cnfn convert_ushort8_sat_rtp(uchar8); -ushort8 __ovld __cnfn convert_ushort8_rtn(uchar8); -ushort8 __ovld __cnfn convert_ushort8_sat_rtn(uchar8); -ushort8 __ovld __cnfn convert_ushort8(uchar8); -ushort8 __ovld __cnfn convert_ushort8_sat(uchar8); -ushort8 __ovld __cnfn convert_ushort8_rte(short8); -ushort8 __ovld __cnfn convert_ushort8_sat_rte(short8); -ushort8 __ovld __cnfn convert_ushort8_rtz(short8); -ushort8 __ovld __cnfn convert_ushort8_sat_rtz(short8); -ushort8 __ovld __cnfn convert_ushort8_rtp(short8); -ushort8 __ovld __cnfn convert_ushort8_sat_rtp(short8); -ushort8 __ovld __cnfn convert_ushort8_rtn(short8); -ushort8 __ovld __cnfn convert_ushort8_sat_rtn(short8); -ushort8 __ovld __cnfn convert_ushort8(short8); -ushort8 __ovld __cnfn convert_ushort8_sat(short8); -ushort8 __ovld __cnfn convert_ushort8_rte(ushort8); -ushort8 __ovld __cnfn convert_ushort8_sat_rte(ushort8); -ushort8 __ovld __cnfn convert_ushort8_rtz(ushort8); -ushort8 __ovld __cnfn convert_ushort8_sat_rtz(ushort8); -ushort8 __ovld __cnfn convert_ushort8_rtp(ushort8); -ushort8 __ovld __cnfn convert_ushort8_sat_rtp(ushort8); -ushort8 __ovld __cnfn convert_ushort8_rtn(ushort8); -ushort8 __ovld __cnfn convert_ushort8_sat_rtn(ushort8); -ushort8 __ovld __cnfn convert_ushort8(ushort8); -ushort8 __ovld __cnfn convert_ushort8_sat(ushort8); -ushort8 __ovld __cnfn convert_ushort8_rte(int8); -ushort8 __ovld __cnfn convert_ushort8_sat_rte(int8); -ushort8 __ovld __cnfn convert_ushort8_rtz(int8); -ushort8 __ovld __cnfn convert_ushort8_sat_rtz(int8); -ushort8 __ovld __cnfn convert_ushort8_rtp(int8); -ushort8 __ovld __cnfn convert_ushort8_sat_rtp(int8); -ushort8 __ovld __cnfn convert_ushort8_rtn(int8); -ushort8 __ovld __cnfn convert_ushort8_sat_rtn(int8); -ushort8 __ovld __cnfn convert_ushort8(int8); -ushort8 __ovld __cnfn convert_ushort8_sat(int8); -ushort8 __ovld __cnfn convert_ushort8_rte(uint8); -ushort8 __ovld __cnfn convert_ushort8_sat_rte(uint8); -ushort8 __ovld __cnfn convert_ushort8_rtz(uint8); -ushort8 __ovld __cnfn convert_ushort8_sat_rtz(uint8); -ushort8 __ovld __cnfn convert_ushort8_rtp(uint8); -ushort8 __ovld __cnfn convert_ushort8_sat_rtp(uint8); -ushort8 __ovld __cnfn convert_ushort8_rtn(uint8); -ushort8 __ovld __cnfn convert_ushort8_sat_rtn(uint8); -ushort8 __ovld __cnfn convert_ushort8(uint8); -ushort8 __ovld __cnfn convert_ushort8_sat(uint8); -ushort8 __ovld __cnfn convert_ushort8_rte(long8); -ushort8 __ovld __cnfn convert_ushort8_sat_rte(long8); -ushort8 __ovld __cnfn convert_ushort8_rtz(long8); -ushort8 __ovld __cnfn convert_ushort8_sat_rtz(long8); -ushort8 __ovld __cnfn convert_ushort8_rtp(long8); -ushort8 __ovld __cnfn convert_ushort8_sat_rtp(long8); -ushort8 __ovld __cnfn convert_ushort8_rtn(long8); -ushort8 __ovld __cnfn convert_ushort8_sat_rtn(long8); -ushort8 __ovld __cnfn convert_ushort8(long8); -ushort8 __ovld __cnfn convert_ushort8_sat(long8); -ushort8 __ovld __cnfn convert_ushort8_rte(ulong8); -ushort8 __ovld __cnfn convert_ushort8_sat_rte(ulong8); -ushort8 __ovld __cnfn convert_ushort8_rtz(ulong8); -ushort8 __ovld __cnfn convert_ushort8_sat_rtz(ulong8); -ushort8 __ovld __cnfn convert_ushort8_rtp(ulong8); -ushort8 __ovld __cnfn convert_ushort8_sat_rtp(ulong8); -ushort8 __ovld __cnfn convert_ushort8_rtn(ulong8); -ushort8 __ovld __cnfn convert_ushort8_sat_rtn(ulong8); -ushort8 __ovld __cnfn convert_ushort8(ulong8); -ushort8 __ovld __cnfn convert_ushort8_sat(ulong8); -ushort8 __ovld __cnfn convert_ushort8_rte(float8); -ushort8 __ovld __cnfn convert_ushort8_sat_rte(float8); -ushort8 __ovld __cnfn convert_ushort8_rtz(float8); -ushort8 __ovld __cnfn convert_ushort8_sat_rtz(float8); -ushort8 __ovld __cnfn convert_ushort8_rtp(float8); -ushort8 __ovld __cnfn convert_ushort8_sat_rtp(float8); -ushort8 __ovld __cnfn convert_ushort8_rtn(float8); -ushort8 __ovld __cnfn convert_ushort8_sat_rtn(float8); -ushort8 __ovld __cnfn convert_ushort8(float8); -ushort8 __ovld __cnfn convert_ushort8_sat(float8); -int8 __ovld __cnfn convert_int8_rte(char8); -int8 __ovld __cnfn convert_int8_sat_rte(char8); -int8 __ovld __cnfn convert_int8_rtz(char8); -int8 __ovld __cnfn convert_int8_sat_rtz(char8); -int8 __ovld __cnfn convert_int8_rtp(char8); -int8 __ovld __cnfn convert_int8_sat_rtp(char8); -int8 __ovld __cnfn convert_int8_rtn(char8); -int8 __ovld __cnfn convert_int8_sat_rtn(char8); -int8 __ovld __cnfn convert_int8(char8); -int8 __ovld __cnfn convert_int8_sat(char8); -int8 __ovld __cnfn convert_int8_rte(uchar8); -int8 __ovld __cnfn convert_int8_sat_rte(uchar8); -int8 __ovld __cnfn convert_int8_rtz(uchar8); -int8 __ovld __cnfn convert_int8_sat_rtz(uchar8); -int8 __ovld __cnfn convert_int8_rtp(uchar8); -int8 __ovld __cnfn convert_int8_sat_rtp(uchar8); -int8 __ovld __cnfn convert_int8_rtn(uchar8); -int8 __ovld __cnfn convert_int8_sat_rtn(uchar8); -int8 __ovld __cnfn convert_int8(uchar8); -int8 __ovld __cnfn convert_int8_sat(uchar8); -int8 __ovld __cnfn convert_int8_rte(short8); -int8 __ovld __cnfn convert_int8_sat_rte(short8); -int8 __ovld __cnfn convert_int8_rtz(short8); -int8 __ovld __cnfn convert_int8_sat_rtz(short8); -int8 __ovld __cnfn convert_int8_rtp(short8); -int8 __ovld __cnfn convert_int8_sat_rtp(short8); -int8 __ovld __cnfn convert_int8_rtn(short8); -int8 __ovld __cnfn convert_int8_sat_rtn(short8); -int8 __ovld __cnfn convert_int8(short8); -int8 __ovld __cnfn convert_int8_sat(short8); -int8 __ovld __cnfn convert_int8_rte(ushort8); -int8 __ovld __cnfn convert_int8_sat_rte(ushort8); -int8 __ovld __cnfn convert_int8_rtz(ushort8); -int8 __ovld __cnfn convert_int8_sat_rtz(ushort8); -int8 __ovld __cnfn convert_int8_rtp(ushort8); -int8 __ovld __cnfn convert_int8_sat_rtp(ushort8); -int8 __ovld __cnfn convert_int8_rtn(ushort8); -int8 __ovld __cnfn convert_int8_sat_rtn(ushort8); -int8 __ovld __cnfn convert_int8(ushort8); -int8 __ovld __cnfn convert_int8_sat(ushort8); -int8 __ovld __cnfn convert_int8_rte(int8); -int8 __ovld __cnfn convert_int8_sat_rte(int8); -int8 __ovld __cnfn convert_int8_rtz(int8); -int8 __ovld __cnfn convert_int8_sat_rtz(int8); -int8 __ovld __cnfn convert_int8_rtp(int8); -int8 __ovld __cnfn convert_int8_sat_rtp(int8); -int8 __ovld __cnfn convert_int8_rtn(int8); -int8 __ovld __cnfn convert_int8_sat_rtn(int8); -int8 __ovld __cnfn convert_int8(int8); -int8 __ovld __cnfn convert_int8_sat(int8); -int8 __ovld __cnfn convert_int8_rte(uint8); -int8 __ovld __cnfn convert_int8_sat_rte(uint8); -int8 __ovld __cnfn convert_int8_rtz(uint8); -int8 __ovld __cnfn convert_int8_sat_rtz(uint8); -int8 __ovld __cnfn convert_int8_rtp(uint8); -int8 __ovld __cnfn convert_int8_sat_rtp(uint8); -int8 __ovld __cnfn convert_int8_rtn(uint8); -int8 __ovld __cnfn convert_int8_sat_rtn(uint8); -int8 __ovld __cnfn convert_int8(uint8); -int8 __ovld __cnfn convert_int8_sat(uint8); -int8 __ovld __cnfn convert_int8_rte(long8); -int8 __ovld __cnfn convert_int8_sat_rte(long8); -int8 __ovld __cnfn convert_int8_rtz(long8); -int8 __ovld __cnfn convert_int8_sat_rtz(long8); -int8 __ovld __cnfn convert_int8_rtp(long8); -int8 __ovld __cnfn convert_int8_sat_rtp(long8); -int8 __ovld __cnfn convert_int8_rtn(long8); -int8 __ovld __cnfn convert_int8_sat_rtn(long8); -int8 __ovld __cnfn convert_int8(long8); -int8 __ovld __cnfn convert_int8_sat(long8); -int8 __ovld __cnfn convert_int8_rte(ulong8); -int8 __ovld __cnfn convert_int8_sat_rte(ulong8); -int8 __ovld __cnfn convert_int8_rtz(ulong8); -int8 __ovld __cnfn convert_int8_sat_rtz(ulong8); -int8 __ovld __cnfn convert_int8_rtp(ulong8); -int8 __ovld __cnfn convert_int8_sat_rtp(ulong8); -int8 __ovld __cnfn convert_int8_rtn(ulong8); -int8 __ovld __cnfn convert_int8_sat_rtn(ulong8); -int8 __ovld __cnfn convert_int8(ulong8); -int8 __ovld __cnfn convert_int8_sat(ulong8); -int8 __ovld __cnfn convert_int8_rte(float8); -int8 __ovld __cnfn convert_int8_sat_rte(float8); -int8 __ovld __cnfn convert_int8_rtz(float8); -int8 __ovld __cnfn convert_int8_sat_rtz(float8); -int8 __ovld __cnfn convert_int8_rtp(float8); -int8 __ovld __cnfn convert_int8_sat_rtp(float8); -int8 __ovld __cnfn convert_int8_rtn(float8); -int8 __ovld __cnfn convert_int8_sat_rtn(float8); -int8 __ovld __cnfn convert_int8(float8); -int8 __ovld __cnfn convert_int8_sat(float8); -uint8 __ovld __cnfn convert_uint8_rte(char8); -uint8 __ovld __cnfn convert_uint8_sat_rte(char8); -uint8 __ovld __cnfn convert_uint8_rtz(char8); -uint8 __ovld __cnfn convert_uint8_sat_rtz(char8); -uint8 __ovld __cnfn convert_uint8_rtp(char8); -uint8 __ovld __cnfn convert_uint8_sat_rtp(char8); -uint8 __ovld __cnfn convert_uint8_rtn(char8); -uint8 __ovld __cnfn convert_uint8_sat_rtn(char8); -uint8 __ovld __cnfn convert_uint8(char8); -uint8 __ovld __cnfn convert_uint8_sat(char8); -uint8 __ovld __cnfn convert_uint8_rte(uchar8); -uint8 __ovld __cnfn convert_uint8_sat_rte(uchar8); -uint8 __ovld __cnfn convert_uint8_rtz(uchar8); -uint8 __ovld __cnfn convert_uint8_sat_rtz(uchar8); -uint8 __ovld __cnfn convert_uint8_rtp(uchar8); -uint8 __ovld __cnfn convert_uint8_sat_rtp(uchar8); -uint8 __ovld __cnfn convert_uint8_rtn(uchar8); -uint8 __ovld __cnfn convert_uint8_sat_rtn(uchar8); -uint8 __ovld __cnfn convert_uint8(uchar8); -uint8 __ovld __cnfn convert_uint8_sat(uchar8); -uint8 __ovld __cnfn convert_uint8_rte(short8); -uint8 __ovld __cnfn convert_uint8_sat_rte(short8); -uint8 __ovld __cnfn convert_uint8_rtz(short8); -uint8 __ovld __cnfn convert_uint8_sat_rtz(short8); -uint8 __ovld __cnfn convert_uint8_rtp(short8); -uint8 __ovld __cnfn convert_uint8_sat_rtp(short8); -uint8 __ovld __cnfn convert_uint8_rtn(short8); -uint8 __ovld __cnfn convert_uint8_sat_rtn(short8); -uint8 __ovld __cnfn convert_uint8(short8); -uint8 __ovld __cnfn convert_uint8_sat(short8); -uint8 __ovld __cnfn convert_uint8_rte(ushort8); -uint8 __ovld __cnfn convert_uint8_sat_rte(ushort8); -uint8 __ovld __cnfn convert_uint8_rtz(ushort8); -uint8 __ovld __cnfn convert_uint8_sat_rtz(ushort8); -uint8 __ovld __cnfn convert_uint8_rtp(ushort8); -uint8 __ovld __cnfn convert_uint8_sat_rtp(ushort8); -uint8 __ovld __cnfn convert_uint8_rtn(ushort8); -uint8 __ovld __cnfn convert_uint8_sat_rtn(ushort8); -uint8 __ovld __cnfn convert_uint8(ushort8); -uint8 __ovld __cnfn convert_uint8_sat(ushort8); -uint8 __ovld __cnfn convert_uint8_rte(int8); -uint8 __ovld __cnfn convert_uint8_sat_rte(int8); -uint8 __ovld __cnfn convert_uint8_rtz(int8); -uint8 __ovld __cnfn convert_uint8_sat_rtz(int8); -uint8 __ovld __cnfn convert_uint8_rtp(int8); -uint8 __ovld __cnfn convert_uint8_sat_rtp(int8); -uint8 __ovld __cnfn convert_uint8_rtn(int8); -uint8 __ovld __cnfn convert_uint8_sat_rtn(int8); -uint8 __ovld __cnfn convert_uint8(int8); -uint8 __ovld __cnfn convert_uint8_sat(int8); -uint8 __ovld __cnfn convert_uint8_rte(uint8); -uint8 __ovld __cnfn convert_uint8_sat_rte(uint8); -uint8 __ovld __cnfn convert_uint8_rtz(uint8); -uint8 __ovld __cnfn convert_uint8_sat_rtz(uint8); -uint8 __ovld __cnfn convert_uint8_rtp(uint8); -uint8 __ovld __cnfn convert_uint8_sat_rtp(uint8); -uint8 __ovld __cnfn convert_uint8_rtn(uint8); -uint8 __ovld __cnfn convert_uint8_sat_rtn(uint8); -uint8 __ovld __cnfn convert_uint8(uint8); -uint8 __ovld __cnfn convert_uint8_sat(uint8); -uint8 __ovld __cnfn convert_uint8_rte(long8); -uint8 __ovld __cnfn convert_uint8_sat_rte(long8); -uint8 __ovld __cnfn convert_uint8_rtz(long8); -uint8 __ovld __cnfn convert_uint8_sat_rtz(long8); -uint8 __ovld __cnfn convert_uint8_rtp(long8); -uint8 __ovld __cnfn convert_uint8_sat_rtp(long8); -uint8 __ovld __cnfn convert_uint8_rtn(long8); -uint8 __ovld __cnfn convert_uint8_sat_rtn(long8); -uint8 __ovld __cnfn convert_uint8(long8); -uint8 __ovld __cnfn convert_uint8_sat(long8); -uint8 __ovld __cnfn convert_uint8_rte(ulong8); -uint8 __ovld __cnfn convert_uint8_sat_rte(ulong8); -uint8 __ovld __cnfn convert_uint8_rtz(ulong8); -uint8 __ovld __cnfn convert_uint8_sat_rtz(ulong8); -uint8 __ovld __cnfn convert_uint8_rtp(ulong8); -uint8 __ovld __cnfn convert_uint8_sat_rtp(ulong8); -uint8 __ovld __cnfn convert_uint8_rtn(ulong8); -uint8 __ovld __cnfn convert_uint8_sat_rtn(ulong8); -uint8 __ovld __cnfn convert_uint8(ulong8); -uint8 __ovld __cnfn convert_uint8_sat(ulong8); -uint8 __ovld __cnfn convert_uint8_rte(float8); -uint8 __ovld __cnfn convert_uint8_sat_rte(float8); -uint8 __ovld __cnfn convert_uint8_rtz(float8); -uint8 __ovld __cnfn convert_uint8_sat_rtz(float8); -uint8 __ovld __cnfn convert_uint8_rtp(float8); -uint8 __ovld __cnfn convert_uint8_sat_rtp(float8); -uint8 __ovld __cnfn convert_uint8_rtn(float8); -uint8 __ovld __cnfn convert_uint8_sat_rtn(float8); -uint8 __ovld __cnfn convert_uint8(float8); -uint8 __ovld __cnfn convert_uint8_sat(float8); -long8 __ovld __cnfn convert_long8_rte(char8); -long8 __ovld __cnfn convert_long8_sat_rte(char8); -long8 __ovld __cnfn convert_long8_rtz(char8); -long8 __ovld __cnfn convert_long8_sat_rtz(char8); -long8 __ovld __cnfn convert_long8_rtp(char8); -long8 __ovld __cnfn convert_long8_sat_rtp(char8); -long8 __ovld __cnfn convert_long8_rtn(char8); -long8 __ovld __cnfn convert_long8_sat_rtn(char8); -long8 __ovld __cnfn convert_long8(char8); -long8 __ovld __cnfn convert_long8_sat(char8); -long8 __ovld __cnfn convert_long8_rte(uchar8); -long8 __ovld __cnfn convert_long8_sat_rte(uchar8); -long8 __ovld __cnfn convert_long8_rtz(uchar8); -long8 __ovld __cnfn convert_long8_sat_rtz(uchar8); -long8 __ovld __cnfn convert_long8_rtp(uchar8); -long8 __ovld __cnfn convert_long8_sat_rtp(uchar8); -long8 __ovld __cnfn convert_long8_rtn(uchar8); -long8 __ovld __cnfn convert_long8_sat_rtn(uchar8); -long8 __ovld __cnfn convert_long8(uchar8); -long8 __ovld __cnfn convert_long8_sat(uchar8); -long8 __ovld __cnfn convert_long8_rte(short8); -long8 __ovld __cnfn convert_long8_sat_rte(short8); -long8 __ovld __cnfn convert_long8_rtz(short8); -long8 __ovld __cnfn convert_long8_sat_rtz(short8); -long8 __ovld __cnfn convert_long8_rtp(short8); -long8 __ovld __cnfn convert_long8_sat_rtp(short8); -long8 __ovld __cnfn convert_long8_rtn(short8); -long8 __ovld __cnfn convert_long8_sat_rtn(short8); -long8 __ovld __cnfn convert_long8(short8); -long8 __ovld __cnfn convert_long8_sat(short8); -long8 __ovld __cnfn convert_long8_rte(ushort8); -long8 __ovld __cnfn convert_long8_sat_rte(ushort8); -long8 __ovld __cnfn convert_long8_rtz(ushort8); -long8 __ovld __cnfn convert_long8_sat_rtz(ushort8); -long8 __ovld __cnfn convert_long8_rtp(ushort8); -long8 __ovld __cnfn convert_long8_sat_rtp(ushort8); -long8 __ovld __cnfn convert_long8_rtn(ushort8); -long8 __ovld __cnfn convert_long8_sat_rtn(ushort8); -long8 __ovld __cnfn convert_long8(ushort8); -long8 __ovld __cnfn convert_long8_sat(ushort8); -long8 __ovld __cnfn convert_long8_rte(int8); -long8 __ovld __cnfn convert_long8_sat_rte(int8); -long8 __ovld __cnfn convert_long8_rtz(int8); -long8 __ovld __cnfn convert_long8_sat_rtz(int8); -long8 __ovld __cnfn convert_long8_rtp(int8); -long8 __ovld __cnfn convert_long8_sat_rtp(int8); -long8 __ovld __cnfn convert_long8_rtn(int8); -long8 __ovld __cnfn convert_long8_sat_rtn(int8); -long8 __ovld __cnfn convert_long8(int8); -long8 __ovld __cnfn convert_long8_sat(int8); -long8 __ovld __cnfn convert_long8_rte(uint8); -long8 __ovld __cnfn convert_long8_sat_rte(uint8); -long8 __ovld __cnfn convert_long8_rtz(uint8); -long8 __ovld __cnfn convert_long8_sat_rtz(uint8); -long8 __ovld __cnfn convert_long8_rtp(uint8); -long8 __ovld __cnfn convert_long8_sat_rtp(uint8); -long8 __ovld __cnfn convert_long8_rtn(uint8); -long8 __ovld __cnfn convert_long8_sat_rtn(uint8); -long8 __ovld __cnfn convert_long8(uint8); -long8 __ovld __cnfn convert_long8_sat(uint8); -long8 __ovld __cnfn convert_long8_rte(long8); -long8 __ovld __cnfn convert_long8_sat_rte(long8); -long8 __ovld __cnfn convert_long8_rtz(long8); -long8 __ovld __cnfn convert_long8_sat_rtz(long8); -long8 __ovld __cnfn convert_long8_rtp(long8); -long8 __ovld __cnfn convert_long8_sat_rtp(long8); -long8 __ovld __cnfn convert_long8_rtn(long8); -long8 __ovld __cnfn convert_long8_sat_rtn(long8); -long8 __ovld __cnfn convert_long8(long8); -long8 __ovld __cnfn convert_long8_sat(long8); -long8 __ovld __cnfn convert_long8_rte(ulong8); -long8 __ovld __cnfn convert_long8_sat_rte(ulong8); -long8 __ovld __cnfn convert_long8_rtz(ulong8); -long8 __ovld __cnfn convert_long8_sat_rtz(ulong8); -long8 __ovld __cnfn convert_long8_rtp(ulong8); -long8 __ovld __cnfn convert_long8_sat_rtp(ulong8); -long8 __ovld __cnfn convert_long8_rtn(ulong8); -long8 __ovld __cnfn convert_long8_sat_rtn(ulong8); -long8 __ovld __cnfn convert_long8(ulong8); -long8 __ovld __cnfn convert_long8_sat(ulong8); -long8 __ovld __cnfn convert_long8_rte(float8); -long8 __ovld __cnfn convert_long8_sat_rte(float8); -long8 __ovld __cnfn convert_long8_rtz(float8); -long8 __ovld __cnfn convert_long8_sat_rtz(float8); -long8 __ovld __cnfn convert_long8_rtp(float8); -long8 __ovld __cnfn convert_long8_sat_rtp(float8); -long8 __ovld __cnfn convert_long8_rtn(float8); -long8 __ovld __cnfn convert_long8_sat_rtn(float8); -long8 __ovld __cnfn convert_long8(float8); -long8 __ovld __cnfn convert_long8_sat(float8); -ulong8 __ovld __cnfn convert_ulong8_rte(char8); -ulong8 __ovld __cnfn convert_ulong8_sat_rte(char8); -ulong8 __ovld __cnfn convert_ulong8_rtz(char8); -ulong8 __ovld __cnfn convert_ulong8_sat_rtz(char8); -ulong8 __ovld __cnfn convert_ulong8_rtp(char8); -ulong8 __ovld __cnfn convert_ulong8_sat_rtp(char8); -ulong8 __ovld __cnfn convert_ulong8_rtn(char8); -ulong8 __ovld __cnfn convert_ulong8_sat_rtn(char8); -ulong8 __ovld __cnfn convert_ulong8(char8); -ulong8 __ovld __cnfn convert_ulong8_sat(char8); -ulong8 __ovld __cnfn convert_ulong8_rte(uchar8); -ulong8 __ovld __cnfn convert_ulong8_sat_rte(uchar8); -ulong8 __ovld __cnfn convert_ulong8_rtz(uchar8); -ulong8 __ovld __cnfn convert_ulong8_sat_rtz(uchar8); -ulong8 __ovld __cnfn convert_ulong8_rtp(uchar8); -ulong8 __ovld __cnfn convert_ulong8_sat_rtp(uchar8); -ulong8 __ovld __cnfn convert_ulong8_rtn(uchar8); -ulong8 __ovld __cnfn convert_ulong8_sat_rtn(uchar8); -ulong8 __ovld __cnfn convert_ulong8(uchar8); -ulong8 __ovld __cnfn convert_ulong8_sat(uchar8); -ulong8 __ovld __cnfn convert_ulong8_rte(short8); -ulong8 __ovld __cnfn convert_ulong8_sat_rte(short8); -ulong8 __ovld __cnfn convert_ulong8_rtz(short8); -ulong8 __ovld __cnfn convert_ulong8_sat_rtz(short8); -ulong8 __ovld __cnfn convert_ulong8_rtp(short8); -ulong8 __ovld __cnfn convert_ulong8_sat_rtp(short8); -ulong8 __ovld __cnfn convert_ulong8_rtn(short8); -ulong8 __ovld __cnfn convert_ulong8_sat_rtn(short8); -ulong8 __ovld __cnfn convert_ulong8(short8); -ulong8 __ovld __cnfn convert_ulong8_sat(short8); -ulong8 __ovld __cnfn convert_ulong8_rte(ushort8); -ulong8 __ovld __cnfn convert_ulong8_sat_rte(ushort8); -ulong8 __ovld __cnfn convert_ulong8_rtz(ushort8); -ulong8 __ovld __cnfn convert_ulong8_sat_rtz(ushort8); -ulong8 __ovld __cnfn convert_ulong8_rtp(ushort8); -ulong8 __ovld __cnfn convert_ulong8_sat_rtp(ushort8); -ulong8 __ovld __cnfn convert_ulong8_rtn(ushort8); -ulong8 __ovld __cnfn convert_ulong8_sat_rtn(ushort8); -ulong8 __ovld __cnfn convert_ulong8(ushort8); -ulong8 __ovld __cnfn convert_ulong8_sat(ushort8); -ulong8 __ovld __cnfn convert_ulong8_rte(int8); -ulong8 __ovld __cnfn convert_ulong8_sat_rte(int8); -ulong8 __ovld __cnfn convert_ulong8_rtz(int8); -ulong8 __ovld __cnfn convert_ulong8_sat_rtz(int8); -ulong8 __ovld __cnfn convert_ulong8_rtp(int8); -ulong8 __ovld __cnfn convert_ulong8_sat_rtp(int8); -ulong8 __ovld __cnfn convert_ulong8_rtn(int8); -ulong8 __ovld __cnfn convert_ulong8_sat_rtn(int8); -ulong8 __ovld __cnfn convert_ulong8(int8); -ulong8 __ovld __cnfn convert_ulong8_sat(int8); -ulong8 __ovld __cnfn convert_ulong8_rte(uint8); -ulong8 __ovld __cnfn convert_ulong8_sat_rte(uint8); -ulong8 __ovld __cnfn convert_ulong8_rtz(uint8); -ulong8 __ovld __cnfn convert_ulong8_sat_rtz(uint8); -ulong8 __ovld __cnfn convert_ulong8_rtp(uint8); -ulong8 __ovld __cnfn convert_ulong8_sat_rtp(uint8); -ulong8 __ovld __cnfn convert_ulong8_rtn(uint8); -ulong8 __ovld __cnfn convert_ulong8_sat_rtn(uint8); -ulong8 __ovld __cnfn convert_ulong8(uint8); -ulong8 __ovld __cnfn convert_ulong8_sat(uint8); -ulong8 __ovld __cnfn convert_ulong8_rte(long8); -ulong8 __ovld __cnfn convert_ulong8_sat_rte(long8); -ulong8 __ovld __cnfn convert_ulong8_rtz(long8); -ulong8 __ovld __cnfn convert_ulong8_sat_rtz(long8); -ulong8 __ovld __cnfn convert_ulong8_rtp(long8); -ulong8 __ovld __cnfn convert_ulong8_sat_rtp(long8); -ulong8 __ovld __cnfn convert_ulong8_rtn(long8); -ulong8 __ovld __cnfn convert_ulong8_sat_rtn(long8); -ulong8 __ovld __cnfn convert_ulong8(long8); -ulong8 __ovld __cnfn convert_ulong8_sat(long8); -ulong8 __ovld __cnfn convert_ulong8_rte(ulong8); -ulong8 __ovld __cnfn convert_ulong8_sat_rte(ulong8); -ulong8 __ovld __cnfn convert_ulong8_rtz(ulong8); -ulong8 __ovld __cnfn convert_ulong8_sat_rtz(ulong8); -ulong8 __ovld __cnfn convert_ulong8_rtp(ulong8); -ulong8 __ovld __cnfn convert_ulong8_sat_rtp(ulong8); -ulong8 __ovld __cnfn convert_ulong8_rtn(ulong8); -ulong8 __ovld __cnfn convert_ulong8_sat_rtn(ulong8); -ulong8 __ovld __cnfn convert_ulong8(ulong8); -ulong8 __ovld __cnfn convert_ulong8_sat(ulong8); -ulong8 __ovld __cnfn convert_ulong8_rte(float8); -ulong8 __ovld __cnfn convert_ulong8_sat_rte(float8); -ulong8 __ovld __cnfn convert_ulong8_rtz(float8); -ulong8 __ovld __cnfn convert_ulong8_sat_rtz(float8); -ulong8 __ovld __cnfn convert_ulong8_rtp(float8); -ulong8 __ovld __cnfn convert_ulong8_sat_rtp(float8); -ulong8 __ovld __cnfn convert_ulong8_rtn(float8); -ulong8 __ovld __cnfn convert_ulong8_sat_rtn(float8); -ulong8 __ovld __cnfn convert_ulong8(float8); -ulong8 __ovld __cnfn convert_ulong8_sat(float8); -float8 __ovld __cnfn convert_float8_rte(char8); -float8 __ovld __cnfn convert_float8_rtz(char8); -float8 __ovld __cnfn convert_float8_rtp(char8); -float8 __ovld __cnfn convert_float8_rtn(char8); -float8 __ovld __cnfn convert_float8(char8); -float8 __ovld __cnfn convert_float8_rte(uchar8); -float8 __ovld __cnfn convert_float8_rtz(uchar8); -float8 __ovld __cnfn convert_float8_rtp(uchar8); -float8 __ovld __cnfn convert_float8_rtn(uchar8); -float8 __ovld __cnfn convert_float8(uchar8); -float8 __ovld __cnfn convert_float8_rte(short8); -float8 __ovld __cnfn convert_float8_rtz(short8); -float8 __ovld __cnfn convert_float8_rtp(short8); -float8 __ovld __cnfn convert_float8_rtn(short8); -float8 __ovld __cnfn convert_float8(short8); -float8 __ovld __cnfn convert_float8_rte(ushort8); -float8 __ovld __cnfn convert_float8_rtz(ushort8); -float8 __ovld __cnfn convert_float8_rtp(ushort8); -float8 __ovld __cnfn convert_float8_rtn(ushort8); -float8 __ovld __cnfn convert_float8(ushort8); -float8 __ovld __cnfn convert_float8_rte(int8); -float8 __ovld __cnfn convert_float8_rtz(int8); -float8 __ovld __cnfn convert_float8_rtp(int8); -float8 __ovld __cnfn convert_float8_rtn(int8); -float8 __ovld __cnfn convert_float8(int8); -float8 __ovld __cnfn convert_float8_rte(uint8); -float8 __ovld __cnfn convert_float8_rtz(uint8); -float8 __ovld __cnfn convert_float8_rtp(uint8); -float8 __ovld __cnfn convert_float8_rtn(uint8); -float8 __ovld __cnfn convert_float8(uint8); -float8 __ovld __cnfn convert_float8_rte(long8); -float8 __ovld __cnfn convert_float8_rtz(long8); -float8 __ovld __cnfn convert_float8_rtp(long8); -float8 __ovld __cnfn convert_float8_rtn(long8); -float8 __ovld __cnfn convert_float8(long8); -float8 __ovld __cnfn convert_float8_rte(ulong8); -float8 __ovld __cnfn convert_float8_rtz(ulong8); -float8 __ovld __cnfn convert_float8_rtp(ulong8); -float8 __ovld __cnfn convert_float8_rtn(ulong8); -float8 __ovld __cnfn convert_float8(ulong8); -float8 __ovld __cnfn convert_float8_rte(float8); -float8 __ovld __cnfn convert_float8_rtz(float8); -float8 __ovld __cnfn convert_float8_rtp(float8); -float8 __ovld __cnfn convert_float8_rtn(float8); -float8 __ovld __cnfn convert_float8(float8); -char16 __ovld __cnfn convert_char16_rte(char16); -char16 __ovld __cnfn convert_char16_sat_rte(char16); -char16 __ovld __cnfn convert_char16_rtz(char16); -char16 __ovld __cnfn convert_char16_sat_rtz(char16); -char16 __ovld __cnfn convert_char16_rtp(char16); -char16 __ovld __cnfn convert_char16_sat_rtp(char16); -char16 __ovld __cnfn convert_char16_rtn(char16); -char16 __ovld __cnfn convert_char16_sat_rtn(char16); -char16 __ovld __cnfn convert_char16(char16); -char16 __ovld __cnfn convert_char16_sat(char16); -char16 __ovld __cnfn convert_char16_rte(uchar16); -char16 __ovld __cnfn convert_char16_sat_rte(uchar16); -char16 __ovld __cnfn convert_char16_rtz(uchar16); -char16 __ovld __cnfn convert_char16_sat_rtz(uchar16); -char16 __ovld __cnfn convert_char16_rtp(uchar16); -char16 __ovld __cnfn convert_char16_sat_rtp(uchar16); -char16 __ovld __cnfn convert_char16_rtn(uchar16); -char16 __ovld __cnfn convert_char16_sat_rtn(uchar16); -char16 __ovld __cnfn convert_char16(uchar16); -char16 __ovld __cnfn convert_char16_sat(uchar16); -char16 __ovld __cnfn convert_char16_rte(short16); -char16 __ovld __cnfn convert_char16_sat_rte(short16); -char16 __ovld __cnfn convert_char16_rtz(short16); -char16 __ovld __cnfn convert_char16_sat_rtz(short16); -char16 __ovld __cnfn convert_char16_rtp(short16); -char16 __ovld __cnfn convert_char16_sat_rtp(short16); -char16 __ovld __cnfn convert_char16_rtn(short16); -char16 __ovld __cnfn convert_char16_sat_rtn(short16); -char16 __ovld __cnfn convert_char16(short16); -char16 __ovld __cnfn convert_char16_sat(short16); -char16 __ovld __cnfn convert_char16_rte(ushort16); -char16 __ovld __cnfn convert_char16_sat_rte(ushort16); -char16 __ovld __cnfn convert_char16_rtz(ushort16); -char16 __ovld __cnfn convert_char16_sat_rtz(ushort16); -char16 __ovld __cnfn convert_char16_rtp(ushort16); -char16 __ovld __cnfn convert_char16_sat_rtp(ushort16); -char16 __ovld __cnfn convert_char16_rtn(ushort16); -char16 __ovld __cnfn convert_char16_sat_rtn(ushort16); -char16 __ovld __cnfn convert_char16(ushort16); -char16 __ovld __cnfn convert_char16_sat(ushort16); -char16 __ovld __cnfn convert_char16_rte(int16); -char16 __ovld __cnfn convert_char16_sat_rte(int16); -char16 __ovld __cnfn convert_char16_rtz(int16); -char16 __ovld __cnfn convert_char16_sat_rtz(int16); -char16 __ovld __cnfn convert_char16_rtp(int16); -char16 __ovld __cnfn convert_char16_sat_rtp(int16); -char16 __ovld __cnfn convert_char16_rtn(int16); -char16 __ovld __cnfn convert_char16_sat_rtn(int16); -char16 __ovld __cnfn convert_char16(int16); -char16 __ovld __cnfn convert_char16_sat(int16); -char16 __ovld __cnfn convert_char16_rte(uint16); -char16 __ovld __cnfn convert_char16_sat_rte(uint16); -char16 __ovld __cnfn convert_char16_rtz(uint16); -char16 __ovld __cnfn convert_char16_sat_rtz(uint16); -char16 __ovld __cnfn convert_char16_rtp(uint16); -char16 __ovld __cnfn convert_char16_sat_rtp(uint16); -char16 __ovld __cnfn convert_char16_rtn(uint16); -char16 __ovld __cnfn convert_char16_sat_rtn(uint16); -char16 __ovld __cnfn convert_char16(uint16); -char16 __ovld __cnfn convert_char16_sat(uint16); -char16 __ovld __cnfn convert_char16_rte(long16); -char16 __ovld __cnfn convert_char16_sat_rte(long16); -char16 __ovld __cnfn convert_char16_rtz(long16); -char16 __ovld __cnfn convert_char16_sat_rtz(long16); -char16 __ovld __cnfn convert_char16_rtp(long16); -char16 __ovld __cnfn convert_char16_sat_rtp(long16); -char16 __ovld __cnfn convert_char16_rtn(long16); -char16 __ovld __cnfn convert_char16_sat_rtn(long16); -char16 __ovld __cnfn convert_char16(long16); -char16 __ovld __cnfn convert_char16_sat(long16); -char16 __ovld __cnfn convert_char16_rte(ulong16); -char16 __ovld __cnfn convert_char16_sat_rte(ulong16); -char16 __ovld __cnfn convert_char16_rtz(ulong16); -char16 __ovld __cnfn convert_char16_sat_rtz(ulong16); -char16 __ovld __cnfn convert_char16_rtp(ulong16); -char16 __ovld __cnfn convert_char16_sat_rtp(ulong16); -char16 __ovld __cnfn convert_char16_rtn(ulong16); -char16 __ovld __cnfn convert_char16_sat_rtn(ulong16); -char16 __ovld __cnfn convert_char16(ulong16); -char16 __ovld __cnfn convert_char16_sat(ulong16); -char16 __ovld __cnfn convert_char16_rte(float16); -char16 __ovld __cnfn convert_char16_sat_rte(float16); -char16 __ovld __cnfn convert_char16_rtz(float16); -char16 __ovld __cnfn convert_char16_sat_rtz(float16); -char16 __ovld __cnfn convert_char16_rtp(float16); -char16 __ovld __cnfn convert_char16_sat_rtp(float16); -char16 __ovld __cnfn convert_char16_rtn(float16); -char16 __ovld __cnfn convert_char16_sat_rtn(float16); -char16 __ovld __cnfn convert_char16(float16); -char16 __ovld __cnfn convert_char16_sat(float16); -uchar16 __ovld __cnfn convert_uchar16_rte(char16); -uchar16 __ovld __cnfn convert_uchar16_sat_rte(char16); -uchar16 __ovld __cnfn convert_uchar16_rtz(char16); -uchar16 __ovld __cnfn convert_uchar16_sat_rtz(char16); -uchar16 __ovld __cnfn convert_uchar16_rtp(char16); -uchar16 __ovld __cnfn convert_uchar16_sat_rtp(char16); -uchar16 __ovld __cnfn convert_uchar16_rtn(char16); -uchar16 __ovld __cnfn convert_uchar16_sat_rtn(char16); -uchar16 __ovld __cnfn convert_uchar16(char16); -uchar16 __ovld __cnfn convert_uchar16_sat(char16); -uchar16 __ovld __cnfn convert_uchar16_rte(uchar16); -uchar16 __ovld __cnfn convert_uchar16_sat_rte(uchar16); -uchar16 __ovld __cnfn convert_uchar16_rtz(uchar16); -uchar16 __ovld __cnfn convert_uchar16_sat_rtz(uchar16); -uchar16 __ovld __cnfn convert_uchar16_rtp(uchar16); -uchar16 __ovld __cnfn convert_uchar16_sat_rtp(uchar16); -uchar16 __ovld __cnfn convert_uchar16_rtn(uchar16); -uchar16 __ovld __cnfn convert_uchar16_sat_rtn(uchar16); -uchar16 __ovld __cnfn convert_uchar16(uchar16); -uchar16 __ovld __cnfn convert_uchar16_sat(uchar16); -uchar16 __ovld __cnfn convert_uchar16_rte(short16); -uchar16 __ovld __cnfn convert_uchar16_sat_rte(short16); -uchar16 __ovld __cnfn convert_uchar16_rtz(short16); -uchar16 __ovld __cnfn convert_uchar16_sat_rtz(short16); -uchar16 __ovld __cnfn convert_uchar16_rtp(short16); -uchar16 __ovld __cnfn convert_uchar16_sat_rtp(short16); -uchar16 __ovld __cnfn convert_uchar16_rtn(short16); -uchar16 __ovld __cnfn convert_uchar16_sat_rtn(short16); -uchar16 __ovld __cnfn convert_uchar16(short16); -uchar16 __ovld __cnfn convert_uchar16_sat(short16); -uchar16 __ovld __cnfn convert_uchar16_rte(ushort16); -uchar16 __ovld __cnfn convert_uchar16_sat_rte(ushort16); -uchar16 __ovld __cnfn convert_uchar16_rtz(ushort16); -uchar16 __ovld __cnfn convert_uchar16_sat_rtz(ushort16); -uchar16 __ovld __cnfn convert_uchar16_rtp(ushort16); -uchar16 __ovld __cnfn convert_uchar16_sat_rtp(ushort16); -uchar16 __ovld __cnfn convert_uchar16_rtn(ushort16); -uchar16 __ovld __cnfn convert_uchar16_sat_rtn(ushort16); -uchar16 __ovld __cnfn convert_uchar16(ushort16); -uchar16 __ovld __cnfn convert_uchar16_sat(ushort16); -uchar16 __ovld __cnfn convert_uchar16_rte(int16); -uchar16 __ovld __cnfn convert_uchar16_sat_rte(int16); -uchar16 __ovld __cnfn convert_uchar16_rtz(int16); -uchar16 __ovld __cnfn convert_uchar16_sat_rtz(int16); -uchar16 __ovld __cnfn convert_uchar16_rtp(int16); -uchar16 __ovld __cnfn convert_uchar16_sat_rtp(int16); -uchar16 __ovld __cnfn convert_uchar16_rtn(int16); -uchar16 __ovld __cnfn convert_uchar16_sat_rtn(int16); -uchar16 __ovld __cnfn convert_uchar16(int16); -uchar16 __ovld __cnfn convert_uchar16_sat(int16); -uchar16 __ovld __cnfn convert_uchar16_rte(uint16); -uchar16 __ovld __cnfn convert_uchar16_sat_rte(uint16); -uchar16 __ovld __cnfn convert_uchar16_rtz(uint16); -uchar16 __ovld __cnfn convert_uchar16_sat_rtz(uint16); -uchar16 __ovld __cnfn convert_uchar16_rtp(uint16); -uchar16 __ovld __cnfn convert_uchar16_sat_rtp(uint16); -uchar16 __ovld __cnfn convert_uchar16_rtn(uint16); -uchar16 __ovld __cnfn convert_uchar16_sat_rtn(uint16); -uchar16 __ovld __cnfn convert_uchar16(uint16); -uchar16 __ovld __cnfn convert_uchar16_sat(uint16); -uchar16 __ovld __cnfn convert_uchar16_rte(long16); -uchar16 __ovld __cnfn convert_uchar16_sat_rte(long16); -uchar16 __ovld __cnfn convert_uchar16_rtz(long16); -uchar16 __ovld __cnfn convert_uchar16_sat_rtz(long16); -uchar16 __ovld __cnfn convert_uchar16_rtp(long16); -uchar16 __ovld __cnfn convert_uchar16_sat_rtp(long16); -uchar16 __ovld __cnfn convert_uchar16_rtn(long16); -uchar16 __ovld __cnfn convert_uchar16_sat_rtn(long16); -uchar16 __ovld __cnfn convert_uchar16(long16); -uchar16 __ovld __cnfn convert_uchar16_sat(long16); -uchar16 __ovld __cnfn convert_uchar16_rte(ulong16); -uchar16 __ovld __cnfn convert_uchar16_sat_rte(ulong16); -uchar16 __ovld __cnfn convert_uchar16_rtz(ulong16); -uchar16 __ovld __cnfn convert_uchar16_sat_rtz(ulong16); -uchar16 __ovld __cnfn convert_uchar16_rtp(ulong16); -uchar16 __ovld __cnfn convert_uchar16_sat_rtp(ulong16); -uchar16 __ovld __cnfn convert_uchar16_rtn(ulong16); -uchar16 __ovld __cnfn convert_uchar16_sat_rtn(ulong16); -uchar16 __ovld __cnfn convert_uchar16(ulong16); -uchar16 __ovld __cnfn convert_uchar16_sat(ulong16); -uchar16 __ovld __cnfn convert_uchar16_rte(float16); -uchar16 __ovld __cnfn convert_uchar16_sat_rte(float16); -uchar16 __ovld __cnfn convert_uchar16_rtz(float16); -uchar16 __ovld __cnfn convert_uchar16_sat_rtz(float16); -uchar16 __ovld __cnfn convert_uchar16_rtp(float16); -uchar16 __ovld __cnfn convert_uchar16_sat_rtp(float16); -uchar16 __ovld __cnfn convert_uchar16_rtn(float16); -uchar16 __ovld __cnfn convert_uchar16_sat_rtn(float16); -uchar16 __ovld __cnfn convert_uchar16(float16); -uchar16 __ovld __cnfn convert_uchar16_sat(float16); -short16 __ovld __cnfn convert_short16_rte(char16); -short16 __ovld __cnfn convert_short16_sat_rte(char16); -short16 __ovld __cnfn convert_short16_rtz(char16); -short16 __ovld __cnfn convert_short16_sat_rtz(char16); -short16 __ovld __cnfn convert_short16_rtp(char16); -short16 __ovld __cnfn convert_short16_sat_rtp(char16); -short16 __ovld __cnfn convert_short16_rtn(char16); -short16 __ovld __cnfn convert_short16_sat_rtn(char16); -short16 __ovld __cnfn convert_short16(char16); -short16 __ovld __cnfn convert_short16_sat(char16); -short16 __ovld __cnfn convert_short16_rte(uchar16); -short16 __ovld __cnfn convert_short16_sat_rte(uchar16); -short16 __ovld __cnfn convert_short16_rtz(uchar16); -short16 __ovld __cnfn convert_short16_sat_rtz(uchar16); -short16 __ovld __cnfn convert_short16_rtp(uchar16); -short16 __ovld __cnfn convert_short16_sat_rtp(uchar16); -short16 __ovld __cnfn convert_short16_rtn(uchar16); -short16 __ovld __cnfn convert_short16_sat_rtn(uchar16); -short16 __ovld __cnfn convert_short16(uchar16); -short16 __ovld __cnfn convert_short16_sat(uchar16); -short16 __ovld __cnfn convert_short16_rte(short16); -short16 __ovld __cnfn convert_short16_sat_rte(short16); -short16 __ovld __cnfn convert_short16_rtz(short16); -short16 __ovld __cnfn convert_short16_sat_rtz(short16); -short16 __ovld __cnfn convert_short16_rtp(short16); -short16 __ovld __cnfn convert_short16_sat_rtp(short16); -short16 __ovld __cnfn convert_short16_rtn(short16); -short16 __ovld __cnfn convert_short16_sat_rtn(short16); -short16 __ovld __cnfn convert_short16(short16); -short16 __ovld __cnfn convert_short16_sat(short16); -short16 __ovld __cnfn convert_short16_rte(ushort16); -short16 __ovld __cnfn convert_short16_sat_rte(ushort16); -short16 __ovld __cnfn convert_short16_rtz(ushort16); -short16 __ovld __cnfn convert_short16_sat_rtz(ushort16); -short16 __ovld __cnfn convert_short16_rtp(ushort16); -short16 __ovld __cnfn convert_short16_sat_rtp(ushort16); -short16 __ovld __cnfn convert_short16_rtn(ushort16); -short16 __ovld __cnfn convert_short16_sat_rtn(ushort16); -short16 __ovld __cnfn convert_short16(ushort16); -short16 __ovld __cnfn convert_short16_sat(ushort16); -short16 __ovld __cnfn convert_short16_rte(int16); -short16 __ovld __cnfn convert_short16_sat_rte(int16); -short16 __ovld __cnfn convert_short16_rtz(int16); -short16 __ovld __cnfn convert_short16_sat_rtz(int16); -short16 __ovld __cnfn convert_short16_rtp(int16); -short16 __ovld __cnfn convert_short16_sat_rtp(int16); -short16 __ovld __cnfn convert_short16_rtn(int16); -short16 __ovld __cnfn convert_short16_sat_rtn(int16); -short16 __ovld __cnfn convert_short16(int16); -short16 __ovld __cnfn convert_short16_sat(int16); -short16 __ovld __cnfn convert_short16_rte(uint16); -short16 __ovld __cnfn convert_short16_sat_rte(uint16); -short16 __ovld __cnfn convert_short16_rtz(uint16); -short16 __ovld __cnfn convert_short16_sat_rtz(uint16); -short16 __ovld __cnfn convert_short16_rtp(uint16); -short16 __ovld __cnfn convert_short16_sat_rtp(uint16); -short16 __ovld __cnfn convert_short16_rtn(uint16); -short16 __ovld __cnfn convert_short16_sat_rtn(uint16); -short16 __ovld __cnfn convert_short16(uint16); -short16 __ovld __cnfn convert_short16_sat(uint16); -short16 __ovld __cnfn convert_short16_rte(long16); -short16 __ovld __cnfn convert_short16_sat_rte(long16); -short16 __ovld __cnfn convert_short16_rtz(long16); -short16 __ovld __cnfn convert_short16_sat_rtz(long16); -short16 __ovld __cnfn convert_short16_rtp(long16); -short16 __ovld __cnfn convert_short16_sat_rtp(long16); -short16 __ovld __cnfn convert_short16_rtn(long16); -short16 __ovld __cnfn convert_short16_sat_rtn(long16); -short16 __ovld __cnfn convert_short16(long16); -short16 __ovld __cnfn convert_short16_sat(long16); -short16 __ovld __cnfn convert_short16_rte(ulong16); -short16 __ovld __cnfn convert_short16_sat_rte(ulong16); -short16 __ovld __cnfn convert_short16_rtz(ulong16); -short16 __ovld __cnfn convert_short16_sat_rtz(ulong16); -short16 __ovld __cnfn convert_short16_rtp(ulong16); -short16 __ovld __cnfn convert_short16_sat_rtp(ulong16); -short16 __ovld __cnfn convert_short16_rtn(ulong16); -short16 __ovld __cnfn convert_short16_sat_rtn(ulong16); -short16 __ovld __cnfn convert_short16(ulong16); -short16 __ovld __cnfn convert_short16_sat(ulong16); -short16 __ovld __cnfn convert_short16_rte(float16); -short16 __ovld __cnfn convert_short16_sat_rte(float16); -short16 __ovld __cnfn convert_short16_rtz(float16); -short16 __ovld __cnfn convert_short16_sat_rtz(float16); -short16 __ovld __cnfn convert_short16_rtp(float16); -short16 __ovld __cnfn convert_short16_sat_rtp(float16); -short16 __ovld __cnfn convert_short16_rtn(float16); -short16 __ovld __cnfn convert_short16_sat_rtn(float16); -short16 __ovld __cnfn convert_short16(float16); -short16 __ovld __cnfn convert_short16_sat(float16); -ushort16 __ovld __cnfn convert_ushort16_rte(char16); -ushort16 __ovld __cnfn convert_ushort16_sat_rte(char16); -ushort16 __ovld __cnfn convert_ushort16_rtz(char16); -ushort16 __ovld __cnfn convert_ushort16_sat_rtz(char16); -ushort16 __ovld __cnfn convert_ushort16_rtp(char16); -ushort16 __ovld __cnfn convert_ushort16_sat_rtp(char16); -ushort16 __ovld __cnfn convert_ushort16_rtn(char16); -ushort16 __ovld __cnfn convert_ushort16_sat_rtn(char16); -ushort16 __ovld __cnfn convert_ushort16(char16); -ushort16 __ovld __cnfn convert_ushort16_sat(char16); -ushort16 __ovld __cnfn convert_ushort16_rte(uchar16); -ushort16 __ovld __cnfn convert_ushort16_sat_rte(uchar16); -ushort16 __ovld __cnfn convert_ushort16_rtz(uchar16); -ushort16 __ovld __cnfn convert_ushort16_sat_rtz(uchar16); -ushort16 __ovld __cnfn convert_ushort16_rtp(uchar16); -ushort16 __ovld __cnfn convert_ushort16_sat_rtp(uchar16); -ushort16 __ovld __cnfn convert_ushort16_rtn(uchar16); -ushort16 __ovld __cnfn convert_ushort16_sat_rtn(uchar16); -ushort16 __ovld __cnfn convert_ushort16(uchar16); -ushort16 __ovld __cnfn convert_ushort16_sat(uchar16); -ushort16 __ovld __cnfn convert_ushort16_rte(short16); -ushort16 __ovld __cnfn convert_ushort16_sat_rte(short16); -ushort16 __ovld __cnfn convert_ushort16_rtz(short16); -ushort16 __ovld __cnfn convert_ushort16_sat_rtz(short16); -ushort16 __ovld __cnfn convert_ushort16_rtp(short16); -ushort16 __ovld __cnfn convert_ushort16_sat_rtp(short16); -ushort16 __ovld __cnfn convert_ushort16_rtn(short16); -ushort16 __ovld __cnfn convert_ushort16_sat_rtn(short16); -ushort16 __ovld __cnfn convert_ushort16(short16); -ushort16 __ovld __cnfn convert_ushort16_sat(short16); -ushort16 __ovld __cnfn convert_ushort16_rte(ushort16); -ushort16 __ovld __cnfn convert_ushort16_sat_rte(ushort16); -ushort16 __ovld __cnfn convert_ushort16_rtz(ushort16); -ushort16 __ovld __cnfn convert_ushort16_sat_rtz(ushort16); -ushort16 __ovld __cnfn convert_ushort16_rtp(ushort16); -ushort16 __ovld __cnfn convert_ushort16_sat_rtp(ushort16); -ushort16 __ovld __cnfn convert_ushort16_rtn(ushort16); -ushort16 __ovld __cnfn convert_ushort16_sat_rtn(ushort16); -ushort16 __ovld __cnfn convert_ushort16(ushort16); -ushort16 __ovld __cnfn convert_ushort16_sat(ushort16); -ushort16 __ovld __cnfn convert_ushort16_rte(int16); -ushort16 __ovld __cnfn convert_ushort16_sat_rte(int16); -ushort16 __ovld __cnfn convert_ushort16_rtz(int16); -ushort16 __ovld __cnfn convert_ushort16_sat_rtz(int16); -ushort16 __ovld __cnfn convert_ushort16_rtp(int16); -ushort16 __ovld __cnfn convert_ushort16_sat_rtp(int16); -ushort16 __ovld __cnfn convert_ushort16_rtn(int16); -ushort16 __ovld __cnfn convert_ushort16_sat_rtn(int16); -ushort16 __ovld __cnfn convert_ushort16(int16); -ushort16 __ovld __cnfn convert_ushort16_sat(int16); -ushort16 __ovld __cnfn convert_ushort16_rte(uint16); -ushort16 __ovld __cnfn convert_ushort16_sat_rte(uint16); -ushort16 __ovld __cnfn convert_ushort16_rtz(uint16); -ushort16 __ovld __cnfn convert_ushort16_sat_rtz(uint16); -ushort16 __ovld __cnfn convert_ushort16_rtp(uint16); -ushort16 __ovld __cnfn convert_ushort16_sat_rtp(uint16); -ushort16 __ovld __cnfn convert_ushort16_rtn(uint16); -ushort16 __ovld __cnfn convert_ushort16_sat_rtn(uint16); -ushort16 __ovld __cnfn convert_ushort16(uint16); -ushort16 __ovld __cnfn convert_ushort16_sat(uint16); -ushort16 __ovld __cnfn convert_ushort16_rte(long16); -ushort16 __ovld __cnfn convert_ushort16_sat_rte(long16); -ushort16 __ovld __cnfn convert_ushort16_rtz(long16); -ushort16 __ovld __cnfn convert_ushort16_sat_rtz(long16); -ushort16 __ovld __cnfn convert_ushort16_rtp(long16); -ushort16 __ovld __cnfn convert_ushort16_sat_rtp(long16); -ushort16 __ovld __cnfn convert_ushort16_rtn(long16); -ushort16 __ovld __cnfn convert_ushort16_sat_rtn(long16); -ushort16 __ovld __cnfn convert_ushort16(long16); -ushort16 __ovld __cnfn convert_ushort16_sat(long16); -ushort16 __ovld __cnfn convert_ushort16_rte(ulong16); -ushort16 __ovld __cnfn convert_ushort16_sat_rte(ulong16); -ushort16 __ovld __cnfn convert_ushort16_rtz(ulong16); -ushort16 __ovld __cnfn convert_ushort16_sat_rtz(ulong16); -ushort16 __ovld __cnfn convert_ushort16_rtp(ulong16); -ushort16 __ovld __cnfn convert_ushort16_sat_rtp(ulong16); -ushort16 __ovld __cnfn convert_ushort16_rtn(ulong16); -ushort16 __ovld __cnfn convert_ushort16_sat_rtn(ulong16); -ushort16 __ovld __cnfn convert_ushort16(ulong16); -ushort16 __ovld __cnfn convert_ushort16_sat(ulong16); -ushort16 __ovld __cnfn convert_ushort16_rte(float16); -ushort16 __ovld __cnfn convert_ushort16_sat_rte(float16); -ushort16 __ovld __cnfn convert_ushort16_rtz(float16); -ushort16 __ovld __cnfn convert_ushort16_sat_rtz(float16); -ushort16 __ovld __cnfn convert_ushort16_rtp(float16); -ushort16 __ovld __cnfn convert_ushort16_sat_rtp(float16); -ushort16 __ovld __cnfn convert_ushort16_rtn(float16); -ushort16 __ovld __cnfn convert_ushort16_sat_rtn(float16); -ushort16 __ovld __cnfn convert_ushort16(float16); -ushort16 __ovld __cnfn convert_ushort16_sat(float16); -int16 __ovld __cnfn convert_int16_rte(char16); -int16 __ovld __cnfn convert_int16_sat_rte(char16); -int16 __ovld __cnfn convert_int16_rtz(char16); -int16 __ovld __cnfn convert_int16_sat_rtz(char16); -int16 __ovld __cnfn convert_int16_rtp(char16); -int16 __ovld __cnfn convert_int16_sat_rtp(char16); -int16 __ovld __cnfn convert_int16_rtn(char16); -int16 __ovld __cnfn convert_int16_sat_rtn(char16); -int16 __ovld __cnfn convert_int16(char16); -int16 __ovld __cnfn convert_int16_sat(char16); -int16 __ovld __cnfn convert_int16_rte(uchar16); -int16 __ovld __cnfn convert_int16_sat_rte(uchar16); -int16 __ovld __cnfn convert_int16_rtz(uchar16); -int16 __ovld __cnfn convert_int16_sat_rtz(uchar16); -int16 __ovld __cnfn convert_int16_rtp(uchar16); -int16 __ovld __cnfn convert_int16_sat_rtp(uchar16); -int16 __ovld __cnfn convert_int16_rtn(uchar16); -int16 __ovld __cnfn convert_int16_sat_rtn(uchar16); -int16 __ovld __cnfn convert_int16(uchar16); -int16 __ovld __cnfn convert_int16_sat(uchar16); -int16 __ovld __cnfn convert_int16_rte(short16); -int16 __ovld __cnfn convert_int16_sat_rte(short16); -int16 __ovld __cnfn convert_int16_rtz(short16); -int16 __ovld __cnfn convert_int16_sat_rtz(short16); -int16 __ovld __cnfn convert_int16_rtp(short16); -int16 __ovld __cnfn convert_int16_sat_rtp(short16); -int16 __ovld __cnfn convert_int16_rtn(short16); -int16 __ovld __cnfn convert_int16_sat_rtn(short16); -int16 __ovld __cnfn convert_int16(short16); -int16 __ovld __cnfn convert_int16_sat(short16); -int16 __ovld __cnfn convert_int16_rte(ushort16); -int16 __ovld __cnfn convert_int16_sat_rte(ushort16); -int16 __ovld __cnfn convert_int16_rtz(ushort16); -int16 __ovld __cnfn convert_int16_sat_rtz(ushort16); -int16 __ovld __cnfn convert_int16_rtp(ushort16); -int16 __ovld __cnfn convert_int16_sat_rtp(ushort16); -int16 __ovld __cnfn convert_int16_rtn(ushort16); -int16 __ovld __cnfn convert_int16_sat_rtn(ushort16); -int16 __ovld __cnfn convert_int16(ushort16); -int16 __ovld __cnfn convert_int16_sat(ushort16); -int16 __ovld __cnfn convert_int16_rte(int16); -int16 __ovld __cnfn convert_int16_sat_rte(int16); -int16 __ovld __cnfn convert_int16_rtz(int16); -int16 __ovld __cnfn convert_int16_sat_rtz(int16); -int16 __ovld __cnfn convert_int16_rtp(int16); -int16 __ovld __cnfn convert_int16_sat_rtp(int16); -int16 __ovld __cnfn convert_int16_rtn(int16); -int16 __ovld __cnfn convert_int16_sat_rtn(int16); -int16 __ovld __cnfn convert_int16(int16); -int16 __ovld __cnfn convert_int16_sat(int16); -int16 __ovld __cnfn convert_int16_rte(uint16); -int16 __ovld __cnfn convert_int16_sat_rte(uint16); -int16 __ovld __cnfn convert_int16_rtz(uint16); -int16 __ovld __cnfn convert_int16_sat_rtz(uint16); -int16 __ovld __cnfn convert_int16_rtp(uint16); -int16 __ovld __cnfn convert_int16_sat_rtp(uint16); -int16 __ovld __cnfn convert_int16_rtn(uint16); -int16 __ovld __cnfn convert_int16_sat_rtn(uint16); -int16 __ovld __cnfn convert_int16(uint16); -int16 __ovld __cnfn convert_int16_sat(uint16); -int16 __ovld __cnfn convert_int16_rte(long16); -int16 __ovld __cnfn convert_int16_sat_rte(long16); -int16 __ovld __cnfn convert_int16_rtz(long16); -int16 __ovld __cnfn convert_int16_sat_rtz(long16); -int16 __ovld __cnfn convert_int16_rtp(long16); -int16 __ovld __cnfn convert_int16_sat_rtp(long16); -int16 __ovld __cnfn convert_int16_rtn(long16); -int16 __ovld __cnfn convert_int16_sat_rtn(long16); -int16 __ovld __cnfn convert_int16(long16); -int16 __ovld __cnfn convert_int16_sat(long16); -int16 __ovld __cnfn convert_int16_rte(ulong16); -int16 __ovld __cnfn convert_int16_sat_rte(ulong16); -int16 __ovld __cnfn convert_int16_rtz(ulong16); -int16 __ovld __cnfn convert_int16_sat_rtz(ulong16); -int16 __ovld __cnfn convert_int16_rtp(ulong16); -int16 __ovld __cnfn convert_int16_sat_rtp(ulong16); -int16 __ovld __cnfn convert_int16_rtn(ulong16); -int16 __ovld __cnfn convert_int16_sat_rtn(ulong16); -int16 __ovld __cnfn convert_int16(ulong16); -int16 __ovld __cnfn convert_int16_sat(ulong16); -int16 __ovld __cnfn convert_int16_rte(float16); -int16 __ovld __cnfn convert_int16_sat_rte(float16); -int16 __ovld __cnfn convert_int16_rtz(float16); -int16 __ovld __cnfn convert_int16_sat_rtz(float16); -int16 __ovld __cnfn convert_int16_rtp(float16); -int16 __ovld __cnfn convert_int16_sat_rtp(float16); -int16 __ovld __cnfn convert_int16_rtn(float16); -int16 __ovld __cnfn convert_int16_sat_rtn(float16); -int16 __ovld __cnfn convert_int16(float16); -int16 __ovld __cnfn convert_int16_sat(float16); -uint16 __ovld __cnfn convert_uint16_rte(char16); -uint16 __ovld __cnfn convert_uint16_sat_rte(char16); -uint16 __ovld __cnfn convert_uint16_rtz(char16); -uint16 __ovld __cnfn convert_uint16_sat_rtz(char16); -uint16 __ovld __cnfn convert_uint16_rtp(char16); -uint16 __ovld __cnfn convert_uint16_sat_rtp(char16); -uint16 __ovld __cnfn convert_uint16_rtn(char16); -uint16 __ovld __cnfn convert_uint16_sat_rtn(char16); -uint16 __ovld __cnfn convert_uint16(char16); -uint16 __ovld __cnfn convert_uint16_sat(char16); -uint16 __ovld __cnfn convert_uint16_rte(uchar16); -uint16 __ovld __cnfn convert_uint16_sat_rte(uchar16); -uint16 __ovld __cnfn convert_uint16_rtz(uchar16); -uint16 __ovld __cnfn convert_uint16_sat_rtz(uchar16); -uint16 __ovld __cnfn convert_uint16_rtp(uchar16); -uint16 __ovld __cnfn convert_uint16_sat_rtp(uchar16); -uint16 __ovld __cnfn convert_uint16_rtn(uchar16); -uint16 __ovld __cnfn convert_uint16_sat_rtn(uchar16); -uint16 __ovld __cnfn convert_uint16(uchar16); -uint16 __ovld __cnfn convert_uint16_sat(uchar16); -uint16 __ovld __cnfn convert_uint16_rte(short16); -uint16 __ovld __cnfn convert_uint16_sat_rte(short16); -uint16 __ovld __cnfn convert_uint16_rtz(short16); -uint16 __ovld __cnfn convert_uint16_sat_rtz(short16); -uint16 __ovld __cnfn convert_uint16_rtp(short16); -uint16 __ovld __cnfn convert_uint16_sat_rtp(short16); -uint16 __ovld __cnfn convert_uint16_rtn(short16); -uint16 __ovld __cnfn convert_uint16_sat_rtn(short16); -uint16 __ovld __cnfn convert_uint16(short16); -uint16 __ovld __cnfn convert_uint16_sat(short16); -uint16 __ovld __cnfn convert_uint16_rte(ushort16); -uint16 __ovld __cnfn convert_uint16_sat_rte(ushort16); -uint16 __ovld __cnfn convert_uint16_rtz(ushort16); -uint16 __ovld __cnfn convert_uint16_sat_rtz(ushort16); -uint16 __ovld __cnfn convert_uint16_rtp(ushort16); -uint16 __ovld __cnfn convert_uint16_sat_rtp(ushort16); -uint16 __ovld __cnfn convert_uint16_rtn(ushort16); -uint16 __ovld __cnfn convert_uint16_sat_rtn(ushort16); -uint16 __ovld __cnfn convert_uint16(ushort16); -uint16 __ovld __cnfn convert_uint16_sat(ushort16); -uint16 __ovld __cnfn convert_uint16_rte(int16); -uint16 __ovld __cnfn convert_uint16_sat_rte(int16); -uint16 __ovld __cnfn convert_uint16_rtz(int16); -uint16 __ovld __cnfn convert_uint16_sat_rtz(int16); -uint16 __ovld __cnfn convert_uint16_rtp(int16); -uint16 __ovld __cnfn convert_uint16_sat_rtp(int16); -uint16 __ovld __cnfn convert_uint16_rtn(int16); -uint16 __ovld __cnfn convert_uint16_sat_rtn(int16); -uint16 __ovld __cnfn convert_uint16(int16); -uint16 __ovld __cnfn convert_uint16_sat(int16); -uint16 __ovld __cnfn convert_uint16_rte(uint16); -uint16 __ovld __cnfn convert_uint16_sat_rte(uint16); -uint16 __ovld __cnfn convert_uint16_rtz(uint16); -uint16 __ovld __cnfn convert_uint16_sat_rtz(uint16); -uint16 __ovld __cnfn convert_uint16_rtp(uint16); -uint16 __ovld __cnfn convert_uint16_sat_rtp(uint16); -uint16 __ovld __cnfn convert_uint16_rtn(uint16); -uint16 __ovld __cnfn convert_uint16_sat_rtn(uint16); -uint16 __ovld __cnfn convert_uint16(uint16); -uint16 __ovld __cnfn convert_uint16_sat(uint16); -uint16 __ovld __cnfn convert_uint16_rte(long16); -uint16 __ovld __cnfn convert_uint16_sat_rte(long16); -uint16 __ovld __cnfn convert_uint16_rtz(long16); -uint16 __ovld __cnfn convert_uint16_sat_rtz(long16); -uint16 __ovld __cnfn convert_uint16_rtp(long16); -uint16 __ovld __cnfn convert_uint16_sat_rtp(long16); -uint16 __ovld __cnfn convert_uint16_rtn(long16); -uint16 __ovld __cnfn convert_uint16_sat_rtn(long16); -uint16 __ovld __cnfn convert_uint16(long16); -uint16 __ovld __cnfn convert_uint16_sat(long16); -uint16 __ovld __cnfn convert_uint16_rte(ulong16); -uint16 __ovld __cnfn convert_uint16_sat_rte(ulong16); -uint16 __ovld __cnfn convert_uint16_rtz(ulong16); -uint16 __ovld __cnfn convert_uint16_sat_rtz(ulong16); -uint16 __ovld __cnfn convert_uint16_rtp(ulong16); -uint16 __ovld __cnfn convert_uint16_sat_rtp(ulong16); -uint16 __ovld __cnfn convert_uint16_rtn(ulong16); -uint16 __ovld __cnfn convert_uint16_sat_rtn(ulong16); -uint16 __ovld __cnfn convert_uint16(ulong16); -uint16 __ovld __cnfn convert_uint16_sat(ulong16); -uint16 __ovld __cnfn convert_uint16_rte(float16); -uint16 __ovld __cnfn convert_uint16_sat_rte(float16); -uint16 __ovld __cnfn convert_uint16_rtz(float16); -uint16 __ovld __cnfn convert_uint16_sat_rtz(float16); -uint16 __ovld __cnfn convert_uint16_rtp(float16); -uint16 __ovld __cnfn convert_uint16_sat_rtp(float16); -uint16 __ovld __cnfn convert_uint16_rtn(float16); -uint16 __ovld __cnfn convert_uint16_sat_rtn(float16); -uint16 __ovld __cnfn convert_uint16(float16); -uint16 __ovld __cnfn convert_uint16_sat(float16); -long16 __ovld __cnfn convert_long16_rte(char16); -long16 __ovld __cnfn convert_long16_sat_rte(char16); -long16 __ovld __cnfn convert_long16_rtz(char16); -long16 __ovld __cnfn convert_long16_sat_rtz(char16); -long16 __ovld __cnfn convert_long16_rtp(char16); -long16 __ovld __cnfn convert_long16_sat_rtp(char16); -long16 __ovld __cnfn convert_long16_rtn(char16); -long16 __ovld __cnfn convert_long16_sat_rtn(char16); -long16 __ovld __cnfn convert_long16(char16); -long16 __ovld __cnfn convert_long16_sat(char16); -long16 __ovld __cnfn convert_long16_rte(uchar16); -long16 __ovld __cnfn convert_long16_sat_rte(uchar16); -long16 __ovld __cnfn convert_long16_rtz(uchar16); -long16 __ovld __cnfn convert_long16_sat_rtz(uchar16); -long16 __ovld __cnfn convert_long16_rtp(uchar16); -long16 __ovld __cnfn convert_long16_sat_rtp(uchar16); -long16 __ovld __cnfn convert_long16_rtn(uchar16); -long16 __ovld __cnfn convert_long16_sat_rtn(uchar16); -long16 __ovld __cnfn convert_long16(uchar16); -long16 __ovld __cnfn convert_long16_sat(uchar16); -long16 __ovld __cnfn convert_long16_rte(short16); -long16 __ovld __cnfn convert_long16_sat_rte(short16); -long16 __ovld __cnfn convert_long16_rtz(short16); -long16 __ovld __cnfn convert_long16_sat_rtz(short16); -long16 __ovld __cnfn convert_long16_rtp(short16); -long16 __ovld __cnfn convert_long16_sat_rtp(short16); -long16 __ovld __cnfn convert_long16_rtn(short16); -long16 __ovld __cnfn convert_long16_sat_rtn(short16); -long16 __ovld __cnfn convert_long16(short16); -long16 __ovld __cnfn convert_long16_sat(short16); -long16 __ovld __cnfn convert_long16_rte(ushort16); -long16 __ovld __cnfn convert_long16_sat_rte(ushort16); -long16 __ovld __cnfn convert_long16_rtz(ushort16); -long16 __ovld __cnfn convert_long16_sat_rtz(ushort16); -long16 __ovld __cnfn convert_long16_rtp(ushort16); -long16 __ovld __cnfn convert_long16_sat_rtp(ushort16); -long16 __ovld __cnfn convert_long16_rtn(ushort16); -long16 __ovld __cnfn convert_long16_sat_rtn(ushort16); -long16 __ovld __cnfn convert_long16(ushort16); -long16 __ovld __cnfn convert_long16_sat(ushort16); -long16 __ovld __cnfn convert_long16_rte(int16); -long16 __ovld __cnfn convert_long16_sat_rte(int16); -long16 __ovld __cnfn convert_long16_rtz(int16); -long16 __ovld __cnfn convert_long16_sat_rtz(int16); -long16 __ovld __cnfn convert_long16_rtp(int16); -long16 __ovld __cnfn convert_long16_sat_rtp(int16); -long16 __ovld __cnfn convert_long16_rtn(int16); -long16 __ovld __cnfn convert_long16_sat_rtn(int16); -long16 __ovld __cnfn convert_long16(int16); -long16 __ovld __cnfn convert_long16_sat(int16); -long16 __ovld __cnfn convert_long16_rte(uint16); -long16 __ovld __cnfn convert_long16_sat_rte(uint16); -long16 __ovld __cnfn convert_long16_rtz(uint16); -long16 __ovld __cnfn convert_long16_sat_rtz(uint16); -long16 __ovld __cnfn convert_long16_rtp(uint16); -long16 __ovld __cnfn convert_long16_sat_rtp(uint16); -long16 __ovld __cnfn convert_long16_rtn(uint16); -long16 __ovld __cnfn convert_long16_sat_rtn(uint16); -long16 __ovld __cnfn convert_long16(uint16); -long16 __ovld __cnfn convert_long16_sat(uint16); -long16 __ovld __cnfn convert_long16_rte(long16); -long16 __ovld __cnfn convert_long16_sat_rte(long16); -long16 __ovld __cnfn convert_long16_rtz(long16); -long16 __ovld __cnfn convert_long16_sat_rtz(long16); -long16 __ovld __cnfn convert_long16_rtp(long16); -long16 __ovld __cnfn convert_long16_sat_rtp(long16); -long16 __ovld __cnfn convert_long16_rtn(long16); -long16 __ovld __cnfn convert_long16_sat_rtn(long16); -long16 __ovld __cnfn convert_long16(long16); -long16 __ovld __cnfn convert_long16_sat(long16); -long16 __ovld __cnfn convert_long16_rte(ulong16); -long16 __ovld __cnfn convert_long16_sat_rte(ulong16); -long16 __ovld __cnfn convert_long16_rtz(ulong16); -long16 __ovld __cnfn convert_long16_sat_rtz(ulong16); -long16 __ovld __cnfn convert_long16_rtp(ulong16); -long16 __ovld __cnfn convert_long16_sat_rtp(ulong16); -long16 __ovld __cnfn convert_long16_rtn(ulong16); -long16 __ovld __cnfn convert_long16_sat_rtn(ulong16); -long16 __ovld __cnfn convert_long16(ulong16); -long16 __ovld __cnfn convert_long16_sat(ulong16); -long16 __ovld __cnfn convert_long16_rte(float16); -long16 __ovld __cnfn convert_long16_sat_rte(float16); -long16 __ovld __cnfn convert_long16_rtz(float16); -long16 __ovld __cnfn convert_long16_sat_rtz(float16); -long16 __ovld __cnfn convert_long16_rtp(float16); -long16 __ovld __cnfn convert_long16_sat_rtp(float16); -long16 __ovld __cnfn convert_long16_rtn(float16); -long16 __ovld __cnfn convert_long16_sat_rtn(float16); -long16 __ovld __cnfn convert_long16(float16); -long16 __ovld __cnfn convert_long16_sat(float16); -ulong16 __ovld __cnfn convert_ulong16_rte(char16); -ulong16 __ovld __cnfn convert_ulong16_sat_rte(char16); -ulong16 __ovld __cnfn convert_ulong16_rtz(char16); -ulong16 __ovld __cnfn convert_ulong16_sat_rtz(char16); -ulong16 __ovld __cnfn convert_ulong16_rtp(char16); -ulong16 __ovld __cnfn convert_ulong16_sat_rtp(char16); -ulong16 __ovld __cnfn convert_ulong16_rtn(char16); -ulong16 __ovld __cnfn convert_ulong16_sat_rtn(char16); -ulong16 __ovld __cnfn convert_ulong16(char16); -ulong16 __ovld __cnfn convert_ulong16_sat(char16); -ulong16 __ovld __cnfn convert_ulong16_rte(uchar16); -ulong16 __ovld __cnfn convert_ulong16_sat_rte(uchar16); -ulong16 __ovld __cnfn convert_ulong16_rtz(uchar16); -ulong16 __ovld __cnfn convert_ulong16_sat_rtz(uchar16); -ulong16 __ovld __cnfn convert_ulong16_rtp(uchar16); -ulong16 __ovld __cnfn convert_ulong16_sat_rtp(uchar16); -ulong16 __ovld __cnfn convert_ulong16_rtn(uchar16); -ulong16 __ovld __cnfn convert_ulong16_sat_rtn(uchar16); -ulong16 __ovld __cnfn convert_ulong16(uchar16); -ulong16 __ovld __cnfn convert_ulong16_sat(uchar16); -ulong16 __ovld __cnfn convert_ulong16_rte(short16); -ulong16 __ovld __cnfn convert_ulong16_sat_rte(short16); -ulong16 __ovld __cnfn convert_ulong16_rtz(short16); -ulong16 __ovld __cnfn convert_ulong16_sat_rtz(short16); -ulong16 __ovld __cnfn convert_ulong16_rtp(short16); -ulong16 __ovld __cnfn convert_ulong16_sat_rtp(short16); -ulong16 __ovld __cnfn convert_ulong16_rtn(short16); -ulong16 __ovld __cnfn convert_ulong16_sat_rtn(short16); -ulong16 __ovld __cnfn convert_ulong16(short16); -ulong16 __ovld __cnfn convert_ulong16_sat(short16); -ulong16 __ovld __cnfn convert_ulong16_rte(ushort16); -ulong16 __ovld __cnfn convert_ulong16_sat_rte(ushort16); -ulong16 __ovld __cnfn convert_ulong16_rtz(ushort16); -ulong16 __ovld __cnfn convert_ulong16_sat_rtz(ushort16); -ulong16 __ovld __cnfn convert_ulong16_rtp(ushort16); -ulong16 __ovld __cnfn convert_ulong16_sat_rtp(ushort16); -ulong16 __ovld __cnfn convert_ulong16_rtn(ushort16); -ulong16 __ovld __cnfn convert_ulong16_sat_rtn(ushort16); -ulong16 __ovld __cnfn convert_ulong16(ushort16); -ulong16 __ovld __cnfn convert_ulong16_sat(ushort16); -ulong16 __ovld __cnfn convert_ulong16_rte(int16); -ulong16 __ovld __cnfn convert_ulong16_sat_rte(int16); -ulong16 __ovld __cnfn convert_ulong16_rtz(int16); -ulong16 __ovld __cnfn convert_ulong16_sat_rtz(int16); -ulong16 __ovld __cnfn convert_ulong16_rtp(int16); -ulong16 __ovld __cnfn convert_ulong16_sat_rtp(int16); -ulong16 __ovld __cnfn convert_ulong16_rtn(int16); -ulong16 __ovld __cnfn convert_ulong16_sat_rtn(int16); -ulong16 __ovld __cnfn convert_ulong16(int16); -ulong16 __ovld __cnfn convert_ulong16_sat(int16); -ulong16 __ovld __cnfn convert_ulong16_rte(uint16); -ulong16 __ovld __cnfn convert_ulong16_sat_rte(uint16); -ulong16 __ovld __cnfn convert_ulong16_rtz(uint16); -ulong16 __ovld __cnfn convert_ulong16_sat_rtz(uint16); -ulong16 __ovld __cnfn convert_ulong16_rtp(uint16); -ulong16 __ovld __cnfn convert_ulong16_sat_rtp(uint16); -ulong16 __ovld __cnfn convert_ulong16_rtn(uint16); -ulong16 __ovld __cnfn convert_ulong16_sat_rtn(uint16); -ulong16 __ovld __cnfn convert_ulong16(uint16); -ulong16 __ovld __cnfn convert_ulong16_sat(uint16); -ulong16 __ovld __cnfn convert_ulong16_rte(long16); -ulong16 __ovld __cnfn convert_ulong16_sat_rte(long16); -ulong16 __ovld __cnfn convert_ulong16_rtz(long16); -ulong16 __ovld __cnfn convert_ulong16_sat_rtz(long16); -ulong16 __ovld __cnfn convert_ulong16_rtp(long16); -ulong16 __ovld __cnfn convert_ulong16_sat_rtp(long16); -ulong16 __ovld __cnfn convert_ulong16_rtn(long16); -ulong16 __ovld __cnfn convert_ulong16_sat_rtn(long16); -ulong16 __ovld __cnfn convert_ulong16(long16); -ulong16 __ovld __cnfn convert_ulong16_sat(long16); -ulong16 __ovld __cnfn convert_ulong16_rte(ulong16); -ulong16 __ovld __cnfn convert_ulong16_sat_rte(ulong16); -ulong16 __ovld __cnfn convert_ulong16_rtz(ulong16); -ulong16 __ovld __cnfn convert_ulong16_sat_rtz(ulong16); -ulong16 __ovld __cnfn convert_ulong16_rtp(ulong16); -ulong16 __ovld __cnfn convert_ulong16_sat_rtp(ulong16); -ulong16 __ovld __cnfn convert_ulong16_rtn(ulong16); -ulong16 __ovld __cnfn convert_ulong16_sat_rtn(ulong16); -ulong16 __ovld __cnfn convert_ulong16(ulong16); -ulong16 __ovld __cnfn convert_ulong16_sat(ulong16); -ulong16 __ovld __cnfn convert_ulong16_rte(float16); -ulong16 __ovld __cnfn convert_ulong16_sat_rte(float16); -ulong16 __ovld __cnfn convert_ulong16_rtz(float16); -ulong16 __ovld __cnfn convert_ulong16_sat_rtz(float16); -ulong16 __ovld __cnfn convert_ulong16_rtp(float16); -ulong16 __ovld __cnfn convert_ulong16_sat_rtp(float16); -ulong16 __ovld __cnfn convert_ulong16_rtn(float16); -ulong16 __ovld __cnfn convert_ulong16_sat_rtn(float16); -ulong16 __ovld __cnfn convert_ulong16(float16); -ulong16 __ovld __cnfn convert_ulong16_sat(float16); -float16 __ovld __cnfn convert_float16_rte(char16); -float16 __ovld __cnfn convert_float16_rtz(char16); -float16 __ovld __cnfn convert_float16_rtp(char16); -float16 __ovld __cnfn convert_float16_rtn(char16); -float16 __ovld __cnfn convert_float16(char16); -float16 __ovld __cnfn convert_float16_rte(uchar16); -float16 __ovld __cnfn convert_float16_rtz(uchar16); -float16 __ovld __cnfn convert_float16_rtp(uchar16); -float16 __ovld __cnfn convert_float16_rtn(uchar16); -float16 __ovld __cnfn convert_float16(uchar16); -float16 __ovld __cnfn convert_float16_rte(short16); -float16 __ovld __cnfn convert_float16_rtz(short16); -float16 __ovld __cnfn convert_float16_rtp(short16); -float16 __ovld __cnfn convert_float16_rtn(short16); -float16 __ovld __cnfn convert_float16(short16); -float16 __ovld __cnfn convert_float16_rte(ushort16); -float16 __ovld __cnfn convert_float16_rtz(ushort16); -float16 __ovld __cnfn convert_float16_rtp(ushort16); -float16 __ovld __cnfn convert_float16_rtn(ushort16); -float16 __ovld __cnfn convert_float16(ushort16); -float16 __ovld __cnfn convert_float16_rte(int16); -float16 __ovld __cnfn convert_float16_rtz(int16); -float16 __ovld __cnfn convert_float16_rtp(int16); -float16 __ovld __cnfn convert_float16_rtn(int16); -float16 __ovld __cnfn convert_float16(int16); -float16 __ovld __cnfn convert_float16_rte(uint16); -float16 __ovld __cnfn convert_float16_rtz(uint16); -float16 __ovld __cnfn convert_float16_rtp(uint16); -float16 __ovld __cnfn convert_float16_rtn(uint16); -float16 __ovld __cnfn convert_float16(uint16); -float16 __ovld __cnfn convert_float16_rte(long16); -float16 __ovld __cnfn convert_float16_rtz(long16); -float16 __ovld __cnfn convert_float16_rtp(long16); -float16 __ovld __cnfn convert_float16_rtn(long16); -float16 __ovld __cnfn convert_float16(long16); -float16 __ovld __cnfn convert_float16_rte(ulong16); -float16 __ovld __cnfn convert_float16_rtz(ulong16); -float16 __ovld __cnfn convert_float16_rtp(ulong16); -float16 __ovld __cnfn convert_float16_rtn(ulong16); -float16 __ovld __cnfn convert_float16(ulong16); -float16 __ovld __cnfn convert_float16_rte(float16); -float16 __ovld __cnfn convert_float16_rtz(float16); -float16 __ovld __cnfn convert_float16_rtp(float16); -float16 __ovld __cnfn convert_float16_rtn(float16); -float16 __ovld __cnfn convert_float16(float16); - -// Conversions with double data type parameters or return value. - -#ifdef cl_khr_fp64 -#pragma OPENCL EXTENSION cl_khr_fp64 : enable -char __ovld __cnfn convert_char(double); -char __ovld __cnfn convert_char_rte(double); -char __ovld __cnfn convert_char_rtn(double); -char __ovld __cnfn convert_char_rtp(double); -char __ovld __cnfn convert_char_rtz(double); -char __ovld __cnfn convert_char_sat(double); -char __ovld __cnfn convert_char_sat_rte(double); -char __ovld __cnfn convert_char_sat_rtn(double); -char __ovld __cnfn convert_char_sat_rtp(double); -char __ovld __cnfn convert_char_sat_rtz(double); -char2 __ovld __cnfn convert_char2(double2); -char2 __ovld __cnfn convert_char2_rte(double2); -char2 __ovld __cnfn convert_char2_rtn(double2); -char2 __ovld __cnfn convert_char2_rtp(double2); -char2 __ovld __cnfn convert_char2_rtz(double2); -char2 __ovld __cnfn convert_char2_sat(double2); -char2 __ovld __cnfn convert_char2_sat_rte(double2); -char2 __ovld __cnfn convert_char2_sat_rtn(double2); -char2 __ovld __cnfn convert_char2_sat_rtp(double2); -char2 __ovld __cnfn convert_char2_sat_rtz(double2); -char3 __ovld __cnfn convert_char3(double3); -char3 __ovld __cnfn convert_char3_rte(double3); -char3 __ovld __cnfn convert_char3_rtn(double3); -char3 __ovld __cnfn convert_char3_rtp(double3); -char3 __ovld __cnfn convert_char3_rtz(double3); -char3 __ovld __cnfn convert_char3_sat(double3); -char3 __ovld __cnfn convert_char3_sat_rte(double3); -char3 __ovld __cnfn convert_char3_sat_rtn(double3); -char3 __ovld __cnfn convert_char3_sat_rtp(double3); -char3 __ovld __cnfn convert_char3_sat_rtz(double3); -char4 __ovld __cnfn convert_char4(double4); -char4 __ovld __cnfn convert_char4_rte(double4); -char4 __ovld __cnfn convert_char4_rtn(double4); -char4 __ovld __cnfn convert_char4_rtp(double4); -char4 __ovld __cnfn convert_char4_rtz(double4); -char4 __ovld __cnfn convert_char4_sat(double4); -char4 __ovld __cnfn convert_char4_sat_rte(double4); -char4 __ovld __cnfn convert_char4_sat_rtn(double4); -char4 __ovld __cnfn convert_char4_sat_rtp(double4); -char4 __ovld __cnfn convert_char4_sat_rtz(double4); -char8 __ovld __cnfn convert_char8(double8); -char8 __ovld __cnfn convert_char8_rte(double8); -char8 __ovld __cnfn convert_char8_rtn(double8); -char8 __ovld __cnfn convert_char8_rtp(double8); -char8 __ovld __cnfn convert_char8_rtz(double8); -char8 __ovld __cnfn convert_char8_sat(double8); -char8 __ovld __cnfn convert_char8_sat_rte(double8); -char8 __ovld __cnfn convert_char8_sat_rtn(double8); -char8 __ovld __cnfn convert_char8_sat_rtp(double8); -char8 __ovld __cnfn convert_char8_sat_rtz(double8); -char16 __ovld __cnfn convert_char16(double16); -char16 __ovld __cnfn convert_char16_rte(double16); -char16 __ovld __cnfn convert_char16_rtn(double16); -char16 __ovld __cnfn convert_char16_rtp(double16); -char16 __ovld __cnfn convert_char16_rtz(double16); -char16 __ovld __cnfn convert_char16_sat(double16); -char16 __ovld __cnfn convert_char16_sat_rte(double16); -char16 __ovld __cnfn convert_char16_sat_rtn(double16); -char16 __ovld __cnfn convert_char16_sat_rtp(double16); -char16 __ovld __cnfn convert_char16_sat_rtz(double16); - -uchar __ovld __cnfn convert_uchar(double); -uchar __ovld __cnfn convert_uchar_rte(double); -uchar __ovld __cnfn convert_uchar_rtn(double); -uchar __ovld __cnfn convert_uchar_rtp(double); -uchar __ovld __cnfn convert_uchar_rtz(double); -uchar __ovld __cnfn convert_uchar_sat(double); -uchar __ovld __cnfn convert_uchar_sat_rte(double); -uchar __ovld __cnfn convert_uchar_sat_rtn(double); -uchar __ovld __cnfn convert_uchar_sat_rtp(double); -uchar __ovld __cnfn convert_uchar_sat_rtz(double); -uchar2 __ovld __cnfn convert_uchar2(double2); -uchar2 __ovld __cnfn convert_uchar2_rte(double2); -uchar2 __ovld __cnfn convert_uchar2_rtn(double2); -uchar2 __ovld __cnfn convert_uchar2_rtp(double2); -uchar2 __ovld __cnfn convert_uchar2_rtz(double2); -uchar2 __ovld __cnfn convert_uchar2_sat(double2); -uchar2 __ovld __cnfn convert_uchar2_sat_rte(double2); -uchar2 __ovld __cnfn convert_uchar2_sat_rtn(double2); -uchar2 __ovld __cnfn convert_uchar2_sat_rtp(double2); -uchar2 __ovld __cnfn convert_uchar2_sat_rtz(double2); -uchar3 __ovld __cnfn convert_uchar3(double3); -uchar3 __ovld __cnfn convert_uchar3_rte(double3); -uchar3 __ovld __cnfn convert_uchar3_rtn(double3); -uchar3 __ovld __cnfn convert_uchar3_rtp(double3); -uchar3 __ovld __cnfn convert_uchar3_rtz(double3); -uchar3 __ovld __cnfn convert_uchar3_sat(double3); -uchar3 __ovld __cnfn convert_uchar3_sat_rte(double3); -uchar3 __ovld __cnfn convert_uchar3_sat_rtn(double3); -uchar3 __ovld __cnfn convert_uchar3_sat_rtp(double3); -uchar3 __ovld __cnfn convert_uchar3_sat_rtz(double3); -uchar4 __ovld __cnfn convert_uchar4(double4); -uchar4 __ovld __cnfn convert_uchar4_rte(double4); -uchar4 __ovld __cnfn convert_uchar4_rtn(double4); -uchar4 __ovld __cnfn convert_uchar4_rtp(double4); -uchar4 __ovld __cnfn convert_uchar4_rtz(double4); -uchar4 __ovld __cnfn convert_uchar4_sat(double4); -uchar4 __ovld __cnfn convert_uchar4_sat_rte(double4); -uchar4 __ovld __cnfn convert_uchar4_sat_rtn(double4); -uchar4 __ovld __cnfn convert_uchar4_sat_rtp(double4); -uchar4 __ovld __cnfn convert_uchar4_sat_rtz(double4); -uchar8 __ovld __cnfn convert_uchar8(double8); -uchar8 __ovld __cnfn convert_uchar8_rte(double8); -uchar8 __ovld __cnfn convert_uchar8_rtn(double8); -uchar8 __ovld __cnfn convert_uchar8_rtp(double8); -uchar8 __ovld __cnfn convert_uchar8_rtz(double8); -uchar8 __ovld __cnfn convert_uchar8_sat(double8); -uchar8 __ovld __cnfn convert_uchar8_sat_rte(double8); -uchar8 __ovld __cnfn convert_uchar8_sat_rtn(double8); -uchar8 __ovld __cnfn convert_uchar8_sat_rtp(double8); -uchar8 __ovld __cnfn convert_uchar8_sat_rtz(double8); -uchar16 __ovld __cnfn convert_uchar16(double16); -uchar16 __ovld __cnfn convert_uchar16_rte(double16); -uchar16 __ovld __cnfn convert_uchar16_rtn(double16); -uchar16 __ovld __cnfn convert_uchar16_rtp(double16); -uchar16 __ovld __cnfn convert_uchar16_rtz(double16); -uchar16 __ovld __cnfn convert_uchar16_sat(double16); -uchar16 __ovld __cnfn convert_uchar16_sat_rte(double16); -uchar16 __ovld __cnfn convert_uchar16_sat_rtn(double16); -uchar16 __ovld __cnfn convert_uchar16_sat_rtp(double16); -uchar16 __ovld __cnfn convert_uchar16_sat_rtz(double16); - -short __ovld __cnfn convert_short(double); -short __ovld __cnfn convert_short_rte(double); -short __ovld __cnfn convert_short_rtn(double); -short __ovld __cnfn convert_short_rtp(double); -short __ovld __cnfn convert_short_rtz(double); -short __ovld __cnfn convert_short_sat(double); -short __ovld __cnfn convert_short_sat_rte(double); -short __ovld __cnfn convert_short_sat_rtn(double); -short __ovld __cnfn convert_short_sat_rtp(double); -short __ovld __cnfn convert_short_sat_rtz(double); -short2 __ovld __cnfn convert_short2(double2); -short2 __ovld __cnfn convert_short2_rte(double2); -short2 __ovld __cnfn convert_short2_rtn(double2); -short2 __ovld __cnfn convert_short2_rtp(double2); -short2 __ovld __cnfn convert_short2_rtz(double2); -short2 __ovld __cnfn convert_short2_sat(double2); -short2 __ovld __cnfn convert_short2_sat_rte(double2); -short2 __ovld __cnfn convert_short2_sat_rtn(double2); -short2 __ovld __cnfn convert_short2_sat_rtp(double2); -short2 __ovld __cnfn convert_short2_sat_rtz(double2); -short3 __ovld __cnfn convert_short3(double3); -short3 __ovld __cnfn convert_short3_rte(double3); -short3 __ovld __cnfn convert_short3_rtn(double3); -short3 __ovld __cnfn convert_short3_rtp(double3); -short3 __ovld __cnfn convert_short3_rtz(double3); -short3 __ovld __cnfn convert_short3_sat(double3); -short3 __ovld __cnfn convert_short3_sat_rte(double3); -short3 __ovld __cnfn convert_short3_sat_rtn(double3); -short3 __ovld __cnfn convert_short3_sat_rtp(double3); -short3 __ovld __cnfn convert_short3_sat_rtz(double3); -short4 __ovld __cnfn convert_short4(double4); -short4 __ovld __cnfn convert_short4_rte(double4); -short4 __ovld __cnfn convert_short4_rtn(double4); -short4 __ovld __cnfn convert_short4_rtp(double4); -short4 __ovld __cnfn convert_short4_rtz(double4); -short4 __ovld __cnfn convert_short4_sat(double4); -short4 __ovld __cnfn convert_short4_sat_rte(double4); -short4 __ovld __cnfn convert_short4_sat_rtn(double4); -short4 __ovld __cnfn convert_short4_sat_rtp(double4); -short4 __ovld __cnfn convert_short4_sat_rtz(double4); -short8 __ovld __cnfn convert_short8(double8); -short8 __ovld __cnfn convert_short8_rte(double8); -short8 __ovld __cnfn convert_short8_rtn(double8); -short8 __ovld __cnfn convert_short8_rtp(double8); -short8 __ovld __cnfn convert_short8_rtz(double8); -short8 __ovld __cnfn convert_short8_sat(double8); -short8 __ovld __cnfn convert_short8_sat_rte(double8); -short8 __ovld __cnfn convert_short8_sat_rtn(double8); -short8 __ovld __cnfn convert_short8_sat_rtp(double8); -short8 __ovld __cnfn convert_short8_sat_rtz(double8); -short16 __ovld __cnfn convert_short16(double16); -short16 __ovld __cnfn convert_short16_rte(double16); -short16 __ovld __cnfn convert_short16_rtn(double16); -short16 __ovld __cnfn convert_short16_rtp(double16); -short16 __ovld __cnfn convert_short16_rtz(double16); -short16 __ovld __cnfn convert_short16_sat(double16); -short16 __ovld __cnfn convert_short16_sat_rte(double16); -short16 __ovld __cnfn convert_short16_sat_rtn(double16); -short16 __ovld __cnfn convert_short16_sat_rtp(double16); -short16 __ovld __cnfn convert_short16_sat_rtz(double16); - -ushort __ovld __cnfn convert_ushort(double); -ushort __ovld __cnfn convert_ushort_rte(double); -ushort __ovld __cnfn convert_ushort_rtn(double); -ushort __ovld __cnfn convert_ushort_rtp(double); -ushort __ovld __cnfn convert_ushort_rtz(double); -ushort __ovld __cnfn convert_ushort_sat(double); -ushort __ovld __cnfn convert_ushort_sat_rte(double); -ushort __ovld __cnfn convert_ushort_sat_rtn(double); -ushort __ovld __cnfn convert_ushort_sat_rtp(double); -ushort __ovld __cnfn convert_ushort_sat_rtz(double); -ushort2 __ovld __cnfn convert_ushort2(double2); -ushort2 __ovld __cnfn convert_ushort2_rte(double2); -ushort2 __ovld __cnfn convert_ushort2_rtn(double2); -ushort2 __ovld __cnfn convert_ushort2_rtp(double2); -ushort2 __ovld __cnfn convert_ushort2_rtz(double2); -ushort2 __ovld __cnfn convert_ushort2_sat(double2); -ushort2 __ovld __cnfn convert_ushort2_sat_rte(double2); -ushort2 __ovld __cnfn convert_ushort2_sat_rtn(double2); -ushort2 __ovld __cnfn convert_ushort2_sat_rtp(double2); -ushort2 __ovld __cnfn convert_ushort2_sat_rtz(double2); -ushort3 __ovld __cnfn convert_ushort3(double3); -ushort3 __ovld __cnfn convert_ushort3_rte(double3); -ushort3 __ovld __cnfn convert_ushort3_rtn(double3); -ushort3 __ovld __cnfn convert_ushort3_rtp(double3); -ushort3 __ovld __cnfn convert_ushort3_rtz(double3); -ushort3 __ovld __cnfn convert_ushort3_sat(double3); -ushort3 __ovld __cnfn convert_ushort3_sat_rte(double3); -ushort3 __ovld __cnfn convert_ushort3_sat_rtn(double3); -ushort3 __ovld __cnfn convert_ushort3_sat_rtp(double3); -ushort3 __ovld __cnfn convert_ushort3_sat_rtz(double3); -ushort4 __ovld __cnfn convert_ushort4(double4); -ushort4 __ovld __cnfn convert_ushort4_rte(double4); -ushort4 __ovld __cnfn convert_ushort4_rtn(double4); -ushort4 __ovld __cnfn convert_ushort4_rtp(double4); -ushort4 __ovld __cnfn convert_ushort4_rtz(double4); -ushort4 __ovld __cnfn convert_ushort4_sat(double4); -ushort4 __ovld __cnfn convert_ushort4_sat_rte(double4); -ushort4 __ovld __cnfn convert_ushort4_sat_rtn(double4); -ushort4 __ovld __cnfn convert_ushort4_sat_rtp(double4); -ushort4 __ovld __cnfn convert_ushort4_sat_rtz(double4); -ushort8 __ovld __cnfn convert_ushort8(double8); -ushort8 __ovld __cnfn convert_ushort8_rte(double8); -ushort8 __ovld __cnfn convert_ushort8_rtn(double8); -ushort8 __ovld __cnfn convert_ushort8_rtp(double8); -ushort8 __ovld __cnfn convert_ushort8_rtz(double8); -ushort8 __ovld __cnfn convert_ushort8_sat(double8); -ushort8 __ovld __cnfn convert_ushort8_sat_rte(double8); -ushort8 __ovld __cnfn convert_ushort8_sat_rtn(double8); -ushort8 __ovld __cnfn convert_ushort8_sat_rtp(double8); -ushort8 __ovld __cnfn convert_ushort8_sat_rtz(double8); -ushort16 __ovld __cnfn convert_ushort16(double16); -ushort16 __ovld __cnfn convert_ushort16_rte(double16); -ushort16 __ovld __cnfn convert_ushort16_rtn(double16); -ushort16 __ovld __cnfn convert_ushort16_rtp(double16); -ushort16 __ovld __cnfn convert_ushort16_rtz(double16); -ushort16 __ovld __cnfn convert_ushort16_sat(double16); -ushort16 __ovld __cnfn convert_ushort16_sat_rte(double16); -ushort16 __ovld __cnfn convert_ushort16_sat_rtn(double16); -ushort16 __ovld __cnfn convert_ushort16_sat_rtp(double16); -ushort16 __ovld __cnfn convert_ushort16_sat_rtz(double16); - -int __ovld __cnfn convert_int(double); -int __ovld __cnfn convert_int_rte(double); -int __ovld __cnfn convert_int_rtn(double); -int __ovld __cnfn convert_int_rtp(double); -int __ovld __cnfn convert_int_rtz(double); -int __ovld __cnfn convert_int_sat(double); -int __ovld __cnfn convert_int_sat_rte(double); -int __ovld __cnfn convert_int_sat_rtn(double); -int __ovld __cnfn convert_int_sat_rtp(double); -int __ovld __cnfn convert_int_sat_rtz(double); -int2 __ovld __cnfn convert_int2(double2); -int2 __ovld __cnfn convert_int2_rte(double2); -int2 __ovld __cnfn convert_int2_rtn(double2); -int2 __ovld __cnfn convert_int2_rtp(double2); -int2 __ovld __cnfn convert_int2_rtz(double2); -int2 __ovld __cnfn convert_int2_sat(double2); -int2 __ovld __cnfn convert_int2_sat_rte(double2); -int2 __ovld __cnfn convert_int2_sat_rtn(double2); -int2 __ovld __cnfn convert_int2_sat_rtp(double2); -int2 __ovld __cnfn convert_int2_sat_rtz(double2); -int3 __ovld __cnfn convert_int3(double3); -int3 __ovld __cnfn convert_int3_rte(double3); -int3 __ovld __cnfn convert_int3_rtn(double3); -int3 __ovld __cnfn convert_int3_rtp(double3); -int3 __ovld __cnfn convert_int3_rtz(double3); -int3 __ovld __cnfn convert_int3_sat(double3); -int3 __ovld __cnfn convert_int3_sat_rte(double3); -int3 __ovld __cnfn convert_int3_sat_rtn(double3); -int3 __ovld __cnfn convert_int3_sat_rtp(double3); -int3 __ovld __cnfn convert_int3_sat_rtz(double3); -int4 __ovld __cnfn convert_int4(double4); -int4 __ovld __cnfn convert_int4_rte(double4); -int4 __ovld __cnfn convert_int4_rtn(double4); -int4 __ovld __cnfn convert_int4_rtp(double4); -int4 __ovld __cnfn convert_int4_rtz(double4); -int4 __ovld __cnfn convert_int4_sat(double4); -int4 __ovld __cnfn convert_int4_sat_rte(double4); -int4 __ovld __cnfn convert_int4_sat_rtn(double4); -int4 __ovld __cnfn convert_int4_sat_rtp(double4); -int4 __ovld __cnfn convert_int4_sat_rtz(double4); -int8 __ovld __cnfn convert_int8(double8); -int8 __ovld __cnfn convert_int8_rte(double8); -int8 __ovld __cnfn convert_int8_rtn(double8); -int8 __ovld __cnfn convert_int8_rtp(double8); -int8 __ovld __cnfn convert_int8_rtz(double8); -int8 __ovld __cnfn convert_int8_sat(double8); -int8 __ovld __cnfn convert_int8_sat_rte(double8); -int8 __ovld __cnfn convert_int8_sat_rtn(double8); -int8 __ovld __cnfn convert_int8_sat_rtp(double8); -int8 __ovld __cnfn convert_int8_sat_rtz(double8); -int16 __ovld __cnfn convert_int16(double16); -int16 __ovld __cnfn convert_int16_rte(double16); -int16 __ovld __cnfn convert_int16_rtn(double16); -int16 __ovld __cnfn convert_int16_rtp(double16); -int16 __ovld __cnfn convert_int16_rtz(double16); -int16 __ovld __cnfn convert_int16_sat(double16); -int16 __ovld __cnfn convert_int16_sat_rte(double16); -int16 __ovld __cnfn convert_int16_sat_rtn(double16); -int16 __ovld __cnfn convert_int16_sat_rtp(double16); -int16 __ovld __cnfn convert_int16_sat_rtz(double16); - -uint __ovld __cnfn convert_uint(double); -uint __ovld __cnfn convert_uint_rte(double); -uint __ovld __cnfn convert_uint_rtn(double); -uint __ovld __cnfn convert_uint_rtp(double); -uint __ovld __cnfn convert_uint_rtz(double); -uint __ovld __cnfn convert_uint_sat(double); -uint __ovld __cnfn convert_uint_sat_rte(double); -uint __ovld __cnfn convert_uint_sat_rtn(double); -uint __ovld __cnfn convert_uint_sat_rtp(double); -uint __ovld __cnfn convert_uint_sat_rtz(double); -uint2 __ovld __cnfn convert_uint2(double2); -uint2 __ovld __cnfn convert_uint2_rte(double2); -uint2 __ovld __cnfn convert_uint2_rtn(double2); -uint2 __ovld __cnfn convert_uint2_rtp(double2); -uint2 __ovld __cnfn convert_uint2_rtz(double2); -uint2 __ovld __cnfn convert_uint2_sat(double2); -uint2 __ovld __cnfn convert_uint2_sat_rte(double2); -uint2 __ovld __cnfn convert_uint2_sat_rtn(double2); -uint2 __ovld __cnfn convert_uint2_sat_rtp(double2); -uint2 __ovld __cnfn convert_uint2_sat_rtz(double2); -uint3 __ovld __cnfn convert_uint3(double3); -uint3 __ovld __cnfn convert_uint3_rte(double3); -uint3 __ovld __cnfn convert_uint3_rtn(double3); -uint3 __ovld __cnfn convert_uint3_rtp(double3); -uint3 __ovld __cnfn convert_uint3_rtz(double3); -uint3 __ovld __cnfn convert_uint3_sat(double3); -uint3 __ovld __cnfn convert_uint3_sat_rte(double3); -uint3 __ovld __cnfn convert_uint3_sat_rtn(double3); -uint3 __ovld __cnfn convert_uint3_sat_rtp(double3); -uint3 __ovld __cnfn convert_uint3_sat_rtz(double3); -uint4 __ovld __cnfn convert_uint4(double4); -uint4 __ovld __cnfn convert_uint4_rte(double4); -uint4 __ovld __cnfn convert_uint4_rtn(double4); -uint4 __ovld __cnfn convert_uint4_rtp(double4); -uint4 __ovld __cnfn convert_uint4_rtz(double4); -uint4 __ovld __cnfn convert_uint4_sat(double4); -uint4 __ovld __cnfn convert_uint4_sat_rte(double4); -uint4 __ovld __cnfn convert_uint4_sat_rtn(double4); -uint4 __ovld __cnfn convert_uint4_sat_rtp(double4); -uint4 __ovld __cnfn convert_uint4_sat_rtz(double4); -uint8 __ovld __cnfn convert_uint8(double8); -uint8 __ovld __cnfn convert_uint8_rte(double8); -uint8 __ovld __cnfn convert_uint8_rtn(double8); -uint8 __ovld __cnfn convert_uint8_rtp(double8); -uint8 __ovld __cnfn convert_uint8_rtz(double8); -uint8 __ovld __cnfn convert_uint8_sat(double8); -uint8 __ovld __cnfn convert_uint8_sat_rte(double8); -uint8 __ovld __cnfn convert_uint8_sat_rtn(double8); -uint8 __ovld __cnfn convert_uint8_sat_rtp(double8); -uint8 __ovld __cnfn convert_uint8_sat_rtz(double8); -uint16 __ovld __cnfn convert_uint16(double16); -uint16 __ovld __cnfn convert_uint16_rte(double16); -uint16 __ovld __cnfn convert_uint16_rtn(double16); -uint16 __ovld __cnfn convert_uint16_rtp(double16); -uint16 __ovld __cnfn convert_uint16_rtz(double16); -uint16 __ovld __cnfn convert_uint16_sat(double16); -uint16 __ovld __cnfn convert_uint16_sat_rte(double16); -uint16 __ovld __cnfn convert_uint16_sat_rtn(double16); -uint16 __ovld __cnfn convert_uint16_sat_rtp(double16); -uint16 __ovld __cnfn convert_uint16_sat_rtz(double16); - -long __ovld __cnfn convert_long(double); -long __ovld __cnfn convert_long_rte(double); -long __ovld __cnfn convert_long_rtn(double); -long __ovld __cnfn convert_long_rtp(double); -long __ovld __cnfn convert_long_rtz(double); -long __ovld __cnfn convert_long_sat(double); -long __ovld __cnfn convert_long_sat_rte(double); -long __ovld __cnfn convert_long_sat_rtn(double); -long __ovld __cnfn convert_long_sat_rtp(double); -long __ovld __cnfn convert_long_sat_rtz(double); -long2 __ovld __cnfn convert_long2(double2); -long2 __ovld __cnfn convert_long2_rte(double2); -long2 __ovld __cnfn convert_long2_rtn(double2); -long2 __ovld __cnfn convert_long2_rtp(double2); -long2 __ovld __cnfn convert_long2_rtz(double2); -long2 __ovld __cnfn convert_long2_sat(double2); -long2 __ovld __cnfn convert_long2_sat_rte(double2); -long2 __ovld __cnfn convert_long2_sat_rtn(double2); -long2 __ovld __cnfn convert_long2_sat_rtp(double2); -long2 __ovld __cnfn convert_long2_sat_rtz(double2); -long3 __ovld __cnfn convert_long3(double3); -long3 __ovld __cnfn convert_long3_rte(double3); -long3 __ovld __cnfn convert_long3_rtn(double3); -long3 __ovld __cnfn convert_long3_rtp(double3); -long3 __ovld __cnfn convert_long3_rtz(double3); -long3 __ovld __cnfn convert_long3_sat(double3); -long3 __ovld __cnfn convert_long3_sat_rte(double3); -long3 __ovld __cnfn convert_long3_sat_rtn(double3); -long3 __ovld __cnfn convert_long3_sat_rtp(double3); -long3 __ovld __cnfn convert_long3_sat_rtz(double3); -long4 __ovld __cnfn convert_long4(double4); -long4 __ovld __cnfn convert_long4_rte(double4); -long4 __ovld __cnfn convert_long4_rtn(double4); -long4 __ovld __cnfn convert_long4_rtp(double4); -long4 __ovld __cnfn convert_long4_rtz(double4); -long4 __ovld __cnfn convert_long4_sat(double4); -long4 __ovld __cnfn convert_long4_sat_rte(double4); -long4 __ovld __cnfn convert_long4_sat_rtn(double4); -long4 __ovld __cnfn convert_long4_sat_rtp(double4); -long4 __ovld __cnfn convert_long4_sat_rtz(double4); -long8 __ovld __cnfn convert_long8(double8); -long8 __ovld __cnfn convert_long8_rte(double8); -long8 __ovld __cnfn convert_long8_rtn(double8); -long8 __ovld __cnfn convert_long8_rtp(double8); -long8 __ovld __cnfn convert_long8_rtz(double8); -long8 __ovld __cnfn convert_long8_sat(double8); -long8 __ovld __cnfn convert_long8_sat_rte(double8); -long8 __ovld __cnfn convert_long8_sat_rtn(double8); -long8 __ovld __cnfn convert_long8_sat_rtp(double8); -long8 __ovld __cnfn convert_long8_sat_rtz(double8); -long16 __ovld __cnfn convert_long16(double16); -long16 __ovld __cnfn convert_long16_rte(double16); -long16 __ovld __cnfn convert_long16_rtn(double16); -long16 __ovld __cnfn convert_long16_rtp(double16); -long16 __ovld __cnfn convert_long16_rtz(double16); -long16 __ovld __cnfn convert_long16_sat(double16); -long16 __ovld __cnfn convert_long16_sat_rte(double16); -long16 __ovld __cnfn convert_long16_sat_rtn(double16); -long16 __ovld __cnfn convert_long16_sat_rtp(double16); -long16 __ovld __cnfn convert_long16_sat_rtz(double16); - -ulong __ovld __cnfn convert_ulong(double); -ulong __ovld __cnfn convert_ulong_rte(double); -ulong __ovld __cnfn convert_ulong_rtn(double); -ulong __ovld __cnfn convert_ulong_rtp(double); -ulong __ovld __cnfn convert_ulong_rtz(double); -ulong __ovld __cnfn convert_ulong_sat(double); -ulong __ovld __cnfn convert_ulong_sat_rte(double); -ulong __ovld __cnfn convert_ulong_sat_rtn(double); -ulong __ovld __cnfn convert_ulong_sat_rtp(double); -ulong __ovld __cnfn convert_ulong_sat_rtz(double); -ulong2 __ovld __cnfn convert_ulong2(double2); -ulong2 __ovld __cnfn convert_ulong2_rte(double2); -ulong2 __ovld __cnfn convert_ulong2_rtn(double2); -ulong2 __ovld __cnfn convert_ulong2_rtp(double2); -ulong2 __ovld __cnfn convert_ulong2_rtz(double2); -ulong2 __ovld __cnfn convert_ulong2_sat(double2); -ulong2 __ovld __cnfn convert_ulong2_sat_rte(double2); -ulong2 __ovld __cnfn convert_ulong2_sat_rtn(double2); -ulong2 __ovld __cnfn convert_ulong2_sat_rtp(double2); -ulong2 __ovld __cnfn convert_ulong2_sat_rtz(double2); -ulong3 __ovld __cnfn convert_ulong3(double3); -ulong3 __ovld __cnfn convert_ulong3_rte(double3); -ulong3 __ovld __cnfn convert_ulong3_rtn(double3); -ulong3 __ovld __cnfn convert_ulong3_rtp(double3); -ulong3 __ovld __cnfn convert_ulong3_rtz(double3); -ulong3 __ovld __cnfn convert_ulong3_sat(double3); -ulong3 __ovld __cnfn convert_ulong3_sat_rte(double3); -ulong3 __ovld __cnfn convert_ulong3_sat_rtn(double3); -ulong3 __ovld __cnfn convert_ulong3_sat_rtp(double3); -ulong3 __ovld __cnfn convert_ulong3_sat_rtz(double3); -ulong4 __ovld __cnfn convert_ulong4(double4); -ulong4 __ovld __cnfn convert_ulong4_rte(double4); -ulong4 __ovld __cnfn convert_ulong4_rtn(double4); -ulong4 __ovld __cnfn convert_ulong4_rtp(double4); -ulong4 __ovld __cnfn convert_ulong4_rtz(double4); -ulong4 __ovld __cnfn convert_ulong4_sat(double4); -ulong4 __ovld __cnfn convert_ulong4_sat_rte(double4); -ulong4 __ovld __cnfn convert_ulong4_sat_rtn(double4); -ulong4 __ovld __cnfn convert_ulong4_sat_rtp(double4); -ulong4 __ovld __cnfn convert_ulong4_sat_rtz(double4); -ulong8 __ovld __cnfn convert_ulong8(double8); -ulong8 __ovld __cnfn convert_ulong8_rte(double8); -ulong8 __ovld __cnfn convert_ulong8_rtn(double8); -ulong8 __ovld __cnfn convert_ulong8_rtp(double8); -ulong8 __ovld __cnfn convert_ulong8_rtz(double8); -ulong8 __ovld __cnfn convert_ulong8_sat(double8); -ulong8 __ovld __cnfn convert_ulong8_sat_rte(double8); -ulong8 __ovld __cnfn convert_ulong8_sat_rtn(double8); -ulong8 __ovld __cnfn convert_ulong8_sat_rtp(double8); -ulong8 __ovld __cnfn convert_ulong8_sat_rtz(double8); -ulong16 __ovld __cnfn convert_ulong16(double16); -ulong16 __ovld __cnfn convert_ulong16_rte(double16); -ulong16 __ovld __cnfn convert_ulong16_rtn(double16); -ulong16 __ovld __cnfn convert_ulong16_rtp(double16); -ulong16 __ovld __cnfn convert_ulong16_rtz(double16); -ulong16 __ovld __cnfn convert_ulong16_sat(double16); -ulong16 __ovld __cnfn convert_ulong16_sat_rte(double16); -ulong16 __ovld __cnfn convert_ulong16_sat_rtn(double16); -ulong16 __ovld __cnfn convert_ulong16_sat_rtp(double16); -ulong16 __ovld __cnfn convert_ulong16_sat_rtz(double16); - -float __ovld __cnfn convert_float(double); -float __ovld __cnfn convert_float_rte(double); -float __ovld __cnfn convert_float_rtn(double); -float __ovld __cnfn convert_float_rtp(double); -float __ovld __cnfn convert_float_rtz(double); -float2 __ovld __cnfn convert_float2(double2); -float2 __ovld __cnfn convert_float2_rte(double2); -float2 __ovld __cnfn convert_float2_rtn(double2); -float2 __ovld __cnfn convert_float2_rtp(double2); -float2 __ovld __cnfn convert_float2_rtz(double2); -float3 __ovld __cnfn convert_float3(double3); -float3 __ovld __cnfn convert_float3_rte(double3); -float3 __ovld __cnfn convert_float3_rtn(double3); -float3 __ovld __cnfn convert_float3_rtp(double3); -float3 __ovld __cnfn convert_float3_rtz(double3); -float4 __ovld __cnfn convert_float4(double4); -float4 __ovld __cnfn convert_float4_rte(double4); -float4 __ovld __cnfn convert_float4_rtn(double4); -float4 __ovld __cnfn convert_float4_rtp(double4); -float4 __ovld __cnfn convert_float4_rtz(double4); -float8 __ovld __cnfn convert_float8(double8); -float8 __ovld __cnfn convert_float8_rte(double8); -float8 __ovld __cnfn convert_float8_rtn(double8); -float8 __ovld __cnfn convert_float8_rtp(double8); -float8 __ovld __cnfn convert_float8_rtz(double8); -float16 __ovld __cnfn convert_float16(double16); -float16 __ovld __cnfn convert_float16_rte(double16); -float16 __ovld __cnfn convert_float16_rtn(double16); -float16 __ovld __cnfn convert_float16_rtp(double16); -float16 __ovld __cnfn convert_float16_rtz(double16); - -double __ovld __cnfn convert_double(char); -double __ovld __cnfn convert_double(double); -double __ovld __cnfn convert_double(float); -double __ovld __cnfn convert_double(int); -double __ovld __cnfn convert_double(long); -double __ovld __cnfn convert_double(short); -double __ovld __cnfn convert_double(uchar); -double __ovld __cnfn convert_double(uint); -double __ovld __cnfn convert_double(ulong); -double __ovld __cnfn convert_double(ushort); -double __ovld __cnfn convert_double_rte(char); -double __ovld __cnfn convert_double_rte(double); -double __ovld __cnfn convert_double_rte(float); -double __ovld __cnfn convert_double_rte(int); -double __ovld __cnfn convert_double_rte(long); -double __ovld __cnfn convert_double_rte(short); -double __ovld __cnfn convert_double_rte(uchar); -double __ovld __cnfn convert_double_rte(uint); -double __ovld __cnfn convert_double_rte(ulong); -double __ovld __cnfn convert_double_rte(ushort); -double __ovld __cnfn convert_double_rtn(char); -double __ovld __cnfn convert_double_rtn(double); -double __ovld __cnfn convert_double_rtn(float); -double __ovld __cnfn convert_double_rtn(int); -double __ovld __cnfn convert_double_rtn(long); -double __ovld __cnfn convert_double_rtn(short); -double __ovld __cnfn convert_double_rtn(uchar); -double __ovld __cnfn convert_double_rtn(uint); -double __ovld __cnfn convert_double_rtn(ulong); -double __ovld __cnfn convert_double_rtn(ushort); -double __ovld __cnfn convert_double_rtp(char); -double __ovld __cnfn convert_double_rtp(double); -double __ovld __cnfn convert_double_rtp(float); -double __ovld __cnfn convert_double_rtp(int); -double __ovld __cnfn convert_double_rtp(long); -double __ovld __cnfn convert_double_rtp(short); -double __ovld __cnfn convert_double_rtp(uchar); -double __ovld __cnfn convert_double_rtp(uint); -double __ovld __cnfn convert_double_rtp(ulong); -double __ovld __cnfn convert_double_rtp(ushort); -double __ovld __cnfn convert_double_rtz(char); -double __ovld __cnfn convert_double_rtz(double); -double __ovld __cnfn convert_double_rtz(float); -double __ovld __cnfn convert_double_rtz(int); -double __ovld __cnfn convert_double_rtz(long); -double __ovld __cnfn convert_double_rtz(short); -double __ovld __cnfn convert_double_rtz(uchar); -double __ovld __cnfn convert_double_rtz(uint); -double __ovld __cnfn convert_double_rtz(ulong); -double __ovld __cnfn convert_double_rtz(ushort); -double2 __ovld __cnfn convert_double2(char2); -double2 __ovld __cnfn convert_double2(double2); -double2 __ovld __cnfn convert_double2(float2); -double2 __ovld __cnfn convert_double2(int2); -double2 __ovld __cnfn convert_double2(long2); -double2 __ovld __cnfn convert_double2(short2); -double2 __ovld __cnfn convert_double2(uchar2); -double2 __ovld __cnfn convert_double2(uint2); -double2 __ovld __cnfn convert_double2(ulong2); -double2 __ovld __cnfn convert_double2(ushort2); -double2 __ovld __cnfn convert_double2_rte(char2); -double2 __ovld __cnfn convert_double2_rte(double2); -double2 __ovld __cnfn convert_double2_rte(float2); -double2 __ovld __cnfn convert_double2_rte(int2); -double2 __ovld __cnfn convert_double2_rte(long2); -double2 __ovld __cnfn convert_double2_rte(short2); -double2 __ovld __cnfn convert_double2_rte(uchar2); -double2 __ovld __cnfn convert_double2_rte(uint2); -double2 __ovld __cnfn convert_double2_rte(ulong2); -double2 __ovld __cnfn convert_double2_rte(ushort2); -double2 __ovld __cnfn convert_double2_rtn(char2); -double2 __ovld __cnfn convert_double2_rtn(double2); -double2 __ovld __cnfn convert_double2_rtn(float2); -double2 __ovld __cnfn convert_double2_rtn(int2); -double2 __ovld __cnfn convert_double2_rtn(long2); -double2 __ovld __cnfn convert_double2_rtn(short2); -double2 __ovld __cnfn convert_double2_rtn(uchar2); -double2 __ovld __cnfn convert_double2_rtn(uint2); -double2 __ovld __cnfn convert_double2_rtn(ulong2); -double2 __ovld __cnfn convert_double2_rtn(ushort2); -double2 __ovld __cnfn convert_double2_rtp(char2); -double2 __ovld __cnfn convert_double2_rtp(double2); -double2 __ovld __cnfn convert_double2_rtp(float2); -double2 __ovld __cnfn convert_double2_rtp(int2); -double2 __ovld __cnfn convert_double2_rtp(long2); -double2 __ovld __cnfn convert_double2_rtp(short2); -double2 __ovld __cnfn convert_double2_rtp(uchar2); -double2 __ovld __cnfn convert_double2_rtp(uint2); -double2 __ovld __cnfn convert_double2_rtp(ulong2); -double2 __ovld __cnfn convert_double2_rtp(ushort2); -double2 __ovld __cnfn convert_double2_rtz(char2); -double2 __ovld __cnfn convert_double2_rtz(double2); -double2 __ovld __cnfn convert_double2_rtz(float2); -double2 __ovld __cnfn convert_double2_rtz(int2); -double2 __ovld __cnfn convert_double2_rtz(long2); -double2 __ovld __cnfn convert_double2_rtz(short2); -double2 __ovld __cnfn convert_double2_rtz(uchar2); -double2 __ovld __cnfn convert_double2_rtz(uint2); -double2 __ovld __cnfn convert_double2_rtz(ulong2); -double2 __ovld __cnfn convert_double2_rtz(ushort2); -double3 __ovld __cnfn convert_double3(char3); -double3 __ovld __cnfn convert_double3(double3); -double3 __ovld __cnfn convert_double3(float3); -double3 __ovld __cnfn convert_double3(int3); -double3 __ovld __cnfn convert_double3(long3); -double3 __ovld __cnfn convert_double3(short3); -double3 __ovld __cnfn convert_double3(uchar3); -double3 __ovld __cnfn convert_double3(uint3); -double3 __ovld __cnfn convert_double3(ulong3); -double3 __ovld __cnfn convert_double3(ushort3); -double3 __ovld __cnfn convert_double3_rte(char3); -double3 __ovld __cnfn convert_double3_rte(double3); -double3 __ovld __cnfn convert_double3_rte(float3); -double3 __ovld __cnfn convert_double3_rte(int3); -double3 __ovld __cnfn convert_double3_rte(long3); -double3 __ovld __cnfn convert_double3_rte(short3); -double3 __ovld __cnfn convert_double3_rte(uchar3); -double3 __ovld __cnfn convert_double3_rte(uint3); -double3 __ovld __cnfn convert_double3_rte(ulong3); -double3 __ovld __cnfn convert_double3_rte(ushort3); -double3 __ovld __cnfn convert_double3_rtn(char3); -double3 __ovld __cnfn convert_double3_rtn(double3); -double3 __ovld __cnfn convert_double3_rtn(float3); -double3 __ovld __cnfn convert_double3_rtn(int3); -double3 __ovld __cnfn convert_double3_rtn(long3); -double3 __ovld __cnfn convert_double3_rtn(short3); -double3 __ovld __cnfn convert_double3_rtn(uchar3); -double3 __ovld __cnfn convert_double3_rtn(uint3); -double3 __ovld __cnfn convert_double3_rtn(ulong3); -double3 __ovld __cnfn convert_double3_rtn(ushort3); -double3 __ovld __cnfn convert_double3_rtp(char3); -double3 __ovld __cnfn convert_double3_rtp(double3); -double3 __ovld __cnfn convert_double3_rtp(float3); -double3 __ovld __cnfn convert_double3_rtp(int3); -double3 __ovld __cnfn convert_double3_rtp(long3); -double3 __ovld __cnfn convert_double3_rtp(short3); -double3 __ovld __cnfn convert_double3_rtp(uchar3); -double3 __ovld __cnfn convert_double3_rtp(uint3); -double3 __ovld __cnfn convert_double3_rtp(ulong3); -double3 __ovld __cnfn convert_double3_rtp(ushort3); -double3 __ovld __cnfn convert_double3_rtz(char3); -double3 __ovld __cnfn convert_double3_rtz(double3); -double3 __ovld __cnfn convert_double3_rtz(float3); -double3 __ovld __cnfn convert_double3_rtz(int3); -double3 __ovld __cnfn convert_double3_rtz(long3); -double3 __ovld __cnfn convert_double3_rtz(short3); -double3 __ovld __cnfn convert_double3_rtz(uchar3); -double3 __ovld __cnfn convert_double3_rtz(uint3); -double3 __ovld __cnfn convert_double3_rtz(ulong3); -double3 __ovld __cnfn convert_double3_rtz(ushort3); -double4 __ovld __cnfn convert_double4(char4); -double4 __ovld __cnfn convert_double4(double4); -double4 __ovld __cnfn convert_double4(float4); -double4 __ovld __cnfn convert_double4(int4); -double4 __ovld __cnfn convert_double4(long4); -double4 __ovld __cnfn convert_double4(short4); -double4 __ovld __cnfn convert_double4(uchar4); -double4 __ovld __cnfn convert_double4(uint4); -double4 __ovld __cnfn convert_double4(ulong4); -double4 __ovld __cnfn convert_double4(ushort4); -double4 __ovld __cnfn convert_double4_rte(char4); -double4 __ovld __cnfn convert_double4_rte(double4); -double4 __ovld __cnfn convert_double4_rte(float4); -double4 __ovld __cnfn convert_double4_rte(int4); -double4 __ovld __cnfn convert_double4_rte(long4); -double4 __ovld __cnfn convert_double4_rte(short4); -double4 __ovld __cnfn convert_double4_rte(uchar4); -double4 __ovld __cnfn convert_double4_rte(uint4); -double4 __ovld __cnfn convert_double4_rte(ulong4); -double4 __ovld __cnfn convert_double4_rte(ushort4); -double4 __ovld __cnfn convert_double4_rtn(char4); -double4 __ovld __cnfn convert_double4_rtn(double4); -double4 __ovld __cnfn convert_double4_rtn(float4); -double4 __ovld __cnfn convert_double4_rtn(int4); -double4 __ovld __cnfn convert_double4_rtn(long4); -double4 __ovld __cnfn convert_double4_rtn(short4); -double4 __ovld __cnfn convert_double4_rtn(uchar4); -double4 __ovld __cnfn convert_double4_rtn(uint4); -double4 __ovld __cnfn convert_double4_rtn(ulong4); -double4 __ovld __cnfn convert_double4_rtn(ushort4); -double4 __ovld __cnfn convert_double4_rtp(char4); -double4 __ovld __cnfn convert_double4_rtp(double4); -double4 __ovld __cnfn convert_double4_rtp(float4); -double4 __ovld __cnfn convert_double4_rtp(int4); -double4 __ovld __cnfn convert_double4_rtp(long4); -double4 __ovld __cnfn convert_double4_rtp(short4); -double4 __ovld __cnfn convert_double4_rtp(uchar4); -double4 __ovld __cnfn convert_double4_rtp(uint4); -double4 __ovld __cnfn convert_double4_rtp(ulong4); -double4 __ovld __cnfn convert_double4_rtp(ushort4); -double4 __ovld __cnfn convert_double4_rtz(char4); -double4 __ovld __cnfn convert_double4_rtz(double4); -double4 __ovld __cnfn convert_double4_rtz(float4); -double4 __ovld __cnfn convert_double4_rtz(int4); -double4 __ovld __cnfn convert_double4_rtz(long4); -double4 __ovld __cnfn convert_double4_rtz(short4); -double4 __ovld __cnfn convert_double4_rtz(uchar4); -double4 __ovld __cnfn convert_double4_rtz(uint4); -double4 __ovld __cnfn convert_double4_rtz(ulong4); -double4 __ovld __cnfn convert_double4_rtz(ushort4); -double8 __ovld __cnfn convert_double8(char8); -double8 __ovld __cnfn convert_double8(double8); -double8 __ovld __cnfn convert_double8(float8); -double8 __ovld __cnfn convert_double8(int8); -double8 __ovld __cnfn convert_double8(long8); -double8 __ovld __cnfn convert_double8(short8); -double8 __ovld __cnfn convert_double8(uchar8); -double8 __ovld __cnfn convert_double8(uint8); -double8 __ovld __cnfn convert_double8(ulong8); -double8 __ovld __cnfn convert_double8(ushort8); -double8 __ovld __cnfn convert_double8_rte(char8); -double8 __ovld __cnfn convert_double8_rte(double8); -double8 __ovld __cnfn convert_double8_rte(float8); -double8 __ovld __cnfn convert_double8_rte(int8); -double8 __ovld __cnfn convert_double8_rte(long8); -double8 __ovld __cnfn convert_double8_rte(short8); -double8 __ovld __cnfn convert_double8_rte(uchar8); -double8 __ovld __cnfn convert_double8_rte(uint8); -double8 __ovld __cnfn convert_double8_rte(ulong8); -double8 __ovld __cnfn convert_double8_rte(ushort8); -double8 __ovld __cnfn convert_double8_rtn(char8); -double8 __ovld __cnfn convert_double8_rtn(double8); -double8 __ovld __cnfn convert_double8_rtn(float8); -double8 __ovld __cnfn convert_double8_rtn(int8); -double8 __ovld __cnfn convert_double8_rtn(long8); -double8 __ovld __cnfn convert_double8_rtn(short8); -double8 __ovld __cnfn convert_double8_rtn(uchar8); -double8 __ovld __cnfn convert_double8_rtn(uint8); -double8 __ovld __cnfn convert_double8_rtn(ulong8); -double8 __ovld __cnfn convert_double8_rtn(ushort8); -double8 __ovld __cnfn convert_double8_rtp(char8); -double8 __ovld __cnfn convert_double8_rtp(double8); -double8 __ovld __cnfn convert_double8_rtp(float8); -double8 __ovld __cnfn convert_double8_rtp(int8); -double8 __ovld __cnfn convert_double8_rtp(long8); -double8 __ovld __cnfn convert_double8_rtp(short8); -double8 __ovld __cnfn convert_double8_rtp(uchar8); -double8 __ovld __cnfn convert_double8_rtp(uint8); -double8 __ovld __cnfn convert_double8_rtp(ulong8); -double8 __ovld __cnfn convert_double8_rtp(ushort8); -double8 __ovld __cnfn convert_double8_rtz(char8); -double8 __ovld __cnfn convert_double8_rtz(double8); -double8 __ovld __cnfn convert_double8_rtz(float8); -double8 __ovld __cnfn convert_double8_rtz(int8); -double8 __ovld __cnfn convert_double8_rtz(long8); -double8 __ovld __cnfn convert_double8_rtz(short8); -double8 __ovld __cnfn convert_double8_rtz(uchar8); -double8 __ovld __cnfn convert_double8_rtz(uint8); -double8 __ovld __cnfn convert_double8_rtz(ulong8); -double8 __ovld __cnfn convert_double8_rtz(ushort8); -double16 __ovld __cnfn convert_double16(char16); -double16 __ovld __cnfn convert_double16(double16); -double16 __ovld __cnfn convert_double16(float16); -double16 __ovld __cnfn convert_double16(int16); -double16 __ovld __cnfn convert_double16(long16); -double16 __ovld __cnfn convert_double16(short16); -double16 __ovld __cnfn convert_double16(uchar16); -double16 __ovld __cnfn convert_double16(uint16); -double16 __ovld __cnfn convert_double16(ulong16); -double16 __ovld __cnfn convert_double16(ushort16); -double16 __ovld __cnfn convert_double16_rte(char16); -double16 __ovld __cnfn convert_double16_rte(double16); -double16 __ovld __cnfn convert_double16_rte(float16); -double16 __ovld __cnfn convert_double16_rte(int16); -double16 __ovld __cnfn convert_double16_rte(long16); -double16 __ovld __cnfn convert_double16_rte(short16); -double16 __ovld __cnfn convert_double16_rte(uchar16); -double16 __ovld __cnfn convert_double16_rte(uint16); -double16 __ovld __cnfn convert_double16_rte(ulong16); -double16 __ovld __cnfn convert_double16_rte(ushort16); -double16 __ovld __cnfn convert_double16_rtn(char16); -double16 __ovld __cnfn convert_double16_rtn(double16); -double16 __ovld __cnfn convert_double16_rtn(float16); -double16 __ovld __cnfn convert_double16_rtn(int16); -double16 __ovld __cnfn convert_double16_rtn(long16); -double16 __ovld __cnfn convert_double16_rtn(short16); -double16 __ovld __cnfn convert_double16_rtn(uchar16); -double16 __ovld __cnfn convert_double16_rtn(uint16); -double16 __ovld __cnfn convert_double16_rtn(ulong16); -double16 __ovld __cnfn convert_double16_rtn(ushort16); -double16 __ovld __cnfn convert_double16_rtp(char16); -double16 __ovld __cnfn convert_double16_rtp(double16); -double16 __ovld __cnfn convert_double16_rtp(float16); -double16 __ovld __cnfn convert_double16_rtp(int16); -double16 __ovld __cnfn convert_double16_rtp(long16); -double16 __ovld __cnfn convert_double16_rtp(short16); -double16 __ovld __cnfn convert_double16_rtp(uchar16); -double16 __ovld __cnfn convert_double16_rtp(uint16); -double16 __ovld __cnfn convert_double16_rtp(ulong16); -double16 __ovld __cnfn convert_double16_rtp(ushort16); -double16 __ovld __cnfn convert_double16_rtz(char16); -double16 __ovld __cnfn convert_double16_rtz(double16); -double16 __ovld __cnfn convert_double16_rtz(float16); -double16 __ovld __cnfn convert_double16_rtz(int16); -double16 __ovld __cnfn convert_double16_rtz(long16); -double16 __ovld __cnfn convert_double16_rtz(short16); -double16 __ovld __cnfn convert_double16_rtz(uchar16); -double16 __ovld __cnfn convert_double16_rtz(uint16); -double16 __ovld __cnfn convert_double16_rtz(ulong16); -double16 __ovld __cnfn convert_double16_rtz(ushort16); -#endif //cl_khr_fp64 - -#ifdef cl_khr_fp16 -#pragma OPENCL EXTENSION cl_khr_fp16 : enable -// Convert half types to non-double types. -uchar __ovld __cnfn convert_uchar(half); -uchar __ovld __cnfn convert_uchar_rte(half); -uchar __ovld __cnfn convert_uchar_rtp(half); -uchar __ovld __cnfn convert_uchar_rtn(half); -uchar __ovld __cnfn convert_uchar_rtz(half); -uchar __ovld __cnfn convert_uchar_sat(half); -uchar __ovld __cnfn convert_uchar_sat_rte(half); -uchar __ovld __cnfn convert_uchar_sat_rtp(half); -uchar __ovld __cnfn convert_uchar_sat_rtn(half); -uchar __ovld __cnfn convert_uchar_sat_rtz(half); -uchar2 __ovld __cnfn convert_uchar2(half2); -uchar2 __ovld __cnfn convert_uchar2_rte(half2); -uchar2 __ovld __cnfn convert_uchar2_rtp(half2); -uchar2 __ovld __cnfn convert_uchar2_rtn(half2); -uchar2 __ovld __cnfn convert_uchar2_rtz(half2); -uchar2 __ovld __cnfn convert_uchar2_sat(half2); -uchar2 __ovld __cnfn convert_uchar2_sat_rte(half2); -uchar2 __ovld __cnfn convert_uchar2_sat_rtp(half2); -uchar2 __ovld __cnfn convert_uchar2_sat_rtn(half2); -uchar2 __ovld __cnfn convert_uchar2_sat_rtz(half2); -uchar3 __ovld __cnfn convert_uchar3(half3); -uchar3 __ovld __cnfn convert_uchar3_rte(half3); -uchar3 __ovld __cnfn convert_uchar3_rtp(half3); -uchar3 __ovld __cnfn convert_uchar3_rtn(half3); -uchar3 __ovld __cnfn convert_uchar3_rtz(half3); -uchar3 __ovld __cnfn convert_uchar3_sat(half3); -uchar3 __ovld __cnfn convert_uchar3_sat_rte(half3); -uchar3 __ovld __cnfn convert_uchar3_sat_rtp(half3); -uchar3 __ovld __cnfn convert_uchar3_sat_rtn(half3); -uchar3 __ovld __cnfn convert_uchar3_sat_rtz(half3); -uchar4 __ovld __cnfn convert_uchar4(half4); -uchar4 __ovld __cnfn convert_uchar4_rte(half4); -uchar4 __ovld __cnfn convert_uchar4_rtp(half4); -uchar4 __ovld __cnfn convert_uchar4_rtn(half4); -uchar4 __ovld __cnfn convert_uchar4_rtz(half4); -uchar4 __ovld __cnfn convert_uchar4_sat(half4); -uchar4 __ovld __cnfn convert_uchar4_sat_rte(half4); -uchar4 __ovld __cnfn convert_uchar4_sat_rtp(half4); -uchar4 __ovld __cnfn convert_uchar4_sat_rtn(half4); -uchar4 __ovld __cnfn convert_uchar4_sat_rtz(half4); -uchar8 __ovld __cnfn convert_uchar8(half8); -uchar8 __ovld __cnfn convert_uchar8_rte(half8); -uchar8 __ovld __cnfn convert_uchar8_rtp(half8); -uchar8 __ovld __cnfn convert_uchar8_rtn(half8); -uchar8 __ovld __cnfn convert_uchar8_rtz(half8); -uchar8 __ovld __cnfn convert_uchar8_sat(half8); -uchar8 __ovld __cnfn convert_uchar8_sat_rte(half8); -uchar8 __ovld __cnfn convert_uchar8_sat_rtp(half8); -uchar8 __ovld __cnfn convert_uchar8_sat_rtn(half8); -uchar8 __ovld __cnfn convert_uchar8_sat_rtz(half8); -uchar16 __ovld __cnfn convert_uchar16(half16); -uchar16 __ovld __cnfn convert_uchar16_rte(half16); -uchar16 __ovld __cnfn convert_uchar16_rtp(half16); -uchar16 __ovld __cnfn convert_uchar16_rtn(half16); -uchar16 __ovld __cnfn convert_uchar16_rtz(half16); -uchar16 __ovld __cnfn convert_uchar16_sat(half16); -uchar16 __ovld __cnfn convert_uchar16_sat_rte(half16); -uchar16 __ovld __cnfn convert_uchar16_sat_rtp(half16); -uchar16 __ovld __cnfn convert_uchar16_sat_rtn(half16); -uchar16 __ovld __cnfn convert_uchar16_sat_rtz(half16); -ushort __ovld __cnfn convert_ushort(half); -ushort __ovld __cnfn convert_ushort_rte(half); -ushort __ovld __cnfn convert_ushort_rtp(half); -ushort __ovld __cnfn convert_ushort_rtn(half); -ushort __ovld __cnfn convert_ushort_rtz(half); -ushort __ovld __cnfn convert_ushort_sat(half); -ushort __ovld __cnfn convert_ushort_sat_rte(half); -ushort __ovld __cnfn convert_ushort_sat_rtp(half); -ushort __ovld __cnfn convert_ushort_sat_rtn(half); -ushort __ovld __cnfn convert_ushort_sat_rtz(half); -ushort2 __ovld __cnfn convert_ushort2(half2); -ushort2 __ovld __cnfn convert_ushort2_rte(half2); -ushort2 __ovld __cnfn convert_ushort2_rtp(half2); -ushort2 __ovld __cnfn convert_ushort2_rtn(half2); -ushort2 __ovld __cnfn convert_ushort2_rtz(half2); -ushort2 __ovld __cnfn convert_ushort2_sat(half2); -ushort2 __ovld __cnfn convert_ushort2_sat_rte(half2); -ushort2 __ovld __cnfn convert_ushort2_sat_rtp(half2); -ushort2 __ovld __cnfn convert_ushort2_sat_rtn(half2); -ushort2 __ovld __cnfn convert_ushort2_sat_rtz(half2); -ushort3 __ovld __cnfn convert_ushort3(half3); -ushort3 __ovld __cnfn convert_ushort3_rte(half3); -ushort3 __ovld __cnfn convert_ushort3_rtp(half3); -ushort3 __ovld __cnfn convert_ushort3_rtn(half3); -ushort3 __ovld __cnfn convert_ushort3_rtz(half3); -ushort3 __ovld __cnfn convert_ushort3_sat(half3); -ushort3 __ovld __cnfn convert_ushort3_sat_rte(half3); -ushort3 __ovld __cnfn convert_ushort3_sat_rtp(half3); -ushort3 __ovld __cnfn convert_ushort3_sat_rtn(half3); -ushort3 __ovld __cnfn convert_ushort3_sat_rtz(half3); -ushort4 __ovld __cnfn convert_ushort4(half4); -ushort4 __ovld __cnfn convert_ushort4_rte(half4); -ushort4 __ovld __cnfn convert_ushort4_rtp(half4); -ushort4 __ovld __cnfn convert_ushort4_rtn(half4); -ushort4 __ovld __cnfn convert_ushort4_rtz(half4); -ushort4 __ovld __cnfn convert_ushort4_sat(half4); -ushort4 __ovld __cnfn convert_ushort4_sat_rte(half4); -ushort4 __ovld __cnfn convert_ushort4_sat_rtp(half4); -ushort4 __ovld __cnfn convert_ushort4_sat_rtn(half4); -ushort4 __ovld __cnfn convert_ushort4_sat_rtz(half4); -ushort8 __ovld __cnfn convert_ushort8(half8); -ushort8 __ovld __cnfn convert_ushort8_rte(half8); -ushort8 __ovld __cnfn convert_ushort8_rtp(half8); -ushort8 __ovld __cnfn convert_ushort8_rtn(half8); -ushort8 __ovld __cnfn convert_ushort8_rtz(half8); -ushort8 __ovld __cnfn convert_ushort8_sat(half8); -ushort8 __ovld __cnfn convert_ushort8_sat_rte(half8); -ushort8 __ovld __cnfn convert_ushort8_sat_rtp(half8); -ushort8 __ovld __cnfn convert_ushort8_sat_rtn(half8); -ushort8 __ovld __cnfn convert_ushort8_sat_rtz(half8); -ushort16 __ovld __cnfn convert_ushort16(half16); -ushort16 __ovld __cnfn convert_ushort16_rte(half16); -ushort16 __ovld __cnfn convert_ushort16_rtp(half16); -ushort16 __ovld __cnfn convert_ushort16_rtn(half16); -ushort16 __ovld __cnfn convert_ushort16_rtz(half16); -ushort16 __ovld __cnfn convert_ushort16_sat(half16); -ushort16 __ovld __cnfn convert_ushort16_sat_rte(half16); -ushort16 __ovld __cnfn convert_ushort16_sat_rtp(half16); -ushort16 __ovld __cnfn convert_ushort16_sat_rtn(half16); -ushort16 __ovld __cnfn convert_ushort16_sat_rtz(half16); -uint __ovld __cnfn convert_uint(half); -uint __ovld __cnfn convert_uint_rte(half); -uint __ovld __cnfn convert_uint_rtp(half); -uint __ovld __cnfn convert_uint_rtn(half); -uint __ovld __cnfn convert_uint_rtz(half); -uint __ovld __cnfn convert_uint_sat(half); -uint __ovld __cnfn convert_uint_sat_rte(half); -uint __ovld __cnfn convert_uint_sat_rtp(half); -uint __ovld __cnfn convert_uint_sat_rtn(half); -uint __ovld __cnfn convert_uint_sat_rtz(half); -uint2 __ovld __cnfn convert_uint2(half2); -uint2 __ovld __cnfn convert_uint2_rte(half2); -uint2 __ovld __cnfn convert_uint2_rtp(half2); -uint2 __ovld __cnfn convert_uint2_rtn(half2); -uint2 __ovld __cnfn convert_uint2_rtz(half2); -uint2 __ovld __cnfn convert_uint2_sat(half2); -uint2 __ovld __cnfn convert_uint2_sat_rte(half2); -uint2 __ovld __cnfn convert_uint2_sat_rtp(half2); -uint2 __ovld __cnfn convert_uint2_sat_rtn(half2); -uint2 __ovld __cnfn convert_uint2_sat_rtz(half2); -uint3 __ovld __cnfn convert_uint3(half3); -uint3 __ovld __cnfn convert_uint3_rte(half3); -uint3 __ovld __cnfn convert_uint3_rtp(half3); -uint3 __ovld __cnfn convert_uint3_rtn(half3); -uint3 __ovld __cnfn convert_uint3_rtz(half3); -uint3 __ovld __cnfn convert_uint3_sat(half3); -uint3 __ovld __cnfn convert_uint3_sat_rte(half3); -uint3 __ovld __cnfn convert_uint3_sat_rtp(half3); -uint3 __ovld __cnfn convert_uint3_sat_rtn(half3); -uint3 __ovld __cnfn convert_uint3_sat_rtz(half3); -uint4 __ovld __cnfn convert_uint4(half4); -uint4 __ovld __cnfn convert_uint4_rte(half4); -uint4 __ovld __cnfn convert_uint4_rtp(half4); -uint4 __ovld __cnfn convert_uint4_rtn(half4); -uint4 __ovld __cnfn convert_uint4_rtz(half4); -uint4 __ovld __cnfn convert_uint4_sat(half4); -uint4 __ovld __cnfn convert_uint4_sat_rte(half4); -uint4 __ovld __cnfn convert_uint4_sat_rtp(half4); -uint4 __ovld __cnfn convert_uint4_sat_rtn(half4); -uint4 __ovld __cnfn convert_uint4_sat_rtz(half4); -uint8 __ovld __cnfn convert_uint8(half8); -uint8 __ovld __cnfn convert_uint8_rte(half8); -uint8 __ovld __cnfn convert_uint8_rtp(half8); -uint8 __ovld __cnfn convert_uint8_rtn(half8); -uint8 __ovld __cnfn convert_uint8_rtz(half8); -uint8 __ovld __cnfn convert_uint8_sat(half8); -uint8 __ovld __cnfn convert_uint8_sat_rte(half8); -uint8 __ovld __cnfn convert_uint8_sat_rtp(half8); -uint8 __ovld __cnfn convert_uint8_sat_rtn(half8); -uint8 __ovld __cnfn convert_uint8_sat_rtz(half8); -uint16 __ovld __cnfn convert_uint16(half16); -uint16 __ovld __cnfn convert_uint16_rte(half16); -uint16 __ovld __cnfn convert_uint16_rtp(half16); -uint16 __ovld __cnfn convert_uint16_rtn(half16); -uint16 __ovld __cnfn convert_uint16_rtz(half16); -uint16 __ovld __cnfn convert_uint16_sat(half16); -uint16 __ovld __cnfn convert_uint16_sat_rte(half16); -uint16 __ovld __cnfn convert_uint16_sat_rtp(half16); -uint16 __ovld __cnfn convert_uint16_sat_rtn(half16); -uint16 __ovld __cnfn convert_uint16_sat_rtz(half16); -ulong __ovld __cnfn convert_ulong(half); -ulong __ovld __cnfn convert_ulong_rte(half); -ulong __ovld __cnfn convert_ulong_rtp(half); -ulong __ovld __cnfn convert_ulong_rtn(half); -ulong __ovld __cnfn convert_ulong_rtz(half); -ulong __ovld __cnfn convert_ulong_sat(half); -ulong __ovld __cnfn convert_ulong_sat_rte(half); -ulong __ovld __cnfn convert_ulong_sat_rtp(half); -ulong __ovld __cnfn convert_ulong_sat_rtn(half); -ulong __ovld __cnfn convert_ulong_sat_rtz(half); -ulong2 __ovld __cnfn convert_ulong2(half2); -ulong2 __ovld __cnfn convert_ulong2_rte(half2); -ulong2 __ovld __cnfn convert_ulong2_rtp(half2); -ulong2 __ovld __cnfn convert_ulong2_rtn(half2); -ulong2 __ovld __cnfn convert_ulong2_rtz(half2); -ulong2 __ovld __cnfn convert_ulong2_sat(half2); -ulong2 __ovld __cnfn convert_ulong2_sat_rte(half2); -ulong2 __ovld __cnfn convert_ulong2_sat_rtp(half2); -ulong2 __ovld __cnfn convert_ulong2_sat_rtn(half2); -ulong2 __ovld __cnfn convert_ulong2_sat_rtz(half2); -ulong3 __ovld __cnfn convert_ulong3(half3); -ulong3 __ovld __cnfn convert_ulong3_rte(half3); -ulong3 __ovld __cnfn convert_ulong3_rtp(half3); -ulong3 __ovld __cnfn convert_ulong3_rtn(half3); -ulong3 __ovld __cnfn convert_ulong3_rtz(half3); -ulong3 __ovld __cnfn convert_ulong3_sat(half3); -ulong3 __ovld __cnfn convert_ulong3_sat_rte(half3); -ulong3 __ovld __cnfn convert_ulong3_sat_rtp(half3); -ulong3 __ovld __cnfn convert_ulong3_sat_rtn(half3); -ulong3 __ovld __cnfn convert_ulong3_sat_rtz(half3); -ulong4 __ovld __cnfn convert_ulong4(half4); -ulong4 __ovld __cnfn convert_ulong4_rte(half4); -ulong4 __ovld __cnfn convert_ulong4_rtp(half4); -ulong4 __ovld __cnfn convert_ulong4_rtn(half4); -ulong4 __ovld __cnfn convert_ulong4_rtz(half4); -ulong4 __ovld __cnfn convert_ulong4_sat(half4); -ulong4 __ovld __cnfn convert_ulong4_sat_rte(half4); -ulong4 __ovld __cnfn convert_ulong4_sat_rtp(half4); -ulong4 __ovld __cnfn convert_ulong4_sat_rtn(half4); -ulong4 __ovld __cnfn convert_ulong4_sat_rtz(half4); -ulong8 __ovld __cnfn convert_ulong8(half8); -ulong8 __ovld __cnfn convert_ulong8_rte(half8); -ulong8 __ovld __cnfn convert_ulong8_rtp(half8); -ulong8 __ovld __cnfn convert_ulong8_rtn(half8); -ulong8 __ovld __cnfn convert_ulong8_rtz(half8); -ulong8 __ovld __cnfn convert_ulong8_sat(half8); -ulong8 __ovld __cnfn convert_ulong8_sat_rte(half8); -ulong8 __ovld __cnfn convert_ulong8_sat_rtp(half8); -ulong8 __ovld __cnfn convert_ulong8_sat_rtn(half8); -ulong8 __ovld __cnfn convert_ulong8_sat_rtz(half8); -ulong16 __ovld __cnfn convert_ulong16(half16); -ulong16 __ovld __cnfn convert_ulong16_rte(half16); -ulong16 __ovld __cnfn convert_ulong16_rtp(half16); -ulong16 __ovld __cnfn convert_ulong16_rtn(half16); -ulong16 __ovld __cnfn convert_ulong16_rtz(half16); -ulong16 __ovld __cnfn convert_ulong16_sat(half16); -ulong16 __ovld __cnfn convert_ulong16_sat_rte(half16); -ulong16 __ovld __cnfn convert_ulong16_sat_rtp(half16); -ulong16 __ovld __cnfn convert_ulong16_sat_rtn(half16); -ulong16 __ovld __cnfn convert_ulong16_sat_rtz(half16); -char __ovld __cnfn convert_char(half); -char __ovld __cnfn convert_char_rte(half); -char __ovld __cnfn convert_char_rtp(half); -char __ovld __cnfn convert_char_rtn(half); -char __ovld __cnfn convert_char_rtz(half); -char __ovld __cnfn convert_char_sat(half); -char __ovld __cnfn convert_char_sat_rte(half); -char __ovld __cnfn convert_char_sat_rtp(half); -char __ovld __cnfn convert_char_sat_rtn(half); -char __ovld __cnfn convert_char_sat_rtz(half); -char2 __ovld __cnfn convert_char2(half2); -char2 __ovld __cnfn convert_char2_rte(half2); -char2 __ovld __cnfn convert_char2_rtp(half2); -char2 __ovld __cnfn convert_char2_rtn(half2); -char2 __ovld __cnfn convert_char2_rtz(half2); -char2 __ovld __cnfn convert_char2_sat(half2); -char2 __ovld __cnfn convert_char2_sat_rte(half2); -char2 __ovld __cnfn convert_char2_sat_rtp(half2); -char2 __ovld __cnfn convert_char2_sat_rtn(half2); -char2 __ovld __cnfn convert_char2_sat_rtz(half2); -char3 __ovld __cnfn convert_char3(half3); -char3 __ovld __cnfn convert_char3_rte(half3); -char3 __ovld __cnfn convert_char3_rtp(half3); -char3 __ovld __cnfn convert_char3_rtn(half3); -char3 __ovld __cnfn convert_char3_rtz(half3); -char3 __ovld __cnfn convert_char3_sat(half3); -char3 __ovld __cnfn convert_char3_sat_rte(half3); -char3 __ovld __cnfn convert_char3_sat_rtp(half3); -char3 __ovld __cnfn convert_char3_sat_rtn(half3); -char3 __ovld __cnfn convert_char3_sat_rtz(half3); -char4 __ovld __cnfn convert_char4(half4); -char4 __ovld __cnfn convert_char4_rte(half4); -char4 __ovld __cnfn convert_char4_rtp(half4); -char4 __ovld __cnfn convert_char4_rtn(half4); -char4 __ovld __cnfn convert_char4_rtz(half4); -char4 __ovld __cnfn convert_char4_sat(half4); -char4 __ovld __cnfn convert_char4_sat_rte(half4); -char4 __ovld __cnfn convert_char4_sat_rtp(half4); -char4 __ovld __cnfn convert_char4_sat_rtn(half4); -char4 __ovld __cnfn convert_char4_sat_rtz(half4); -char8 __ovld __cnfn convert_char8(half8); -char8 __ovld __cnfn convert_char8_rte(half8); -char8 __ovld __cnfn convert_char8_rtp(half8); -char8 __ovld __cnfn convert_char8_rtn(half8); -char8 __ovld __cnfn convert_char8_rtz(half8); -char8 __ovld __cnfn convert_char8_sat(half8); -char8 __ovld __cnfn convert_char8_sat_rte(half8); -char8 __ovld __cnfn convert_char8_sat_rtp(half8); -char8 __ovld __cnfn convert_char8_sat_rtn(half8); -char8 __ovld __cnfn convert_char8_sat_rtz(half8); -char16 __ovld __cnfn convert_char16(half16); -char16 __ovld __cnfn convert_char16_rte(half16); -char16 __ovld __cnfn convert_char16_rtp(half16); -char16 __ovld __cnfn convert_char16_rtn(half16); -char16 __ovld __cnfn convert_char16_rtz(half16); -char16 __ovld __cnfn convert_char16_sat(half16); -char16 __ovld __cnfn convert_char16_sat_rte(half16); -char16 __ovld __cnfn convert_char16_sat_rtp(half16); -char16 __ovld __cnfn convert_char16_sat_rtn(half16); -char16 __ovld __cnfn convert_char16_sat_rtz(half16); -short __ovld __cnfn convert_short(half); -short __ovld __cnfn convert_short_rte(half); -short __ovld __cnfn convert_short_rtp(half); -short __ovld __cnfn convert_short_rtn(half); -short __ovld __cnfn convert_short_rtz(half); -short __ovld __cnfn convert_short_sat(half); -short __ovld __cnfn convert_short_sat_rte(half); -short __ovld __cnfn convert_short_sat_rtp(half); -short __ovld __cnfn convert_short_sat_rtn(half); -short __ovld __cnfn convert_short_sat_rtz(half); -short2 __ovld __cnfn convert_short2(half2); -short2 __ovld __cnfn convert_short2_rte(half2); -short2 __ovld __cnfn convert_short2_rtp(half2); -short2 __ovld __cnfn convert_short2_rtn(half2); -short2 __ovld __cnfn convert_short2_rtz(half2); -short2 __ovld __cnfn convert_short2_sat(half2); -short2 __ovld __cnfn convert_short2_sat_rte(half2); -short2 __ovld __cnfn convert_short2_sat_rtp(half2); -short2 __ovld __cnfn convert_short2_sat_rtn(half2); -short2 __ovld __cnfn convert_short2_sat_rtz(half2); -short3 __ovld __cnfn convert_short3(half3); -short3 __ovld __cnfn convert_short3_rte(half3); -short3 __ovld __cnfn convert_short3_rtp(half3); -short3 __ovld __cnfn convert_short3_rtn(half3); -short3 __ovld __cnfn convert_short3_rtz(half3); -short3 __ovld __cnfn convert_short3_sat(half3); -short3 __ovld __cnfn convert_short3_sat_rte(half3); -short3 __ovld __cnfn convert_short3_sat_rtp(half3); -short3 __ovld __cnfn convert_short3_sat_rtn(half3); -short3 __ovld __cnfn convert_short3_sat_rtz(half3); -short4 __ovld __cnfn convert_short4(half4); -short4 __ovld __cnfn convert_short4_rte(half4); -short4 __ovld __cnfn convert_short4_rtp(half4); -short4 __ovld __cnfn convert_short4_rtn(half4); -short4 __ovld __cnfn convert_short4_rtz(half4); -short4 __ovld __cnfn convert_short4_sat(half4); -short4 __ovld __cnfn convert_short4_sat_rte(half4); -short4 __ovld __cnfn convert_short4_sat_rtp(half4); -short4 __ovld __cnfn convert_short4_sat_rtn(half4); -short4 __ovld __cnfn convert_short4_sat_rtz(half4); -short8 __ovld __cnfn convert_short8(half8); -short8 __ovld __cnfn convert_short8_rte(half8); -short8 __ovld __cnfn convert_short8_rtp(half8); -short8 __ovld __cnfn convert_short8_rtn(half8); -short8 __ovld __cnfn convert_short8_rtz(half8); -short8 __ovld __cnfn convert_short8_sat(half8); -short8 __ovld __cnfn convert_short8_sat_rte(half8); -short8 __ovld __cnfn convert_short8_sat_rtp(half8); -short8 __ovld __cnfn convert_short8_sat_rtn(half8); -short8 __ovld __cnfn convert_short8_sat_rtz(half8); -short16 __ovld __cnfn convert_short16(half16); -short16 __ovld __cnfn convert_short16_rte(half16); -short16 __ovld __cnfn convert_short16_rtp(half16); -short16 __ovld __cnfn convert_short16_rtn(half16); -short16 __ovld __cnfn convert_short16_rtz(half16); -short16 __ovld __cnfn convert_short16_sat(half16); -short16 __ovld __cnfn convert_short16_sat_rte(half16); -short16 __ovld __cnfn convert_short16_sat_rtp(half16); -short16 __ovld __cnfn convert_short16_sat_rtn(half16); -short16 __ovld __cnfn convert_short16_sat_rtz(half16); -int __ovld __cnfn convert_int(half); -int __ovld __cnfn convert_int_rte(half); -int __ovld __cnfn convert_int_rtp(half); -int __ovld __cnfn convert_int_rtn(half); -int __ovld __cnfn convert_int_rtz(half); -int __ovld __cnfn convert_int_sat(half); -int __ovld __cnfn convert_int_sat_rte(half); -int __ovld __cnfn convert_int_sat_rtp(half); -int __ovld __cnfn convert_int_sat_rtn(half); -int __ovld __cnfn convert_int_sat_rtz(half); -int2 __ovld __cnfn convert_int2(half2); -int2 __ovld __cnfn convert_int2_rte(half2); -int2 __ovld __cnfn convert_int2_rtp(half2); -int2 __ovld __cnfn convert_int2_rtn(half2); -int2 __ovld __cnfn convert_int2_rtz(half2); -int2 __ovld __cnfn convert_int2_sat(half2); -int2 __ovld __cnfn convert_int2_sat_rte(half2); -int2 __ovld __cnfn convert_int2_sat_rtp(half2); -int2 __ovld __cnfn convert_int2_sat_rtn(half2); -int2 __ovld __cnfn convert_int2_sat_rtz(half2); -int3 __ovld __cnfn convert_int3(half3); -int3 __ovld __cnfn convert_int3_rte(half3); -int3 __ovld __cnfn convert_int3_rtp(half3); -int3 __ovld __cnfn convert_int3_rtn(half3); -int3 __ovld __cnfn convert_int3_rtz(half3); -int3 __ovld __cnfn convert_int3_sat(half3); -int3 __ovld __cnfn convert_int3_sat_rte(half3); -int3 __ovld __cnfn convert_int3_sat_rtp(half3); -int3 __ovld __cnfn convert_int3_sat_rtn(half3); -int3 __ovld __cnfn convert_int3_sat_rtz(half3); -int4 __ovld __cnfn convert_int4(half4); -int4 __ovld __cnfn convert_int4_rte(half4); -int4 __ovld __cnfn convert_int4_rtp(half4); -int4 __ovld __cnfn convert_int4_rtn(half4); -int4 __ovld __cnfn convert_int4_rtz(half4); -int4 __ovld __cnfn convert_int4_sat(half4); -int4 __ovld __cnfn convert_int4_sat_rte(half4); -int4 __ovld __cnfn convert_int4_sat_rtp(half4); -int4 __ovld __cnfn convert_int4_sat_rtn(half4); -int4 __ovld __cnfn convert_int4_sat_rtz(half4); -int8 __ovld __cnfn convert_int8(half8); -int8 __ovld __cnfn convert_int8_rte(half8); -int8 __ovld __cnfn convert_int8_rtp(half8); -int8 __ovld __cnfn convert_int8_rtn(half8); -int8 __ovld __cnfn convert_int8_rtz(half8); -int8 __ovld __cnfn convert_int8_sat(half8); -int8 __ovld __cnfn convert_int8_sat_rte(half8); -int8 __ovld __cnfn convert_int8_sat_rtp(half8); -int8 __ovld __cnfn convert_int8_sat_rtn(half8); -int8 __ovld __cnfn convert_int8_sat_rtz(half8); -int16 __ovld __cnfn convert_int16(half16); -int16 __ovld __cnfn convert_int16_rte(half16); -int16 __ovld __cnfn convert_int16_rtp(half16); -int16 __ovld __cnfn convert_int16_rtn(half16); -int16 __ovld __cnfn convert_int16_rtz(half16); -int16 __ovld __cnfn convert_int16_sat(half16); -int16 __ovld __cnfn convert_int16_sat_rte(half16); -int16 __ovld __cnfn convert_int16_sat_rtp(half16); -int16 __ovld __cnfn convert_int16_sat_rtn(half16); -int16 __ovld __cnfn convert_int16_sat_rtz(half16); -long __ovld __cnfn convert_long(half); -long __ovld __cnfn convert_long_rte(half); -long __ovld __cnfn convert_long_rtp(half); -long __ovld __cnfn convert_long_rtn(half); -long __ovld __cnfn convert_long_rtz(half); -long __ovld __cnfn convert_long_sat(half); -long __ovld __cnfn convert_long_sat_rte(half); -long __ovld __cnfn convert_long_sat_rtp(half); -long __ovld __cnfn convert_long_sat_rtn(half); -long __ovld __cnfn convert_long_sat_rtz(half); -long2 __ovld __cnfn convert_long2(half2); -long2 __ovld __cnfn convert_long2_rte(half2); -long2 __ovld __cnfn convert_long2_rtp(half2); -long2 __ovld __cnfn convert_long2_rtn(half2); -long2 __ovld __cnfn convert_long2_rtz(half2); -long2 __ovld __cnfn convert_long2_sat(half2); -long2 __ovld __cnfn convert_long2_sat_rte(half2); -long2 __ovld __cnfn convert_long2_sat_rtp(half2); -long2 __ovld __cnfn convert_long2_sat_rtn(half2); -long2 __ovld __cnfn convert_long2_sat_rtz(half2); -long3 __ovld __cnfn convert_long3(half3); -long3 __ovld __cnfn convert_long3_rte(half3); -long3 __ovld __cnfn convert_long3_rtp(half3); -long3 __ovld __cnfn convert_long3_rtn(half3); -long3 __ovld __cnfn convert_long3_rtz(half3); -long3 __ovld __cnfn convert_long3_sat(half3); -long3 __ovld __cnfn convert_long3_sat_rte(half3); -long3 __ovld __cnfn convert_long3_sat_rtp(half3); -long3 __ovld __cnfn convert_long3_sat_rtn(half3); -long3 __ovld __cnfn convert_long3_sat_rtz(half3); -long4 __ovld __cnfn convert_long4(half4); -long4 __ovld __cnfn convert_long4_rte(half4); -long4 __ovld __cnfn convert_long4_rtp(half4); -long4 __ovld __cnfn convert_long4_rtn(half4); -long4 __ovld __cnfn convert_long4_rtz(half4); -long4 __ovld __cnfn convert_long4_sat(half4); -long4 __ovld __cnfn convert_long4_sat_rte(half4); -long4 __ovld __cnfn convert_long4_sat_rtp(half4); -long4 __ovld __cnfn convert_long4_sat_rtn(half4); -long4 __ovld __cnfn convert_long4_sat_rtz(half4); -long8 __ovld __cnfn convert_long8(half8); -long8 __ovld __cnfn convert_long8_rte(half8); -long8 __ovld __cnfn convert_long8_rtp(half8); -long8 __ovld __cnfn convert_long8_rtn(half8); -long8 __ovld __cnfn convert_long8_rtz(half8); -long8 __ovld __cnfn convert_long8_sat(half8); -long8 __ovld __cnfn convert_long8_sat_rte(half8); -long8 __ovld __cnfn convert_long8_sat_rtp(half8); -long8 __ovld __cnfn convert_long8_sat_rtn(half8); -long8 __ovld __cnfn convert_long8_sat_rtz(half8); -long16 __ovld __cnfn convert_long16(half16); -long16 __ovld __cnfn convert_long16_rte(half16); -long16 __ovld __cnfn convert_long16_rtp(half16); -long16 __ovld __cnfn convert_long16_rtn(half16); -long16 __ovld __cnfn convert_long16_rtz(half16); -long16 __ovld __cnfn convert_long16_sat(half16); -long16 __ovld __cnfn convert_long16_sat_rte(half16); -long16 __ovld __cnfn convert_long16_sat_rtp(half16); -long16 __ovld __cnfn convert_long16_sat_rtn(half16); -long16 __ovld __cnfn convert_long16_sat_rtz(half16); -float __ovld __cnfn convert_float(half); -float __ovld __cnfn convert_float_rte(half); -float __ovld __cnfn convert_float_rtp(half); -float __ovld __cnfn convert_float_rtn(half); -float __ovld __cnfn convert_float_rtz(half); -float2 __ovld __cnfn convert_float2(half2); -float2 __ovld __cnfn convert_float2_rte(half2); -float2 __ovld __cnfn convert_float2_rtp(half2); -float2 __ovld __cnfn convert_float2_rtn(half2); -float2 __ovld __cnfn convert_float2_rtz(half2); -float3 __ovld __cnfn convert_float3(half3); -float3 __ovld __cnfn convert_float3_rte(half3); -float3 __ovld __cnfn convert_float3_rtp(half3); -float3 __ovld __cnfn convert_float3_rtn(half3); -float3 __ovld __cnfn convert_float3_rtz(half3); -float4 __ovld __cnfn convert_float4(half4); -float4 __ovld __cnfn convert_float4_rte(half4); -float4 __ovld __cnfn convert_float4_rtp(half4); -float4 __ovld __cnfn convert_float4_rtn(half4); -float4 __ovld __cnfn convert_float4_rtz(half4); -float8 __ovld __cnfn convert_float8(half8); -float8 __ovld __cnfn convert_float8_rte(half8); -float8 __ovld __cnfn convert_float8_rtp(half8); -float8 __ovld __cnfn convert_float8_rtn(half8); -float8 __ovld __cnfn convert_float8_rtz(half8); -float16 __ovld __cnfn convert_float16(half16); -float16 __ovld __cnfn convert_float16_rte(half16); -float16 __ovld __cnfn convert_float16_rtp(half16); -float16 __ovld __cnfn convert_float16_rtn(half16); -float16 __ovld __cnfn convert_float16_rtz(half16); - -// Convert non-double types to half types. -half __ovld __cnfn convert_half(uchar); -half __ovld __cnfn convert_half(ushort); -half __ovld __cnfn convert_half(uint); -half __ovld __cnfn convert_half(ulong); -half __ovld __cnfn convert_half(char); -half __ovld __cnfn convert_half(short); -half __ovld __cnfn convert_half(int); -half __ovld __cnfn convert_half(long); -half __ovld __cnfn convert_half(float); -half __ovld __cnfn convert_half(half); -half __ovld __cnfn convert_half_rte(uchar); -half __ovld __cnfn convert_half_rte(ushort); -half __ovld __cnfn convert_half_rte(uint); -half __ovld __cnfn convert_half_rte(ulong); -half __ovld __cnfn convert_half_rte(char); -half __ovld __cnfn convert_half_rte(short); -half __ovld __cnfn convert_half_rte(int); -half __ovld __cnfn convert_half_rte(long); -half __ovld __cnfn convert_half_rte(float); -half __ovld __cnfn convert_half_rte(half); -half __ovld __cnfn convert_half_rtp(uchar); -half __ovld __cnfn convert_half_rtp(ushort); -half __ovld __cnfn convert_half_rtp(uint); -half __ovld __cnfn convert_half_rtp(ulong); -half __ovld __cnfn convert_half_rtp(char); -half __ovld __cnfn convert_half_rtp(short); -half __ovld __cnfn convert_half_rtp(int); -half __ovld __cnfn convert_half_rtp(long); -half __ovld __cnfn convert_half_rtp(float); -half __ovld __cnfn convert_half_rtp(half); -half __ovld __cnfn convert_half_rtn(uchar); -half __ovld __cnfn convert_half_rtn(ushort); -half __ovld __cnfn convert_half_rtn(uint); -half __ovld __cnfn convert_half_rtn(ulong); -half __ovld __cnfn convert_half_rtn(char); -half __ovld __cnfn convert_half_rtn(short); -half __ovld __cnfn convert_half_rtn(int); -half __ovld __cnfn convert_half_rtn(long); -half __ovld __cnfn convert_half_rtn(float); -half __ovld __cnfn convert_half_rtn(half); -half __ovld __cnfn convert_half_rtz(uchar); -half __ovld __cnfn convert_half_rtz(ushort); -half __ovld __cnfn convert_half_rtz(uint); -half __ovld __cnfn convert_half_rtz(ulong); -half __ovld __cnfn convert_half_rtz(char); -half __ovld __cnfn convert_half_rtz(short); -half __ovld __cnfn convert_half_rtz(int); -half __ovld __cnfn convert_half_rtz(long); -half __ovld __cnfn convert_half_rtz(float); -half __ovld __cnfn convert_half_rtz(half); -half2 __ovld __cnfn convert_half2(char2); -half2 __ovld __cnfn convert_half2(uchar2); -half2 __ovld __cnfn convert_half2(short2); -half2 __ovld __cnfn convert_half2(ushort2); -half2 __ovld __cnfn convert_half2(int2); -half2 __ovld __cnfn convert_half2(uint2); -half2 __ovld __cnfn convert_half2(long2); -half2 __ovld __cnfn convert_half2(ulong2); -half2 __ovld __cnfn convert_half2(float2); -half2 __ovld __cnfn convert_half2(half2); -half2 __ovld __cnfn convert_half2_rte(char2); -half2 __ovld __cnfn convert_half2_rte(uchar2); -half2 __ovld __cnfn convert_half2_rte(short2); -half2 __ovld __cnfn convert_half2_rte(ushort2); -half2 __ovld __cnfn convert_half2_rte(int2); -half2 __ovld __cnfn convert_half2_rte(uint2); -half2 __ovld __cnfn convert_half2_rte(long2); -half2 __ovld __cnfn convert_half2_rte(ulong2); -half2 __ovld __cnfn convert_half2_rte(float2); -half2 __ovld __cnfn convert_half2_rte(half2); -half2 __ovld __cnfn convert_half2_rtp(char2); -half2 __ovld __cnfn convert_half2_rtp(uchar2); -half2 __ovld __cnfn convert_half2_rtp(short2); -half2 __ovld __cnfn convert_half2_rtp(ushort2); -half2 __ovld __cnfn convert_half2_rtp(int2); -half2 __ovld __cnfn convert_half2_rtp(uint2); -half2 __ovld __cnfn convert_half2_rtp(long2); -half2 __ovld __cnfn convert_half2_rtp(ulong2); -half2 __ovld __cnfn convert_half2_rtp(float2); -half2 __ovld __cnfn convert_half2_rtp(half2); -half2 __ovld __cnfn convert_half2_rtn(char2); -half2 __ovld __cnfn convert_half2_rtn(uchar2); -half2 __ovld __cnfn convert_half2_rtn(short2); -half2 __ovld __cnfn convert_half2_rtn(ushort2); -half2 __ovld __cnfn convert_half2_rtn(int2); -half2 __ovld __cnfn convert_half2_rtn(uint2); -half2 __ovld __cnfn convert_half2_rtn(long2); -half2 __ovld __cnfn convert_half2_rtn(ulong2); -half2 __ovld __cnfn convert_half2_rtn(float2); -half2 __ovld __cnfn convert_half2_rtn(half2); -half2 __ovld __cnfn convert_half2_rtz(char2); -half2 __ovld __cnfn convert_half2_rtz(uchar2); -half2 __ovld __cnfn convert_half2_rtz(short2); -half2 __ovld __cnfn convert_half2_rtz(ushort2); -half2 __ovld __cnfn convert_half2_rtz(int2); -half2 __ovld __cnfn convert_half2_rtz(uint2); -half2 __ovld __cnfn convert_half2_rtz(long2); -half2 __ovld __cnfn convert_half2_rtz(ulong2); -half2 __ovld __cnfn convert_half2_rtz(float2); -half2 __ovld __cnfn convert_half2_rtz(half2); -half3 __ovld __cnfn convert_half3(char3); -half3 __ovld __cnfn convert_half3(uchar3); -half3 __ovld __cnfn convert_half3(short3); -half3 __ovld __cnfn convert_half3(ushort3); -half3 __ovld __cnfn convert_half3(int3); -half3 __ovld __cnfn convert_half3(uint3); -half3 __ovld __cnfn convert_half3(long3); -half3 __ovld __cnfn convert_half3(ulong3); -half3 __ovld __cnfn convert_half3(float3); -half3 __ovld __cnfn convert_half3(half3); -half3 __ovld __cnfn convert_half3_rte(char3); -half3 __ovld __cnfn convert_half3_rte(uchar3); -half3 __ovld __cnfn convert_half3_rte(short3); -half3 __ovld __cnfn convert_half3_rte(ushort3); -half3 __ovld __cnfn convert_half3_rte(int3); -half3 __ovld __cnfn convert_half3_rte(uint3); -half3 __ovld __cnfn convert_half3_rte(long3); -half3 __ovld __cnfn convert_half3_rte(ulong3); -half3 __ovld __cnfn convert_half3_rte(float3); -half3 __ovld __cnfn convert_half3_rte(half3); -half3 __ovld __cnfn convert_half3_rtp(char3); -half3 __ovld __cnfn convert_half3_rtp(uchar3); -half3 __ovld __cnfn convert_half3_rtp(short3); -half3 __ovld __cnfn convert_half3_rtp(ushort3); -half3 __ovld __cnfn convert_half3_rtp(int3); -half3 __ovld __cnfn convert_half3_rtp(uint3); -half3 __ovld __cnfn convert_half3_rtp(long3); -half3 __ovld __cnfn convert_half3_rtp(ulong3); -half3 __ovld __cnfn convert_half3_rtp(float3); -half3 __ovld __cnfn convert_half3_rtp(half3); -half3 __ovld __cnfn convert_half3_rtn(char3); -half3 __ovld __cnfn convert_half3_rtn(uchar3); -half3 __ovld __cnfn convert_half3_rtn(short3); -half3 __ovld __cnfn convert_half3_rtn(ushort3); -half3 __ovld __cnfn convert_half3_rtn(int3); -half3 __ovld __cnfn convert_half3_rtn(uint3); -half3 __ovld __cnfn convert_half3_rtn(long3); -half3 __ovld __cnfn convert_half3_rtn(ulong3); -half3 __ovld __cnfn convert_half3_rtn(float3); -half3 __ovld __cnfn convert_half3_rtn(half3); -half3 __ovld __cnfn convert_half3_rtz(char3); -half3 __ovld __cnfn convert_half3_rtz(uchar3); -half3 __ovld __cnfn convert_half3_rtz(short3); -half3 __ovld __cnfn convert_half3_rtz(ushort3); -half3 __ovld __cnfn convert_half3_rtz(int3); -half3 __ovld __cnfn convert_half3_rtz(uint3); -half3 __ovld __cnfn convert_half3_rtz(long3); -half3 __ovld __cnfn convert_half3_rtz(ulong3); -half3 __ovld __cnfn convert_half3_rtz(float3); -half3 __ovld __cnfn convert_half3_rtz(half3); -half4 __ovld __cnfn convert_half4(char4); -half4 __ovld __cnfn convert_half4(uchar4); -half4 __ovld __cnfn convert_half4(short4); -half4 __ovld __cnfn convert_half4(ushort4); -half4 __ovld __cnfn convert_half4(int4); -half4 __ovld __cnfn convert_half4(uint4); -half4 __ovld __cnfn convert_half4(long4); -half4 __ovld __cnfn convert_half4(ulong4); -half4 __ovld __cnfn convert_half4(float4); -half4 __ovld __cnfn convert_half4(half4); -half4 __ovld __cnfn convert_half4_rte(char4); -half4 __ovld __cnfn convert_half4_rte(uchar4); -half4 __ovld __cnfn convert_half4_rte(short4); -half4 __ovld __cnfn convert_half4_rte(ushort4); -half4 __ovld __cnfn convert_half4_rte(int4); -half4 __ovld __cnfn convert_half4_rte(uint4); -half4 __ovld __cnfn convert_half4_rte(long4); -half4 __ovld __cnfn convert_half4_rte(ulong4); -half4 __ovld __cnfn convert_half4_rte(float4); -half4 __ovld __cnfn convert_half4_rte(half4); -half4 __ovld __cnfn convert_half4_rtp(char4); -half4 __ovld __cnfn convert_half4_rtp(uchar4); -half4 __ovld __cnfn convert_half4_rtp(short4); -half4 __ovld __cnfn convert_half4_rtp(ushort4); -half4 __ovld __cnfn convert_half4_rtp(int4); -half4 __ovld __cnfn convert_half4_rtp(uint4); -half4 __ovld __cnfn convert_half4_rtp(long4); -half4 __ovld __cnfn convert_half4_rtp(ulong4); -half4 __ovld __cnfn convert_half4_rtp(float4); -half4 __ovld __cnfn convert_half4_rtp(half4); -half4 __ovld __cnfn convert_half4_rtn(char4); -half4 __ovld __cnfn convert_half4_rtn(uchar4); -half4 __ovld __cnfn convert_half4_rtn(short4); -half4 __ovld __cnfn convert_half4_rtn(ushort4); -half4 __ovld __cnfn convert_half4_rtn(int4); -half4 __ovld __cnfn convert_half4_rtn(uint4); -half4 __ovld __cnfn convert_half4_rtn(long4); -half4 __ovld __cnfn convert_half4_rtn(ulong4); -half4 __ovld __cnfn convert_half4_rtn(float4); -half4 __ovld __cnfn convert_half4_rtn(half4); -half4 __ovld __cnfn convert_half4_rtz(char4); -half4 __ovld __cnfn convert_half4_rtz(uchar4); -half4 __ovld __cnfn convert_half4_rtz(short4); -half4 __ovld __cnfn convert_half4_rtz(ushort4); -half4 __ovld __cnfn convert_half4_rtz(int4); -half4 __ovld __cnfn convert_half4_rtz(uint4); -half4 __ovld __cnfn convert_half4_rtz(long4); -half4 __ovld __cnfn convert_half4_rtz(ulong4); -half4 __ovld __cnfn convert_half4_rtz(float4); -half4 __ovld __cnfn convert_half4_rtz(half4); -half8 __ovld __cnfn convert_half8(char8); -half8 __ovld __cnfn convert_half8(uchar8); -half8 __ovld __cnfn convert_half8(short8); -half8 __ovld __cnfn convert_half8(ushort8); -half8 __ovld __cnfn convert_half8(int8); -half8 __ovld __cnfn convert_half8(uint8); -half8 __ovld __cnfn convert_half8(long8); -half8 __ovld __cnfn convert_half8(ulong8); -half8 __ovld __cnfn convert_half8(float8); -half8 __ovld __cnfn convert_half8(half8); -half8 __ovld __cnfn convert_half8_rte(char8); -half8 __ovld __cnfn convert_half8_rte(uchar8); -half8 __ovld __cnfn convert_half8_rte(short8); -half8 __ovld __cnfn convert_half8_rte(ushort8); -half8 __ovld __cnfn convert_half8_rte(int8); -half8 __ovld __cnfn convert_half8_rte(uint8); -half8 __ovld __cnfn convert_half8_rte(long8); -half8 __ovld __cnfn convert_half8_rte(ulong8); -half8 __ovld __cnfn convert_half8_rte(float8); -half8 __ovld __cnfn convert_half8_rte(half8); -half8 __ovld __cnfn convert_half8_rtp(char8); -half8 __ovld __cnfn convert_half8_rtp(uchar8); -half8 __ovld __cnfn convert_half8_rtp(short8); -half8 __ovld __cnfn convert_half8_rtp(ushort8); -half8 __ovld __cnfn convert_half8_rtp(int8); -half8 __ovld __cnfn convert_half8_rtp(uint8); -half8 __ovld __cnfn convert_half8_rtp(long8); -half8 __ovld __cnfn convert_half8_rtp(ulong8); -half8 __ovld __cnfn convert_half8_rtp(float8); -half8 __ovld __cnfn convert_half8_rtp(half8); -half8 __ovld __cnfn convert_half8_rtn(char8); -half8 __ovld __cnfn convert_half8_rtn(uchar8); -half8 __ovld __cnfn convert_half8_rtn(short8); -half8 __ovld __cnfn convert_half8_rtn(ushort8); -half8 __ovld __cnfn convert_half8_rtn(int8); -half8 __ovld __cnfn convert_half8_rtn(uint8); -half8 __ovld __cnfn convert_half8_rtn(long8); -half8 __ovld __cnfn convert_half8_rtn(ulong8); -half8 __ovld __cnfn convert_half8_rtn(float8); -half8 __ovld __cnfn convert_half8_rtn(half8); -half8 __ovld __cnfn convert_half8_rtz(char8); -half8 __ovld __cnfn convert_half8_rtz(uchar8); -half8 __ovld __cnfn convert_half8_rtz(short8); -half8 __ovld __cnfn convert_half8_rtz(ushort8); -half8 __ovld __cnfn convert_half8_rtz(int8); -half8 __ovld __cnfn convert_half8_rtz(uint8); -half8 __ovld __cnfn convert_half8_rtz(long8); -half8 __ovld __cnfn convert_half8_rtz(ulong8); -half8 __ovld __cnfn convert_half8_rtz(float8); -half8 __ovld __cnfn convert_half8_rtz(half8); -half16 __ovld __cnfn convert_half16(char16); -half16 __ovld __cnfn convert_half16(uchar16); -half16 __ovld __cnfn convert_half16(short16); -half16 __ovld __cnfn convert_half16(ushort16); -half16 __ovld __cnfn convert_half16(int16); -half16 __ovld __cnfn convert_half16(uint16); -half16 __ovld __cnfn convert_half16(long16); -half16 __ovld __cnfn convert_half16(ulong16); -half16 __ovld __cnfn convert_half16(float16); -half16 __ovld __cnfn convert_half16(half16); -half16 __ovld __cnfn convert_half16_rte(char16); -half16 __ovld __cnfn convert_half16_rte(uchar16); -half16 __ovld __cnfn convert_half16_rte(short16); -half16 __ovld __cnfn convert_half16_rte(ushort16); -half16 __ovld __cnfn convert_half16_rte(int16); -half16 __ovld __cnfn convert_half16_rte(uint16); -half16 __ovld __cnfn convert_half16_rte(long16); -half16 __ovld __cnfn convert_half16_rte(ulong16); -half16 __ovld __cnfn convert_half16_rte(float16); -half16 __ovld __cnfn convert_half16_rte(half16); -half16 __ovld __cnfn convert_half16_rtp(char16); -half16 __ovld __cnfn convert_half16_rtp(uchar16); -half16 __ovld __cnfn convert_half16_rtp(short16); -half16 __ovld __cnfn convert_half16_rtp(ushort16); -half16 __ovld __cnfn convert_half16_rtp(int16); -half16 __ovld __cnfn convert_half16_rtp(uint16); -half16 __ovld __cnfn convert_half16_rtp(long16); -half16 __ovld __cnfn convert_half16_rtp(ulong16); -half16 __ovld __cnfn convert_half16_rtp(float16); -half16 __ovld __cnfn convert_half16_rtp(half16); -half16 __ovld __cnfn convert_half16_rtn(char16); -half16 __ovld __cnfn convert_half16_rtn(uchar16); -half16 __ovld __cnfn convert_half16_rtn(short16); -half16 __ovld __cnfn convert_half16_rtn(ushort16); -half16 __ovld __cnfn convert_half16_rtn(int16); -half16 __ovld __cnfn convert_half16_rtn(uint16); -half16 __ovld __cnfn convert_half16_rtn(long16); -half16 __ovld __cnfn convert_half16_rtn(ulong16); -half16 __ovld __cnfn convert_half16_rtn(float16); -half16 __ovld __cnfn convert_half16_rtn(half16); -half16 __ovld __cnfn convert_half16_rtz(char16); -half16 __ovld __cnfn convert_half16_rtz(uchar16); -half16 __ovld __cnfn convert_half16_rtz(short16); -half16 __ovld __cnfn convert_half16_rtz(ushort16); -half16 __ovld __cnfn convert_half16_rtz(int16); -half16 __ovld __cnfn convert_half16_rtz(uint16); -half16 __ovld __cnfn convert_half16_rtz(long16); -half16 __ovld __cnfn convert_half16_rtz(ulong16); -half16 __ovld __cnfn convert_half16_rtz(float16); -half16 __ovld __cnfn convert_half16_rtz(half16); - -// Convert half types to double types. -#ifdef cl_khr_fp64 -double __ovld __cnfn convert_double(half); -double __ovld __cnfn convert_double_rte(half); -double __ovld __cnfn convert_double_rtp(half); -double __ovld __cnfn convert_double_rtn(half); -double __ovld __cnfn convert_double_rtz(half); -double2 __ovld __cnfn convert_double2(half2); -double2 __ovld __cnfn convert_double2_rte(half2); -double2 __ovld __cnfn convert_double2_rtp(half2); -double2 __ovld __cnfn convert_double2_rtn(half2); -double2 __ovld __cnfn convert_double2_rtz(half2); -double3 __ovld __cnfn convert_double3(half3); -double3 __ovld __cnfn convert_double3_rte(half3); -double3 __ovld __cnfn convert_double3_rtp(half3); -double3 __ovld __cnfn convert_double3_rtn(half3); -double3 __ovld __cnfn convert_double3_rtz(half3); -double4 __ovld __cnfn convert_double4(half4); -double4 __ovld __cnfn convert_double4_rte(half4); -double4 __ovld __cnfn convert_double4_rtp(half4); -double4 __ovld __cnfn convert_double4_rtn(half4); -double4 __ovld __cnfn convert_double4_rtz(half4); -double8 __ovld __cnfn convert_double8(half8); -double8 __ovld __cnfn convert_double8_rte(half8); -double8 __ovld __cnfn convert_double8_rtp(half8); -double8 __ovld __cnfn convert_double8_rtn(half8); -double8 __ovld __cnfn convert_double8_rtz(half8); -double16 __ovld __cnfn convert_double16(half16); -double16 __ovld __cnfn convert_double16_rte(half16); -double16 __ovld __cnfn convert_double16_rtp(half16); -double16 __ovld __cnfn convert_double16_rtn(half16); -double16 __ovld __cnfn convert_double16_rtz(half16); - -// Convert double types to half types. -half __ovld __cnfn convert_half(double); -half __ovld __cnfn convert_half_rte(double); -half __ovld __cnfn convert_half_rtp(double); -half __ovld __cnfn convert_half_rtn(double); -half __ovld __cnfn convert_half_rtz(double); -half2 __ovld __cnfn convert_half2(double2); -half2 __ovld __cnfn convert_half2_rte(double2); -half2 __ovld __cnfn convert_half2_rtp(double2); -half2 __ovld __cnfn convert_half2_rtn(double2); -half2 __ovld __cnfn convert_half2_rtz(double2); -half3 __ovld __cnfn convert_half3(double3); -half3 __ovld __cnfn convert_half3_rte(double3); -half3 __ovld __cnfn convert_half3_rtp(double3); -half3 __ovld __cnfn convert_half3_rtn(double3); -half3 __ovld __cnfn convert_half3_rtz(double3); -half4 __ovld __cnfn convert_half4(double4); -half4 __ovld __cnfn convert_half4_rte(double4); -half4 __ovld __cnfn convert_half4_rtp(double4); -half4 __ovld __cnfn convert_half4_rtn(double4); -half4 __ovld __cnfn convert_half4_rtz(double4); -half8 __ovld __cnfn convert_half8(double8); -half8 __ovld __cnfn convert_half8_rte(double8); -half8 __ovld __cnfn convert_half8_rtp(double8); -half8 __ovld __cnfn convert_half8_rtn(double8); -half8 __ovld __cnfn convert_half8_rtz(double8); -half16 __ovld __cnfn convert_half16(double16); -half16 __ovld __cnfn convert_half16_rte(double16); -half16 __ovld __cnfn convert_half16_rtp(double16); -half16 __ovld __cnfn convert_half16_rtn(double16); -half16 __ovld __cnfn convert_half16_rtz(double16); -#endif //cl_khr_fp64 - -#endif // cl_khr_fp16 - -// OpenCL v1.1 s6.11.1, v1.2 s6.12.1, v2.0 s6.13.1 - Work-item Functions - -/** - * Returns the number of dimensions in use. This is the - * value given to the work_dim argument specified in - * clEnqueueNDRangeKernel. - * For clEnqueueTask, this returns 1. - */ -uint __ovld __cnfn get_work_dim(void); - -/** - * Returns the number of global work-items specified for - * dimension identified by dimindx. This value is given by - * the global_work_size argument to - * clEnqueueNDRangeKernel. Valid values of dimindx - * are 0 to get_work_dim() - 1. For other values of - * dimindx, get_global_size() returns 1. - * For clEnqueueTask, this always returns 1. - */ -size_t __ovld __cnfn get_global_size(uint); - -/** - * Returns the unique global work-item ID value for - * dimension identified by dimindx. The global work-item - * ID specifies the work-item ID based on the number of - * global work-items specified to execute the kernel. Valid - * values of dimindx are 0 to get_work_dim() - 1. For - * other values of dimindx, get_global_id() returns 0. - * For clEnqueueTask, this returns 0. - */ -size_t __ovld __cnfn get_global_id(uint); - -/** - * Returns the number of local work-items specified in - * dimension identified by dimindx. This value is given by - * the local_work_size argument to - * clEnqueueNDRangeKernel if local_work_size is not - * NULL; otherwise the OpenCL implementation chooses - * an appropriate local_work_size value which is returned - * by this function. Valid values of dimindx are 0 to - * get_work_dim() - 1. For other values of dimindx, - * get_local_size() returns 1. - * For clEnqueueTask, this always returns 1. - */ -size_t __ovld __cnfn get_local_size(uint); - -/** - * Returns the unique local work-item ID i.e. a work-item - * within a specific work-group for dimension identified by - * dimindx. Valid values of dimindx are 0 to - * get_work_dim() - 1. For other values of dimindx, - * get_local_id() returns 0. - * For clEnqueueTask, this returns 0. - */ -size_t __ovld __cnfn get_local_id(uint); - -/** - * Returns the number of work-groups that will execute a - * kernel for dimension identified by dimindx. - * Valid values of dimindx are 0 to get_work_dim() - 1. - * For other values of dimindx, get_num_groups() returns 1. - * For clEnqueueTask, this always returns 1. - */ -size_t __ovld __cnfn get_num_groups(uint); - -/** - * get_group_id returns the work-group ID which is a - * number from 0 .. get_num_groups(dimindx) - 1. - * Valid values of dimindx are 0 to get_work_dim() - 1. - * For other values, get_group_id() returns 0. - * For clEnqueueTask, this returns 0. - */ -size_t __ovld __cnfn get_group_id(uint); - -/** - * get_global_offset returns the offset values specified in - * global_work_offset argument to - * clEnqueueNDRangeKernel. - * Valid values of dimindx are 0 to get_work_dim() - 1. - * For other values, get_global_offset() returns 0. - * For clEnqueueTask, this returns 0. - */ -size_t __ovld __cnfn get_global_offset(uint); - -#if defined(__OPENCL_CPP_VERSION__) || (__OPENCL_C_VERSION__ >= CL_VERSION_2_0) -size_t __ovld get_enqueued_local_size(uint); -size_t __ovld get_global_linear_id(void); -size_t __ovld get_local_linear_id(void); -#endif //defined(__OPENCL_CPP_VERSION__) || (__OPENCL_C_VERSION__ >= CL_VERSION_2_0) - -// OpenCL v1.1 s6.11.2, v1.2 s6.12.2, v2.0 s6.13.2 - Math functions - -/** - * Arc cosine function. - */ -float __ovld __cnfn acos(float); -float2 __ovld __cnfn acos(float2); -float3 __ovld __cnfn acos(float3); -float4 __ovld __cnfn acos(float4); -float8 __ovld __cnfn acos(float8); -float16 __ovld __cnfn acos(float16); -#ifdef cl_khr_fp64 -double __ovld __cnfn acos(double); -double2 __ovld __cnfn acos(double2); -double3 __ovld __cnfn acos(double3); -double4 __ovld __cnfn acos(double4); -double8 __ovld __cnfn acos(double8); -double16 __ovld __cnfn acos(double16); -#endif //cl_khr_fp64 -#ifdef cl_khr_fp16 -half __ovld __cnfn acos(half); -half2 __ovld __cnfn acos(half2); -half3 __ovld __cnfn acos(half3); -half4 __ovld __cnfn acos(half4); -half8 __ovld __cnfn acos(half8); -half16 __ovld __cnfn acos(half16); -#endif //cl_khr_fp16 - -/** - * Inverse hyperbolic cosine. - */ -float __ovld __cnfn acosh(float); -float2 __ovld __cnfn acosh(float2); -float3 __ovld __cnfn acosh(float3); -float4 __ovld __cnfn acosh(float4); -float8 __ovld __cnfn acosh(float8); -float16 __ovld __cnfn acosh(float16); -#ifdef cl_khr_fp64 -double __ovld __cnfn acosh(double); -double2 __ovld __cnfn acosh(double2); -double3 __ovld __cnfn acosh(double3); -double4 __ovld __cnfn acosh(double4); -double8 __ovld __cnfn acosh(double8); -double16 __ovld __cnfn acosh(double16); -#endif //cl_khr_fp64 -#ifdef cl_khr_fp16 -half __ovld __cnfn acosh(half); -half2 __ovld __cnfn acosh(half2); -half3 __ovld __cnfn acosh(half3); -half4 __ovld __cnfn acosh(half4); -half8 __ovld __cnfn acosh(half8); -half16 __ovld __cnfn acosh(half16); -#endif //cl_khr_fp16 - -/** - * Compute acos (x) / PI. - */ -float __ovld __cnfn acospi(float); -float2 __ovld __cnfn acospi(float2); -float3 __ovld __cnfn acospi(float3); -float4 __ovld __cnfn acospi(float4); -float8 __ovld __cnfn acospi(float8); -float16 __ovld __cnfn acospi(float16); -#ifdef cl_khr_fp64 -double __ovld __cnfn acospi(double); -double2 __ovld __cnfn acospi(double2); -double3 __ovld __cnfn acospi(double3); -double4 __ovld __cnfn acospi(double4); -double8 __ovld __cnfn acospi(double8); -double16 __ovld __cnfn acospi(double16); -#endif //cl_khr_fp64 -#ifdef cl_khr_fp16 -half __ovld __cnfn acospi(half); -half2 __ovld __cnfn acospi(half2); -half3 __ovld __cnfn acospi(half3); -half4 __ovld __cnfn acospi(half4); -half8 __ovld __cnfn acospi(half8); -half16 __ovld __cnfn acospi(half16); -#endif //cl_khr_fp16 - -/** - * Arc sine function. - */ -float __ovld __cnfn asin(float); -float2 __ovld __cnfn asin(float2); -float3 __ovld __cnfn asin(float3); -float4 __ovld __cnfn asin(float4); -float8 __ovld __cnfn asin(float8); -float16 __ovld __cnfn asin(float16); -#ifdef cl_khr_fp64 -double __ovld __cnfn asin(double); -double2 __ovld __cnfn asin(double2); -double3 __ovld __cnfn asin(double3); -double4 __ovld __cnfn asin(double4); -double8 __ovld __cnfn asin(double8); -double16 __ovld __cnfn asin(double16); -#endif //cl_khr_fp64 -#ifdef cl_khr_fp16 -half __ovld __cnfn asin(half); -half2 __ovld __cnfn asin(half2); -half3 __ovld __cnfn asin(half3); -half4 __ovld __cnfn asin(half4); -half8 __ovld __cnfn asin(half8); -half16 __ovld __cnfn asin(half16); -#endif //cl_khr_fp16 - -/** - * Inverse hyperbolic sine. - */ -float __ovld __cnfn asinh(float); -float2 __ovld __cnfn asinh(float2); -float3 __ovld __cnfn asinh(float3); -float4 __ovld __cnfn asinh(float4); -float8 __ovld __cnfn asinh(float8); -float16 __ovld __cnfn asinh(float16); -#ifdef cl_khr_fp64 -double __ovld __cnfn asinh(double); -double2 __ovld __cnfn asinh(double2); -double3 __ovld __cnfn asinh(double3); -double4 __ovld __cnfn asinh(double4); -double8 __ovld __cnfn asinh(double8); -double16 __ovld __cnfn asinh(double16); -#endif //cl_khr_fp64 -#ifdef cl_khr_fp16 -half __ovld __cnfn asinh(half); -half2 __ovld __cnfn asinh(half2); -half3 __ovld __cnfn asinh(half3); -half4 __ovld __cnfn asinh(half4); -half8 __ovld __cnfn asinh(half8); -half16 __ovld __cnfn asinh(half16); -#endif //cl_khr_fp16 - -/** - * Compute asin (x) / PI. - */ -float __ovld __cnfn asinpi(float); -float2 __ovld __cnfn asinpi(float2); -float3 __ovld __cnfn asinpi(float3); -float4 __ovld __cnfn asinpi(float4); -float8 __ovld __cnfn asinpi(float8); -float16 __ovld __cnfn asinpi(float16); -#ifdef cl_khr_fp64 -double __ovld __cnfn asinpi(double); -double2 __ovld __cnfn asinpi(double2); -double3 __ovld __cnfn asinpi(double3); -double4 __ovld __cnfn asinpi(double4); -double8 __ovld __cnfn asinpi(double8); -double16 __ovld __cnfn asinpi(double16); -#endif //cl_khr_fp64 -#ifdef cl_khr_fp16 -half __ovld __cnfn asinpi(half); -half2 __ovld __cnfn asinpi(half2); -half3 __ovld __cnfn asinpi(half3); -half4 __ovld __cnfn asinpi(half4); -half8 __ovld __cnfn asinpi(half8); -half16 __ovld __cnfn asinpi(half16); -#endif //cl_khr_fp16 - -/** - * Arc tangent function. - */ -float __ovld __cnfn atan(float); -float2 __ovld __cnfn atan(float2); -float3 __ovld __cnfn atan(float3); -float4 __ovld __cnfn atan(float4); -float8 __ovld __cnfn atan(float8); -float16 __ovld __cnfn atan(float16); -#ifdef cl_khr_fp64 -double __ovld __cnfn atan(double); -double2 __ovld __cnfn atan(double2); -double3 __ovld __cnfn atan(double3); -double4 __ovld __cnfn atan(double4); -double8 __ovld __cnfn atan(double8); -double16 __ovld __cnfn atan(double16); -#endif //cl_khr_fp64 -#ifdef cl_khr_fp16 -half __ovld __cnfn atan(half); -half2 __ovld __cnfn atan(half2); -half3 __ovld __cnfn atan(half3); -half4 __ovld __cnfn atan(half4); -half8 __ovld __cnfn atan(half8); -half16 __ovld __cnfn atan(half16); -#endif //cl_khr_fp16 - -/** - * Arc tangent of y / x. - */ -float __ovld __cnfn atan2(float, float); -float2 __ovld __cnfn atan2(float2, float2); -float3 __ovld __cnfn atan2(float3, float3); -float4 __ovld __cnfn atan2(float4, float4); -float8 __ovld __cnfn atan2(float8, float8); -float16 __ovld __cnfn atan2(float16, float16); -#ifdef cl_khr_fp64 -double __ovld __cnfn atan2(double, double); -double2 __ovld __cnfn atan2(double2, double2); -double3 __ovld __cnfn atan2(double3, double3); -double4 __ovld __cnfn atan2(double4, double4); -double8 __ovld __cnfn atan2(double8, double8); -double16 __ovld __cnfn atan2(double16, double16); -#endif //cl_khr_fp64 -#ifdef cl_khr_fp16 -half __ovld __cnfn atan2(half, half); -half2 __ovld __cnfn atan2(half2, half2); -half3 __ovld __cnfn atan2(half3, half3); -half4 __ovld __cnfn atan2(half4, half4); -half8 __ovld __cnfn atan2(half8, half8); -half16 __ovld __cnfn atan2(half16, half16); -#endif //cl_khr_fp16 - -/** - * Hyperbolic arc tangent. - */ -float __ovld __cnfn atanh(float); -float2 __ovld __cnfn atanh(float2); -float3 __ovld __cnfn atanh(float3); -float4 __ovld __cnfn atanh(float4); -float8 __ovld __cnfn atanh(float8); -float16 __ovld __cnfn atanh(float16); -#ifdef cl_khr_fp64 -double __ovld __cnfn atanh(double); -double2 __ovld __cnfn atanh(double2); -double3 __ovld __cnfn atanh(double3); -double4 __ovld __cnfn atanh(double4); -double8 __ovld __cnfn atanh(double8); -double16 __ovld __cnfn atanh(double16); -#endif //cl_khr_fp64 -#ifdef cl_khr_fp16 -half __ovld __cnfn atanh(half); -half2 __ovld __cnfn atanh(half2); -half3 __ovld __cnfn atanh(half3); -half4 __ovld __cnfn atanh(half4); -half8 __ovld __cnfn atanh(half8); -half16 __ovld __cnfn atanh(half16); -#endif //cl_khr_fp16 - -/** - * Compute atan (x) / PI. - */ -float __ovld __cnfn atanpi(float); -float2 __ovld __cnfn atanpi(float2); -float3 __ovld __cnfn atanpi(float3); -float4 __ovld __cnfn atanpi(float4); -float8 __ovld __cnfn atanpi(float8); -float16 __ovld __cnfn atanpi(float16); -#ifdef cl_khr_fp64 -double __ovld __cnfn atanpi(double); -double2 __ovld __cnfn atanpi(double2); -double3 __ovld __cnfn atanpi(double3); -double4 __ovld __cnfn atanpi(double4); -double8 __ovld __cnfn atanpi(double8); -double16 __ovld __cnfn atanpi(double16); -#endif //cl_khr_fp64 -#ifdef cl_khr_fp16 -half __ovld __cnfn atanpi(half); -half2 __ovld __cnfn atanpi(half2); -half3 __ovld __cnfn atanpi(half3); -half4 __ovld __cnfn atanpi(half4); -half8 __ovld __cnfn atanpi(half8); -half16 __ovld __cnfn atanpi(half16); -#endif //cl_khr_fp16 - -/** - * Compute atan2 (y, x) / PI. - */ -float __ovld __cnfn atan2pi(float, float); -float2 __ovld __cnfn atan2pi(float2, float2); -float3 __ovld __cnfn atan2pi(float3, float3); -float4 __ovld __cnfn atan2pi(float4, float4); -float8 __ovld __cnfn atan2pi(float8, float8); -float16 __ovld __cnfn atan2pi(float16, float16); -#ifdef cl_khr_fp64 -double __ovld __cnfn atan2pi(double, double); -double2 __ovld __cnfn atan2pi(double2, double2); -double3 __ovld __cnfn atan2pi(double3, double3); -double4 __ovld __cnfn atan2pi(double4, double4); -double8 __ovld __cnfn atan2pi(double8, double8); -double16 __ovld __cnfn atan2pi(double16, double16); -#endif //cl_khr_fp64 -#ifdef cl_khr_fp16 -half __ovld __cnfn atan2pi(half, half); -half2 __ovld __cnfn atan2pi(half2, half2); -half3 __ovld __cnfn atan2pi(half3, half3); -half4 __ovld __cnfn atan2pi(half4, half4); -half8 __ovld __cnfn atan2pi(half8, half8); -half16 __ovld __cnfn atan2pi(half16, half16); -#endif //cl_khr_fp16 - -/** - * Compute cube-root. - */ -float __ovld __cnfn cbrt(float); -float2 __ovld __cnfn cbrt(float2); -float3 __ovld __cnfn cbrt(float3); -float4 __ovld __cnfn cbrt(float4); -float8 __ovld __cnfn cbrt(float8); -float16 __ovld __cnfn cbrt(float16); -#ifdef cl_khr_fp64 -double __ovld __cnfn cbrt(double); -double2 __ovld __cnfn cbrt(double2); -double3 __ovld __cnfn cbrt(double3); -double4 __ovld __cnfn cbrt(double4); -double8 __ovld __cnfn cbrt(double8); -double16 __ovld __cnfn cbrt(double16); -#endif //cl_khr_fp64 -#ifdef cl_khr_fp16 -half __ovld __cnfn cbrt(half); -half2 __ovld __cnfn cbrt(half2); -half3 __ovld __cnfn cbrt(half3); -half4 __ovld __cnfn cbrt(half4); -half8 __ovld __cnfn cbrt(half8); -half16 __ovld __cnfn cbrt(half16); -#endif //cl_khr_fp16 - -/** - * Round to integral value using the round to positive - * infinity rounding mode. - */ -float __ovld __cnfn ceil(float); -float2 __ovld __cnfn ceil(float2); -float3 __ovld __cnfn ceil(float3); -float4 __ovld __cnfn ceil(float4); -float8 __ovld __cnfn ceil(float8); -float16 __ovld __cnfn ceil(float16); -#ifdef cl_khr_fp64 -double __ovld __cnfn ceil(double); -double2 __ovld __cnfn ceil(double2); -double3 __ovld __cnfn ceil(double3); -double4 __ovld __cnfn ceil(double4); -double8 __ovld __cnfn ceil(double8); -double16 __ovld __cnfn ceil(double16); -#endif //cl_khr_fp64 -#ifdef cl_khr_fp16 -half __ovld __cnfn ceil(half); -half2 __ovld __cnfn ceil(half2); -half3 __ovld __cnfn ceil(half3); -half4 __ovld __cnfn ceil(half4); -half8 __ovld __cnfn ceil(half8); -half16 __ovld __cnfn ceil(half16); -#endif //cl_khr_fp16 - -/** - * Returns x with its sign changed to match the sign of y. - */ -float __ovld __cnfn copysign(float, float); -float2 __ovld __cnfn copysign(float2, float2); -float3 __ovld __cnfn copysign(float3, float3); -float4 __ovld __cnfn copysign(float4, float4); -float8 __ovld __cnfn copysign(float8, float8); -float16 __ovld __cnfn copysign(float16, float16); -#ifdef cl_khr_fp64 -double __ovld __cnfn copysign(double, double); -double2 __ovld __cnfn copysign(double2, double2); -double3 __ovld __cnfn copysign(double3, double3); -double4 __ovld __cnfn copysign(double4, double4); -double8 __ovld __cnfn copysign(double8, double8); -double16 __ovld __cnfn copysign(double16, double16); -#endif //cl_khr_fp64 -#ifdef cl_khr_fp16 -half __ovld __cnfn copysign(half, half); -half2 __ovld __cnfn copysign(half2, half2); -half3 __ovld __cnfn copysign(half3, half3); -half4 __ovld __cnfn copysign(half4, half4); -half8 __ovld __cnfn copysign(half8, half8); -half16 __ovld __cnfn copysign(half16, half16); -#endif //cl_khr_fp16 - -/** - * Compute cosine. - */ -float __ovld __cnfn cos(float); -float2 __ovld __cnfn cos(float2); -float3 __ovld __cnfn cos(float3); -float4 __ovld __cnfn cos(float4); -float8 __ovld __cnfn cos(float8); -float16 __ovld __cnfn cos(float16); -#ifdef cl_khr_fp64 -double __ovld __cnfn cos(double); -double2 __ovld __cnfn cos(double2); -double3 __ovld __cnfn cos(double3); -double4 __ovld __cnfn cos(double4); -double8 __ovld __cnfn cos(double8); -double16 __ovld __cnfn cos(double16); -#endif //cl_khr_fp64 -#ifdef cl_khr_fp16 -half __ovld __cnfn cos(half); -half2 __ovld __cnfn cos(half2); -half3 __ovld __cnfn cos(half3); -half4 __ovld __cnfn cos(half4); -half8 __ovld __cnfn cos(half8); -half16 __ovld __cnfn cos(half16); -#endif //cl_khr_fp16 - -/** - * Compute hyperbolic cosine. - */ -float __ovld __cnfn cosh(float); -float2 __ovld __cnfn cosh(float2); -float3 __ovld __cnfn cosh(float3); -float4 __ovld __cnfn cosh(float4); -float8 __ovld __cnfn cosh(float8); -float16 __ovld __cnfn cosh(float16); -#ifdef cl_khr_fp64 -double __ovld __cnfn cosh(double); -double2 __ovld __cnfn cosh(double2); -double3 __ovld __cnfn cosh(double3); -double4 __ovld __cnfn cosh(double4); -double8 __ovld __cnfn cosh(double8); -double16 __ovld __cnfn cosh(double16); -#endif //cl_khr_fp64 -#ifdef cl_khr_fp16 -half __ovld __cnfn cosh(half); -half2 __ovld __cnfn cosh(half2); -half3 __ovld __cnfn cosh(half3); -half4 __ovld __cnfn cosh(half4); -half8 __ovld __cnfn cosh(half8); -half16 __ovld __cnfn cosh(half16); -#endif //cl_khr_fp16 - -/** - * Compute cos (PI * x). - */ -float __ovld __cnfn cospi(float); -float2 __ovld __cnfn cospi(float2); -float3 __ovld __cnfn cospi(float3); -float4 __ovld __cnfn cospi(float4); -float8 __ovld __cnfn cospi(float8); -float16 __ovld __cnfn cospi(float16); -#ifdef cl_khr_fp64 -double __ovld __cnfn cospi(double); -double2 __ovld __cnfn cospi(double2); -double3 __ovld __cnfn cospi(double3); -double4 __ovld __cnfn cospi(double4); -double8 __ovld __cnfn cospi(double8); -double16 __ovld __cnfn cospi(double16); -#endif //cl_khr_fp64 -#ifdef cl_khr_fp16 -half __ovld __cnfn cospi(half); -half2 __ovld __cnfn cospi(half2); -half3 __ovld __cnfn cospi(half3); -half4 __ovld __cnfn cospi(half4); -half8 __ovld __cnfn cospi(half8); -half16 __ovld __cnfn cospi(half16); -#endif //cl_khr_fp16 - -/** - * Complementary error function. - */ -float __ovld __cnfn erfc(float); -float2 __ovld __cnfn erfc(float2); -float3 __ovld __cnfn erfc(float3); -float4 __ovld __cnfn erfc(float4); -float8 __ovld __cnfn erfc(float8); -float16 __ovld __cnfn erfc(float16); -#ifdef cl_khr_fp64 -double __ovld __cnfn erfc(double); -double2 __ovld __cnfn erfc(double2); -double3 __ovld __cnfn erfc(double3); -double4 __ovld __cnfn erfc(double4); -double8 __ovld __cnfn erfc(double8); -double16 __ovld __cnfn erfc(double16); -#endif //cl_khr_fp64 -#ifdef cl_khr_fp16 -half __ovld __cnfn erfc(half); -half2 __ovld __cnfn erfc(half2); -half3 __ovld __cnfn erfc(half3); -half4 __ovld __cnfn erfc(half4); -half8 __ovld __cnfn erfc(half8); -half16 __ovld __cnfn erfc(half16); -#endif //cl_khr_fp16 - -/** - * Error function encountered in integrating the - * normal distribution. - */ -float __ovld __cnfn erf(float); -float2 __ovld __cnfn erf(float2); -float3 __ovld __cnfn erf(float3); -float4 __ovld __cnfn erf(float4); -float8 __ovld __cnfn erf(float8); -float16 __ovld __cnfn erf(float16); -#ifdef cl_khr_fp64 -double __ovld __cnfn erf(double); -double2 __ovld __cnfn erf(double2); -double3 __ovld __cnfn erf(double3); -double4 __ovld __cnfn erf(double4); -double8 __ovld __cnfn erf(double8); -double16 __ovld __cnfn erf(double16); -#endif //cl_khr_fp64 -#ifdef cl_khr_fp16 -half __ovld __cnfn erf(half); -half2 __ovld __cnfn erf(half2); -half3 __ovld __cnfn erf(half3); -half4 __ovld __cnfn erf(half4); -half8 __ovld __cnfn erf(half8); -half16 __ovld __cnfn erf(half16); -#endif //cl_khr_fp16 - -/** - * Compute the base e exponential function of x. - */ -float __ovld __cnfn exp(float); -float2 __ovld __cnfn exp(float2); -float3 __ovld __cnfn exp(float3); -float4 __ovld __cnfn exp(float4); -float8 __ovld __cnfn exp(float8); -float16 __ovld __cnfn exp(float16); -#ifdef cl_khr_fp64 -double __ovld __cnfn exp(double); -double2 __ovld __cnfn exp(double2); -double3 __ovld __cnfn exp(double3); -double4 __ovld __cnfn exp(double4); -double8 __ovld __cnfn exp(double8); -double16 __ovld __cnfn exp(double16); -#endif //cl_khr_fp64 -#ifdef cl_khr_fp16 -half __ovld __cnfn exp(half); -half2 __ovld __cnfn exp(half2); -half3 __ovld __cnfn exp(half3); -half4 __ovld __cnfn exp(half4); -half8 __ovld __cnfn exp(half8); -half16 __ovld __cnfn exp(half16); -#endif //cl_khr_fp16 - -/** - * Exponential base 2 function. - */ -float __ovld __cnfn exp2(float); -float2 __ovld __cnfn exp2(float2); -float3 __ovld __cnfn exp2(float3); -float4 __ovld __cnfn exp2(float4); -float8 __ovld __cnfn exp2(float8); -float16 __ovld __cnfn exp2(float16); -#ifdef cl_khr_fp64 -double __ovld __cnfn exp2(double); -double2 __ovld __cnfn exp2(double2); -double3 __ovld __cnfn exp2(double3); -double4 __ovld __cnfn exp2(double4); -double8 __ovld __cnfn exp2(double8); -double16 __ovld __cnfn exp2(double16); -#endif //cl_khr_fp64 -#ifdef cl_khr_fp16 -half __ovld __cnfn exp2(half); -half2 __ovld __cnfn exp2(half2); -half3 __ovld __cnfn exp2(half3); -half4 __ovld __cnfn exp2(half4); -half8 __ovld __cnfn exp2(half8); -half16 __ovld __cnfn exp2(half16); -#endif //cl_khr_fp16 - -/** - * Exponential base 10 function. - */ -float __ovld __cnfn exp10(float); -float2 __ovld __cnfn exp10(float2); -float3 __ovld __cnfn exp10(float3); -float4 __ovld __cnfn exp10(float4); -float8 __ovld __cnfn exp10(float8); -float16 __ovld __cnfn exp10(float16); -#ifdef cl_khr_fp64 -double __ovld __cnfn exp10(double); -double2 __ovld __cnfn exp10(double2); -double3 __ovld __cnfn exp10(double3); -double4 __ovld __cnfn exp10(double4); -double8 __ovld __cnfn exp10(double8); -double16 __ovld __cnfn exp10(double16); -#endif //cl_khr_fp64 -#ifdef cl_khr_fp16 -half __ovld __cnfn exp10(half); -half2 __ovld __cnfn exp10(half2); -half3 __ovld __cnfn exp10(half3); -half4 __ovld __cnfn exp10(half4); -half8 __ovld __cnfn exp10(half8); -half16 __ovld __cnfn exp10(half16); -#endif //cl_khr_fp16 - -/** - * Compute e^x- 1.0. - */ -float __ovld __cnfn expm1(float); -float2 __ovld __cnfn expm1(float2); -float3 __ovld __cnfn expm1(float3); -float4 __ovld __cnfn expm1(float4); -float8 __ovld __cnfn expm1(float8); -float16 __ovld __cnfn expm1(float16); -#ifdef cl_khr_fp64 -double __ovld __cnfn expm1(double); -double2 __ovld __cnfn expm1(double2); -double3 __ovld __cnfn expm1(double3); -double4 __ovld __cnfn expm1(double4); -double8 __ovld __cnfn expm1(double8); -double16 __ovld __cnfn expm1(double16); -#endif //cl_khr_fp64 -#ifdef cl_khr_fp16 -half __ovld __cnfn expm1(half); -half2 __ovld __cnfn expm1(half2); -half3 __ovld __cnfn expm1(half3); -half4 __ovld __cnfn expm1(half4); -half8 __ovld __cnfn expm1(half8); -half16 __ovld __cnfn expm1(half16); -#endif //cl_khr_fp16 - -/** - * Compute absolute value of a floating-point number. - */ -float __ovld __cnfn fabs(float); -float2 __ovld __cnfn fabs(float2); -float3 __ovld __cnfn fabs(float3); -float4 __ovld __cnfn fabs(float4); -float8 __ovld __cnfn fabs(float8); -float16 __ovld __cnfn fabs(float16); -#ifdef cl_khr_fp64 -double __ovld __cnfn fabs(double); -double2 __ovld __cnfn fabs(double2); -double3 __ovld __cnfn fabs(double3); -double4 __ovld __cnfn fabs(double4); -double8 __ovld __cnfn fabs(double8); -double16 __ovld __cnfn fabs(double16); -#endif //cl_khr_fp64 -#ifdef cl_khr_fp16 -half __ovld __cnfn fabs(half); -half2 __ovld __cnfn fabs(half2); -half3 __ovld __cnfn fabs(half3); -half4 __ovld __cnfn fabs(half4); -half8 __ovld __cnfn fabs(half8); -half16 __ovld __cnfn fabs(half16); -#endif //cl_khr_fp16 - -/** - * x - y if x > y, +0 if x is less than or equal to y. - */ -float __ovld __cnfn fdim(float, float); -float2 __ovld __cnfn fdim(float2, float2); -float3 __ovld __cnfn fdim(float3, float3); -float4 __ovld __cnfn fdim(float4, float4); -float8 __ovld __cnfn fdim(float8, float8); -float16 __ovld __cnfn fdim(float16, float16); -#ifdef cl_khr_fp64 -double __ovld __cnfn fdim(double, double); -double2 __ovld __cnfn fdim(double2, double2); -double3 __ovld __cnfn fdim(double3, double3); -double4 __ovld __cnfn fdim(double4, double4); -double8 __ovld __cnfn fdim(double8, double8); -double16 __ovld __cnfn fdim(double16, double16); -#endif //cl_khr_fp64 -#ifdef cl_khr_fp16 -half __ovld __cnfn fdim(half, half); -half2 __ovld __cnfn fdim(half2, half2); -half3 __ovld __cnfn fdim(half3, half3); -half4 __ovld __cnfn fdim(half4, half4); -half8 __ovld __cnfn fdim(half8, half8); -half16 __ovld __cnfn fdim(half16, half16); -#endif //cl_khr_fp16 - -/** - * Round to integral value using the round to -ve - * infinity rounding mode. - */ -float __ovld __cnfn floor(float); -float2 __ovld __cnfn floor(float2); -float3 __ovld __cnfn floor(float3); -float4 __ovld __cnfn floor(float4); -float8 __ovld __cnfn floor(float8); -float16 __ovld __cnfn floor(float16); -#ifdef cl_khr_fp64 -double __ovld __cnfn floor(double); -double2 __ovld __cnfn floor(double2); -double3 __ovld __cnfn floor(double3); -double4 __ovld __cnfn floor(double4); -double8 __ovld __cnfn floor(double8); -double16 __ovld __cnfn floor(double16); -#endif //cl_khr_fp64 -#ifdef cl_khr_fp16 -half __ovld __cnfn floor(half); -half2 __ovld __cnfn floor(half2); -half3 __ovld __cnfn floor(half3); -half4 __ovld __cnfn floor(half4); -half8 __ovld __cnfn floor(half8); -half16 __ovld __cnfn floor(half16); -#endif //cl_khr_fp16 - -/** - * Returns the correctly rounded floating-point - * representation of the sum of c with the infinitely - * precise product of a and b. Rounding of - * intermediate products shall not occur. Edge case - * behavior is per the IEEE 754-2008 standard. - */ -float __ovld __cnfn fma(float, float, float); -float2 __ovld __cnfn fma(float2, float2, float2); -float3 __ovld __cnfn fma(float3, float3, float3); -float4 __ovld __cnfn fma(float4, float4, float4); -float8 __ovld __cnfn fma(float8, float8, float8); -float16 __ovld __cnfn fma(float16, float16, float16); -#ifdef cl_khr_fp64 -double __ovld __cnfn fma(double, double, double); -double2 __ovld __cnfn fma(double2, double2, double2); -double3 __ovld __cnfn fma(double3, double3, double3); -double4 __ovld __cnfn fma(double4, double4, double4); -double8 __ovld __cnfn fma(double8, double8, double8); -double16 __ovld __cnfn fma(double16, double16, double16); -#endif //cl_khr_fp64 -#ifdef cl_khr_fp16 -half __ovld __cnfn fma(half, half, half); -half2 __ovld __cnfn fma(half2, half2, half2); -half3 __ovld __cnfn fma(half3, half3, half3); -half4 __ovld __cnfn fma(half4, half4, half4); -half8 __ovld __cnfn fma(half8, half8, half8); -half16 __ovld __cnfn fma(half16, half16, half16); -#endif //cl_khr_fp16 - -/** - * Returns y if x < y, otherwise it returns x. If one - * argument is a NaN, fmax() returns the other - * argument. If both arguments are NaNs, fmax() - * returns a NaN. - */ -float __ovld __cnfn fmax(float, float); -float2 __ovld __cnfn fmax(float2, float2); -float3 __ovld __cnfn fmax(float3, float3); -float4 __ovld __cnfn fmax(float4, float4); -float8 __ovld __cnfn fmax(float8, float8); -float16 __ovld __cnfn fmax(float16, float16); -float2 __ovld __cnfn fmax(float2, float); -float3 __ovld __cnfn fmax(float3, float); -float4 __ovld __cnfn fmax(float4, float); -float8 __ovld __cnfn fmax(float8, float); -float16 __ovld __cnfn fmax(float16, float); -#ifdef cl_khr_fp64 -double __ovld __cnfn fmax(double, double); -double2 __ovld __cnfn fmax(double2, double2); -double3 __ovld __cnfn fmax(double3, double3); -double4 __ovld __cnfn fmax(double4, double4); -double8 __ovld __cnfn fmax(double8, double8); -double16 __ovld __cnfn fmax(double16, double16); -double2 __ovld __cnfn fmax(double2, double); -double3 __ovld __cnfn fmax(double3, double); -double4 __ovld __cnfn fmax(double4, double); -double8 __ovld __cnfn fmax(double8, double); -double16 __ovld __cnfn fmax(double16, double); -#endif //cl_khr_fp64 -#ifdef cl_khr_fp16 -half __ovld __cnfn fmax(half, half); -half2 __ovld __cnfn fmax(half2, half2); -half3 __ovld __cnfn fmax(half3, half3); -half4 __ovld __cnfn fmax(half4, half4); -half8 __ovld __cnfn fmax(half8, half8); -half16 __ovld __cnfn fmax(half16, half16); -half2 __ovld __cnfn fmax(half2, half); -half3 __ovld __cnfn fmax(half3, half); -half4 __ovld __cnfn fmax(half4, half); -half8 __ovld __cnfn fmax(half8, half); -half16 __ovld __cnfn fmax(half16, half); -#endif //cl_khr_fp16 - -/** - * Returns y if y < x, otherwise it returns x. If one - * argument is a NaN, fmin() returns the other - * argument. If both arguments are NaNs, fmin() - * returns a NaN. - */ -float __ovld __cnfn fmin(float, float); -float2 __ovld __cnfn fmin(float2, float2); -float3 __ovld __cnfn fmin(float3, float3); -float4 __ovld __cnfn fmin(float4, float4); -float8 __ovld __cnfn fmin(float8, float8); -float16 __ovld __cnfn fmin(float16, float16); -float2 __ovld __cnfn fmin(float2, float); -float3 __ovld __cnfn fmin(float3, float); -float4 __ovld __cnfn fmin(float4, float); -float8 __ovld __cnfn fmin(float8, float); -float16 __ovld __cnfn fmin(float16, float); -#ifdef cl_khr_fp64 -double __ovld __cnfn fmin(double, double); -double2 __ovld __cnfn fmin(double2, double2); -double3 __ovld __cnfn fmin(double3, double3); -double4 __ovld __cnfn fmin(double4, double4); -double8 __ovld __cnfn fmin(double8, double8); -double16 __ovld __cnfn fmin(double16, double16); -double2 __ovld __cnfn fmin(double2, double); -double3 __ovld __cnfn fmin(double3, double); -double4 __ovld __cnfn fmin(double4, double); -double8 __ovld __cnfn fmin(double8, double); -double16 __ovld __cnfn fmin(double16, double); -#endif //cl_khr_fp64 -#ifdef cl_khr_fp16 -half __ovld __cnfn fmin(half, half); -half2 __ovld __cnfn fmin(half2, half2); -half3 __ovld __cnfn fmin(half3, half3); -half4 __ovld __cnfn fmin(half4, half4); -half8 __ovld __cnfn fmin(half8, half8); -half16 __ovld __cnfn fmin(half16, half16); -half2 __ovld __cnfn fmin(half2, half); -half3 __ovld __cnfn fmin(half3, half); -half4 __ovld __cnfn fmin(half4, half); -half8 __ovld __cnfn fmin(half8, half); -half16 __ovld __cnfn fmin(half16, half); -#endif //cl_khr_fp16 - -/** - * Modulus. Returns x - y * trunc (x/y). - */ -float __ovld __cnfn fmod(float, float); -float2 __ovld __cnfn fmod(float2, float2); -float3 __ovld __cnfn fmod(float3, float3); -float4 __ovld __cnfn fmod(float4, float4); -float8 __ovld __cnfn fmod(float8, float8); -float16 __ovld __cnfn fmod(float16, float16); -#ifdef cl_khr_fp64 -double __ovld __cnfn fmod(double, double); -double2 __ovld __cnfn fmod(double2, double2); -double3 __ovld __cnfn fmod(double3, double3); -double4 __ovld __cnfn fmod(double4, double4); -double8 __ovld __cnfn fmod(double8, double8); -double16 __ovld __cnfn fmod(double16, double16); -#endif //cl_khr_fp64 -#ifdef cl_khr_fp16 -half __ovld __cnfn fmod(half, half); -half2 __ovld __cnfn fmod(half2, half2); -half3 __ovld __cnfn fmod(half3, half3); -half4 __ovld __cnfn fmod(half4, half4); -half8 __ovld __cnfn fmod(half8, half8); -half16 __ovld __cnfn fmod(half16, half16); -#endif //cl_khr_fp16 - -/** - * Returns fmin(x - floor (x), 0x1.fffffep-1f ). - * floor(x) is returned in iptr. - */ -#if defined(__opencl_c_generic_address_space) -float __ovld fract(float, float *); -float2 __ovld fract(float2, float2 *); -float3 __ovld fract(float3, float3 *); -float4 __ovld fract(float4, float4 *); -float8 __ovld fract(float8, float8 *); -float16 __ovld fract(float16, float16 *); -#ifdef cl_khr_fp64 -double __ovld fract(double, double *); -double2 __ovld fract(double2, double2 *); -double3 __ovld fract(double3, double3 *); -double4 __ovld fract(double4, double4 *); -double8 __ovld fract(double8, double8 *); -double16 __ovld fract(double16, double16 *); -#endif //cl_khr_fp64 -#ifdef cl_khr_fp16 -half __ovld fract(half, half *); -half2 __ovld fract(half2, half2 *); -half3 __ovld fract(half3, half3 *); -half4 __ovld fract(half4, half4 *); -half8 __ovld fract(half8, half8 *); -half16 __ovld fract(half16, half16 *); -#endif //cl_khr_fp16 -#endif //defined(__opencl_c_generic_address_space) - -#if defined(__opencl_c_named_address_space_builtins) -float __ovld fract(float, __global float *); -float2 __ovld fract(float2, __global float2 *); -float3 __ovld fract(float3, __global float3 *); -float4 __ovld fract(float4, __global float4 *); -float8 __ovld fract(float8, __global float8 *); -float16 __ovld fract(float16, __global float16 *); -float __ovld fract(float, __local float *); -float2 __ovld fract(float2, __local float2 *); -float3 __ovld fract(float3, __local float3 *); -float4 __ovld fract(float4, __local float4 *); -float8 __ovld fract(float8, __local float8 *); -float16 __ovld fract(float16, __local float16 *); -float __ovld fract(float, __private float *); -float2 __ovld fract(float2, __private float2 *); -float3 __ovld fract(float3, __private float3 *); -float4 __ovld fract(float4, __private float4 *); -float8 __ovld fract(float8, __private float8 *); -float16 __ovld fract(float16, __private float16 *); -#ifdef cl_khr_fp64 -double __ovld fract(double, __global double *); -double2 __ovld fract(double2, __global double2 *); -double3 __ovld fract(double3, __global double3 *); -double4 __ovld fract(double4, __global double4 *); -double8 __ovld fract(double8, __global double8 *); -double16 __ovld fract(double16, __global double16 *); -double __ovld fract(double, __local double *); -double2 __ovld fract(double2, __local double2 *); -double3 __ovld fract(double3, __local double3 *); -double4 __ovld fract(double4, __local double4 *); -double8 __ovld fract(double8, __local double8 *); -double16 __ovld fract(double16, __local double16 *); -double __ovld fract(double, __private double *); -double2 __ovld fract(double2, __private double2 *); -double3 __ovld fract(double3, __private double3 *); -double4 __ovld fract(double4, __private double4 *); -double8 __ovld fract(double8, __private double8 *); -double16 __ovld fract(double16, __private double16 *); -#endif //cl_khr_fp64 -#ifdef cl_khr_fp16 -half __ovld fract(half, __global half *); -half2 __ovld fract(half2, __global half2 *); -half3 __ovld fract(half3, __global half3 *); -half4 __ovld fract(half4, __global half4 *); -half8 __ovld fract(half8, __global half8 *); -half16 __ovld fract(half16, __global half16 *); -half __ovld fract(half, __local half *); -half2 __ovld fract(half2, __local half2 *); -half3 __ovld fract(half3, __local half3 *); -half4 __ovld fract(half4, __local half4 *); -half8 __ovld fract(half8, __local half8 *); -half16 __ovld fract(half16, __local half16 *); -half __ovld fract(half, __private half *); -half2 __ovld fract(half2, __private half2 *); -half3 __ovld fract(half3, __private half3 *); -half4 __ovld fract(half4, __private half4 *); -half8 __ovld fract(half8, __private half8 *); -half16 __ovld fract(half16, __private half16 *); -#endif //cl_khr_fp16 -#endif //defined(__opencl_c_named_address_space_builtins) - -/** - * Extract mantissa and exponent from x. For each - * component the mantissa returned is a float with - * magnitude in the interval [1/2, 1) or 0. Each - * component of x equals mantissa returned * 2^exp. - */ -#if defined(__opencl_c_generic_address_space) -float __ovld frexp(float, int *); -float2 __ovld frexp(float2, int2 *); -float3 __ovld frexp(float3, int3 *); -float4 __ovld frexp(float4, int4 *); -float8 __ovld frexp(float8, int8 *); -float16 __ovld frexp(float16, int16 *); -#ifdef cl_khr_fp64 -double __ovld frexp(double, int *); -double2 __ovld frexp(double2, int2 *); -double3 __ovld frexp(double3, int3 *); -double4 __ovld frexp(double4, int4 *); -double8 __ovld frexp(double8, int8 *); -double16 __ovld frexp(double16, int16 *); -#endif //cl_khr_fp64 -#ifdef cl_khr_fp16 -half __ovld frexp(half, int *); -half2 __ovld frexp(half2, int2 *); -half3 __ovld frexp(half3, int3 *); -half4 __ovld frexp(half4, int4 *); -half8 __ovld frexp(half8, int8 *); -half16 __ovld frexp(half16, int16 *); -#endif //cl_khr_fp16 -#endif //defined(__opencl_c_generic_address_space) - -#if defined(__opencl_c_named_address_space_builtins) -float __ovld frexp(float, __global int *); -float2 __ovld frexp(float2, __global int2 *); -float3 __ovld frexp(float3, __global int3 *); -float4 __ovld frexp(float4, __global int4 *); -float8 __ovld frexp(float8, __global int8 *); -float16 __ovld frexp(float16, __global int16 *); -float __ovld frexp(float, __local int *); -float2 __ovld frexp(float2, __local int2 *); -float3 __ovld frexp(float3, __local int3 *); -float4 __ovld frexp(float4, __local int4 *); -float8 __ovld frexp(float8, __local int8 *); -float16 __ovld frexp(float16, __local int16 *); -float __ovld frexp(float, __private int *); -float2 __ovld frexp(float2, __private int2 *); -float3 __ovld frexp(float3, __private int3 *); -float4 __ovld frexp(float4, __private int4 *); -float8 __ovld frexp(float8, __private int8 *); -float16 __ovld frexp(float16, __private int16 *); -#ifdef cl_khr_fp64 -double __ovld frexp(double, __global int *); -double2 __ovld frexp(double2, __global int2 *); -double3 __ovld frexp(double3, __global int3 *); -double4 __ovld frexp(double4, __global int4 *); -double8 __ovld frexp(double8, __global int8 *); -double16 __ovld frexp(double16, __global int16 *); -double __ovld frexp(double, __local int *); -double2 __ovld frexp(double2, __local int2 *); -double3 __ovld frexp(double3, __local int3 *); -double4 __ovld frexp(double4, __local int4 *); -double8 __ovld frexp(double8, __local int8 *); -double16 __ovld frexp(double16, __local int16 *); -double __ovld frexp(double, __private int *); -double2 __ovld frexp(double2, __private int2 *); -double3 __ovld frexp(double3, __private int3 *); -double4 __ovld frexp(double4, __private int4 *); -double8 __ovld frexp(double8, __private int8 *); -double16 __ovld frexp(double16, __private int16 *); -#endif //cl_khr_fp64 -#ifdef cl_khr_fp16 -half __ovld frexp(half, __global int *); -half2 __ovld frexp(half2, __global int2 *); -half3 __ovld frexp(half3, __global int3 *); -half4 __ovld frexp(half4, __global int4 *); -half8 __ovld frexp(half8, __global int8 *); -half16 __ovld frexp(half16, __global int16 *); -half __ovld frexp(half, __local int *); -half2 __ovld frexp(half2, __local int2 *); -half3 __ovld frexp(half3, __local int3 *); -half4 __ovld frexp(half4, __local int4 *); -half8 __ovld frexp(half8, __local int8 *); -half16 __ovld frexp(half16, __local int16 *); -half __ovld frexp(half, __private int *); -half2 __ovld frexp(half2, __private int2 *); -half3 __ovld frexp(half3, __private int3 *); -half4 __ovld frexp(half4, __private int4 *); -half8 __ovld frexp(half8, __private int8 *); -half16 __ovld frexp(half16, __private int16 *); -#endif //cl_khr_fp16 -#endif //defined(__opencl_c_named_address_space_builtins) - -/** - * Compute the value of the square root of x^2 + y^2 - * without undue overflow or underflow. - */ -float __ovld __cnfn hypot(float, float); -float2 __ovld __cnfn hypot(float2, float2); -float3 __ovld __cnfn hypot(float3, float3); -float4 __ovld __cnfn hypot(float4, float4); -float8 __ovld __cnfn hypot(float8, float8); -float16 __ovld __cnfn hypot(float16, float16); -#ifdef cl_khr_fp64 -double __ovld __cnfn hypot(double, double); -double2 __ovld __cnfn hypot(double2, double2); -double3 __ovld __cnfn hypot(double3, double3); -double4 __ovld __cnfn hypot(double4, double4); -double8 __ovld __cnfn hypot(double8, double8); -double16 __ovld __cnfn hypot(double16, double16); -#endif //cl_khr_fp64 -#ifdef cl_khr_fp16 -half __ovld __cnfn hypot(half, half); -half2 __ovld __cnfn hypot(half2, half2); -half3 __ovld __cnfn hypot(half3, half3); -half4 __ovld __cnfn hypot(half4, half4); -half8 __ovld __cnfn hypot(half8, half8); -half16 __ovld __cnfn hypot(half16, half16); -#endif //cl_khr_fp16 - -/** - * Return the exponent as an integer value. - */ -int __ovld __cnfn ilogb(float); -int2 __ovld __cnfn ilogb(float2); -int3 __ovld __cnfn ilogb(float3); -int4 __ovld __cnfn ilogb(float4); -int8 __ovld __cnfn ilogb(float8); -int16 __ovld __cnfn ilogb(float16); -#ifdef cl_khr_fp64 -int __ovld __cnfn ilogb(double); -int2 __ovld __cnfn ilogb(double2); -int3 __ovld __cnfn ilogb(double3); -int4 __ovld __cnfn ilogb(double4); -int8 __ovld __cnfn ilogb(double8); -int16 __ovld __cnfn ilogb(double16); -#endif //cl_khr_fp64 -#ifdef cl_khr_fp16 -int __ovld __cnfn ilogb(half); -int2 __ovld __cnfn ilogb(half2); -int3 __ovld __cnfn ilogb(half3); -int4 __ovld __cnfn ilogb(half4); -int8 __ovld __cnfn ilogb(half8); -int16 __ovld __cnfn ilogb(half16); -#endif //cl_khr_fp16 - -/** - * Multiply x by 2 to the power n. - */ -float __ovld __cnfn ldexp(float, int); -float2 __ovld __cnfn ldexp(float2, int2); -float3 __ovld __cnfn ldexp(float3, int3); -float4 __ovld __cnfn ldexp(float4, int4); -float8 __ovld __cnfn ldexp(float8, int8); -float16 __ovld __cnfn ldexp(float16, int16); -float2 __ovld __cnfn ldexp(float2, int); -float3 __ovld __cnfn ldexp(float3, int); -float4 __ovld __cnfn ldexp(float4, int); -float8 __ovld __cnfn ldexp(float8, int); -float16 __ovld __cnfn ldexp(float16, int); -#ifdef cl_khr_fp64 -double __ovld __cnfn ldexp(double, int); -double2 __ovld __cnfn ldexp(double2, int2); -double3 __ovld __cnfn ldexp(double3, int3); -double4 __ovld __cnfn ldexp(double4, int4); -double8 __ovld __cnfn ldexp(double8, int8); -double16 __ovld __cnfn ldexp(double16, int16); -double2 __ovld __cnfn ldexp(double2, int); -double3 __ovld __cnfn ldexp(double3, int); -double4 __ovld __cnfn ldexp(double4, int); -double8 __ovld __cnfn ldexp(double8, int); -double16 __ovld __cnfn ldexp(double16, int); -#endif //cl_khr_fp64 -#ifdef cl_khr_fp16 -half __ovld __cnfn ldexp(half, int); -half2 __ovld __cnfn ldexp(half2, int2); -half3 __ovld __cnfn ldexp(half3, int3); -half4 __ovld __cnfn ldexp(half4, int4); -half8 __ovld __cnfn ldexp(half8, int8); -half16 __ovld __cnfn ldexp(half16, int16); -half2 __ovld __cnfn ldexp(half2, int); -half3 __ovld __cnfn ldexp(half3, int); -half4 __ovld __cnfn ldexp(half4, int); -half8 __ovld __cnfn ldexp(half8, int); -half16 __ovld __cnfn ldexp(half16, int); -#endif //cl_khr_fp16 - -/** - * Log gamma function. Returns the natural - * logarithm of the absolute value of the gamma - * function. The sign of the gamma function is - * returned in the signp argument of lgamma_r. - */ -float __ovld __cnfn lgamma(float); -float2 __ovld __cnfn lgamma(float2); -float3 __ovld __cnfn lgamma(float3); -float4 __ovld __cnfn lgamma(float4); -float8 __ovld __cnfn lgamma(float8); -float16 __ovld __cnfn lgamma(float16); -#ifdef cl_khr_fp64 -double __ovld __cnfn lgamma(double); -double2 __ovld __cnfn lgamma(double2); -double3 __ovld __cnfn lgamma(double3); -double4 __ovld __cnfn lgamma(double4); -double8 __ovld __cnfn lgamma(double8); -double16 __ovld __cnfn lgamma(double16); -#endif //cl_khr_fp64 -#ifdef cl_khr_fp16 -half __ovld __cnfn lgamma(half); -half2 __ovld __cnfn lgamma(half2); -half3 __ovld __cnfn lgamma(half3); -half4 __ovld __cnfn lgamma(half4); -half8 __ovld __cnfn lgamma(half8); -half16 __ovld __cnfn lgamma(half16); -#endif //cl_khr_fp16 - -#if defined(__opencl_c_generic_address_space) -float __ovld lgamma_r(float, int *); -float2 __ovld lgamma_r(float2, int2 *); -float3 __ovld lgamma_r(float3, int3 *); -float4 __ovld lgamma_r(float4, int4 *); -float8 __ovld lgamma_r(float8, int8 *); -float16 __ovld lgamma_r(float16, int16 *); -#ifdef cl_khr_fp64 -double __ovld lgamma_r(double, int *); -double2 __ovld lgamma_r(double2, int2 *); -double3 __ovld lgamma_r(double3, int3 *); -double4 __ovld lgamma_r(double4, int4 *); -double8 __ovld lgamma_r(double8, int8 *); -double16 __ovld lgamma_r(double16, int16 *); -#endif //cl_khr_fp64 -#ifdef cl_khr_fp16 -half __ovld lgamma_r(half, int *); -half2 __ovld lgamma_r(half2, int2 *); -half3 __ovld lgamma_r(half3, int3 *); -half4 __ovld lgamma_r(half4, int4 *); -half8 __ovld lgamma_r(half8, int8 *); -half16 __ovld lgamma_r(half16, int16 *); -#endif //cl_khr_fp16 -#endif //defined(__opencl_c_generic_address_space) - -#if defined(__opencl_c_named_address_space_builtins) -float __ovld lgamma_r(float, __global int *); -float2 __ovld lgamma_r(float2, __global int2 *); -float3 __ovld lgamma_r(float3, __global int3 *); -float4 __ovld lgamma_r(float4, __global int4 *); -float8 __ovld lgamma_r(float8, __global int8 *); -float16 __ovld lgamma_r(float16, __global int16 *); -float __ovld lgamma_r(float, __local int *); -float2 __ovld lgamma_r(float2, __local int2 *); -float3 __ovld lgamma_r(float3, __local int3 *); -float4 __ovld lgamma_r(float4, __local int4 *); -float8 __ovld lgamma_r(float8, __local int8 *); -float16 __ovld lgamma_r(float16, __local int16 *); -float __ovld lgamma_r(float, __private int *); -float2 __ovld lgamma_r(float2, __private int2 *); -float3 __ovld lgamma_r(float3, __private int3 *); -float4 __ovld lgamma_r(float4, __private int4 *); -float8 __ovld lgamma_r(float8, __private int8 *); -float16 __ovld lgamma_r(float16, __private int16 *); -#ifdef cl_khr_fp64 -double __ovld lgamma_r(double, __global int *); -double2 __ovld lgamma_r(double2, __global int2 *); -double3 __ovld lgamma_r(double3, __global int3 *); -double4 __ovld lgamma_r(double4, __global int4 *); -double8 __ovld lgamma_r(double8, __global int8 *); -double16 __ovld lgamma_r(double16, __global int16 *); -double __ovld lgamma_r(double, __local int *); -double2 __ovld lgamma_r(double2, __local int2 *); -double3 __ovld lgamma_r(double3, __local int3 *); -double4 __ovld lgamma_r(double4, __local int4 *); -double8 __ovld lgamma_r(double8, __local int8 *); -double16 __ovld lgamma_r(double16, __local int16 *); -double __ovld lgamma_r(double, __private int *); -double2 __ovld lgamma_r(double2, __private int2 *); -double3 __ovld lgamma_r(double3, __private int3 *); -double4 __ovld lgamma_r(double4, __private int4 *); -double8 __ovld lgamma_r(double8, __private int8 *); -double16 __ovld lgamma_r(double16, __private int16 *); -#endif //cl_khr_fp64 -#ifdef cl_khr_fp16 -half __ovld lgamma_r(half, __global int *); -half2 __ovld lgamma_r(half2, __global int2 *); -half3 __ovld lgamma_r(half3, __global int3 *); -half4 __ovld lgamma_r(half4, __global int4 *); -half8 __ovld lgamma_r(half8, __global int8 *); -half16 __ovld lgamma_r(half16, __global int16 *); -half __ovld lgamma_r(half, __local int *); -half2 __ovld lgamma_r(half2, __local int2 *); -half3 __ovld lgamma_r(half3, __local int3 *); -half4 __ovld lgamma_r(half4, __local int4 *); -half8 __ovld lgamma_r(half8, __local int8 *); -half16 __ovld lgamma_r(half16, __local int16 *); -half __ovld lgamma_r(half, __private int *); -half2 __ovld lgamma_r(half2, __private int2 *); -half3 __ovld lgamma_r(half3, __private int3 *); -half4 __ovld lgamma_r(half4, __private int4 *); -half8 __ovld lgamma_r(half8, __private int8 *); -half16 __ovld lgamma_r(half16, __private int16 *); -#endif //cl_khr_fp16 -#endif //defined(__opencl_c_named_address_space_builtins) - -/** - * Compute natural logarithm. - */ -float __ovld __cnfn log(float); -float2 __ovld __cnfn log(float2); -float3 __ovld __cnfn log(float3); -float4 __ovld __cnfn log(float4); -float8 __ovld __cnfn log(float8); -float16 __ovld __cnfn log(float16); -#ifdef cl_khr_fp64 -double __ovld __cnfn log(double); -double2 __ovld __cnfn log(double2); -double3 __ovld __cnfn log(double3); -double4 __ovld __cnfn log(double4); -double8 __ovld __cnfn log(double8); -double16 __ovld __cnfn log(double16); -#endif //cl_khr_fp64 -#ifdef cl_khr_fp16 -half __ovld __cnfn log(half); -half2 __ovld __cnfn log(half2); -half3 __ovld __cnfn log(half3); -half4 __ovld __cnfn log(half4); -half8 __ovld __cnfn log(half8); -half16 __ovld __cnfn log(half16); -#endif //cl_khr_fp16 - -/** - * Compute a base 2 logarithm. - */ -float __ovld __cnfn log2(float); -float2 __ovld __cnfn log2(float2); -float3 __ovld __cnfn log2(float3); -float4 __ovld __cnfn log2(float4); -float8 __ovld __cnfn log2(float8); -float16 __ovld __cnfn log2(float16); -#ifdef cl_khr_fp64 -double __ovld __cnfn log2(double); -double2 __ovld __cnfn log2(double2); -double3 __ovld __cnfn log2(double3); -double4 __ovld __cnfn log2(double4); -double8 __ovld __cnfn log2(double8); -double16 __ovld __cnfn log2(double16); -#endif //cl_khr_fp64 -#ifdef cl_khr_fp16 -half __ovld __cnfn log2(half); -half2 __ovld __cnfn log2(half2); -half3 __ovld __cnfn log2(half3); -half4 __ovld __cnfn log2(half4); -half8 __ovld __cnfn log2(half8); -half16 __ovld __cnfn log2(half16); -#endif //cl_khr_fp16 - -/** - * Compute a base 10 logarithm. - */ -float __ovld __cnfn log10(float); -float2 __ovld __cnfn log10(float2); -float3 __ovld __cnfn log10(float3); -float4 __ovld __cnfn log10(float4); -float8 __ovld __cnfn log10(float8); -float16 __ovld __cnfn log10(float16); -#ifdef cl_khr_fp64 -double __ovld __cnfn log10(double); -double2 __ovld __cnfn log10(double2); -double3 __ovld __cnfn log10(double3); -double4 __ovld __cnfn log10(double4); -double8 __ovld __cnfn log10(double8); -double16 __ovld __cnfn log10(double16); -#endif //cl_khr_fp64 -#ifdef cl_khr_fp16 -half __ovld __cnfn log10(half); -half2 __ovld __cnfn log10(half2); -half3 __ovld __cnfn log10(half3); -half4 __ovld __cnfn log10(half4); -half8 __ovld __cnfn log10(half8); -half16 __ovld __cnfn log10(half16); -#endif //cl_khr_fp16 - -/** - * Compute a base e logarithm of (1.0 + x). - */ -float __ovld __cnfn log1p(float); -float2 __ovld __cnfn log1p(float2); -float3 __ovld __cnfn log1p(float3); -float4 __ovld __cnfn log1p(float4); -float8 __ovld __cnfn log1p(float8); -float16 __ovld __cnfn log1p(float16); -#ifdef cl_khr_fp64 -double __ovld __cnfn log1p(double); -double2 __ovld __cnfn log1p(double2); -double3 __ovld __cnfn log1p(double3); -double4 __ovld __cnfn log1p(double4); -double8 __ovld __cnfn log1p(double8); -double16 __ovld __cnfn log1p(double16); -#endif //cl_khr_fp64 -#ifdef cl_khr_fp16 -half __ovld __cnfn log1p(half); -half2 __ovld __cnfn log1p(half2); -half3 __ovld __cnfn log1p(half3); -half4 __ovld __cnfn log1p(half4); -half8 __ovld __cnfn log1p(half8); -half16 __ovld __cnfn log1p(half16); -#endif //cl_khr_fp16 - -/** - * Compute the exponent of x, which is the integral - * part of logr | x |. - */ -float __ovld __cnfn logb(float); -float2 __ovld __cnfn logb(float2); -float3 __ovld __cnfn logb(float3); -float4 __ovld __cnfn logb(float4); -float8 __ovld __cnfn logb(float8); -float16 __ovld __cnfn logb(float16); -#ifdef cl_khr_fp64 -double __ovld __cnfn logb(double); -double2 __ovld __cnfn logb(double2); -double3 __ovld __cnfn logb(double3); -double4 __ovld __cnfn logb(double4); -double8 __ovld __cnfn logb(double8); -double16 __ovld __cnfn logb(double16); -#endif //cl_khr_fp64 -#ifdef cl_khr_fp16 -half __ovld __cnfn logb(half); -half2 __ovld __cnfn logb(half2); -half3 __ovld __cnfn logb(half3); -half4 __ovld __cnfn logb(half4); -half8 __ovld __cnfn logb(half8); -half16 __ovld __cnfn logb(half16); -#endif //cl_khr_fp16 - -/** - * mad approximates a * b + c. Whether or how the - * product of a * b is rounded and how supernormal or - * subnormal intermediate products are handled is not - * defined. mad is intended to be used where speed is - * preferred over accuracy. - */ -float __ovld __cnfn mad(float, float, float); -float2 __ovld __cnfn mad(float2, float2, float2); -float3 __ovld __cnfn mad(float3, float3, float3); -float4 __ovld __cnfn mad(float4, float4, float4); -float8 __ovld __cnfn mad(float8, float8, float8); -float16 __ovld __cnfn mad(float16, float16, float16); -#ifdef cl_khr_fp64 -double __ovld __cnfn mad(double, double, double); -double2 __ovld __cnfn mad(double2, double2, double2); -double3 __ovld __cnfn mad(double3, double3, double3); -double4 __ovld __cnfn mad(double4, double4, double4); -double8 __ovld __cnfn mad(double8, double8, double8); -double16 __ovld __cnfn mad(double16, double16, double16); -#endif //cl_khr_fp64 -#ifdef cl_khr_fp16 -half __ovld __cnfn mad(half, half, half); -half2 __ovld __cnfn mad(half2, half2, half2); -half3 __ovld __cnfn mad(half3, half3, half3); -half4 __ovld __cnfn mad(half4, half4, half4); -half8 __ovld __cnfn mad(half8, half8, half8); -half16 __ovld __cnfn mad(half16, half16, half16); -#endif //cl_khr_fp16 - -/** - * Returns x if | x | > | y |, y if | y | > | x |, otherwise - * fmax(x, y). - */ -float __ovld __cnfn maxmag(float, float); -float2 __ovld __cnfn maxmag(float2, float2); -float3 __ovld __cnfn maxmag(float3, float3); -float4 __ovld __cnfn maxmag(float4, float4); -float8 __ovld __cnfn maxmag(float8, float8); -float16 __ovld __cnfn maxmag(float16, float16); -#ifdef cl_khr_fp64 -double __ovld __cnfn maxmag(double, double); -double2 __ovld __cnfn maxmag(double2, double2); -double3 __ovld __cnfn maxmag(double3, double3); -double4 __ovld __cnfn maxmag(double4, double4); -double8 __ovld __cnfn maxmag(double8, double8); -double16 __ovld __cnfn maxmag(double16, double16); -#endif //cl_khr_fp64 -#ifdef cl_khr_fp16 -half __ovld __cnfn maxmag(half, half); -half2 __ovld __cnfn maxmag(half2, half2); -half3 __ovld __cnfn maxmag(half3, half3); -half4 __ovld __cnfn maxmag(half4, half4); -half8 __ovld __cnfn maxmag(half8, half8); -half16 __ovld __cnfn maxmag(half16, half16); -#endif //cl_khr_fp16 - -/** - * Returns x if | x | < | y |, y if | y | < | x |, otherwise - * fmin(x, y). - */ -float __ovld __cnfn minmag(float, float); -float2 __ovld __cnfn minmag(float2, float2); -float3 __ovld __cnfn minmag(float3, float3); -float4 __ovld __cnfn minmag(float4, float4); -float8 __ovld __cnfn minmag(float8, float8); -float16 __ovld __cnfn minmag(float16, float16); -#ifdef cl_khr_fp64 -double __ovld __cnfn minmag(double, double); -double2 __ovld __cnfn minmag(double2, double2); -double3 __ovld __cnfn minmag(double3, double3); -double4 __ovld __cnfn minmag(double4, double4); -double8 __ovld __cnfn minmag(double8, double8); -double16 __ovld __cnfn minmag(double16, double16); -#endif //cl_khr_fp64 -#ifdef cl_khr_fp16 -half __ovld __cnfn minmag(half, half); -half2 __ovld __cnfn minmag(half2, half2); -half3 __ovld __cnfn minmag(half3, half3); -half4 __ovld __cnfn minmag(half4, half4); -half8 __ovld __cnfn minmag(half8, half8); -half16 __ovld __cnfn minmag(half16, half16); -#endif //cl_khr_fp16 - -/** - * Decompose a floating-point number. The modf - * function breaks the argument x into integral and - * fractional parts, each of which has the same sign as - * the argument. It stores the integral part in the object - * pointed to by iptr. - */ -#if defined(__opencl_c_generic_address_space) -float __ovld modf(float, float *); -float2 __ovld modf(float2, float2 *); -float3 __ovld modf(float3, float3 *); -float4 __ovld modf(float4, float4 *); -float8 __ovld modf(float8, float8 *); -float16 __ovld modf(float16, float16 *); -#ifdef cl_khr_fp64 -double __ovld modf(double, double *); -double2 __ovld modf(double2, double2 *); -double3 __ovld modf(double3, double3 *); -double4 __ovld modf(double4, double4 *); -double8 __ovld modf(double8, double8 *); -double16 __ovld modf(double16, double16 *); -#endif //cl_khr_fp64 -#ifdef cl_khr_fp16 -half __ovld modf(half, half *); -half2 __ovld modf(half2, half2 *); -half3 __ovld modf(half3, half3 *); -half4 __ovld modf(half4, half4 *); -half8 __ovld modf(half8, half8 *); -half16 __ovld modf(half16, half16 *); -#endif //cl_khr_fp16 -#endif //defined(__opencl_c_generic_address_space) - -#if defined(__opencl_c_named_address_space_builtins) -float __ovld modf(float, __global float *); -float2 __ovld modf(float2, __global float2 *); -float3 __ovld modf(float3, __global float3 *); -float4 __ovld modf(float4, __global float4 *); -float8 __ovld modf(float8, __global float8 *); -float16 __ovld modf(float16, __global float16 *); -float __ovld modf(float, __local float *); -float2 __ovld modf(float2, __local float2 *); -float3 __ovld modf(float3, __local float3 *); -float4 __ovld modf(float4, __local float4 *); -float8 __ovld modf(float8, __local float8 *); -float16 __ovld modf(float16, __local float16 *); -float __ovld modf(float, __private float *); -float2 __ovld modf(float2, __private float2 *); -float3 __ovld modf(float3, __private float3 *); -float4 __ovld modf(float4, __private float4 *); -float8 __ovld modf(float8, __private float8 *); -float16 __ovld modf(float16, __private float16 *); -#ifdef cl_khr_fp64 -double __ovld modf(double, __global double *); -double2 __ovld modf(double2, __global double2 *); -double3 __ovld modf(double3, __global double3 *); -double4 __ovld modf(double4, __global double4 *); -double8 __ovld modf(double8, __global double8 *); -double16 __ovld modf(double16, __global double16 *); -double __ovld modf(double, __local double *); -double2 __ovld modf(double2, __local double2 *); -double3 __ovld modf(double3, __local double3 *); -double4 __ovld modf(double4, __local double4 *); -double8 __ovld modf(double8, __local double8 *); -double16 __ovld modf(double16, __local double16 *); -double __ovld modf(double, __private double *); -double2 __ovld modf(double2, __private double2 *); -double3 __ovld modf(double3, __private double3 *); -double4 __ovld modf(double4, __private double4 *); -double8 __ovld modf(double8, __private double8 *); -double16 __ovld modf(double16, __private double16 *); -#endif //cl_khr_fp64 -#ifdef cl_khr_fp16 -half __ovld modf(half, __global half *); -half2 __ovld modf(half2, __global half2 *); -half3 __ovld modf(half3, __global half3 *); -half4 __ovld modf(half4, __global half4 *); -half8 __ovld modf(half8, __global half8 *); -half16 __ovld modf(half16, __global half16 *); -half __ovld modf(half, __local half *); -half2 __ovld modf(half2, __local half2 *); -half3 __ovld modf(half3, __local half3 *); -half4 __ovld modf(half4, __local half4 *); -half8 __ovld modf(half8, __local half8 *); -half16 __ovld modf(half16, __local half16 *); -half __ovld modf(half, __private half *); -half2 __ovld modf(half2, __private half2 *); -half3 __ovld modf(half3, __private half3 *); -half4 __ovld modf(half4, __private half4 *); -half8 __ovld modf(half8, __private half8 *); -half16 __ovld modf(half16, __private half16 *); -#endif //cl_khr_fp16 -#endif //defined(__opencl_c_named_address_space_builtins) - -/** - * Returns a quiet NaN. The nancode may be placed - * in the significand of the resulting NaN. - */ -float __ovld __cnfn nan(uint); -float2 __ovld __cnfn nan(uint2); -float3 __ovld __cnfn nan(uint3); -float4 __ovld __cnfn nan(uint4); -float8 __ovld __cnfn nan(uint8); -float16 __ovld __cnfn nan(uint16); -#ifdef cl_khr_fp64 -double __ovld __cnfn nan(ulong); -double2 __ovld __cnfn nan(ulong2); -double3 __ovld __cnfn nan(ulong3); -double4 __ovld __cnfn nan(ulong4); -double8 __ovld __cnfn nan(ulong8); -double16 __ovld __cnfn nan(ulong16); -#endif //cl_khr_fp64 -#ifdef cl_khr_fp16 -half __ovld __cnfn nan(ushort); -half2 __ovld __cnfn nan(ushort2); -half3 __ovld __cnfn nan(ushort3); -half4 __ovld __cnfn nan(ushort4); -half8 __ovld __cnfn nan(ushort8); -half16 __ovld __cnfn nan(ushort16); -#endif //cl_khr_fp16 - -/** - * Computes the next representable single-precision - * floating-point value following x in the direction of - * y. Thus, if y is less than x, nextafter() returns the - * largest representable floating-point number less - * than x. - */ -float __ovld __cnfn nextafter(float, float); -float2 __ovld __cnfn nextafter(float2, float2); -float3 __ovld __cnfn nextafter(float3, float3); -float4 __ovld __cnfn nextafter(float4, float4); -float8 __ovld __cnfn nextafter(float8, float8); -float16 __ovld __cnfn nextafter(float16, float16); -#ifdef cl_khr_fp64 -double __ovld __cnfn nextafter(double, double); -double2 __ovld __cnfn nextafter(double2, double2); -double3 __ovld __cnfn nextafter(double3, double3); -double4 __ovld __cnfn nextafter(double4, double4); -double8 __ovld __cnfn nextafter(double8, double8); -double16 __ovld __cnfn nextafter(double16, double16); -#endif //cl_khr_fp64 -#ifdef cl_khr_fp16 -half __ovld __cnfn nextafter(half, half); -half2 __ovld __cnfn nextafter(half2, half2); -half3 __ovld __cnfn nextafter(half3, half3); -half4 __ovld __cnfn nextafter(half4, half4); -half8 __ovld __cnfn nextafter(half8, half8); -half16 __ovld __cnfn nextafter(half16, half16); -#endif //cl_khr_fp16 - -/** - * Compute x to the power y. - */ -float __ovld __cnfn pow(float, float); -float2 __ovld __cnfn pow(float2, float2); -float3 __ovld __cnfn pow(float3, float3); -float4 __ovld __cnfn pow(float4, float4); -float8 __ovld __cnfn pow(float8, float8); -float16 __ovld __cnfn pow(float16, float16); -#ifdef cl_khr_fp64 -double __ovld __cnfn pow(double, double); -double2 __ovld __cnfn pow(double2, double2); -double3 __ovld __cnfn pow(double3, double3); -double4 __ovld __cnfn pow(double4, double4); -double8 __ovld __cnfn pow(double8, double8); -double16 __ovld __cnfn pow(double16, double16); -#endif //cl_khr_fp64 -#ifdef cl_khr_fp16 -half __ovld __cnfn pow(half, half); -half2 __ovld __cnfn pow(half2, half2); -half3 __ovld __cnfn pow(half3, half3); -half4 __ovld __cnfn pow(half4, half4); -half8 __ovld __cnfn pow(half8, half8); -half16 __ovld __cnfn pow(half16, half16); -#endif //cl_khr_fp16 - -/** - * Compute x to the power y, where y is an integer. - */ -float __ovld __cnfn pown(float, int); -float2 __ovld __cnfn pown(float2, int2); -float3 __ovld __cnfn pown(float3, int3); -float4 __ovld __cnfn pown(float4, int4); -float8 __ovld __cnfn pown(float8, int8); -float16 __ovld __cnfn pown(float16, int16); -#ifdef cl_khr_fp64 -double __ovld __cnfn pown(double, int); -double2 __ovld __cnfn pown(double2, int2); -double3 __ovld __cnfn pown(double3, int3); -double4 __ovld __cnfn pown(double4, int4); -double8 __ovld __cnfn pown(double8, int8); -double16 __ovld __cnfn pown(double16, int16); -#endif //cl_khr_fp64 -#ifdef cl_khr_fp16 -half __ovld __cnfn pown(half, int); -half2 __ovld __cnfn pown(half2, int2); -half3 __ovld __cnfn pown(half3, int3); -half4 __ovld __cnfn pown(half4, int4); -half8 __ovld __cnfn pown(half8, int8); -half16 __ovld __cnfn pown(half16, int16); -#endif //cl_khr_fp16 - -/** - * Compute x to the power y, where x is >= 0. - */ -float __ovld __cnfn powr(float, float); -float2 __ovld __cnfn powr(float2, float2); -float3 __ovld __cnfn powr(float3, float3); -float4 __ovld __cnfn powr(float4, float4); -float8 __ovld __cnfn powr(float8, float8); -float16 __ovld __cnfn powr(float16, float16); -#ifdef cl_khr_fp64 -double __ovld __cnfn powr(double, double); -double2 __ovld __cnfn powr(double2, double2); -double3 __ovld __cnfn powr(double3, double3); -double4 __ovld __cnfn powr(double4, double4); -double8 __ovld __cnfn powr(double8, double8); -double16 __ovld __cnfn powr(double16, double16); -#endif //cl_khr_fp64 -#ifdef cl_khr_fp16 -half __ovld __cnfn powr(half, half); -half2 __ovld __cnfn powr(half2, half2); -half3 __ovld __cnfn powr(half3, half3); -half4 __ovld __cnfn powr(half4, half4); -half8 __ovld __cnfn powr(half8, half8); -half16 __ovld __cnfn powr(half16, half16); -#endif //cl_khr_fp16 - -/** - * Compute the value r such that r = x - n*y, where n - * is the integer nearest the exact value of x/y. If there - * are two integers closest to x/y, n shall be the even - * one. If r is zero, it is given the same sign as x. - */ -float __ovld __cnfn remainder(float, float); -float2 __ovld __cnfn remainder(float2, float2); -float3 __ovld __cnfn remainder(float3, float3); -float4 __ovld __cnfn remainder(float4, float4); -float8 __ovld __cnfn remainder(float8, float8); -float16 __ovld __cnfn remainder(float16, float16); -#ifdef cl_khr_fp64 -double __ovld __cnfn remainder(double, double); -double2 __ovld __cnfn remainder(double2, double2); -double3 __ovld __cnfn remainder(double3, double3); -double4 __ovld __cnfn remainder(double4, double4); -double8 __ovld __cnfn remainder(double8, double8); -double16 __ovld __cnfn remainder(double16, double16); -#endif //cl_khr_fp64 -#ifdef cl_khr_fp16 -half __ovld __cnfn remainder(half, half); -half2 __ovld __cnfn remainder(half2, half2); -half3 __ovld __cnfn remainder(half3, half3); -half4 __ovld __cnfn remainder(half4, half4); -half8 __ovld __cnfn remainder(half8, half8); -half16 __ovld __cnfn remainder(half16, half16); -#endif //cl_khr_fp16 - -/** - * The remquo function computes the value r such - * that r = x - n*y, where n is the integer nearest the - * exact value of x/y. If there are two integers closest - * to x/y, n shall be the even one. If r is zero, it is - * given the same sign as x. This is the same value - * that is returned by the remainder function. - * remquo also calculates the lower seven bits of the - * integral quotient x/y, and gives that value the same - * sign as x/y. It stores this signed value in the object - * pointed to by quo. - */ -#if defined(__opencl_c_generic_address_space) -float __ovld remquo(float, float, int *); -float2 __ovld remquo(float2, float2, int2 *); -float3 __ovld remquo(float3, float3, int3 *); -float4 __ovld remquo(float4, float4, int4 *); -float8 __ovld remquo(float8, float8, int8 *); -float16 __ovld remquo(float16, float16, int16 *); -#ifdef cl_khr_fp64 -double __ovld remquo(double, double, int *); -double2 __ovld remquo(double2, double2, int2 *); -double3 __ovld remquo(double3, double3, int3 *); -double4 __ovld remquo(double4, double4, int4 *); -double8 __ovld remquo(double8, double8, int8 *); -double16 __ovld remquo(double16, double16, int16 *); -#endif //cl_khr_fp64 -#ifdef cl_khr_fp16 -half __ovld remquo(half, half, int *); -half2 __ovld remquo(half2, half2, int2 *); -half3 __ovld remquo(half3, half3, int3 *); -half4 __ovld remquo(half4, half4, int4 *); -half8 __ovld remquo(half8, half8, int8 *); -half16 __ovld remquo(half16, half16, int16 *); -#endif //cl_khr_fp16 -#endif //defined(__opencl_c_generic_address_space) - -#if defined(__opencl_c_named_address_space_builtins) -float __ovld remquo(float, float, __global int *); -float2 __ovld remquo(float2, float2, __global int2 *); -float3 __ovld remquo(float3, float3, __global int3 *); -float4 __ovld remquo(float4, float4, __global int4 *); -float8 __ovld remquo(float8, float8, __global int8 *); -float16 __ovld remquo(float16, float16, __global int16 *); -float __ovld remquo(float, float, __local int *); -float2 __ovld remquo(float2, float2, __local int2 *); -float3 __ovld remquo(float3, float3, __local int3 *); -float4 __ovld remquo(float4, float4, __local int4 *); -float8 __ovld remquo(float8, float8, __local int8 *); -float16 __ovld remquo(float16, float16, __local int16 *); -float __ovld remquo(float, float, __private int *); -float2 __ovld remquo(float2, float2, __private int2 *); -float3 __ovld remquo(float3, float3, __private int3 *); -float4 __ovld remquo(float4, float4, __private int4 *); -float8 __ovld remquo(float8, float8, __private int8 *); -float16 __ovld remquo(float16, float16, __private int16 *); -#ifdef cl_khr_fp64 -double __ovld remquo(double, double, __global int *); -double2 __ovld remquo(double2, double2, __global int2 *); -double3 __ovld remquo(double3, double3, __global int3 *); -double4 __ovld remquo(double4, double4, __global int4 *); -double8 __ovld remquo(double8, double8, __global int8 *); -double16 __ovld remquo(double16, double16, __global int16 *); -double __ovld remquo(double, double, __local int *); -double2 __ovld remquo(double2, double2, __local int2 *); -double3 __ovld remquo(double3, double3, __local int3 *); -double4 __ovld remquo(double4, double4, __local int4 *); -double8 __ovld remquo(double8, double8, __local int8 *); -double16 __ovld remquo(double16, double16, __local int16 *); -double __ovld remquo(double, double, __private int *); -double2 __ovld remquo(double2, double2, __private int2 *); -double3 __ovld remquo(double3, double3, __private int3 *); -double4 __ovld remquo(double4, double4, __private int4 *); -double8 __ovld remquo(double8, double8, __private int8 *); -double16 __ovld remquo(double16, double16, __private int16 *); -#endif //cl_khr_fp64 -#ifdef cl_khr_fp16 -half __ovld remquo(half, half, __global int *); -half2 __ovld remquo(half2, half2, __global int2 *); -half3 __ovld remquo(half3, half3, __global int3 *); -half4 __ovld remquo(half4, half4, __global int4 *); -half8 __ovld remquo(half8, half8, __global int8 *); -half16 __ovld remquo(half16, half16, __global int16 *); -half __ovld remquo(half, half, __local int *); -half2 __ovld remquo(half2, half2, __local int2 *); -half3 __ovld remquo(half3, half3, __local int3 *); -half4 __ovld remquo(half4, half4, __local int4 *); -half8 __ovld remquo(half8, half8, __local int8 *); -half16 __ovld remquo(half16, half16, __local int16 *); -half __ovld remquo(half, half, __private int *); -half2 __ovld remquo(half2, half2, __private int2 *); -half3 __ovld remquo(half3, half3, __private int3 *); -half4 __ovld remquo(half4, half4, __private int4 *); -half8 __ovld remquo(half8, half8, __private int8 *); -half16 __ovld remquo(half16, half16, __private int16 *); -#endif //cl_khr_fp16 -#endif //defined(__opencl_c_named_address_space_builtins) -/** - * Round to integral value (using round to nearest - * even rounding mode) in floating-point format. - * Refer to section 7.1 for description of rounding - * modes. - */ -float __ovld __cnfn rint(float); -float2 __ovld __cnfn rint(float2); -float3 __ovld __cnfn rint(float3); -float4 __ovld __cnfn rint(float4); -float8 __ovld __cnfn rint(float8); -float16 __ovld __cnfn rint(float16); -#ifdef cl_khr_fp64 -double __ovld __cnfn rint(double); -double2 __ovld __cnfn rint(double2); -double3 __ovld __cnfn rint(double3); -double4 __ovld __cnfn rint(double4); -double8 __ovld __cnfn rint(double8); -double16 __ovld __cnfn rint(double16); -#endif //cl_khr_fp64 -#ifdef cl_khr_fp16 -half __ovld __cnfn rint(half); -half2 __ovld __cnfn rint(half2); -half3 __ovld __cnfn rint(half3); -half4 __ovld __cnfn rint(half4); -half8 __ovld __cnfn rint(half8); -half16 __ovld __cnfn rint(half16); -#endif //cl_khr_fp16 - -/** - * Compute x to the power 1/y. - */ -float __ovld __cnfn rootn(float, int); -float2 __ovld __cnfn rootn(float2, int2); -float3 __ovld __cnfn rootn(float3, int3); -float4 __ovld __cnfn rootn(float4, int4); -float8 __ovld __cnfn rootn(float8, int8); -float16 __ovld __cnfn rootn(float16, int16); -#ifdef cl_khr_fp64 -double __ovld __cnfn rootn(double, int); -double2 __ovld __cnfn rootn(double2, int2); -double3 __ovld __cnfn rootn(double3, int3); -double4 __ovld __cnfn rootn(double4, int4); -double8 __ovld __cnfn rootn(double8, int8); -double16 __ovld __cnfn rootn(double16, int16); -#endif //cl_khr_fp64 -#ifdef cl_khr_fp16 -half __ovld __cnfn rootn(half, int); -half2 __ovld __cnfn rootn(half2, int2); -half3 __ovld __cnfn rootn(half3, int3); -half4 __ovld __cnfn rootn(half4, int4); -half8 __ovld __cnfn rootn(half8, int8); -half16 __ovld __cnfn rootn(half16, int16); -#endif //cl_khr_fp16 - -/** - * Return the integral value nearest to x rounding - * halfway cases away from zero, regardless of the - * current rounding direction. - */ -float __ovld __cnfn round(float); -float2 __ovld __cnfn round(float2); -float3 __ovld __cnfn round(float3); -float4 __ovld __cnfn round(float4); -float8 __ovld __cnfn round(float8); -float16 __ovld __cnfn round(float16); -#ifdef cl_khr_fp64 -double __ovld __cnfn round(double); -double2 __ovld __cnfn round(double2); -double3 __ovld __cnfn round(double3); -double4 __ovld __cnfn round(double4); -double8 __ovld __cnfn round(double8); -double16 __ovld __cnfn round(double16); -#endif //cl_khr_fp64 -#ifdef cl_khr_fp16 -half __ovld __cnfn round(half); -half2 __ovld __cnfn round(half2); -half3 __ovld __cnfn round(half3); -half4 __ovld __cnfn round(half4); -half8 __ovld __cnfn round(half8); -half16 __ovld __cnfn round(half16); -#endif //cl_khr_fp16 - -/** - * Compute inverse square root. - */ -float __ovld __cnfn rsqrt(float); -float2 __ovld __cnfn rsqrt(float2); -float3 __ovld __cnfn rsqrt(float3); -float4 __ovld __cnfn rsqrt(float4); -float8 __ovld __cnfn rsqrt(float8); -float16 __ovld __cnfn rsqrt(float16); -#ifdef cl_khr_fp64 -double __ovld __cnfn rsqrt(double); -double2 __ovld __cnfn rsqrt(double2); -double3 __ovld __cnfn rsqrt(double3); -double4 __ovld __cnfn rsqrt(double4); -double8 __ovld __cnfn rsqrt(double8); -double16 __ovld __cnfn rsqrt(double16); -#endif //cl_khr_fp64 -#ifdef cl_khr_fp16 -half __ovld __cnfn rsqrt(half); -half2 __ovld __cnfn rsqrt(half2); -half3 __ovld __cnfn rsqrt(half3); -half4 __ovld __cnfn rsqrt(half4); -half8 __ovld __cnfn rsqrt(half8); -half16 __ovld __cnfn rsqrt(half16); -#endif //cl_khr_fp16 - -/** - * Compute sine. - */ -float __ovld __cnfn sin(float); -float2 __ovld __cnfn sin(float2); -float3 __ovld __cnfn sin(float3); -float4 __ovld __cnfn sin(float4); -float8 __ovld __cnfn sin(float8); -float16 __ovld __cnfn sin(float16); -#ifdef cl_khr_fp64 -double __ovld __cnfn sin(double); -double2 __ovld __cnfn sin(double2); -double3 __ovld __cnfn sin(double3); -double4 __ovld __cnfn sin(double4); -double8 __ovld __cnfn sin(double8); -double16 __ovld __cnfn sin(double16); -#endif //cl_khr_fp64 -#ifdef cl_khr_fp16 -half __ovld __cnfn sin(half); -half2 __ovld __cnfn sin(half2); -half3 __ovld __cnfn sin(half3); -half4 __ovld __cnfn sin(half4); -half8 __ovld __cnfn sin(half8); -half16 __ovld __cnfn sin(half16); -#endif //cl_khr_fp16 - -/** - * Compute sine and cosine of x. The computed sine - * is the return value and computed cosine is returned - * in cosval. - */ -#if defined(__opencl_c_generic_address_space) -float __ovld sincos(float, float *); -float2 __ovld sincos(float2, float2 *); -float3 __ovld sincos(float3, float3 *); -float4 __ovld sincos(float4, float4 *); -float8 __ovld sincos(float8, float8 *); -float16 __ovld sincos(float16, float16 *); -#ifdef cl_khr_fp64 -double __ovld sincos(double, double *); -double2 __ovld sincos(double2, double2 *); -double3 __ovld sincos(double3, double3 *); -double4 __ovld sincos(double4, double4 *); -double8 __ovld sincos(double8, double8 *); -double16 __ovld sincos(double16, double16 *); -#endif //cl_khr_fp64 -#ifdef cl_khr_fp16 -half __ovld sincos(half, half *); -half2 __ovld sincos(half2, half2 *); -half3 __ovld sincos(half3, half3 *); -half4 __ovld sincos(half4, half4 *); -half8 __ovld sincos(half8, half8 *); -half16 __ovld sincos(half16, half16 *); -#endif //cl_khr_fp16 -#endif //defined(__opencl_c_generic_address_space) - -#if defined(__opencl_c_named_address_space_builtins) -float __ovld sincos(float, __global float *); -float2 __ovld sincos(float2, __global float2 *); -float3 __ovld sincos(float3, __global float3 *); -float4 __ovld sincos(float4, __global float4 *); -float8 __ovld sincos(float8, __global float8 *); -float16 __ovld sincos(float16, __global float16 *); -float __ovld sincos(float, __local float *); -float2 __ovld sincos(float2, __local float2 *); -float3 __ovld sincos(float3, __local float3 *); -float4 __ovld sincos(float4, __local float4 *); -float8 __ovld sincos(float8, __local float8 *); -float16 __ovld sincos(float16, __local float16 *); -float __ovld sincos(float, __private float *); -float2 __ovld sincos(float2, __private float2 *); -float3 __ovld sincos(float3, __private float3 *); -float4 __ovld sincos(float4, __private float4 *); -float8 __ovld sincos(float8, __private float8 *); -float16 __ovld sincos(float16, __private float16 *); -#ifdef cl_khr_fp64 -double __ovld sincos(double, __global double *); -double2 __ovld sincos(double2, __global double2 *); -double3 __ovld sincos(double3, __global double3 *); -double4 __ovld sincos(double4, __global double4 *); -double8 __ovld sincos(double8, __global double8 *); -double16 __ovld sincos(double16, __global double16 *); -double __ovld sincos(double, __local double *); -double2 __ovld sincos(double2, __local double2 *); -double3 __ovld sincos(double3, __local double3 *); -double4 __ovld sincos(double4, __local double4 *); -double8 __ovld sincos(double8, __local double8 *); -double16 __ovld sincos(double16, __local double16 *); -double __ovld sincos(double, __private double *); -double2 __ovld sincos(double2, __private double2 *); -double3 __ovld sincos(double3, __private double3 *); -double4 __ovld sincos(double4, __private double4 *); -double8 __ovld sincos(double8, __private double8 *); -double16 __ovld sincos(double16, __private double16 *); -#endif //cl_khr_fp64 -#ifdef cl_khr_fp16 -half __ovld sincos(half, __global half *); -half2 __ovld sincos(half2, __global half2 *); -half3 __ovld sincos(half3, __global half3 *); -half4 __ovld sincos(half4, __global half4 *); -half8 __ovld sincos(half8, __global half8 *); -half16 __ovld sincos(half16, __global half16 *); -half __ovld sincos(half, __local half *); -half2 __ovld sincos(half2, __local half2 *); -half3 __ovld sincos(half3, __local half3 *); -half4 __ovld sincos(half4, __local half4 *); -half8 __ovld sincos(half8, __local half8 *); -half16 __ovld sincos(half16, __local half16 *); -half __ovld sincos(half, __private half *); -half2 __ovld sincos(half2, __private half2 *); -half3 __ovld sincos(half3, __private half3 *); -half4 __ovld sincos(half4, __private half4 *); -half8 __ovld sincos(half8, __private half8 *); -half16 __ovld sincos(half16, __private half16 *); -#endif //cl_khr_fp16 -#endif //defined(__opencl_c_named_address_space_builtins) - -/** - * Compute hyperbolic sine. - */ -float __ovld __cnfn sinh(float); -float2 __ovld __cnfn sinh(float2); -float3 __ovld __cnfn sinh(float3); -float4 __ovld __cnfn sinh(float4); -float8 __ovld __cnfn sinh(float8); -float16 __ovld __cnfn sinh(float16); -#ifdef cl_khr_fp64 -double __ovld __cnfn sinh(double); -double2 __ovld __cnfn sinh(double2); -double3 __ovld __cnfn sinh(double3); -double4 __ovld __cnfn sinh(double4); -double8 __ovld __cnfn sinh(double8); -double16 __ovld __cnfn sinh(double16); -#endif //cl_khr_fp64 -#ifdef cl_khr_fp16 -half __ovld __cnfn sinh(half); -half2 __ovld __cnfn sinh(half2); -half3 __ovld __cnfn sinh(half3); -half4 __ovld __cnfn sinh(half4); -half8 __ovld __cnfn sinh(half8); -half16 __ovld __cnfn sinh(half16); -#endif //cl_khr_fp16 - -/** - * Compute sin (PI * x). - */ -float __ovld __cnfn sinpi(float); -float2 __ovld __cnfn sinpi(float2); -float3 __ovld __cnfn sinpi(float3); -float4 __ovld __cnfn sinpi(float4); -float8 __ovld __cnfn sinpi(float8); -float16 __ovld __cnfn sinpi(float16); -#ifdef cl_khr_fp64 -double __ovld __cnfn sinpi(double); -double2 __ovld __cnfn sinpi(double2); -double3 __ovld __cnfn sinpi(double3); -double4 __ovld __cnfn sinpi(double4); -double8 __ovld __cnfn sinpi(double8); -double16 __ovld __cnfn sinpi(double16); -#endif //cl_khr_fp64 -#ifdef cl_khr_fp16 -half __ovld __cnfn sinpi(half); -half2 __ovld __cnfn sinpi(half2); -half3 __ovld __cnfn sinpi(half3); -half4 __ovld __cnfn sinpi(half4); -half8 __ovld __cnfn sinpi(half8); -half16 __ovld __cnfn sinpi(half16); -#endif //cl_khr_fp16 - -/** - * Compute square root. - */ -float __ovld __cnfn sqrt(float); -float2 __ovld __cnfn sqrt(float2); -float3 __ovld __cnfn sqrt(float3); -float4 __ovld __cnfn sqrt(float4); -float8 __ovld __cnfn sqrt(float8); -float16 __ovld __cnfn sqrt(float16); -#ifdef cl_khr_fp64 -double __ovld __cnfn sqrt(double); -double2 __ovld __cnfn sqrt(double2); -double3 __ovld __cnfn sqrt(double3); -double4 __ovld __cnfn sqrt(double4); -double8 __ovld __cnfn sqrt(double8); -double16 __ovld __cnfn sqrt(double16); -#endif //cl_khr_fp64 -#ifdef cl_khr_fp16 -half __ovld __cnfn sqrt(half); -half2 __ovld __cnfn sqrt(half2); -half3 __ovld __cnfn sqrt(half3); -half4 __ovld __cnfn sqrt(half4); -half8 __ovld __cnfn sqrt(half8); -half16 __ovld __cnfn sqrt(half16); -#endif //cl_khr_fp16 - -/** - * Compute tangent. - */ -float __ovld __cnfn tan(float); -float2 __ovld __cnfn tan(float2); -float3 __ovld __cnfn tan(float3); -float4 __ovld __cnfn tan(float4); -float8 __ovld __cnfn tan(float8); -float16 __ovld __cnfn tan(float16); -#ifdef cl_khr_fp64 -double __ovld __cnfn tan(double); -double2 __ovld __cnfn tan(double2); -double3 __ovld __cnfn tan(double3); -double4 __ovld __cnfn tan(double4); -double8 __ovld __cnfn tan(double8); -double16 __ovld __cnfn tan(double16); -#endif //cl_khr_fp64 -#ifdef cl_khr_fp16 -half __ovld __cnfn tan(half); -half2 __ovld __cnfn tan(half2); -half3 __ovld __cnfn tan(half3); -half4 __ovld __cnfn tan(half4); -half8 __ovld __cnfn tan(half8); -half16 __ovld __cnfn tan(half16); -#endif //cl_khr_fp16 - -/** - * Compute hyperbolic tangent. - */ -float __ovld __cnfn tanh(float); -float2 __ovld __cnfn tanh(float2); -float3 __ovld __cnfn tanh(float3); -float4 __ovld __cnfn tanh(float4); -float8 __ovld __cnfn tanh(float8); -float16 __ovld __cnfn tanh(float16); -#ifdef cl_khr_fp64 -double __ovld __cnfn tanh(double); -double2 __ovld __cnfn tanh(double2); -double3 __ovld __cnfn tanh(double3); -double4 __ovld __cnfn tanh(double4); -double8 __ovld __cnfn tanh(double8); -double16 __ovld __cnfn tanh(double16); -#endif //cl_khr_fp64 -#ifdef cl_khr_fp16 -half __ovld __cnfn tanh(half); -half2 __ovld __cnfn tanh(half2); -half3 __ovld __cnfn tanh(half3); -half4 __ovld __cnfn tanh(half4); -half8 __ovld __cnfn tanh(half8); -half16 __ovld __cnfn tanh(half16); -#endif //cl_khr_fp16 - -/** - * Compute tan (PI * x). - */ -float __ovld __cnfn tanpi(float); -float2 __ovld __cnfn tanpi(float2); -float3 __ovld __cnfn tanpi(float3); -float4 __ovld __cnfn tanpi(float4); -float8 __ovld __cnfn tanpi(float8); -float16 __ovld __cnfn tanpi(float16); -#ifdef cl_khr_fp64 -double __ovld __cnfn tanpi(double); -double2 __ovld __cnfn tanpi(double2); -double3 __ovld __cnfn tanpi(double3); -double4 __ovld __cnfn tanpi(double4); -double8 __ovld __cnfn tanpi(double8); -double16 __ovld __cnfn tanpi(double16); -#endif //cl_khr_fp64 -#ifdef cl_khr_fp16 -half __ovld __cnfn tanpi(half); -half2 __ovld __cnfn tanpi(half2); -half3 __ovld __cnfn tanpi(half3); -half4 __ovld __cnfn tanpi(half4); -half8 __ovld __cnfn tanpi(half8); -half16 __ovld __cnfn tanpi(half16); -#endif //cl_khr_fp16 - -/** - * Compute the gamma function. - */ -float __ovld __cnfn tgamma(float); -float2 __ovld __cnfn tgamma(float2); -float3 __ovld __cnfn tgamma(float3); -float4 __ovld __cnfn tgamma(float4); -float8 __ovld __cnfn tgamma(float8); -float16 __ovld __cnfn tgamma(float16); -#ifdef cl_khr_fp64 -double __ovld __cnfn tgamma(double); -double2 __ovld __cnfn tgamma(double2); -double3 __ovld __cnfn tgamma(double3); -double4 __ovld __cnfn tgamma(double4); -double8 __ovld __cnfn tgamma(double8); -double16 __ovld __cnfn tgamma(double16); -#endif //cl_khr_fp64 -#ifdef cl_khr_fp16 -half __ovld __cnfn tgamma(half); -half2 __ovld __cnfn tgamma(half2); -half3 __ovld __cnfn tgamma(half3); -half4 __ovld __cnfn tgamma(half4); -half8 __ovld __cnfn tgamma(half8); -half16 __ovld __cnfn tgamma(half16); -#endif //cl_khr_fp16 - -/** - * Round to integral value using the round to zero - * rounding mode. - */ -float __ovld __cnfn trunc(float); -float2 __ovld __cnfn trunc(float2); -float3 __ovld __cnfn trunc(float3); -float4 __ovld __cnfn trunc(float4); -float8 __ovld __cnfn trunc(float8); -float16 __ovld __cnfn trunc(float16); -#ifdef cl_khr_fp64 -double __ovld __cnfn trunc(double); -double2 __ovld __cnfn trunc(double2); -double3 __ovld __cnfn trunc(double3); -double4 __ovld __cnfn trunc(double4); -double8 __ovld __cnfn trunc(double8); -double16 __ovld __cnfn trunc(double16); -#endif //cl_khr_fp64 -#ifdef cl_khr_fp16 -half __ovld __cnfn trunc(half); -half2 __ovld __cnfn trunc(half2); -half3 __ovld __cnfn trunc(half3); -half4 __ovld __cnfn trunc(half4); -half8 __ovld __cnfn trunc(half8); -half16 __ovld __cnfn trunc(half16); -#endif //cl_khr_fp16 - -/** - * Compute cosine. x must be in the range -2^16 ... +2^16. - */ -float __ovld __cnfn half_cos(float); -float2 __ovld __cnfn half_cos(float2); -float3 __ovld __cnfn half_cos(float3); -float4 __ovld __cnfn half_cos(float4); -float8 __ovld __cnfn half_cos(float8); -float16 __ovld __cnfn half_cos(float16); - -/** - * Compute x / y. - */ -float __ovld __cnfn half_divide(float, float); -float2 __ovld __cnfn half_divide(float2, float2); -float3 __ovld __cnfn half_divide(float3, float3); -float4 __ovld __cnfn half_divide(float4, float4); -float8 __ovld __cnfn half_divide(float8, float8); -float16 __ovld __cnfn half_divide(float16, float16); - -/** - * Compute the base- e exponential of x. - */ -float __ovld __cnfn half_exp(float); -float2 __ovld __cnfn half_exp(float2); -float3 __ovld __cnfn half_exp(float3); -float4 __ovld __cnfn half_exp(float4); -float8 __ovld __cnfn half_exp(float8); -float16 __ovld __cnfn half_exp(float16); - -/** - * Compute the base- 2 exponential of x. - */ -float __ovld __cnfn half_exp2(float); -float2 __ovld __cnfn half_exp2(float2); -float3 __ovld __cnfn half_exp2(float3); -float4 __ovld __cnfn half_exp2(float4); -float8 __ovld __cnfn half_exp2(float8); -float16 __ovld __cnfn half_exp2(float16); - -/** - * Compute the base- 10 exponential of x. - */ -float __ovld __cnfn half_exp10(float); -float2 __ovld __cnfn half_exp10(float2); -float3 __ovld __cnfn half_exp10(float3); -float4 __ovld __cnfn half_exp10(float4); -float8 __ovld __cnfn half_exp10(float8); -float16 __ovld __cnfn half_exp10(float16); - -/** - * Compute natural logarithm. - */ -float __ovld __cnfn half_log(float); -float2 __ovld __cnfn half_log(float2); -float3 __ovld __cnfn half_log(float3); -float4 __ovld __cnfn half_log(float4); -float8 __ovld __cnfn half_log(float8); -float16 __ovld __cnfn half_log(float16); - -/** - * Compute a base 2 logarithm. - */ -float __ovld __cnfn half_log2(float); -float2 __ovld __cnfn half_log2(float2); -float3 __ovld __cnfn half_log2(float3); -float4 __ovld __cnfn half_log2(float4); -float8 __ovld __cnfn half_log2(float8); -float16 __ovld __cnfn half_log2(float16); - -/** - * Compute a base 10 logarithm. - */ -float __ovld __cnfn half_log10(float); -float2 __ovld __cnfn half_log10(float2); -float3 __ovld __cnfn half_log10(float3); -float4 __ovld __cnfn half_log10(float4); -float8 __ovld __cnfn half_log10(float8); -float16 __ovld __cnfn half_log10(float16); - -/** - * Compute x to the power y, where x is >= 0. - */ -float __ovld __cnfn half_powr(float, float); -float2 __ovld __cnfn half_powr(float2, float2); -float3 __ovld __cnfn half_powr(float3, float3); -float4 __ovld __cnfn half_powr(float4, float4); -float8 __ovld __cnfn half_powr(float8, float8); -float16 __ovld __cnfn half_powr(float16, float16); - -/** - * Compute reciprocal. - */ -float __ovld __cnfn half_recip(float); -float2 __ovld __cnfn half_recip(float2); -float3 __ovld __cnfn half_recip(float3); -float4 __ovld __cnfn half_recip(float4); -float8 __ovld __cnfn half_recip(float8); -float16 __ovld __cnfn half_recip(float16); - -/** - * Compute inverse square root. - */ -float __ovld __cnfn half_rsqrt(float); -float2 __ovld __cnfn half_rsqrt(float2); -float3 __ovld __cnfn half_rsqrt(float3); -float4 __ovld __cnfn half_rsqrt(float4); -float8 __ovld __cnfn half_rsqrt(float8); -float16 __ovld __cnfn half_rsqrt(float16); - -/** - * Compute sine. x must be in the range -2^16 ... +2^16. - */ -float __ovld __cnfn half_sin(float); -float2 __ovld __cnfn half_sin(float2); -float3 __ovld __cnfn half_sin(float3); -float4 __ovld __cnfn half_sin(float4); -float8 __ovld __cnfn half_sin(float8); -float16 __ovld __cnfn half_sin(float16); - -/** - * Compute square root. - */ -float __ovld __cnfn half_sqrt(float); -float2 __ovld __cnfn half_sqrt(float2); -float3 __ovld __cnfn half_sqrt(float3); -float4 __ovld __cnfn half_sqrt(float4); -float8 __ovld __cnfn half_sqrt(float8); -float16 __ovld __cnfn half_sqrt(float16); - -/** - * Compute tangent. x must be in the range -216 ... +216. - */ -float __ovld __cnfn half_tan(float); -float2 __ovld __cnfn half_tan(float2); -float3 __ovld __cnfn half_tan(float3); -float4 __ovld __cnfn half_tan(float4); -float8 __ovld __cnfn half_tan(float8); -float16 __ovld __cnfn half_tan(float16); - -/** - * Compute cosine over an implementation-defined range. - * The maximum error is implementation-defined. - */ -float __ovld __cnfn native_cos(float); -float2 __ovld __cnfn native_cos(float2); -float3 __ovld __cnfn native_cos(float3); -float4 __ovld __cnfn native_cos(float4); -float8 __ovld __cnfn native_cos(float8); -float16 __ovld __cnfn native_cos(float16); - -/** - * Compute x / y over an implementation-defined range. - * The maximum error is implementation-defined. - */ -float __ovld __cnfn native_divide(float, float); -float2 __ovld __cnfn native_divide(float2, float2); -float3 __ovld __cnfn native_divide(float3, float3); -float4 __ovld __cnfn native_divide(float4, float4); -float8 __ovld __cnfn native_divide(float8, float8); -float16 __ovld __cnfn native_divide(float16, float16); - -/** - * Compute the base- e exponential of x over an - * implementation-defined range. The maximum error is - * implementation-defined. - */ -float __ovld __cnfn native_exp(float); -float2 __ovld __cnfn native_exp(float2); -float3 __ovld __cnfn native_exp(float3); -float4 __ovld __cnfn native_exp(float4); -float8 __ovld __cnfn native_exp(float8); -float16 __ovld __cnfn native_exp(float16); - -/** - * Compute the base- 2 exponential of x over an - * implementation-defined range. The maximum error is - * implementation-defined. - */ -float __ovld __cnfn native_exp2(float); -float2 __ovld __cnfn native_exp2(float2); -float3 __ovld __cnfn native_exp2(float3); -float4 __ovld __cnfn native_exp2(float4); -float8 __ovld __cnfn native_exp2(float8); -float16 __ovld __cnfn native_exp2(float16); - -/** - * Compute the base- 10 exponential of x over an - * implementation-defined range. The maximum error is - * implementation-defined. - */ -float __ovld __cnfn native_exp10(float); -float2 __ovld __cnfn native_exp10(float2); -float3 __ovld __cnfn native_exp10(float3); -float4 __ovld __cnfn native_exp10(float4); -float8 __ovld __cnfn native_exp10(float8); -float16 __ovld __cnfn native_exp10(float16); - -/** - * Compute natural logarithm over an implementationdefined - * range. The maximum error is implementation - * defined. - */ -float __ovld __cnfn native_log(float); -float2 __ovld __cnfn native_log(float2); -float3 __ovld __cnfn native_log(float3); -float4 __ovld __cnfn native_log(float4); -float8 __ovld __cnfn native_log(float8); -float16 __ovld __cnfn native_log(float16); - -/** - * Compute a base 2 logarithm over an implementationdefined - * range. The maximum error is implementationdefined. - */ -float __ovld __cnfn native_log2(float); -float2 __ovld __cnfn native_log2(float2); -float3 __ovld __cnfn native_log2(float3); -float4 __ovld __cnfn native_log2(float4); -float8 __ovld __cnfn native_log2(float8); -float16 __ovld __cnfn native_log2(float16); - -/** - * Compute a base 10 logarithm over an implementationdefined - * range. The maximum error is implementationdefined. - */ -float __ovld __cnfn native_log10(float); -float2 __ovld __cnfn native_log10(float2); -float3 __ovld __cnfn native_log10(float3); -float4 __ovld __cnfn native_log10(float4); -float8 __ovld __cnfn native_log10(float8); -float16 __ovld __cnfn native_log10(float16); - -/** - * Compute x to the power y, where x is >= 0. The range of - * x and y are implementation-defined. The maximum error - * is implementation-defined. - */ -float __ovld __cnfn native_powr(float, float); -float2 __ovld __cnfn native_powr(float2, float2); -float3 __ovld __cnfn native_powr(float3, float3); -float4 __ovld __cnfn native_powr(float4, float4); -float8 __ovld __cnfn native_powr(float8, float8); -float16 __ovld __cnfn native_powr(float16, float16); - -/** - * Compute reciprocal over an implementation-defined - * range. The maximum error is implementation-defined. - */ -float __ovld __cnfn native_recip(float); -float2 __ovld __cnfn native_recip(float2); -float3 __ovld __cnfn native_recip(float3); -float4 __ovld __cnfn native_recip(float4); -float8 __ovld __cnfn native_recip(float8); -float16 __ovld __cnfn native_recip(float16); - -/** - * Compute inverse square root over an implementationdefined - * range. The maximum error is implementationdefined. - */ -float __ovld __cnfn native_rsqrt(float); -float2 __ovld __cnfn native_rsqrt(float2); -float3 __ovld __cnfn native_rsqrt(float3); -float4 __ovld __cnfn native_rsqrt(float4); -float8 __ovld __cnfn native_rsqrt(float8); -float16 __ovld __cnfn native_rsqrt(float16); - -/** - * Compute sine over an implementation-defined range. - * The maximum error is implementation-defined. - */ -float __ovld __cnfn native_sin(float); -float2 __ovld __cnfn native_sin(float2); -float3 __ovld __cnfn native_sin(float3); -float4 __ovld __cnfn native_sin(float4); -float8 __ovld __cnfn native_sin(float8); -float16 __ovld __cnfn native_sin(float16); - -/** - * Compute square root over an implementation-defined - * range. The maximum error is implementation-defined. - */ -float __ovld __cnfn native_sqrt(float); -float2 __ovld __cnfn native_sqrt(float2); -float3 __ovld __cnfn native_sqrt(float3); -float4 __ovld __cnfn native_sqrt(float4); -float8 __ovld __cnfn native_sqrt(float8); -float16 __ovld __cnfn native_sqrt(float16); - -/** - * Compute tangent over an implementation-defined range. - * The maximum error is implementation-defined. - */ -float __ovld __cnfn native_tan(float); -float2 __ovld __cnfn native_tan(float2); -float3 __ovld __cnfn native_tan(float3); -float4 __ovld __cnfn native_tan(float4); -float8 __ovld __cnfn native_tan(float8); -float16 __ovld __cnfn native_tan(float16); - -// OpenCL v1.1 s6.11.3, v1.2 s6.12.3, v2.0 s6.13.3 - Integer Functions - -/** - * Returns | x |. - */ -uchar __ovld __cnfn abs(char); -uchar __ovld __cnfn abs(uchar); -uchar2 __ovld __cnfn abs(char2); -uchar2 __ovld __cnfn abs(uchar2); -uchar3 __ovld __cnfn abs(char3); -uchar3 __ovld __cnfn abs(uchar3); -uchar4 __ovld __cnfn abs(char4); -uchar4 __ovld __cnfn abs(uchar4); -uchar8 __ovld __cnfn abs(char8); -uchar8 __ovld __cnfn abs(uchar8); -uchar16 __ovld __cnfn abs(char16); -uchar16 __ovld __cnfn abs(uchar16); -ushort __ovld __cnfn abs(short); -ushort __ovld __cnfn abs(ushort); -ushort2 __ovld __cnfn abs(short2); -ushort2 __ovld __cnfn abs(ushort2); -ushort3 __ovld __cnfn abs(short3); -ushort3 __ovld __cnfn abs(ushort3); -ushort4 __ovld __cnfn abs(short4); -ushort4 __ovld __cnfn abs(ushort4); -ushort8 __ovld __cnfn abs(short8); -ushort8 __ovld __cnfn abs(ushort8); -ushort16 __ovld __cnfn abs(short16); -ushort16 __ovld __cnfn abs(ushort16); -uint __ovld __cnfn abs(int); -uint __ovld __cnfn abs(uint); -uint2 __ovld __cnfn abs(int2); -uint2 __ovld __cnfn abs(uint2); -uint3 __ovld __cnfn abs(int3); -uint3 __ovld __cnfn abs(uint3); -uint4 __ovld __cnfn abs(int4); -uint4 __ovld __cnfn abs(uint4); -uint8 __ovld __cnfn abs(int8); -uint8 __ovld __cnfn abs(uint8); -uint16 __ovld __cnfn abs(int16); -uint16 __ovld __cnfn abs(uint16); -ulong __ovld __cnfn abs(long); -ulong __ovld __cnfn abs(ulong); -ulong2 __ovld __cnfn abs(long2); -ulong2 __ovld __cnfn abs(ulong2); -ulong3 __ovld __cnfn abs(long3); -ulong3 __ovld __cnfn abs(ulong3); -ulong4 __ovld __cnfn abs(long4); -ulong4 __ovld __cnfn abs(ulong4); -ulong8 __ovld __cnfn abs(long8); -ulong8 __ovld __cnfn abs(ulong8); -ulong16 __ovld __cnfn abs(long16); -ulong16 __ovld __cnfn abs(ulong16); - -/** - * Returns | x - y | without modulo overflow. - */ -uchar __ovld __cnfn abs_diff(char, char); -uchar __ovld __cnfn abs_diff(uchar, uchar); -uchar2 __ovld __cnfn abs_diff(char2, char2); -uchar2 __ovld __cnfn abs_diff(uchar2, uchar2); -uchar3 __ovld __cnfn abs_diff(char3, char3); -uchar3 __ovld __cnfn abs_diff(uchar3, uchar3); -uchar4 __ovld __cnfn abs_diff(char4, char4); -uchar4 __ovld __cnfn abs_diff(uchar4, uchar4); -uchar8 __ovld __cnfn abs_diff(char8, char8); -uchar8 __ovld __cnfn abs_diff(uchar8, uchar8); -uchar16 __ovld __cnfn abs_diff(char16, char16); -uchar16 __ovld __cnfn abs_diff(uchar16, uchar16); -ushort __ovld __cnfn abs_diff(short, short); -ushort __ovld __cnfn abs_diff(ushort, ushort); -ushort2 __ovld __cnfn abs_diff(short2, short2); -ushort2 __ovld __cnfn abs_diff(ushort2, ushort2); -ushort3 __ovld __cnfn abs_diff(short3, short3); -ushort3 __ovld __cnfn abs_diff(ushort3, ushort3); -ushort4 __ovld __cnfn abs_diff(short4, short4); -ushort4 __ovld __cnfn abs_diff(ushort4, ushort4); -ushort8 __ovld __cnfn abs_diff(short8, short8); -ushort8 __ovld __cnfn abs_diff(ushort8, ushort8); -ushort16 __ovld __cnfn abs_diff(short16, short16); -ushort16 __ovld __cnfn abs_diff(ushort16, ushort16); -uint __ovld __cnfn abs_diff(int, int); -uint __ovld __cnfn abs_diff(uint, uint); -uint2 __ovld __cnfn abs_diff(int2, int2); -uint2 __ovld __cnfn abs_diff(uint2, uint2); -uint3 __ovld __cnfn abs_diff(int3, int3); -uint3 __ovld __cnfn abs_diff(uint3, uint3); -uint4 __ovld __cnfn abs_diff(int4, int4); -uint4 __ovld __cnfn abs_diff(uint4, uint4); -uint8 __ovld __cnfn abs_diff(int8, int8); -uint8 __ovld __cnfn abs_diff(uint8, uint8); -uint16 __ovld __cnfn abs_diff(int16, int16); -uint16 __ovld __cnfn abs_diff(uint16, uint16); -ulong __ovld __cnfn abs_diff(long, long); -ulong __ovld __cnfn abs_diff(ulong, ulong); -ulong2 __ovld __cnfn abs_diff(long2, long2); -ulong2 __ovld __cnfn abs_diff(ulong2, ulong2); -ulong3 __ovld __cnfn abs_diff(long3, long3); -ulong3 __ovld __cnfn abs_diff(ulong3, ulong3); -ulong4 __ovld __cnfn abs_diff(long4, long4); -ulong4 __ovld __cnfn abs_diff(ulong4, ulong4); -ulong8 __ovld __cnfn abs_diff(long8, long8); -ulong8 __ovld __cnfn abs_diff(ulong8, ulong8); -ulong16 __ovld __cnfn abs_diff(long16, long16); -ulong16 __ovld __cnfn abs_diff(ulong16, ulong16); - -/** - * Returns x + y and saturates the result. - */ -char __ovld __cnfn add_sat(char, char); -uchar __ovld __cnfn add_sat(uchar, uchar); -char2 __ovld __cnfn add_sat(char2, char2); -uchar2 __ovld __cnfn add_sat(uchar2, uchar2); -char3 __ovld __cnfn add_sat(char3, char3); -uchar3 __ovld __cnfn add_sat(uchar3, uchar3); -char4 __ovld __cnfn add_sat(char4, char4); -uchar4 __ovld __cnfn add_sat(uchar4, uchar4); -char8 __ovld __cnfn add_sat(char8, char8); -uchar8 __ovld __cnfn add_sat(uchar8, uchar8); -char16 __ovld __cnfn add_sat(char16, char16); -uchar16 __ovld __cnfn add_sat(uchar16, uchar16); -short __ovld __cnfn add_sat(short, short); -ushort __ovld __cnfn add_sat(ushort, ushort); -short2 __ovld __cnfn add_sat(short2, short2); -ushort2 __ovld __cnfn add_sat(ushort2, ushort2); -short3 __ovld __cnfn add_sat(short3, short3); -ushort3 __ovld __cnfn add_sat(ushort3, ushort3); -short4 __ovld __cnfn add_sat(short4, short4); -ushort4 __ovld __cnfn add_sat(ushort4, ushort4); -short8 __ovld __cnfn add_sat(short8, short8); -ushort8 __ovld __cnfn add_sat(ushort8, ushort8); -short16 __ovld __cnfn add_sat(short16, short16); -ushort16 __ovld __cnfn add_sat(ushort16, ushort16); -int __ovld __cnfn add_sat(int, int); -uint __ovld __cnfn add_sat(uint, uint); -int2 __ovld __cnfn add_sat(int2, int2); -uint2 __ovld __cnfn add_sat(uint2, uint2); -int3 __ovld __cnfn add_sat(int3, int3); -uint3 __ovld __cnfn add_sat(uint3, uint3); -int4 __ovld __cnfn add_sat(int4, int4); -uint4 __ovld __cnfn add_sat(uint4, uint4); -int8 __ovld __cnfn add_sat(int8, int8); -uint8 __ovld __cnfn add_sat(uint8, uint8); -int16 __ovld __cnfn add_sat(int16, int16); -uint16 __ovld __cnfn add_sat(uint16, uint16); -long __ovld __cnfn add_sat(long, long); -ulong __ovld __cnfn add_sat(ulong, ulong); -long2 __ovld __cnfn add_sat(long2, long2); -ulong2 __ovld __cnfn add_sat(ulong2, ulong2); -long3 __ovld __cnfn add_sat(long3, long3); -ulong3 __ovld __cnfn add_sat(ulong3, ulong3); -long4 __ovld __cnfn add_sat(long4, long4); -ulong4 __ovld __cnfn add_sat(ulong4, ulong4); -long8 __ovld __cnfn add_sat(long8, long8); -ulong8 __ovld __cnfn add_sat(ulong8, ulong8); -long16 __ovld __cnfn add_sat(long16, long16); -ulong16 __ovld __cnfn add_sat(ulong16, ulong16); - -/** - * Returns (x + y) >> 1. The intermediate sum does - * not modulo overflow. - */ -char __ovld __cnfn hadd(char, char); -uchar __ovld __cnfn hadd(uchar, uchar); -char2 __ovld __cnfn hadd(char2, char2); -uchar2 __ovld __cnfn hadd(uchar2, uchar2); -char3 __ovld __cnfn hadd(char3, char3); -uchar3 __ovld __cnfn hadd(uchar3, uchar3); -char4 __ovld __cnfn hadd(char4, char4); -uchar4 __ovld __cnfn hadd(uchar4, uchar4); -char8 __ovld __cnfn hadd(char8, char8); -uchar8 __ovld __cnfn hadd(uchar8, uchar8); -char16 __ovld __cnfn hadd(char16, char16); -uchar16 __ovld __cnfn hadd(uchar16, uchar16); -short __ovld __cnfn hadd(short, short); -ushort __ovld __cnfn hadd(ushort, ushort); -short2 __ovld __cnfn hadd(short2, short2); -ushort2 __ovld __cnfn hadd(ushort2, ushort2); -short3 __ovld __cnfn hadd(short3, short3); -ushort3 __ovld __cnfn hadd(ushort3, ushort3); -short4 __ovld __cnfn hadd(short4, short4); -ushort4 __ovld __cnfn hadd(ushort4, ushort4); -short8 __ovld __cnfn hadd(short8, short8); -ushort8 __ovld __cnfn hadd(ushort8, ushort8); -short16 __ovld __cnfn hadd(short16, short16); -ushort16 __ovld __cnfn hadd(ushort16, ushort16); -int __ovld __cnfn hadd(int, int); -uint __ovld __cnfn hadd(uint, uint); -int2 __ovld __cnfn hadd(int2, int2); -uint2 __ovld __cnfn hadd(uint2, uint2); -int3 __ovld __cnfn hadd(int3, int3); -uint3 __ovld __cnfn hadd(uint3, uint3); -int4 __ovld __cnfn hadd(int4, int4); -uint4 __ovld __cnfn hadd(uint4, uint4); -int8 __ovld __cnfn hadd(int8, int8); -uint8 __ovld __cnfn hadd(uint8, uint8); -int16 __ovld __cnfn hadd(int16, int16); -uint16 __ovld __cnfn hadd(uint16, uint16); -long __ovld __cnfn hadd(long, long); -ulong __ovld __cnfn hadd(ulong, ulong); -long2 __ovld __cnfn hadd(long2, long2); -ulong2 __ovld __cnfn hadd(ulong2, ulong2); -long3 __ovld __cnfn hadd(long3, long3); -ulong3 __ovld __cnfn hadd(ulong3, ulong3); -long4 __ovld __cnfn hadd(long4, long4); -ulong4 __ovld __cnfn hadd(ulong4, ulong4); -long8 __ovld __cnfn hadd(long8, long8); -ulong8 __ovld __cnfn hadd(ulong8, ulong8); -long16 __ovld __cnfn hadd(long16, long16); -ulong16 __ovld __cnfn hadd(ulong16, ulong16); - -/** - * Returns (x + y + 1) >> 1. The intermediate sum - * does not modulo overflow. - */ -char __ovld __cnfn rhadd(char, char); -uchar __ovld __cnfn rhadd(uchar, uchar); -char2 __ovld __cnfn rhadd(char2, char2); -uchar2 __ovld __cnfn rhadd(uchar2, uchar2); -char3 __ovld __cnfn rhadd(char3, char3); -uchar3 __ovld __cnfn rhadd(uchar3, uchar3); -char4 __ovld __cnfn rhadd(char4, char4); -uchar4 __ovld __cnfn rhadd(uchar4, uchar4); -char8 __ovld __cnfn rhadd(char8, char8); -uchar8 __ovld __cnfn rhadd(uchar8, uchar8); -char16 __ovld __cnfn rhadd(char16, char16); -uchar16 __ovld __cnfn rhadd(uchar16, uchar16); -short __ovld __cnfn rhadd(short, short); -ushort __ovld __cnfn rhadd(ushort, ushort); -short2 __ovld __cnfn rhadd(short2, short2); -ushort2 __ovld __cnfn rhadd(ushort2, ushort2); -short3 __ovld __cnfn rhadd(short3, short3); -ushort3 __ovld __cnfn rhadd(ushort3, ushort3); -short4 __ovld __cnfn rhadd(short4, short4); -ushort4 __ovld __cnfn rhadd(ushort4, ushort4); -short8 __ovld __cnfn rhadd(short8, short8); -ushort8 __ovld __cnfn rhadd(ushort8, ushort8); -short16 __ovld __cnfn rhadd(short16, short16); -ushort16 __ovld __cnfn rhadd(ushort16, ushort16); -int __ovld __cnfn rhadd(int, int); -uint __ovld __cnfn rhadd(uint, uint); -int2 __ovld __cnfn rhadd(int2, int2); -uint2 __ovld __cnfn rhadd(uint2, uint2); -int3 __ovld __cnfn rhadd(int3, int3); -uint3 __ovld __cnfn rhadd(uint3, uint3); -int4 __ovld __cnfn rhadd(int4, int4); -uint4 __ovld __cnfn rhadd(uint4, uint4); -int8 __ovld __cnfn rhadd(int8, int8); -uint8 __ovld __cnfn rhadd(uint8, uint8); -int16 __ovld __cnfn rhadd(int16, int16); -uint16 __ovld __cnfn rhadd(uint16, uint16); -long __ovld __cnfn rhadd(long, long); -ulong __ovld __cnfn rhadd(ulong, ulong); -long2 __ovld __cnfn rhadd(long2, long2); -ulong2 __ovld __cnfn rhadd(ulong2, ulong2); -long3 __ovld __cnfn rhadd(long3, long3); -ulong3 __ovld __cnfn rhadd(ulong3, ulong3); -long4 __ovld __cnfn rhadd(long4, long4); -ulong4 __ovld __cnfn rhadd(ulong4, ulong4); -long8 __ovld __cnfn rhadd(long8, long8); -ulong8 __ovld __cnfn rhadd(ulong8, ulong8); -long16 __ovld __cnfn rhadd(long16, long16); -ulong16 __ovld __cnfn rhadd(ulong16, ulong16); - -/** - * Returns min(max(x, minval), maxval). - * Results are undefined if minval > maxval. - */ -char __ovld __cnfn clamp(char, char, char); -uchar __ovld __cnfn clamp(uchar, uchar, uchar); -char2 __ovld __cnfn clamp(char2, char2, char2); -uchar2 __ovld __cnfn clamp(uchar2, uchar2, uchar2); -char3 __ovld __cnfn clamp(char3, char3, char3); -uchar3 __ovld __cnfn clamp(uchar3, uchar3, uchar3); -char4 __ovld __cnfn clamp(char4, char4, char4); -uchar4 __ovld __cnfn clamp(uchar4, uchar4, uchar4); -char8 __ovld __cnfn clamp(char8, char8, char8); -uchar8 __ovld __cnfn clamp(uchar8, uchar8, uchar8); -char16 __ovld __cnfn clamp(char16, char16, char16); -uchar16 __ovld __cnfn clamp(uchar16, uchar16, uchar16); -short __ovld __cnfn clamp(short, short, short); -ushort __ovld __cnfn clamp(ushort, ushort, ushort); -short2 __ovld __cnfn clamp(short2, short2, short2); -ushort2 __ovld __cnfn clamp(ushort2, ushort2, ushort2); -short3 __ovld __cnfn clamp(short3, short3, short3); -ushort3 __ovld __cnfn clamp(ushort3, ushort3, ushort3); -short4 __ovld __cnfn clamp(short4, short4, short4); -ushort4 __ovld __cnfn clamp(ushort4, ushort4, ushort4); -short8 __ovld __cnfn clamp(short8, short8, short8); -ushort8 __ovld __cnfn clamp(ushort8, ushort8, ushort8); -short16 __ovld __cnfn clamp(short16, short16, short16); -ushort16 __ovld __cnfn clamp(ushort16, ushort16, ushort16); -int __ovld __cnfn clamp(int, int, int); -uint __ovld __cnfn clamp(uint, uint, uint); -int2 __ovld __cnfn clamp(int2, int2, int2); -uint2 __ovld __cnfn clamp(uint2, uint2, uint2); -int3 __ovld __cnfn clamp(int3, int3, int3); -uint3 __ovld __cnfn clamp(uint3, uint3, uint3); -int4 __ovld __cnfn clamp(int4, int4, int4); -uint4 __ovld __cnfn clamp(uint4, uint4, uint4); -int8 __ovld __cnfn clamp(int8, int8, int8); -uint8 __ovld __cnfn clamp(uint8, uint8, uint8); -int16 __ovld __cnfn clamp(int16, int16, int16); -uint16 __ovld __cnfn clamp(uint16, uint16, uint16); -long __ovld __cnfn clamp(long, long, long); -ulong __ovld __cnfn clamp(ulong, ulong, ulong); -long2 __ovld __cnfn clamp(long2, long2, long2); -ulong2 __ovld __cnfn clamp(ulong2, ulong2, ulong2); -long3 __ovld __cnfn clamp(long3, long3, long3); -ulong3 __ovld __cnfn clamp(ulong3, ulong3, ulong3); -long4 __ovld __cnfn clamp(long4, long4, long4); -ulong4 __ovld __cnfn clamp(ulong4, ulong4, ulong4); -long8 __ovld __cnfn clamp(long8, long8, long8); -ulong8 __ovld __cnfn clamp(ulong8, ulong8, ulong8); -long16 __ovld __cnfn clamp(long16, long16, long16); -ulong16 __ovld __cnfn clamp(ulong16, ulong16, ulong16); -char2 __ovld __cnfn clamp(char2, char, char); -uchar2 __ovld __cnfn clamp(uchar2, uchar, uchar); -char3 __ovld __cnfn clamp(char3, char, char); -uchar3 __ovld __cnfn clamp(uchar3, uchar, uchar); -char4 __ovld __cnfn clamp(char4, char, char); -uchar4 __ovld __cnfn clamp(uchar4, uchar, uchar); -char8 __ovld __cnfn clamp(char8, char, char); -uchar8 __ovld __cnfn clamp(uchar8, uchar, uchar); -char16 __ovld __cnfn clamp(char16, char, char); -uchar16 __ovld __cnfn clamp(uchar16, uchar, uchar); -short2 __ovld __cnfn clamp(short2, short, short); -ushort2 __ovld __cnfn clamp(ushort2, ushort, ushort); -short3 __ovld __cnfn clamp(short3, short, short); -ushort3 __ovld __cnfn clamp(ushort3, ushort, ushort); -short4 __ovld __cnfn clamp(short4, short, short); -ushort4 __ovld __cnfn clamp(ushort4, ushort, ushort); -short8 __ovld __cnfn clamp(short8, short, short); -ushort8 __ovld __cnfn clamp(ushort8, ushort, ushort); -short16 __ovld __cnfn clamp(short16, short, short); -ushort16 __ovld __cnfn clamp(ushort16, ushort, ushort); -int2 __ovld __cnfn clamp(int2, int, int); -uint2 __ovld __cnfn clamp(uint2, uint, uint); -int3 __ovld __cnfn clamp(int3, int, int); -uint3 __ovld __cnfn clamp(uint3, uint, uint); -int4 __ovld __cnfn clamp(int4, int, int); -uint4 __ovld __cnfn clamp(uint4, uint, uint); -int8 __ovld __cnfn clamp(int8, int, int); -uint8 __ovld __cnfn clamp(uint8, uint, uint); -int16 __ovld __cnfn clamp(int16, int, int); -uint16 __ovld __cnfn clamp(uint16, uint, uint); -long2 __ovld __cnfn clamp(long2, long, long); -ulong2 __ovld __cnfn clamp(ulong2, ulong, ulong); -long3 __ovld __cnfn clamp(long3, long, long); -ulong3 __ovld __cnfn clamp(ulong3, ulong, ulong); -long4 __ovld __cnfn clamp(long4, long, long); -ulong4 __ovld __cnfn clamp(ulong4, ulong, ulong); -long8 __ovld __cnfn clamp(long8, long, long); -ulong8 __ovld __cnfn clamp(ulong8, ulong, ulong); -long16 __ovld __cnfn clamp(long16, long, long); -ulong16 __ovld __cnfn clamp(ulong16, ulong, ulong); - -/** - * Returns the number of leading 0-bits in x, starting - * at the most significant bit position. - */ -char __ovld __cnfn clz(char); -uchar __ovld __cnfn clz(uchar); -char2 __ovld __cnfn clz(char2); -uchar2 __ovld __cnfn clz(uchar2); -char3 __ovld __cnfn clz(char3); -uchar3 __ovld __cnfn clz(uchar3); -char4 __ovld __cnfn clz(char4); -uchar4 __ovld __cnfn clz(uchar4); -char8 __ovld __cnfn clz(char8); -uchar8 __ovld __cnfn clz(uchar8); -char16 __ovld __cnfn clz(char16); -uchar16 __ovld __cnfn clz(uchar16); -short __ovld __cnfn clz(short); -ushort __ovld __cnfn clz(ushort); -short2 __ovld __cnfn clz(short2); -ushort2 __ovld __cnfn clz(ushort2); -short3 __ovld __cnfn clz(short3); -ushort3 __ovld __cnfn clz(ushort3); -short4 __ovld __cnfn clz(short4); -ushort4 __ovld __cnfn clz(ushort4); -short8 __ovld __cnfn clz(short8); -ushort8 __ovld __cnfn clz(ushort8); -short16 __ovld __cnfn clz(short16); -ushort16 __ovld __cnfn clz(ushort16); -int __ovld __cnfn clz(int); -uint __ovld __cnfn clz(uint); -int2 __ovld __cnfn clz(int2); -uint2 __ovld __cnfn clz(uint2); -int3 __ovld __cnfn clz(int3); -uint3 __ovld __cnfn clz(uint3); -int4 __ovld __cnfn clz(int4); -uint4 __ovld __cnfn clz(uint4); -int8 __ovld __cnfn clz(int8); -uint8 __ovld __cnfn clz(uint8); -int16 __ovld __cnfn clz(int16); -uint16 __ovld __cnfn clz(uint16); -long __ovld __cnfn clz(long); -ulong __ovld __cnfn clz(ulong); -long2 __ovld __cnfn clz(long2); -ulong2 __ovld __cnfn clz(ulong2); -long3 __ovld __cnfn clz(long3); -ulong3 __ovld __cnfn clz(ulong3); -long4 __ovld __cnfn clz(long4); -ulong4 __ovld __cnfn clz(ulong4); -long8 __ovld __cnfn clz(long8); -ulong8 __ovld __cnfn clz(ulong8); -long16 __ovld __cnfn clz(long16); -ulong16 __ovld __cnfn clz(ulong16); - -/** - * Returns the count of trailing 0-bits in x. If x is 0, - * returns the size in bits of the type of x or - * component type of x, if x is a vector. - */ -#if defined(__OPENCL_CPP_VERSION__) || (__OPENCL_C_VERSION__ >= CL_VERSION_2_0) -char __ovld __cnfn ctz(char); -uchar __ovld __cnfn ctz(uchar); -char2 __ovld __cnfn ctz(char2); -uchar2 __ovld __cnfn ctz(uchar2); -char3 __ovld __cnfn ctz(char3); -uchar3 __ovld __cnfn ctz(uchar3); -char4 __ovld __cnfn ctz(char4); -uchar4 __ovld __cnfn ctz(uchar4); -char8 __ovld __cnfn ctz(char8); -uchar8 __ovld __cnfn ctz(uchar8); -char16 __ovld __cnfn ctz(char16); -uchar16 __ovld __cnfn ctz(uchar16); -short __ovld __cnfn ctz(short); -ushort __ovld __cnfn ctz(ushort); -short2 __ovld __cnfn ctz(short2); -ushort2 __ovld __cnfn ctz(ushort2); -short3 __ovld __cnfn ctz(short3); -ushort3 __ovld __cnfn ctz(ushort3); -short4 __ovld __cnfn ctz(short4); -ushort4 __ovld __cnfn ctz(ushort4); -short8 __ovld __cnfn ctz(short8); -ushort8 __ovld __cnfn ctz(ushort8); -short16 __ovld __cnfn ctz(short16); -ushort16 __ovld __cnfn ctz(ushort16); -int __ovld __cnfn ctz(int); -uint __ovld __cnfn ctz(uint); -int2 __ovld __cnfn ctz(int2); -uint2 __ovld __cnfn ctz(uint2); -int3 __ovld __cnfn ctz(int3); -uint3 __ovld __cnfn ctz(uint3); -int4 __ovld __cnfn ctz(int4); -uint4 __ovld __cnfn ctz(uint4); -int8 __ovld __cnfn ctz(int8); -uint8 __ovld __cnfn ctz(uint8); -int16 __ovld __cnfn ctz(int16); -uint16 __ovld __cnfn ctz(uint16); -long __ovld __cnfn ctz(long); -ulong __ovld __cnfn ctz(ulong); -long2 __ovld __cnfn ctz(long2); -ulong2 __ovld __cnfn ctz(ulong2); -long3 __ovld __cnfn ctz(long3); -ulong3 __ovld __cnfn ctz(ulong3); -long4 __ovld __cnfn ctz(long4); -ulong4 __ovld __cnfn ctz(ulong4); -long8 __ovld __cnfn ctz(long8); -ulong8 __ovld __cnfn ctz(ulong8); -long16 __ovld __cnfn ctz(long16); -ulong16 __ovld __cnfn ctz(ulong16); -#endif //defined(__OPENCL_CPP_VERSION__) || (__OPENCL_C_VERSION__ >= CL_VERSION_2_0) - -/** - * Returns mul_hi(a, b) + c. - */ -char __ovld __cnfn mad_hi(char, char, char); -uchar __ovld __cnfn mad_hi(uchar, uchar, uchar); -char2 __ovld __cnfn mad_hi(char2, char2, char2); -uchar2 __ovld __cnfn mad_hi(uchar2, uchar2, uchar2); -char3 __ovld __cnfn mad_hi(char3, char3, char3); -uchar3 __ovld __cnfn mad_hi(uchar3, uchar3, uchar3); -char4 __ovld __cnfn mad_hi(char4, char4, char4); -uchar4 __ovld __cnfn mad_hi(uchar4, uchar4, uchar4); -char8 __ovld __cnfn mad_hi(char8, char8, char8); -uchar8 __ovld __cnfn mad_hi(uchar8, uchar8, uchar8); -char16 __ovld __cnfn mad_hi(char16, char16, char16); -uchar16 __ovld __cnfn mad_hi(uchar16, uchar16, uchar16); -short __ovld __cnfn mad_hi(short, short, short); -ushort __ovld __cnfn mad_hi(ushort, ushort, ushort); -short2 __ovld __cnfn mad_hi(short2, short2, short2); -ushort2 __ovld __cnfn mad_hi(ushort2, ushort2, ushort2); -short3 __ovld __cnfn mad_hi(short3, short3, short3); -ushort3 __ovld __cnfn mad_hi(ushort3, ushort3, ushort3); -short4 __ovld __cnfn mad_hi(short4, short4, short4); -ushort4 __ovld __cnfn mad_hi(ushort4, ushort4, ushort4); -short8 __ovld __cnfn mad_hi(short8, short8, short8); -ushort8 __ovld __cnfn mad_hi(ushort8, ushort8, ushort8); -short16 __ovld __cnfn mad_hi(short16, short16, short16); -ushort16 __ovld __cnfn mad_hi(ushort16, ushort16, ushort16); -int __ovld __cnfn mad_hi(int, int, int); -uint __ovld __cnfn mad_hi(uint, uint, uint); -int2 __ovld __cnfn mad_hi(int2, int2, int2); -uint2 __ovld __cnfn mad_hi(uint2, uint2, uint2); -int3 __ovld __cnfn mad_hi(int3, int3, int3); -uint3 __ovld __cnfn mad_hi(uint3, uint3, uint3); -int4 __ovld __cnfn mad_hi(int4, int4, int4); -uint4 __ovld __cnfn mad_hi(uint4, uint4, uint4); -int8 __ovld __cnfn mad_hi(int8, int8, int8); -uint8 __ovld __cnfn mad_hi(uint8, uint8, uint8); -int16 __ovld __cnfn mad_hi(int16, int16, int16); -uint16 __ovld __cnfn mad_hi(uint16, uint16, uint16); -long __ovld __cnfn mad_hi(long, long, long); -ulong __ovld __cnfn mad_hi(ulong, ulong, ulong); -long2 __ovld __cnfn mad_hi(long2, long2, long2); -ulong2 __ovld __cnfn mad_hi(ulong2, ulong2, ulong2); -long3 __ovld __cnfn mad_hi(long3, long3, long3); -ulong3 __ovld __cnfn mad_hi(ulong3, ulong3, ulong3); -long4 __ovld __cnfn mad_hi(long4, long4, long4); -ulong4 __ovld __cnfn mad_hi(ulong4, ulong4, ulong4); -long8 __ovld __cnfn mad_hi(long8, long8, long8); -ulong8 __ovld __cnfn mad_hi(ulong8, ulong8, ulong8); -long16 __ovld __cnfn mad_hi(long16, long16, long16); -ulong16 __ovld __cnfn mad_hi(ulong16, ulong16, ulong16); - -/** - * Returns a * b + c and saturates the result. - */ -char __ovld __cnfn mad_sat(char, char, char); -uchar __ovld __cnfn mad_sat(uchar, uchar, uchar); -char2 __ovld __cnfn mad_sat(char2, char2, char2); -uchar2 __ovld __cnfn mad_sat(uchar2, uchar2, uchar2); -char3 __ovld __cnfn mad_sat(char3, char3, char3); -uchar3 __ovld __cnfn mad_sat(uchar3, uchar3, uchar3); -char4 __ovld __cnfn mad_sat(char4, char4, char4); -uchar4 __ovld __cnfn mad_sat(uchar4, uchar4, uchar4); -char8 __ovld __cnfn mad_sat(char8, char8, char8); -uchar8 __ovld __cnfn mad_sat(uchar8, uchar8, uchar8); -char16 __ovld __cnfn mad_sat(char16, char16, char16); -uchar16 __ovld __cnfn mad_sat(uchar16, uchar16, uchar16); -short __ovld __cnfn mad_sat(short, short, short); -ushort __ovld __cnfn mad_sat(ushort, ushort, ushort); -short2 __ovld __cnfn mad_sat(short2, short2, short2); -ushort2 __ovld __cnfn mad_sat(ushort2, ushort2, ushort2); -short3 __ovld __cnfn mad_sat(short3, short3, short3); -ushort3 __ovld __cnfn mad_sat(ushort3, ushort3, ushort3); -short4 __ovld __cnfn mad_sat(short4, short4, short4); -ushort4 __ovld __cnfn mad_sat(ushort4, ushort4, ushort4); -short8 __ovld __cnfn mad_sat(short8, short8, short8); -ushort8 __ovld __cnfn mad_sat(ushort8, ushort8, ushort8); -short16 __ovld __cnfn mad_sat(short16, short16, short16); -ushort16 __ovld __cnfn mad_sat(ushort16, ushort16, ushort16); -int __ovld __cnfn mad_sat(int, int, int); -uint __ovld __cnfn mad_sat(uint, uint, uint); -int2 __ovld __cnfn mad_sat(int2, int2, int2); -uint2 __ovld __cnfn mad_sat(uint2, uint2, uint2); -int3 __ovld __cnfn mad_sat(int3, int3, int3); -uint3 __ovld __cnfn mad_sat(uint3, uint3, uint3); -int4 __ovld __cnfn mad_sat(int4, int4, int4); -uint4 __ovld __cnfn mad_sat(uint4, uint4, uint4); -int8 __ovld __cnfn mad_sat(int8, int8, int8); -uint8 __ovld __cnfn mad_sat(uint8, uint8, uint8); -int16 __ovld __cnfn mad_sat(int16, int16, int16); -uint16 __ovld __cnfn mad_sat(uint16, uint16, uint16); -long __ovld __cnfn mad_sat(long, long, long); -ulong __ovld __cnfn mad_sat(ulong, ulong, ulong); -long2 __ovld __cnfn mad_sat(long2, long2, long2); -ulong2 __ovld __cnfn mad_sat(ulong2, ulong2, ulong2); -long3 __ovld __cnfn mad_sat(long3, long3, long3); -ulong3 __ovld __cnfn mad_sat(ulong3, ulong3, ulong3); -long4 __ovld __cnfn mad_sat(long4, long4, long4); -ulong4 __ovld __cnfn mad_sat(ulong4, ulong4, ulong4); -long8 __ovld __cnfn mad_sat(long8, long8, long8); -ulong8 __ovld __cnfn mad_sat(ulong8, ulong8, ulong8); -long16 __ovld __cnfn mad_sat(long16, long16, long16); -ulong16 __ovld __cnfn mad_sat(ulong16, ulong16, ulong16); - -/** - * Returns y if x < y, otherwise it returns x. - */ -char __ovld __cnfn max(char, char); -uchar __ovld __cnfn max(uchar, uchar); -char2 __ovld __cnfn max(char2, char2); -uchar2 __ovld __cnfn max(uchar2, uchar2); -char3 __ovld __cnfn max(char3, char3); -uchar3 __ovld __cnfn max(uchar3, uchar3); -char4 __ovld __cnfn max(char4, char4); -uchar4 __ovld __cnfn max(uchar4, uchar4); -char8 __ovld __cnfn max(char8, char8); -uchar8 __ovld __cnfn max(uchar8, uchar8); -char16 __ovld __cnfn max(char16, char16); -uchar16 __ovld __cnfn max(uchar16, uchar16); -short __ovld __cnfn max(short, short); -ushort __ovld __cnfn max(ushort, ushort); -short2 __ovld __cnfn max(short2, short2); -ushort2 __ovld __cnfn max(ushort2, ushort2); -short3 __ovld __cnfn max(short3, short3); -ushort3 __ovld __cnfn max(ushort3, ushort3); -short4 __ovld __cnfn max(short4, short4); -ushort4 __ovld __cnfn max(ushort4, ushort4); -short8 __ovld __cnfn max(short8, short8); -ushort8 __ovld __cnfn max(ushort8, ushort8); -short16 __ovld __cnfn max(short16, short16); -ushort16 __ovld __cnfn max(ushort16, ushort16); -int __ovld __cnfn max(int, int); -uint __ovld __cnfn max(uint, uint); -int2 __ovld __cnfn max(int2, int2); -uint2 __ovld __cnfn max(uint2, uint2); -int3 __ovld __cnfn max(int3, int3); -uint3 __ovld __cnfn max(uint3, uint3); -int4 __ovld __cnfn max(int4, int4); -uint4 __ovld __cnfn max(uint4, uint4); -int8 __ovld __cnfn max(int8, int8); -uint8 __ovld __cnfn max(uint8, uint8); -int16 __ovld __cnfn max(int16, int16); -uint16 __ovld __cnfn max(uint16, uint16); -long __ovld __cnfn max(long, long); -ulong __ovld __cnfn max(ulong, ulong); -long2 __ovld __cnfn max(long2, long2); -ulong2 __ovld __cnfn max(ulong2, ulong2); -long3 __ovld __cnfn max(long3, long3); -ulong3 __ovld __cnfn max(ulong3, ulong3); -long4 __ovld __cnfn max(long4, long4); -ulong4 __ovld __cnfn max(ulong4, ulong4); -long8 __ovld __cnfn max(long8, long8); -ulong8 __ovld __cnfn max(ulong8, ulong8); -long16 __ovld __cnfn max(long16, long16); -ulong16 __ovld __cnfn max(ulong16, ulong16); -char2 __ovld __cnfn max(char2, char); -uchar2 __ovld __cnfn max(uchar2, uchar); -char3 __ovld __cnfn max(char3, char); -uchar3 __ovld __cnfn max(uchar3, uchar); -char4 __ovld __cnfn max(char4, char); -uchar4 __ovld __cnfn max(uchar4, uchar); -char8 __ovld __cnfn max(char8, char); -uchar8 __ovld __cnfn max(uchar8, uchar); -char16 __ovld __cnfn max(char16, char); -uchar16 __ovld __cnfn max(uchar16, uchar); -short2 __ovld __cnfn max(short2, short); -ushort2 __ovld __cnfn max(ushort2, ushort); -short3 __ovld __cnfn max(short3, short); -ushort3 __ovld __cnfn max(ushort3, ushort); -short4 __ovld __cnfn max(short4, short); -ushort4 __ovld __cnfn max(ushort4, ushort); -short8 __ovld __cnfn max(short8, short); -ushort8 __ovld __cnfn max(ushort8, ushort); -short16 __ovld __cnfn max(short16, short); -ushort16 __ovld __cnfn max(ushort16, ushort); -int2 __ovld __cnfn max(int2, int); -uint2 __ovld __cnfn max(uint2, uint); -int3 __ovld __cnfn max(int3, int); -uint3 __ovld __cnfn max(uint3, uint); -int4 __ovld __cnfn max(int4, int); -uint4 __ovld __cnfn max(uint4, uint); -int8 __ovld __cnfn max(int8, int); -uint8 __ovld __cnfn max(uint8, uint); -int16 __ovld __cnfn max(int16, int); -uint16 __ovld __cnfn max(uint16, uint); -long2 __ovld __cnfn max(long2, long); -ulong2 __ovld __cnfn max(ulong2, ulong); -long3 __ovld __cnfn max(long3, long); -ulong3 __ovld __cnfn max(ulong3, ulong); -long4 __ovld __cnfn max(long4, long); -ulong4 __ovld __cnfn max(ulong4, ulong); -long8 __ovld __cnfn max(long8, long); -ulong8 __ovld __cnfn max(ulong8, ulong); -long16 __ovld __cnfn max(long16, long); -ulong16 __ovld __cnfn max(ulong16, ulong); - -/** - * Returns y if y < x, otherwise it returns x. - */ -char __ovld __cnfn min(char, char); -uchar __ovld __cnfn min(uchar, uchar); -char2 __ovld __cnfn min(char2, char2); -uchar2 __ovld __cnfn min(uchar2, uchar2); -char3 __ovld __cnfn min(char3, char3); -uchar3 __ovld __cnfn min(uchar3, uchar3); -char4 __ovld __cnfn min(char4, char4); -uchar4 __ovld __cnfn min(uchar4, uchar4); -char8 __ovld __cnfn min(char8, char8); -uchar8 __ovld __cnfn min(uchar8, uchar8); -char16 __ovld __cnfn min(char16, char16); -uchar16 __ovld __cnfn min(uchar16, uchar16); -short __ovld __cnfn min(short, short); -ushort __ovld __cnfn min(ushort, ushort); -short2 __ovld __cnfn min(short2, short2); -ushort2 __ovld __cnfn min(ushort2, ushort2); -short3 __ovld __cnfn min(short3, short3); -ushort3 __ovld __cnfn min(ushort3, ushort3); -short4 __ovld __cnfn min(short4, short4); -ushort4 __ovld __cnfn min(ushort4, ushort4); -short8 __ovld __cnfn min(short8, short8); -ushort8 __ovld __cnfn min(ushort8, ushort8); -short16 __ovld __cnfn min(short16, short16); -ushort16 __ovld __cnfn min(ushort16, ushort16); -int __ovld __cnfn min(int, int); -uint __ovld __cnfn min(uint, uint); -int2 __ovld __cnfn min(int2, int2); -uint2 __ovld __cnfn min(uint2, uint2); -int3 __ovld __cnfn min(int3, int3); -uint3 __ovld __cnfn min(uint3, uint3); -int4 __ovld __cnfn min(int4, int4); -uint4 __ovld __cnfn min(uint4, uint4); -int8 __ovld __cnfn min(int8, int8); -uint8 __ovld __cnfn min(uint8, uint8); -int16 __ovld __cnfn min(int16, int16); -uint16 __ovld __cnfn min(uint16, uint16); -long __ovld __cnfn min(long, long); -ulong __ovld __cnfn min(ulong, ulong); -long2 __ovld __cnfn min(long2, long2); -ulong2 __ovld __cnfn min(ulong2, ulong2); -long3 __ovld __cnfn min(long3, long3); -ulong3 __ovld __cnfn min(ulong3, ulong3); -long4 __ovld __cnfn min(long4, long4); -ulong4 __ovld __cnfn min(ulong4, ulong4); -long8 __ovld __cnfn min(long8, long8); -ulong8 __ovld __cnfn min(ulong8, ulong8); -long16 __ovld __cnfn min(long16, long16); -ulong16 __ovld __cnfn min(ulong16, ulong16); -char2 __ovld __cnfn min(char2, char); -uchar2 __ovld __cnfn min(uchar2, uchar); -char3 __ovld __cnfn min(char3, char); -uchar3 __ovld __cnfn min(uchar3, uchar); -char4 __ovld __cnfn min(char4, char); -uchar4 __ovld __cnfn min(uchar4, uchar); -char8 __ovld __cnfn min(char8, char); -uchar8 __ovld __cnfn min(uchar8, uchar); -char16 __ovld __cnfn min(char16, char); -uchar16 __ovld __cnfn min(uchar16, uchar); -short2 __ovld __cnfn min(short2, short); -ushort2 __ovld __cnfn min(ushort2, ushort); -short3 __ovld __cnfn min(short3, short); -ushort3 __ovld __cnfn min(ushort3, ushort); -short4 __ovld __cnfn min(short4, short); -ushort4 __ovld __cnfn min(ushort4, ushort); -short8 __ovld __cnfn min(short8, short); -ushort8 __ovld __cnfn min(ushort8, ushort); -short16 __ovld __cnfn min(short16, short); -ushort16 __ovld __cnfn min(ushort16, ushort); -int2 __ovld __cnfn min(int2, int); -uint2 __ovld __cnfn min(uint2, uint); -int3 __ovld __cnfn min(int3, int); -uint3 __ovld __cnfn min(uint3, uint); -int4 __ovld __cnfn min(int4, int); -uint4 __ovld __cnfn min(uint4, uint); -int8 __ovld __cnfn min(int8, int); -uint8 __ovld __cnfn min(uint8, uint); -int16 __ovld __cnfn min(int16, int); -uint16 __ovld __cnfn min(uint16, uint); -long2 __ovld __cnfn min(long2, long); -ulong2 __ovld __cnfn min(ulong2, ulong); -long3 __ovld __cnfn min(long3, long); -ulong3 __ovld __cnfn min(ulong3, ulong); -long4 __ovld __cnfn min(long4, long); -ulong4 __ovld __cnfn min(ulong4, ulong); -long8 __ovld __cnfn min(long8, long); -ulong8 __ovld __cnfn min(ulong8, ulong); -long16 __ovld __cnfn min(long16, long); -ulong16 __ovld __cnfn min(ulong16, ulong); - -/** - * Computes x * y and returns the high half of the - * product of x and y. - */ -char __ovld __cnfn mul_hi(char, char); -uchar __ovld __cnfn mul_hi(uchar, uchar); -char2 __ovld __cnfn mul_hi(char2, char2); -uchar2 __ovld __cnfn mul_hi(uchar2, uchar2); -char3 __ovld __cnfn mul_hi(char3, char3); -uchar3 __ovld __cnfn mul_hi(uchar3, uchar3); -char4 __ovld __cnfn mul_hi(char4, char4); -uchar4 __ovld __cnfn mul_hi(uchar4, uchar4); -char8 __ovld __cnfn mul_hi(char8, char8); -uchar8 __ovld __cnfn mul_hi(uchar8, uchar8); -char16 __ovld __cnfn mul_hi(char16, char16); -uchar16 __ovld __cnfn mul_hi(uchar16, uchar16); -short __ovld __cnfn mul_hi(short, short); -ushort __ovld __cnfn mul_hi(ushort, ushort); -short2 __ovld __cnfn mul_hi(short2, short2); -ushort2 __ovld __cnfn mul_hi(ushort2, ushort2); -short3 __ovld __cnfn mul_hi(short3, short3); -ushort3 __ovld __cnfn mul_hi(ushort3, ushort3); -short4 __ovld __cnfn mul_hi(short4, short4); -ushort4 __ovld __cnfn mul_hi(ushort4, ushort4); -short8 __ovld __cnfn mul_hi(short8, short8); -ushort8 __ovld __cnfn mul_hi(ushort8, ushort8); -short16 __ovld __cnfn mul_hi(short16, short16); -ushort16 __ovld __cnfn mul_hi(ushort16, ushort16); -int __ovld __cnfn mul_hi(int, int); -uint __ovld __cnfn mul_hi(uint, uint); -int2 __ovld __cnfn mul_hi(int2, int2); -uint2 __ovld __cnfn mul_hi(uint2, uint2); -int3 __ovld __cnfn mul_hi(int3, int3); -uint3 __ovld __cnfn mul_hi(uint3, uint3); -int4 __ovld __cnfn mul_hi(int4, int4); -uint4 __ovld __cnfn mul_hi(uint4, uint4); -int8 __ovld __cnfn mul_hi(int8, int8); -uint8 __ovld __cnfn mul_hi(uint8, uint8); -int16 __ovld __cnfn mul_hi(int16, int16); -uint16 __ovld __cnfn mul_hi(uint16, uint16); -long __ovld __cnfn mul_hi(long, long); -ulong __ovld __cnfn mul_hi(ulong, ulong); -long2 __ovld __cnfn mul_hi(long2, long2); -ulong2 __ovld __cnfn mul_hi(ulong2, ulong2); -long3 __ovld __cnfn mul_hi(long3, long3); -ulong3 __ovld __cnfn mul_hi(ulong3, ulong3); -long4 __ovld __cnfn mul_hi(long4, long4); -ulong4 __ovld __cnfn mul_hi(ulong4, ulong4); -long8 __ovld __cnfn mul_hi(long8, long8); -ulong8 __ovld __cnfn mul_hi(ulong8, ulong8); -long16 __ovld __cnfn mul_hi(long16, long16); -ulong16 __ovld __cnfn mul_hi(ulong16, ulong16); - -/** - * For each element in v, the bits are shifted left by - * the number of bits given by the corresponding - * element in i (subject to usual shift modulo rules - * described in section 6.3). Bits shifted off the left - * side of the element are shifted back in from the - * right. - */ -char __ovld __cnfn rotate(char, char); -uchar __ovld __cnfn rotate(uchar, uchar); -char2 __ovld __cnfn rotate(char2, char2); -uchar2 __ovld __cnfn rotate(uchar2, uchar2); -char3 __ovld __cnfn rotate(char3, char3); -uchar3 __ovld __cnfn rotate(uchar3, uchar3); -char4 __ovld __cnfn rotate(char4, char4); -uchar4 __ovld __cnfn rotate(uchar4, uchar4); -char8 __ovld __cnfn rotate(char8, char8); -uchar8 __ovld __cnfn rotate(uchar8, uchar8); -char16 __ovld __cnfn rotate(char16, char16); -uchar16 __ovld __cnfn rotate(uchar16, uchar16); -short __ovld __cnfn rotate(short, short); -ushort __ovld __cnfn rotate(ushort, ushort); -short2 __ovld __cnfn rotate(short2, short2); -ushort2 __ovld __cnfn rotate(ushort2, ushort2); -short3 __ovld __cnfn rotate(short3, short3); -ushort3 __ovld __cnfn rotate(ushort3, ushort3); -short4 __ovld __cnfn rotate(short4, short4); -ushort4 __ovld __cnfn rotate(ushort4, ushort4); -short8 __ovld __cnfn rotate(short8, short8); -ushort8 __ovld __cnfn rotate(ushort8, ushort8); -short16 __ovld __cnfn rotate(short16, short16); -ushort16 __ovld __cnfn rotate(ushort16, ushort16); -int __ovld __cnfn rotate(int, int); -uint __ovld __cnfn rotate(uint, uint); -int2 __ovld __cnfn rotate(int2, int2); -uint2 __ovld __cnfn rotate(uint2, uint2); -int3 __ovld __cnfn rotate(int3, int3); -uint3 __ovld __cnfn rotate(uint3, uint3); -int4 __ovld __cnfn rotate(int4, int4); -uint4 __ovld __cnfn rotate(uint4, uint4); -int8 __ovld __cnfn rotate(int8, int8); -uint8 __ovld __cnfn rotate(uint8, uint8); -int16 __ovld __cnfn rotate(int16, int16); -uint16 __ovld __cnfn rotate(uint16, uint16); -long __ovld __cnfn rotate(long, long); -ulong __ovld __cnfn rotate(ulong, ulong); -long2 __ovld __cnfn rotate(long2, long2); -ulong2 __ovld __cnfn rotate(ulong2, ulong2); -long3 __ovld __cnfn rotate(long3, long3); -ulong3 __ovld __cnfn rotate(ulong3, ulong3); -long4 __ovld __cnfn rotate(long4, long4); -ulong4 __ovld __cnfn rotate(ulong4, ulong4); -long8 __ovld __cnfn rotate(long8, long8); -ulong8 __ovld __cnfn rotate(ulong8, ulong8); -long16 __ovld __cnfn rotate(long16, long16); -ulong16 __ovld __cnfn rotate(ulong16, ulong16); - -/** - * Returns x - y and saturates the result. - */ -char __ovld __cnfn sub_sat(char, char); -uchar __ovld __cnfn sub_sat(uchar, uchar); -char2 __ovld __cnfn sub_sat(char2, char2); -uchar2 __ovld __cnfn sub_sat(uchar2, uchar2); -char3 __ovld __cnfn sub_sat(char3, char3); -uchar3 __ovld __cnfn sub_sat(uchar3, uchar3); -char4 __ovld __cnfn sub_sat(char4, char4); -uchar4 __ovld __cnfn sub_sat(uchar4, uchar4); -char8 __ovld __cnfn sub_sat(char8, char8); -uchar8 __ovld __cnfn sub_sat(uchar8, uchar8); -char16 __ovld __cnfn sub_sat(char16, char16); -uchar16 __ovld __cnfn sub_sat(uchar16, uchar16); -short __ovld __cnfn sub_sat(short, short); -ushort __ovld __cnfn sub_sat(ushort, ushort); -short2 __ovld __cnfn sub_sat(short2, short2); -ushort2 __ovld __cnfn sub_sat(ushort2, ushort2); -short3 __ovld __cnfn sub_sat(short3, short3); -ushort3 __ovld __cnfn sub_sat(ushort3, ushort3); -short4 __ovld __cnfn sub_sat(short4, short4); -ushort4 __ovld __cnfn sub_sat(ushort4, ushort4); -short8 __ovld __cnfn sub_sat(short8, short8); -ushort8 __ovld __cnfn sub_sat(ushort8, ushort8); -short16 __ovld __cnfn sub_sat(short16, short16); -ushort16 __ovld __cnfn sub_sat(ushort16, ushort16); -int __ovld __cnfn sub_sat(int, int); -uint __ovld __cnfn sub_sat(uint, uint); -int2 __ovld __cnfn sub_sat(int2, int2); -uint2 __ovld __cnfn sub_sat(uint2, uint2); -int3 __ovld __cnfn sub_sat(int3, int3); -uint3 __ovld __cnfn sub_sat(uint3, uint3); -int4 __ovld __cnfn sub_sat(int4, int4); -uint4 __ovld __cnfn sub_sat(uint4, uint4); -int8 __ovld __cnfn sub_sat(int8, int8); -uint8 __ovld __cnfn sub_sat(uint8, uint8); -int16 __ovld __cnfn sub_sat(int16, int16); -uint16 __ovld __cnfn sub_sat(uint16, uint16); -long __ovld __cnfn sub_sat(long, long); -ulong __ovld __cnfn sub_sat(ulong, ulong); -long2 __ovld __cnfn sub_sat(long2, long2); -ulong2 __ovld __cnfn sub_sat(ulong2, ulong2); -long3 __ovld __cnfn sub_sat(long3, long3); -ulong3 __ovld __cnfn sub_sat(ulong3, ulong3); -long4 __ovld __cnfn sub_sat(long4, long4); -ulong4 __ovld __cnfn sub_sat(ulong4, ulong4); -long8 __ovld __cnfn sub_sat(long8, long8); -ulong8 __ovld __cnfn sub_sat(ulong8, ulong8); -long16 __ovld __cnfn sub_sat(long16, long16); -ulong16 __ovld __cnfn sub_sat(ulong16, ulong16); - -/** - * result[i] = ((short)hi[i] << 8) | lo[i] - * result[i] = ((ushort)hi[i] << 8) | lo[i] - */ -short __ovld __cnfn upsample(char, uchar); -ushort __ovld __cnfn upsample(uchar, uchar); -short2 __ovld __cnfn upsample(char2, uchar2); -short3 __ovld __cnfn upsample(char3, uchar3); -short4 __ovld __cnfn upsample(char4, uchar4); -short8 __ovld __cnfn upsample(char8, uchar8); -short16 __ovld __cnfn upsample(char16, uchar16); -ushort2 __ovld __cnfn upsample(uchar2, uchar2); -ushort3 __ovld __cnfn upsample(uchar3, uchar3); -ushort4 __ovld __cnfn upsample(uchar4, uchar4); -ushort8 __ovld __cnfn upsample(uchar8, uchar8); -ushort16 __ovld __cnfn upsample(uchar16, uchar16); - -/** - * result[i] = ((int)hi[i] << 16) | lo[i] - * result[i] = ((uint)hi[i] << 16) | lo[i] - */ -int __ovld __cnfn upsample(short, ushort); -uint __ovld __cnfn upsample(ushort, ushort); -int2 __ovld __cnfn upsample(short2, ushort2); -int3 __ovld __cnfn upsample(short3, ushort3); -int4 __ovld __cnfn upsample(short4, ushort4); -int8 __ovld __cnfn upsample(short8, ushort8); -int16 __ovld __cnfn upsample(short16, ushort16); -uint2 __ovld __cnfn upsample(ushort2, ushort2); -uint3 __ovld __cnfn upsample(ushort3, ushort3); -uint4 __ovld __cnfn upsample(ushort4, ushort4); -uint8 __ovld __cnfn upsample(ushort8, ushort8); -uint16 __ovld __cnfn upsample(ushort16, ushort16); -/** - * result[i] = ((long)hi[i] << 32) | lo[i] - * result[i] = ((ulong)hi[i] << 32) | lo[i] - */ -long __ovld __cnfn upsample(int, uint); -ulong __ovld __cnfn upsample(uint, uint); -long2 __ovld __cnfn upsample(int2, uint2); -long3 __ovld __cnfn upsample(int3, uint3); -long4 __ovld __cnfn upsample(int4, uint4); -long8 __ovld __cnfn upsample(int8, uint8); -long16 __ovld __cnfn upsample(int16, uint16); -ulong2 __ovld __cnfn upsample(uint2, uint2); -ulong3 __ovld __cnfn upsample(uint3, uint3); -ulong4 __ovld __cnfn upsample(uint4, uint4); -ulong8 __ovld __cnfn upsample(uint8, uint8); -ulong16 __ovld __cnfn upsample(uint16, uint16); - -/* - * popcount(x): returns the number of set bit in x - */ -#if defined(__OPENCL_CPP_VERSION__) || (__OPENCL_C_VERSION__ >= CL_VERSION_1_2) -char __ovld __cnfn popcount(char); -uchar __ovld __cnfn popcount(uchar); -char2 __ovld __cnfn popcount(char2); -uchar2 __ovld __cnfn popcount(uchar2); -char3 __ovld __cnfn popcount(char3); -uchar3 __ovld __cnfn popcount(uchar3); -char4 __ovld __cnfn popcount(char4); -uchar4 __ovld __cnfn popcount(uchar4); -char8 __ovld __cnfn popcount(char8); -uchar8 __ovld __cnfn popcount(uchar8); -char16 __ovld __cnfn popcount(char16); -uchar16 __ovld __cnfn popcount(uchar16); -short __ovld __cnfn popcount(short); -ushort __ovld __cnfn popcount(ushort); -short2 __ovld __cnfn popcount(short2); -ushort2 __ovld __cnfn popcount(ushort2); -short3 __ovld __cnfn popcount(short3); -ushort3 __ovld __cnfn popcount(ushort3); -short4 __ovld __cnfn popcount(short4); -ushort4 __ovld __cnfn popcount(ushort4); -short8 __ovld __cnfn popcount(short8); -ushort8 __ovld __cnfn popcount(ushort8); -short16 __ovld __cnfn popcount(short16); -ushort16 __ovld __cnfn popcount(ushort16); -int __ovld __cnfn popcount(int); -uint __ovld __cnfn popcount(uint); -int2 __ovld __cnfn popcount(int2); -uint2 __ovld __cnfn popcount(uint2); -int3 __ovld __cnfn popcount(int3); -uint3 __ovld __cnfn popcount(uint3); -int4 __ovld __cnfn popcount(int4); -uint4 __ovld __cnfn popcount(uint4); -int8 __ovld __cnfn popcount(int8); -uint8 __ovld __cnfn popcount(uint8); -int16 __ovld __cnfn popcount(int16); -uint16 __ovld __cnfn popcount(uint16); -long __ovld __cnfn popcount(long); -ulong __ovld __cnfn popcount(ulong); -long2 __ovld __cnfn popcount(long2); -ulong2 __ovld __cnfn popcount(ulong2); -long3 __ovld __cnfn popcount(long3); -ulong3 __ovld __cnfn popcount(ulong3); -long4 __ovld __cnfn popcount(long4); -ulong4 __ovld __cnfn popcount(ulong4); -long8 __ovld __cnfn popcount(long8); -ulong8 __ovld __cnfn popcount(ulong8); -long16 __ovld __cnfn popcount(long16); -ulong16 __ovld __cnfn popcount(ulong16); -#endif // defined(__OPENCL_CPP_VERSION__) || (__OPENCL_C_VERSION__ >= CL_VERSION_1_2) - -/** - * Multiply two 24-bit integer values x and y and add - * the 32-bit integer result to the 32-bit integer z. - * Refer to definition of mul24 to see how the 24-bit - * integer multiplication is performed. - */ -int __ovld __cnfn mad24(int, int, int); -uint __ovld __cnfn mad24(uint, uint, uint); -int2 __ovld __cnfn mad24(int2, int2, int2); -uint2 __ovld __cnfn mad24(uint2, uint2, uint2); -int3 __ovld __cnfn mad24(int3, int3, int3); -uint3 __ovld __cnfn mad24(uint3, uint3, uint3); -int4 __ovld __cnfn mad24(int4, int4, int4); -uint4 __ovld __cnfn mad24(uint4, uint4, uint4); -int8 __ovld __cnfn mad24(int8, int8, int8); -uint8 __ovld __cnfn mad24(uint8, uint8, uint8); -int16 __ovld __cnfn mad24(int16, int16, int16); -uint16 __ovld __cnfn mad24(uint16, uint16, uint16); - -/** - * Multiply two 24-bit integer values x and y. x and y - * are 32-bit integers but only the low 24-bits are used - * to perform the multiplication. mul24 should only - * be used when values in x and y are in the range [- - * 2^23, 2^23-1] if x and y are signed integers and in the - * range [0, 2^24-1] if x and y are unsigned integers. If - * x and y are not in this range, the multiplication - * result is implementation-defined. - */ -int __ovld __cnfn mul24(int, int); -uint __ovld __cnfn mul24(uint, uint); -int2 __ovld __cnfn mul24(int2, int2); -uint2 __ovld __cnfn mul24(uint2, uint2); -int3 __ovld __cnfn mul24(int3, int3); -uint3 __ovld __cnfn mul24(uint3, uint3); -int4 __ovld __cnfn mul24(int4, int4); -uint4 __ovld __cnfn mul24(uint4, uint4); -int8 __ovld __cnfn mul24(int8, int8); -uint8 __ovld __cnfn mul24(uint8, uint8); -int16 __ovld __cnfn mul24(int16, int16); -uint16 __ovld __cnfn mul24(uint16, uint16); - -// OpenCL v1.1 s6.11.4, v1.2 s6.12.4, v2.0 s6.13.4 - Common Functions - -/** - * Returns fmin(fmax(x, minval), maxval). - * Results are undefined if minval > maxval. - */ -float __ovld __cnfn clamp(float, float, float); -float2 __ovld __cnfn clamp(float2, float2, float2); -float3 __ovld __cnfn clamp(float3, float3, float3); -float4 __ovld __cnfn clamp(float4, float4, float4); -float8 __ovld __cnfn clamp(float8, float8, float8); -float16 __ovld __cnfn clamp(float16, float16, float16); -float2 __ovld __cnfn clamp(float2, float, float); -float3 __ovld __cnfn clamp(float3, float, float); -float4 __ovld __cnfn clamp(float4, float, float); -float8 __ovld __cnfn clamp(float8, float, float); -float16 __ovld __cnfn clamp(float16, float, float); -#ifdef cl_khr_fp64 -double __ovld __cnfn clamp(double, double, double); -double2 __ovld __cnfn clamp(double2, double2, double2); -double3 __ovld __cnfn clamp(double3, double3, double3); -double4 __ovld __cnfn clamp(double4, double4, double4); -double8 __ovld __cnfn clamp(double8, double8, double8); -double16 __ovld __cnfn clamp(double16, double16, double16); -double2 __ovld __cnfn clamp(double2, double, double); -double3 __ovld __cnfn clamp(double3, double, double); -double4 __ovld __cnfn clamp(double4, double, double); -double8 __ovld __cnfn clamp(double8, double, double); -double16 __ovld __cnfn clamp(double16, double, double); -#endif //cl_khr_fp64 -#ifdef cl_khr_fp16 -half __ovld __cnfn clamp(half, half, half); -half2 __ovld __cnfn clamp(half2, half2, half2); -half3 __ovld __cnfn clamp(half3, half3, half3); -half4 __ovld __cnfn clamp(half4, half4, half4); -half8 __ovld __cnfn clamp(half8, half8, half8); -half16 __ovld __cnfn clamp(half16, half16, half16); -half2 __ovld __cnfn clamp(half2, half, half); -half3 __ovld __cnfn clamp(half3, half, half); -half4 __ovld __cnfn clamp(half4, half, half); -half8 __ovld __cnfn clamp(half8, half, half); -half16 __ovld __cnfn clamp(half16, half, half); -#endif //cl_khr_fp16 - -/** - * Converts radians to degrees, i.e. (180 / PI) * - * radians. - */ -float __ovld __cnfn degrees(float); -float2 __ovld __cnfn degrees(float2); -float3 __ovld __cnfn degrees(float3); -float4 __ovld __cnfn degrees(float4); -float8 __ovld __cnfn degrees(float8); -float16 __ovld __cnfn degrees(float16); -#ifdef cl_khr_fp64 -double __ovld __cnfn degrees(double); -double2 __ovld __cnfn degrees(double2); -double3 __ovld __cnfn degrees(double3); -double4 __ovld __cnfn degrees(double4); -double8 __ovld __cnfn degrees(double8); -double16 __ovld __cnfn degrees(double16); -#endif //cl_khr_fp64 -#ifdef cl_khr_fp16 -half __ovld __cnfn degrees(half); -half2 __ovld __cnfn degrees(half2); -half3 __ovld __cnfn degrees(half3); -half4 __ovld __cnfn degrees(half4); -half8 __ovld __cnfn degrees(half8); -half16 __ovld __cnfn degrees(half16); -#endif //cl_khr_fp16 - -/** - * Returns y if x < y, otherwise it returns x. If x and y - * are infinite or NaN, the return values are undefined. - */ -float __ovld __cnfn max(float, float); -float2 __ovld __cnfn max(float2, float2); -float3 __ovld __cnfn max(float3, float3); -float4 __ovld __cnfn max(float4, float4); -float8 __ovld __cnfn max(float8, float8); -float16 __ovld __cnfn max(float16, float16); -float2 __ovld __cnfn max(float2, float); -float3 __ovld __cnfn max(float3, float); -float4 __ovld __cnfn max(float4, float); -float8 __ovld __cnfn max(float8, float); -float16 __ovld __cnfn max(float16, float); -#ifdef cl_khr_fp64 -double __ovld __cnfn max(double, double); -double2 __ovld __cnfn max(double2, double2); -double3 __ovld __cnfn max(double3, double3); -double4 __ovld __cnfn max(double4, double4); -double8 __ovld __cnfn max(double8, double8); -double16 __ovld __cnfn max(double16, double16); -double2 __ovld __cnfn max(double2, double); -double3 __ovld __cnfn max(double3, double); -double4 __ovld __cnfn max(double4, double); -double8 __ovld __cnfn max(double8, double); -double16 __ovld __cnfn max(double16, double); -#endif //cl_khr_fp64 -#ifdef cl_khr_fp16 -half __ovld __cnfn max(half, half); -half2 __ovld __cnfn max(half2, half2); -half3 __ovld __cnfn max(half3, half3); -half4 __ovld __cnfn max(half4, half4); -half8 __ovld __cnfn max(half8, half8); -half16 __ovld __cnfn max(half16, half16); -half2 __ovld __cnfn max(half2, half); -half3 __ovld __cnfn max(half3, half); -half4 __ovld __cnfn max(half4, half); -half8 __ovld __cnfn max(half8, half); -half16 __ovld __cnfn max(half16, half); -#endif //cl_khr_fp16 - -/** - * Returns y if y < x, otherwise it returns x. If x and y - * are infinite or NaN, the return values are undefined. - */ -float __ovld __cnfn min(float, float); -float2 __ovld __cnfn min(float2, float2); -float3 __ovld __cnfn min(float3, float3); -float4 __ovld __cnfn min(float4, float4); -float8 __ovld __cnfn min(float8, float8); -float16 __ovld __cnfn min(float16, float16); -float2 __ovld __cnfn min(float2, float); -float3 __ovld __cnfn min(float3, float); -float4 __ovld __cnfn min(float4, float); -float8 __ovld __cnfn min(float8, float); -float16 __ovld __cnfn min(float16, float); -#ifdef cl_khr_fp64 -double __ovld __cnfn min(double, double); -double2 __ovld __cnfn min(double2, double2); -double3 __ovld __cnfn min(double3, double3); -double4 __ovld __cnfn min(double4, double4); -double8 __ovld __cnfn min(double8, double8); -double16 __ovld __cnfn min(double16, double16); -double2 __ovld __cnfn min(double2, double); -double3 __ovld __cnfn min(double3, double); -double4 __ovld __cnfn min(double4, double); -double8 __ovld __cnfn min(double8, double); -double16 __ovld __cnfn min(double16, double); -#endif //cl_khr_fp64 -#ifdef cl_khr_fp16 -half __ovld __cnfn min(half, half); -half2 __ovld __cnfn min(half2, half2); -half3 __ovld __cnfn min(half3, half3); -half4 __ovld __cnfn min(half4, half4); -half8 __ovld __cnfn min(half8, half8); -half16 __ovld __cnfn min(half16, half16); -half2 __ovld __cnfn min(half2, half); -half3 __ovld __cnfn min(half3, half); -half4 __ovld __cnfn min(half4, half); -half8 __ovld __cnfn min(half8, half); -half16 __ovld __cnfn min(half16, half); -#endif //cl_khr_fp16 - -/** - * Returns the linear blend of x & y implemented as: - * x + (y - x) * a - * a must be a value in the range 0.0 ... 1.0. If a is not - * in the range 0.0 ... 1.0, the return values are - * undefined. - */ -float __ovld __cnfn mix(float, float, float); -float2 __ovld __cnfn mix(float2, float2, float2); -float3 __ovld __cnfn mix(float3, float3, float3); -float4 __ovld __cnfn mix(float4, float4, float4); -float8 __ovld __cnfn mix(float8, float8, float8); -float16 __ovld __cnfn mix(float16, float16, float16); -float2 __ovld __cnfn mix(float2, float2, float); -float3 __ovld __cnfn mix(float3, float3, float); -float4 __ovld __cnfn mix(float4, float4, float); -float8 __ovld __cnfn mix(float8, float8, float); -float16 __ovld __cnfn mix(float16, float16, float); -#ifdef cl_khr_fp64 -double __ovld __cnfn mix(double, double, double); -double2 __ovld __cnfn mix(double2, double2, double2); -double3 __ovld __cnfn mix(double3, double3, double3); -double4 __ovld __cnfn mix(double4, double4, double4); -double8 __ovld __cnfn mix(double8, double8, double8); -double16 __ovld __cnfn mix(double16, double16, double16); -double2 __ovld __cnfn mix(double2, double2, double); -double3 __ovld __cnfn mix(double3, double3, double); -double4 __ovld __cnfn mix(double4, double4, double); -double8 __ovld __cnfn mix(double8, double8, double); -double16 __ovld __cnfn mix(double16, double16, double); -#endif //cl_khr_fp64 -#ifdef cl_khr_fp16 -half __ovld __cnfn mix(half, half, half); -half2 __ovld __cnfn mix(half2, half2, half2); -half3 __ovld __cnfn mix(half3, half3, half3); -half4 __ovld __cnfn mix(half4, half4, half4); -half8 __ovld __cnfn mix(half8, half8, half8); -half16 __ovld __cnfn mix(half16, half16, half16); -half2 __ovld __cnfn mix(half2, half2, half); -half3 __ovld __cnfn mix(half3, half3, half); -half4 __ovld __cnfn mix(half4, half4, half); -half8 __ovld __cnfn mix(half8, half8, half); -half16 __ovld __cnfn mix(half16, half16, half); -#endif //cl_khr_fp16 - -/** - * Converts degrees to radians, i.e. (PI / 180) * - * degrees. - */ -float __ovld __cnfn radians(float); -float2 __ovld __cnfn radians(float2); -float3 __ovld __cnfn radians(float3); -float4 __ovld __cnfn radians(float4); -float8 __ovld __cnfn radians(float8); -float16 __ovld __cnfn radians(float16); -#ifdef cl_khr_fp64 -double __ovld __cnfn radians(double); -double2 __ovld __cnfn radians(double2); -double3 __ovld __cnfn radians(double3); -double4 __ovld __cnfn radians(double4); -double8 __ovld __cnfn radians(double8); -double16 __ovld __cnfn radians(double16); -#endif //cl_khr_fp64 -#ifdef cl_khr_fp16 -half __ovld __cnfn radians(half); -half2 __ovld __cnfn radians(half2); -half3 __ovld __cnfn radians(half3); -half4 __ovld __cnfn radians(half4); -half8 __ovld __cnfn radians(half8); -half16 __ovld __cnfn radians(half16); -#endif //cl_khr_fp16 - -/** - * Returns 0.0 if x < edge, otherwise it returns 1.0. - */ -float __ovld __cnfn step(float, float); -float2 __ovld __cnfn step(float2, float2); -float3 __ovld __cnfn step(float3, float3); -float4 __ovld __cnfn step(float4, float4); -float8 __ovld __cnfn step(float8, float8); -float16 __ovld __cnfn step(float16, float16); -float2 __ovld __cnfn step(float, float2); -float3 __ovld __cnfn step(float, float3); -float4 __ovld __cnfn step(float, float4); -float8 __ovld __cnfn step(float, float8); -float16 __ovld __cnfn step(float, float16); -#ifdef cl_khr_fp64 -double __ovld __cnfn step(double, double); -double2 __ovld __cnfn step(double2, double2); -double3 __ovld __cnfn step(double3, double3); -double4 __ovld __cnfn step(double4, double4); -double8 __ovld __cnfn step(double8, double8); -double16 __ovld __cnfn step(double16, double16); -double2 __ovld __cnfn step(double, double2); -double3 __ovld __cnfn step(double, double3); -double4 __ovld __cnfn step(double, double4); -double8 __ovld __cnfn step(double, double8); -double16 __ovld __cnfn step(double, double16); -#endif //cl_khr_fp64 -#ifdef cl_khr_fp16 -half __ovld __cnfn step(half, half); -half2 __ovld __cnfn step(half2, half2); -half3 __ovld __cnfn step(half3, half3); -half4 __ovld __cnfn step(half4, half4); -half8 __ovld __cnfn step(half8, half8); -half16 __ovld __cnfn step(half16, half16); -half2 __ovld __cnfn step(half, half2); -half3 __ovld __cnfn step(half, half3); -half4 __ovld __cnfn step(half, half4); -half8 __ovld __cnfn step(half, half8); -half16 __ovld __cnfn step(half, half16); -#endif //cl_khr_fp16 - -/** - * Returns 0.0 if x <= edge0 and 1.0 if x >= edge1 and - * performs smooth Hermite interpolation between 0 - * and 1when edge0 < x < edge1. This is useful in - * cases where you would want a threshold function - * with a smooth transition. - * This is equivalent to: - * gentype t; - * t = clamp ((x - edge0) / (edge1 - edge0), 0, 1); - * return t * t * (3 - 2 * t); - * Results are undefined if edge0 >= edge1 or if x, - * edge0 or edge1 is a NaN. - */ -float __ovld __cnfn smoothstep(float, float, float); -float2 __ovld __cnfn smoothstep(float2, float2, float2); -float3 __ovld __cnfn smoothstep(float3, float3, float3); -float4 __ovld __cnfn smoothstep(float4, float4, float4); -float8 __ovld __cnfn smoothstep(float8, float8, float8); -float16 __ovld __cnfn smoothstep(float16, float16, float16); -float2 __ovld __cnfn smoothstep(float, float, float2); -float3 __ovld __cnfn smoothstep(float, float, float3); -float4 __ovld __cnfn smoothstep(float, float, float4); -float8 __ovld __cnfn smoothstep(float, float, float8); -float16 __ovld __cnfn smoothstep(float, float, float16); -#ifdef cl_khr_fp64 -double __ovld __cnfn smoothstep(double, double, double); -double2 __ovld __cnfn smoothstep(double2, double2, double2); -double3 __ovld __cnfn smoothstep(double3, double3, double3); -double4 __ovld __cnfn smoothstep(double4, double4, double4); -double8 __ovld __cnfn smoothstep(double8, double8, double8); -double16 __ovld __cnfn smoothstep(double16, double16, double16); -double2 __ovld __cnfn smoothstep(double, double, double2); -double3 __ovld __cnfn smoothstep(double, double, double3); -double4 __ovld __cnfn smoothstep(double, double, double4); -double8 __ovld __cnfn smoothstep(double, double, double8); -double16 __ovld __cnfn smoothstep(double, double, double16); -#endif //cl_khr_fp64 -#ifdef cl_khr_fp16 -half __ovld __cnfn smoothstep(half, half, half); -half2 __ovld __cnfn smoothstep(half2, half2, half2); -half3 __ovld __cnfn smoothstep(half3, half3, half3); -half4 __ovld __cnfn smoothstep(half4, half4, half4); -half8 __ovld __cnfn smoothstep(half8, half8, half8); -half16 __ovld __cnfn smoothstep(half16, half16, half16); -half2 __ovld __cnfn smoothstep(half, half, half2); -half3 __ovld __cnfn smoothstep(half, half, half3); -half4 __ovld __cnfn smoothstep(half, half, half4); -half8 __ovld __cnfn smoothstep(half, half, half8); -half16 __ovld __cnfn smoothstep(half, half, half16); -#endif //cl_khr_fp16 - -/** - * Returns 1.0 if x > 0, -0.0 if x = -0.0, +0.0 if x = - * +0.0, or -1.0 if x < 0. Returns 0.0 if x is a NaN. - */ -float __ovld __cnfn sign(float); -float2 __ovld __cnfn sign(float2); -float3 __ovld __cnfn sign(float3); -float4 __ovld __cnfn sign(float4); -float8 __ovld __cnfn sign(float8); -float16 __ovld __cnfn sign(float16); -#ifdef cl_khr_fp64 -double __ovld __cnfn sign(double); -double2 __ovld __cnfn sign(double2); -double3 __ovld __cnfn sign(double3); -double4 __ovld __cnfn sign(double4); -double8 __ovld __cnfn sign(double8); -double16 __ovld __cnfn sign(double16); -#endif //cl_khr_fp64 -#ifdef cl_khr_fp16 -half __ovld __cnfn sign(half); -half2 __ovld __cnfn sign(half2); -half3 __ovld __cnfn sign(half3); -half4 __ovld __cnfn sign(half4); -half8 __ovld __cnfn sign(half8); -half16 __ovld __cnfn sign(half16); -#endif //cl_khr_fp16 - -// OpenCL v1.1 s6.11.5, v1.2 s6.12.5, v2.0 s6.13.5 - Geometric Functions - -/** - * Returns the cross product of p0.xyz and p1.xyz. The - * w component of float4 result returned will be 0.0. - */ -float4 __ovld __cnfn cross(float4, float4); -float3 __ovld __cnfn cross(float3, float3); -#ifdef cl_khr_fp64 -double4 __ovld __cnfn cross(double4, double4); -double3 __ovld __cnfn cross(double3, double3); -#endif //cl_khr_fp64 -#ifdef cl_khr_fp16 -half4 __ovld __cnfn cross(half4, half4); -half3 __ovld __cnfn cross(half3, half3); -#endif //cl_khr_fp16 - -/** - * Compute dot product. - */ -float __ovld __cnfn dot(float, float); -float __ovld __cnfn dot(float2, float2); -float __ovld __cnfn dot(float3, float3); -float __ovld __cnfn dot(float4, float4); -#ifdef cl_khr_fp64 -double __ovld __cnfn dot(double, double); -double __ovld __cnfn dot(double2, double2); -double __ovld __cnfn dot(double3, double3); -double __ovld __cnfn dot(double4, double4); -#endif //cl_khr_fp64 -#ifdef cl_khr_fp16 -half __ovld __cnfn dot(half, half); -half __ovld __cnfn dot(half2, half2); -half __ovld __cnfn dot(half3, half3); -half __ovld __cnfn dot(half4, half4); -#endif //cl_khr_fp16 - -/** - * Returns the distance between p0 and p1. This is - * calculated as length(p0 - p1). - */ -float __ovld __cnfn distance(float, float); -float __ovld __cnfn distance(float2, float2); -float __ovld __cnfn distance(float3, float3); -float __ovld __cnfn distance(float4, float4); -#ifdef cl_khr_fp64 -double __ovld __cnfn distance(double, double); -double __ovld __cnfn distance(double2, double2); -double __ovld __cnfn distance(double3, double3); -double __ovld __cnfn distance(double4, double4); -#endif //cl_khr_fp64 -#ifdef cl_khr_fp16 -half __ovld __cnfn distance(half, half); -half __ovld __cnfn distance(half2, half2); -half __ovld __cnfn distance(half3, half3); -half __ovld __cnfn distance(half4, half4); -#endif //cl_khr_fp16 - -/** - * Return the length of vector p, i.e., - * sqrt(p.x2 + p.y 2 + ...) - */ -float __ovld __cnfn length(float); -float __ovld __cnfn length(float2); -float __ovld __cnfn length(float3); -float __ovld __cnfn length(float4); -#ifdef cl_khr_fp64 -double __ovld __cnfn length(double); -double __ovld __cnfn length(double2); -double __ovld __cnfn length(double3); -double __ovld __cnfn length(double4); -#endif //cl_khr_fp64 -#ifdef cl_khr_fp16 -half __ovld __cnfn length(half); -half __ovld __cnfn length(half2); -half __ovld __cnfn length(half3); -half __ovld __cnfn length(half4); -#endif //cl_khr_fp16 - -/** - * Returns a vector in the same direction as p but with a - * length of 1. - */ -float __ovld __cnfn normalize(float); -float2 __ovld __cnfn normalize(float2); -float3 __ovld __cnfn normalize(float3); -float4 __ovld __cnfn normalize(float4); -#ifdef cl_khr_fp64 -double __ovld __cnfn normalize(double); -double2 __ovld __cnfn normalize(double2); -double3 __ovld __cnfn normalize(double3); -double4 __ovld __cnfn normalize(double4); -#endif //cl_khr_fp64 -#ifdef cl_khr_fp16 -half __ovld __cnfn normalize(half); -half2 __ovld __cnfn normalize(half2); -half3 __ovld __cnfn normalize(half3); -half4 __ovld __cnfn normalize(half4); -#endif //cl_khr_fp16 - -/** - * Returns fast_length(p0 - p1). - */ -float __ovld __cnfn fast_distance(float, float); -float __ovld __cnfn fast_distance(float2, float2); -float __ovld __cnfn fast_distance(float3, float3); -float __ovld __cnfn fast_distance(float4, float4); - -/** - * Returns the length of vector p computed as: - * half_sqrt(p.x2 + p.y2 + ...) - */ -float __ovld __cnfn fast_length(float); -float __ovld __cnfn fast_length(float2); -float __ovld __cnfn fast_length(float3); -float __ovld __cnfn fast_length(float4); - -/** - * Returns a vector in the same direction as p but with a - * length of 1. fast_normalize is computed as: - * p * half_rsqrt (p.x^2 + p.y^2 + ... ) - * The result shall be within 8192 ulps error from the - * infinitely precise result of - * if (all(p == 0.0f)) - * result = p; - * else - * result = p / sqrt (p.x^2 + p.y^2 + ...); - * with the following exceptions: - * 1) If the sum of squares is greater than FLT_MAX - * then the value of the floating-point values in the - * result vector are undefined. - * 2) If the sum of squares is less than FLT_MIN then - * the implementation may return back p. - * 3) If the device is in "denorms are flushed to zero" - * mode, individual operand elements with magnitude - * less than sqrt(FLT_MIN) may be flushed to zero - * before proceeding with the calculation. - */ -float __ovld __cnfn fast_normalize(float); -float2 __ovld __cnfn fast_normalize(float2); -float3 __ovld __cnfn fast_normalize(float3); -float4 __ovld __cnfn fast_normalize(float4); - -// OpenCL v1.1 s6.11.6, v1.2 s6.12.6, v2.0 s6.13.6 - Relational Functions - -/** - * intn isequal (floatn x, floatn y) - * Returns the component-wise compare of x == y. - */ -int __ovld __cnfn isequal(float, float); -int2 __ovld __cnfn isequal(float2, float2); -int3 __ovld __cnfn isequal(float3, float3); -int4 __ovld __cnfn isequal(float4, float4); -int8 __ovld __cnfn isequal(float8, float8); -int16 __ovld __cnfn isequal(float16, float16); -#ifdef cl_khr_fp64 -int __ovld __cnfn isequal(double, double); -long2 __ovld __cnfn isequal(double2, double2); -long3 __ovld __cnfn isequal(double3, double3); -long4 __ovld __cnfn isequal(double4, double4); -long8 __ovld __cnfn isequal(double8, double8); -long16 __ovld __cnfn isequal(double16, double16); -#endif //cl_khr_fp64 -#ifdef cl_khr_fp16 -int __ovld __cnfn isequal(half, half); -short2 __ovld __cnfn isequal(half2, half2); -short3 __ovld __cnfn isequal(half3, half3); -short4 __ovld __cnfn isequal(half4, half4); -short8 __ovld __cnfn isequal(half8, half8); -short16 __ovld __cnfn isequal(half16, half16); -#endif //cl_khr_fp16 - -/** - * Returns the component-wise compare of x != y. - */ -int __ovld __cnfn isnotequal(float, float); -int2 __ovld __cnfn isnotequal(float2, float2); -int3 __ovld __cnfn isnotequal(float3, float3); -int4 __ovld __cnfn isnotequal(float4, float4); -int8 __ovld __cnfn isnotequal(float8, float8); -int16 __ovld __cnfn isnotequal(float16, float16); -#ifdef cl_khr_fp64 -int __ovld __cnfn isnotequal(double, double); -long2 __ovld __cnfn isnotequal(double2, double2); -long3 __ovld __cnfn isnotequal(double3, double3); -long4 __ovld __cnfn isnotequal(double4, double4); -long8 __ovld __cnfn isnotequal(double8, double8); -long16 __ovld __cnfn isnotequal(double16, double16); -#endif //cl_khr_fp64 -#ifdef cl_khr_fp16 -int __ovld __cnfn isnotequal(half, half); -short2 __ovld __cnfn isnotequal(half2, half2); -short3 __ovld __cnfn isnotequal(half3, half3); -short4 __ovld __cnfn isnotequal(half4, half4); -short8 __ovld __cnfn isnotequal(half8, half8); -short16 __ovld __cnfn isnotequal(half16, half16); -#endif //cl_khr_fp16 - -/** - * Returns the component-wise compare of x > y. - */ -int __ovld __cnfn isgreater(float, float); -int2 __ovld __cnfn isgreater(float2, float2); -int3 __ovld __cnfn isgreater(float3, float3); -int4 __ovld __cnfn isgreater(float4, float4); -int8 __ovld __cnfn isgreater(float8, float8); -int16 __ovld __cnfn isgreater(float16, float16); -#ifdef cl_khr_fp64 -int __ovld __cnfn isgreater(double, double); -long2 __ovld __cnfn isgreater(double2, double2); -long3 __ovld __cnfn isgreater(double3, double3); -long4 __ovld __cnfn isgreater(double4, double4); -long8 __ovld __cnfn isgreater(double8, double8); -long16 __ovld __cnfn isgreater(double16, double16); -#endif //cl_khr_fp64 -#ifdef cl_khr_fp16 -int __ovld __cnfn isgreater(half, half); -short2 __ovld __cnfn isgreater(half2, half2); -short3 __ovld __cnfn isgreater(half3, half3); -short4 __ovld __cnfn isgreater(half4, half4); -short8 __ovld __cnfn isgreater(half8, half8); -short16 __ovld __cnfn isgreater(half16, half16); -#endif //cl_khr_fp16 - -/** - * Returns the component-wise compare of x >= y. - */ -int __ovld __cnfn isgreaterequal(float, float); -int2 __ovld __cnfn isgreaterequal(float2, float2); -int3 __ovld __cnfn isgreaterequal(float3, float3); -int4 __ovld __cnfn isgreaterequal(float4, float4); -int8 __ovld __cnfn isgreaterequal(float8, float8); -int16 __ovld __cnfn isgreaterequal(float16, float16); -#ifdef cl_khr_fp64 -int __ovld __cnfn isgreaterequal(double, double); -long2 __ovld __cnfn isgreaterequal(double2, double2); -long3 __ovld __cnfn isgreaterequal(double3, double3); -long4 __ovld __cnfn isgreaterequal(double4, double4); -long8 __ovld __cnfn isgreaterequal(double8, double8); -long16 __ovld __cnfn isgreaterequal(double16, double16); -#endif //cl_khr_fp64 -#ifdef cl_khr_fp16 -int __ovld __cnfn isgreaterequal(half, half); -short2 __ovld __cnfn isgreaterequal(half2, half2); -short3 __ovld __cnfn isgreaterequal(half3, half3); -short4 __ovld __cnfn isgreaterequal(half4, half4); -short8 __ovld __cnfn isgreaterequal(half8, half8); -short16 __ovld __cnfn isgreaterequal(half16, half16); -#endif //cl_khr_fp16 - -/** - * Returns the component-wise compare of x < y. - */ -int __ovld __cnfn isless(float, float); -int2 __ovld __cnfn isless(float2, float2); -int3 __ovld __cnfn isless(float3, float3); -int4 __ovld __cnfn isless(float4, float4); -int8 __ovld __cnfn isless(float8, float8); -int16 __ovld __cnfn isless(float16, float16); -#ifdef cl_khr_fp64 -int __ovld __cnfn isless(double, double); -long2 __ovld __cnfn isless(double2, double2); -long3 __ovld __cnfn isless(double3, double3); -long4 __ovld __cnfn isless(double4, double4); -long8 __ovld __cnfn isless(double8, double8); -long16 __ovld __cnfn isless(double16, double16); -#endif //cl_khr_fp64 -#ifdef cl_khr_fp16 -int __ovld __cnfn isless(half, half); -short2 __ovld __cnfn isless(half2, half2); -short3 __ovld __cnfn isless(half3, half3); -short4 __ovld __cnfn isless(half4, half4); -short8 __ovld __cnfn isless(half8, half8); -short16 __ovld __cnfn isless(half16, half16); -#endif //cl_khr_fp16 - -/** - * Returns the component-wise compare of x <= y. - */ -int __ovld __cnfn islessequal(float, float); -int2 __ovld __cnfn islessequal(float2, float2); -int3 __ovld __cnfn islessequal(float3, float3); -int4 __ovld __cnfn islessequal(float4, float4); -int8 __ovld __cnfn islessequal(float8, float8); -int16 __ovld __cnfn islessequal(float16, float16); -#ifdef cl_khr_fp64 -int __ovld __cnfn islessequal(double, double); -long2 __ovld __cnfn islessequal(double2, double2); -long3 __ovld __cnfn islessequal(double3, double3); -long4 __ovld __cnfn islessequal(double4, double4); -long8 __ovld __cnfn islessequal(double8, double8); -long16 __ovld __cnfn islessequal(double16, double16); -#endif //cl_khr_fp64 -#ifdef cl_khr_fp16 -int __ovld __cnfn islessequal(half, half); -short2 __ovld __cnfn islessequal(half2, half2); -short3 __ovld __cnfn islessequal(half3, half3); -short4 __ovld __cnfn islessequal(half4, half4); -short8 __ovld __cnfn islessequal(half8, half8); -short16 __ovld __cnfn islessequal(half16, half16); -#endif //cl_khr_fp16 - -/** - * Returns the component-wise compare of - * (x < y) || (x > y) . - */ -int __ovld __cnfn islessgreater(float, float); -int2 __ovld __cnfn islessgreater(float2, float2); -int3 __ovld __cnfn islessgreater(float3, float3); -int4 __ovld __cnfn islessgreater(float4, float4); -int8 __ovld __cnfn islessgreater(float8, float8); -int16 __ovld __cnfn islessgreater(float16, float16); -#ifdef cl_khr_fp64 -int __ovld __cnfn islessgreater(double, double); -long2 __ovld __cnfn islessgreater(double2, double2); -long3 __ovld __cnfn islessgreater(double3, double3); -long4 __ovld __cnfn islessgreater(double4, double4); -long8 __ovld __cnfn islessgreater(double8, double8); -long16 __ovld __cnfn islessgreater(double16, double16); -#endif //cl_khr_fp64 -#ifdef cl_khr_fp16 -int __ovld __cnfn islessgreater(half, half); -short2 __ovld __cnfn islessgreater(half2, half2); -short3 __ovld __cnfn islessgreater(half3, half3); -short4 __ovld __cnfn islessgreater(half4, half4); -short8 __ovld __cnfn islessgreater(half8, half8); -short16 __ovld __cnfn islessgreater(half16, half16); -#endif //cl_khr_fp16 - -/** - * Test for finite value. - */ -int __ovld __cnfn isfinite(float); -int2 __ovld __cnfn isfinite(float2); -int3 __ovld __cnfn isfinite(float3); -int4 __ovld __cnfn isfinite(float4); -int8 __ovld __cnfn isfinite(float8); -int16 __ovld __cnfn isfinite(float16); -#ifdef cl_khr_fp64 -int __ovld __cnfn isfinite(double); -long2 __ovld __cnfn isfinite(double2); -long3 __ovld __cnfn isfinite(double3); -long4 __ovld __cnfn isfinite(double4); -long8 __ovld __cnfn isfinite(double8); -long16 __ovld __cnfn isfinite(double16); -#endif //cl_khr_fp64 -#ifdef cl_khr_fp16 -int __ovld __cnfn isfinite(half); -short2 __ovld __cnfn isfinite(half2); -short3 __ovld __cnfn isfinite(half3); -short4 __ovld __cnfn isfinite(half4); -short8 __ovld __cnfn isfinite(half8); -short16 __ovld __cnfn isfinite(half16); -#endif //cl_khr_fp16 - -/** - * Test for infinity value (+ve or -ve) . - */ -int __ovld __cnfn isinf(float); -int2 __ovld __cnfn isinf(float2); -int3 __ovld __cnfn isinf(float3); -int4 __ovld __cnfn isinf(float4); -int8 __ovld __cnfn isinf(float8); -int16 __ovld __cnfn isinf(float16); -#ifdef cl_khr_fp64 -int __ovld __cnfn isinf(double); -long2 __ovld __cnfn isinf(double2); -long3 __ovld __cnfn isinf(double3); -long4 __ovld __cnfn isinf(double4); -long8 __ovld __cnfn isinf(double8); -long16 __ovld __cnfn isinf(double16); -#endif //cl_khr_fp64 -#ifdef cl_khr_fp16 -int __ovld __cnfn isinf(half); -short2 __ovld __cnfn isinf(half2); -short3 __ovld __cnfn isinf(half3); -short4 __ovld __cnfn isinf(half4); -short8 __ovld __cnfn isinf(half8); -short16 __ovld __cnfn isinf(half16); -#endif //cl_khr_fp16 - -/** - * Test for a NaN. - */ -int __ovld __cnfn isnan(float); -int2 __ovld __cnfn isnan(float2); -int3 __ovld __cnfn isnan(float3); -int4 __ovld __cnfn isnan(float4); -int8 __ovld __cnfn isnan(float8); -int16 __ovld __cnfn isnan(float16); -#ifdef cl_khr_fp64 -int __ovld __cnfn isnan(double); -long2 __ovld __cnfn isnan(double2); -long3 __ovld __cnfn isnan(double3); -long4 __ovld __cnfn isnan(double4); -long8 __ovld __cnfn isnan(double8); -long16 __ovld __cnfn isnan(double16); -#endif //cl_khr_fp64 -#ifdef cl_khr_fp16 -int __ovld __cnfn isnan(half); -short2 __ovld __cnfn isnan(half2); -short3 __ovld __cnfn isnan(half3); -short4 __ovld __cnfn isnan(half4); -short8 __ovld __cnfn isnan(half8); -short16 __ovld __cnfn isnan(half16); -#endif //cl_khr_fp16 - -/** - * Test for a normal value. - */ -int __ovld __cnfn isnormal(float); -int2 __ovld __cnfn isnormal(float2); -int3 __ovld __cnfn isnormal(float3); -int4 __ovld __cnfn isnormal(float4); -int8 __ovld __cnfn isnormal(float8); -int16 __ovld __cnfn isnormal(float16); -#ifdef cl_khr_fp64 -int __ovld __cnfn isnormal(double); -long2 __ovld __cnfn isnormal(double2); -long3 __ovld __cnfn isnormal(double3); -long4 __ovld __cnfn isnormal(double4); -long8 __ovld __cnfn isnormal(double8); -long16 __ovld __cnfn isnormal(double16); -#endif //cl_khr_fp64 -#ifdef cl_khr_fp16 -int __ovld __cnfn isnormal(half); -short2 __ovld __cnfn isnormal(half2); -short3 __ovld __cnfn isnormal(half3); -short4 __ovld __cnfn isnormal(half4); -short8 __ovld __cnfn isnormal(half8); -short16 __ovld __cnfn isnormal(half16); -#endif //cl_khr_fp16 - -/** - * Test if arguments are ordered. isordered() takes - * arguments x and y, and returns the result - * isequal(x, x) && isequal(y, y). - */ -int __ovld __cnfn isordered(float, float); -int2 __ovld __cnfn isordered(float2, float2); -int3 __ovld __cnfn isordered(float3, float3); -int4 __ovld __cnfn isordered(float4, float4); -int8 __ovld __cnfn isordered(float8, float8); -int16 __ovld __cnfn isordered(float16, float16); -#ifdef cl_khr_fp64 -int __ovld __cnfn isordered(double, double); -long2 __ovld __cnfn isordered(double2, double2); -long3 __ovld __cnfn isordered(double3, double3); -long4 __ovld __cnfn isordered(double4, double4); -long8 __ovld __cnfn isordered(double8, double8); -long16 __ovld __cnfn isordered(double16, double16); -#endif //cl_khr_fp64 -#ifdef cl_khr_fp16 -int __ovld __cnfn isordered(half, half); -short2 __ovld __cnfn isordered(half2, half2); -short3 __ovld __cnfn isordered(half3, half3); -short4 __ovld __cnfn isordered(half4, half4); -short8 __ovld __cnfn isordered(half8, half8); -short16 __ovld __cnfn isordered(half16, half16); -#endif //cl_khr_fp16 - -/** - * Test if arguments are unordered. isunordered() - * takes arguments x and y, returning non-zero if x or y - * is NaN, and zero otherwise. - */ -int __ovld __cnfn isunordered(float, float); -int2 __ovld __cnfn isunordered(float2, float2); -int3 __ovld __cnfn isunordered(float3, float3); -int4 __ovld __cnfn isunordered(float4, float4); -int8 __ovld __cnfn isunordered(float8, float8); -int16 __ovld __cnfn isunordered(float16, float16); -#ifdef cl_khr_fp64 -int __ovld __cnfn isunordered(double, double); -long2 __ovld __cnfn isunordered(double2, double2); -long3 __ovld __cnfn isunordered(double3, double3); -long4 __ovld __cnfn isunordered(double4, double4); -long8 __ovld __cnfn isunordered(double8, double8); -long16 __ovld __cnfn isunordered(double16, double16); -#endif //cl_khr_fp64 -#ifdef cl_khr_fp16 -int __ovld __cnfn isunordered(half, half); -short2 __ovld __cnfn isunordered(half2, half2); -short3 __ovld __cnfn isunordered(half3, half3); -short4 __ovld __cnfn isunordered(half4, half4); -short8 __ovld __cnfn isunordered(half8, half8); -short16 __ovld __cnfn isunordered(half16, half16); -#endif //cl_khr_fp16 - -/** - * Test for sign bit. The scalar version of the function - * returns a 1 if the sign bit in the float is set else returns - * 0. The vector version of the function returns the - * following for each component in floatn: a -1 if the - * sign bit in the float is set else returns 0. - */ -int __ovld __cnfn signbit(float); -int2 __ovld __cnfn signbit(float2); -int3 __ovld __cnfn signbit(float3); -int4 __ovld __cnfn signbit(float4); -int8 __ovld __cnfn signbit(float8); -int16 __ovld __cnfn signbit(float16); -#ifdef cl_khr_fp64 -int __ovld __cnfn signbit(double); -long2 __ovld __cnfn signbit(double2); -long3 __ovld __cnfn signbit(double3); -long4 __ovld __cnfn signbit(double4); -long8 __ovld __cnfn signbit(double8); -long16 __ovld __cnfn signbit(double16); -#endif //cl_khr_fp64 -#ifdef cl_khr_fp16 -int __ovld __cnfn signbit(half); -short2 __ovld __cnfn signbit(half2); -short3 __ovld __cnfn signbit(half3); -short4 __ovld __cnfn signbit(half4); -short8 __ovld __cnfn signbit(half8); -short16 __ovld __cnfn signbit(half16); -#endif //cl_khr_fp16 - -/** - * Returns 1 if the most significant bit in any component - * of x is set; otherwise returns 0. - */ -int __ovld __cnfn any(char); -int __ovld __cnfn any(char2); -int __ovld __cnfn any(char3); -int __ovld __cnfn any(char4); -int __ovld __cnfn any(char8); -int __ovld __cnfn any(char16); -int __ovld __cnfn any(short); -int __ovld __cnfn any(short2); -int __ovld __cnfn any(short3); -int __ovld __cnfn any(short4); -int __ovld __cnfn any(short8); -int __ovld __cnfn any(short16); -int __ovld __cnfn any(int); -int __ovld __cnfn any(int2); -int __ovld __cnfn any(int3); -int __ovld __cnfn any(int4); -int __ovld __cnfn any(int8); -int __ovld __cnfn any(int16); -int __ovld __cnfn any(long); -int __ovld __cnfn any(long2); -int __ovld __cnfn any(long3); -int __ovld __cnfn any(long4); -int __ovld __cnfn any(long8); -int __ovld __cnfn any(long16); - -/** - * Returns 1 if the most significant bit in all components - * of x is set; otherwise returns 0. - */ -int __ovld __cnfn all(char); -int __ovld __cnfn all(char2); -int __ovld __cnfn all(char3); -int __ovld __cnfn all(char4); -int __ovld __cnfn all(char8); -int __ovld __cnfn all(char16); -int __ovld __cnfn all(short); -int __ovld __cnfn all(short2); -int __ovld __cnfn all(short3); -int __ovld __cnfn all(short4); -int __ovld __cnfn all(short8); -int __ovld __cnfn all(short16); -int __ovld __cnfn all(int); -int __ovld __cnfn all(int2); -int __ovld __cnfn all(int3); -int __ovld __cnfn all(int4); -int __ovld __cnfn all(int8); -int __ovld __cnfn all(int16); -int __ovld __cnfn all(long); -int __ovld __cnfn all(long2); -int __ovld __cnfn all(long3); -int __ovld __cnfn all(long4); -int __ovld __cnfn all(long8); -int __ovld __cnfn all(long16); - -/** - * Each bit of the result is the corresponding bit of a if - * the corresponding bit of c is 0. Otherwise it is the - * corresponding bit of b. - */ -char __ovld __cnfn bitselect(char, char, char); -uchar __ovld __cnfn bitselect(uchar, uchar, uchar); -char2 __ovld __cnfn bitselect(char2, char2, char2); -uchar2 __ovld __cnfn bitselect(uchar2, uchar2, uchar2); -char3 __ovld __cnfn bitselect(char3, char3, char3); -uchar3 __ovld __cnfn bitselect(uchar3, uchar3, uchar3); -char4 __ovld __cnfn bitselect(char4, char4, char4); -uchar4 __ovld __cnfn bitselect(uchar4, uchar4, uchar4); -char8 __ovld __cnfn bitselect(char8, char8, char8); -uchar8 __ovld __cnfn bitselect(uchar8, uchar8, uchar8); -char16 __ovld __cnfn bitselect(char16, char16, char16); -uchar16 __ovld __cnfn bitselect(uchar16, uchar16, uchar16); -short __ovld __cnfn bitselect(short, short, short); -ushort __ovld __cnfn bitselect(ushort, ushort, ushort); -short2 __ovld __cnfn bitselect(short2, short2, short2); -ushort2 __ovld __cnfn bitselect(ushort2, ushort2, ushort2); -short3 __ovld __cnfn bitselect(short3, short3, short3); -ushort3 __ovld __cnfn bitselect(ushort3, ushort3, ushort3); -short4 __ovld __cnfn bitselect(short4, short4, short4); -ushort4 __ovld __cnfn bitselect(ushort4, ushort4, ushort4); -short8 __ovld __cnfn bitselect(short8, short8, short8); -ushort8 __ovld __cnfn bitselect(ushort8, ushort8, ushort8); -short16 __ovld __cnfn bitselect(short16, short16, short16); -ushort16 __ovld __cnfn bitselect(ushort16, ushort16, ushort16); -int __ovld __cnfn bitselect(int, int, int); -uint __ovld __cnfn bitselect(uint, uint, uint); -int2 __ovld __cnfn bitselect(int2, int2, int2); -uint2 __ovld __cnfn bitselect(uint2, uint2, uint2); -int3 __ovld __cnfn bitselect(int3, int3, int3); -uint3 __ovld __cnfn bitselect(uint3, uint3, uint3); -int4 __ovld __cnfn bitselect(int4, int4, int4); -uint4 __ovld __cnfn bitselect(uint4, uint4, uint4); -int8 __ovld __cnfn bitselect(int8, int8, int8); -uint8 __ovld __cnfn bitselect(uint8, uint8, uint8); -int16 __ovld __cnfn bitselect(int16, int16, int16); -uint16 __ovld __cnfn bitselect(uint16, uint16, uint16); -long __ovld __cnfn bitselect(long, long, long); -ulong __ovld __cnfn bitselect(ulong, ulong, ulong); -long2 __ovld __cnfn bitselect(long2, long2, long2); -ulong2 __ovld __cnfn bitselect(ulong2, ulong2, ulong2); -long3 __ovld __cnfn bitselect(long3, long3, long3); -ulong3 __ovld __cnfn bitselect(ulong3, ulong3, ulong3); -long4 __ovld __cnfn bitselect(long4, long4, long4); -ulong4 __ovld __cnfn bitselect(ulong4, ulong4, ulong4); -long8 __ovld __cnfn bitselect(long8, long8, long8); -ulong8 __ovld __cnfn bitselect(ulong8, ulong8, ulong8); -long16 __ovld __cnfn bitselect(long16, long16, long16); -ulong16 __ovld __cnfn bitselect(ulong16, ulong16, ulong16); -float __ovld __cnfn bitselect(float, float, float); -float2 __ovld __cnfn bitselect(float2, float2, float2); -float3 __ovld __cnfn bitselect(float3, float3, float3); -float4 __ovld __cnfn bitselect(float4, float4, float4); -float8 __ovld __cnfn bitselect(float8, float8, float8); -float16 __ovld __cnfn bitselect(float16, float16, float16); -#ifdef cl_khr_fp64 -double __ovld __cnfn bitselect(double, double, double); -double2 __ovld __cnfn bitselect(double2, double2, double2); -double3 __ovld __cnfn bitselect(double3, double3, double3); -double4 __ovld __cnfn bitselect(double4, double4, double4); -double8 __ovld __cnfn bitselect(double8, double8, double8); -double16 __ovld __cnfn bitselect(double16, double16, double16); -#endif //cl_khr_fp64 -#ifdef cl_khr_fp16 -half __ovld __cnfn bitselect(half, half, half); -half2 __ovld __cnfn bitselect(half2, half2, half2); -half3 __ovld __cnfn bitselect(half3, half3, half3); -half4 __ovld __cnfn bitselect(half4, half4, half4); -half8 __ovld __cnfn bitselect(half8, half8, half8); -half16 __ovld __cnfn bitselect(half16, half16, half16); -#endif //cl_khr_fp16 - -/** - * For each component of a vector type, - * result[i] = if MSB of c[i] is set ? b[i] : a[i]. - * For a scalar type, result = c ? b : a. - * b and a must have the same type. - * c must have the same number of elements and bits as a. - */ -char __ovld __cnfn select(char, char, char); -uchar __ovld __cnfn select(uchar, uchar, char); -char2 __ovld __cnfn select(char2, char2, char2); -uchar2 __ovld __cnfn select(uchar2, uchar2, char2); -char3 __ovld __cnfn select(char3, char3, char3); -uchar3 __ovld __cnfn select(uchar3, uchar3, char3); -char4 __ovld __cnfn select(char4, char4, char4); -uchar4 __ovld __cnfn select(uchar4, uchar4, char4); -char8 __ovld __cnfn select(char8, char8, char8); -uchar8 __ovld __cnfn select(uchar8, uchar8, char8); -char16 __ovld __cnfn select(char16, char16, char16); -uchar16 __ovld __cnfn select(uchar16, uchar16, char16); - -short __ovld __cnfn select(short, short, short); -ushort __ovld __cnfn select(ushort, ushort, short); -short2 __ovld __cnfn select(short2, short2, short2); -ushort2 __ovld __cnfn select(ushort2, ushort2, short2); -short3 __ovld __cnfn select(short3, short3, short3); -ushort3 __ovld __cnfn select(ushort3, ushort3, short3); -short4 __ovld __cnfn select(short4, short4, short4); -ushort4 __ovld __cnfn select(ushort4, ushort4, short4); -short8 __ovld __cnfn select(short8, short8, short8); -ushort8 __ovld __cnfn select(ushort8, ushort8, short8); -short16 __ovld __cnfn select(short16, short16, short16); -ushort16 __ovld __cnfn select(ushort16, ushort16, short16); - -int __ovld __cnfn select(int, int, int); -uint __ovld __cnfn select(uint, uint, int); -int2 __ovld __cnfn select(int2, int2, int2); -uint2 __ovld __cnfn select(uint2, uint2, int2); -int3 __ovld __cnfn select(int3, int3, int3); -uint3 __ovld __cnfn select(uint3, uint3, int3); -int4 __ovld __cnfn select(int4, int4, int4); -uint4 __ovld __cnfn select(uint4, uint4, int4); -int8 __ovld __cnfn select(int8, int8, int8); -uint8 __ovld __cnfn select(uint8, uint8, int8); -int16 __ovld __cnfn select(int16, int16, int16); -uint16 __ovld __cnfn select(uint16, uint16, int16); -float __ovld __cnfn select(float, float, int); -float2 __ovld __cnfn select(float2, float2, int2); -float3 __ovld __cnfn select(float3, float3, int3); -float4 __ovld __cnfn select(float4, float4, int4); -float8 __ovld __cnfn select(float8, float8, int8); -float16 __ovld __cnfn select(float16, float16, int16); - -long __ovld __cnfn select(long, long, long); -ulong __ovld __cnfn select(ulong, ulong, long); -long2 __ovld __cnfn select(long2, long2, long2); -ulong2 __ovld __cnfn select(ulong2, ulong2, long2); -long3 __ovld __cnfn select(long3, long3, long3); -ulong3 __ovld __cnfn select(ulong3, ulong3, long3); -long4 __ovld __cnfn select(long4, long4, long4); -ulong4 __ovld __cnfn select(ulong4, ulong4, long4); -long8 __ovld __cnfn select(long8, long8, long8); -ulong8 __ovld __cnfn select(ulong8, ulong8, long8); -long16 __ovld __cnfn select(long16, long16, long16); -ulong16 __ovld __cnfn select(ulong16, ulong16, long16); - -char __ovld __cnfn select(char, char, uchar); -uchar __ovld __cnfn select(uchar, uchar, uchar); -char2 __ovld __cnfn select(char2, char2, uchar2); -uchar2 __ovld __cnfn select(uchar2, uchar2, uchar2); -char3 __ovld __cnfn select(char3, char3, uchar3); -uchar3 __ovld __cnfn select(uchar3, uchar3, uchar3); -char4 __ovld __cnfn select(char4, char4, uchar4); -uchar4 __ovld __cnfn select(uchar4, uchar4, uchar4); -char8 __ovld __cnfn select(char8, char8, uchar8); -uchar8 __ovld __cnfn select(uchar8, uchar8, uchar8); -char16 __ovld __cnfn select(char16, char16, uchar16); -uchar16 __ovld __cnfn select(uchar16, uchar16, uchar16); - -short __ovld __cnfn select(short, short, ushort); -ushort __ovld __cnfn select(ushort, ushort, ushort); -short2 __ovld __cnfn select(short2, short2, ushort2); -ushort2 __ovld __cnfn select(ushort2, ushort2, ushort2); -short3 __ovld __cnfn select(short3, short3, ushort3); -ushort3 __ovld __cnfn select(ushort3, ushort3, ushort3); -short4 __ovld __cnfn select(short4, short4, ushort4); -ushort4 __ovld __cnfn select(ushort4, ushort4, ushort4); -short8 __ovld __cnfn select(short8, short8, ushort8); -ushort8 __ovld __cnfn select(ushort8, ushort8, ushort8); -short16 __ovld __cnfn select(short16, short16, ushort16); -ushort16 __ovld __cnfn select(ushort16, ushort16, ushort16); - -int __ovld __cnfn select(int, int, uint); -uint __ovld __cnfn select(uint, uint, uint); -int2 __ovld __cnfn select(int2, int2, uint2); -uint2 __ovld __cnfn select(uint2, uint2, uint2); -int3 __ovld __cnfn select(int3, int3, uint3); -uint3 __ovld __cnfn select(uint3, uint3, uint3); -int4 __ovld __cnfn select(int4, int4, uint4); -uint4 __ovld __cnfn select(uint4, uint4, uint4); -int8 __ovld __cnfn select(int8, int8, uint8); -uint8 __ovld __cnfn select(uint8, uint8, uint8); -int16 __ovld __cnfn select(int16, int16, uint16); -uint16 __ovld __cnfn select(uint16, uint16, uint16); -float __ovld __cnfn select(float, float, uint); -float2 __ovld __cnfn select(float2, float2, uint2); -float3 __ovld __cnfn select(float3, float3, uint3); -float4 __ovld __cnfn select(float4, float4, uint4); -float8 __ovld __cnfn select(float8, float8, uint8); -float16 __ovld __cnfn select(float16, float16, uint16); - -long __ovld __cnfn select(long, long, ulong); -ulong __ovld __cnfn select(ulong, ulong, ulong); -long2 __ovld __cnfn select(long2, long2, ulong2); -ulong2 __ovld __cnfn select(ulong2, ulong2, ulong2); -long3 __ovld __cnfn select(long3, long3, ulong3); -ulong3 __ovld __cnfn select(ulong3, ulong3, ulong3); -long4 __ovld __cnfn select(long4, long4, ulong4); -ulong4 __ovld __cnfn select(ulong4, ulong4, ulong4); -long8 __ovld __cnfn select(long8, long8, ulong8); -ulong8 __ovld __cnfn select(ulong8, ulong8, ulong8); -long16 __ovld __cnfn select(long16, long16, ulong16); -ulong16 __ovld __cnfn select(ulong16, ulong16, ulong16); - -#ifdef cl_khr_fp64 -double __ovld __cnfn select(double, double, long); -double2 __ovld __cnfn select(double2, double2, long2); -double3 __ovld __cnfn select(double3, double3, long3); -double4 __ovld __cnfn select(double4, double4, long4); -double8 __ovld __cnfn select(double8, double8, long8); -double16 __ovld __cnfn select(double16, double16, long16); -double __ovld __cnfn select(double, double, ulong); -double2 __ovld __cnfn select(double2, double2, ulong2); -double3 __ovld __cnfn select(double3, double3, ulong3); -double4 __ovld __cnfn select(double4, double4, ulong4); -double8 __ovld __cnfn select(double8, double8, ulong8); -double16 __ovld __cnfn select(double16, double16, ulong16); -#endif //cl_khr_fp64 -#ifdef cl_khr_fp16 -half __ovld __cnfn select(half, half, short); -half2 __ovld __cnfn select(half2, half2, short2); -half3 __ovld __cnfn select(half3, half3, short3); -half4 __ovld __cnfn select(half4, half4, short4); -half8 __ovld __cnfn select(half8, half8, short8); -half16 __ovld __cnfn select(half16, half16, short16); -half __ovld __cnfn select(half, half, ushort); -half2 __ovld __cnfn select(half2, half2, ushort2); -half3 __ovld __cnfn select(half3, half3, ushort3); -half4 __ovld __cnfn select(half4, half4, ushort4); -half8 __ovld __cnfn select(half8, half8, ushort8); -half16 __ovld __cnfn select(half16, half16, ushort16); -#endif //cl_khr_fp16 - -// OpenCL v1.1 s6.11.7, v1.2 s6.12.7, v2.0 s6.13.7 - Vector Data Load and Store Functions -// OpenCL extensions v1.1 s9.6.6, v1.2 s9.5.6, v2.0 s9.4.6 - Vector Data Load and Store Functions for Half Type -/** - * Use generic type gentype to indicate the built-in data types - * char, uchar, short, ushort, int, uint, long, ulong, float, - * double or half. - * - * vloadn return sizeof (gentypen) bytes of data read from address (p + (offset * n)). - * - * vstoren write sizeof (gentypen) bytes given by data to address (p + (offset * n)). - * - * The address computed as (p + (offset * n)) must be - * 8-bit aligned if gentype is char, uchar; - * 16-bit aligned if gentype is short, ushort, half; - * 32-bit aligned if gentype is int, uint, float; - * 64-bit aligned if gentype is long, ulong, double. - */ - -char2 __ovld __purefn vload2(size_t, const __constant char *); -uchar2 __ovld __purefn vload2(size_t, const __constant uchar *); -short2 __ovld __purefn vload2(size_t, const __constant short *); -ushort2 __ovld __purefn vload2(size_t, const __constant ushort *); -int2 __ovld __purefn vload2(size_t, const __constant int *); -uint2 __ovld __purefn vload2(size_t, const __constant uint *); -long2 __ovld __purefn vload2(size_t, const __constant long *); -ulong2 __ovld __purefn vload2(size_t, const __constant ulong *); -float2 __ovld __purefn vload2(size_t, const __constant float *); -char3 __ovld __purefn vload3(size_t, const __constant char *); -uchar3 __ovld __purefn vload3(size_t, const __constant uchar *); -short3 __ovld __purefn vload3(size_t, const __constant short *); -ushort3 __ovld __purefn vload3(size_t, const __constant ushort *); -int3 __ovld __purefn vload3(size_t, const __constant int *); -uint3 __ovld __purefn vload3(size_t, const __constant uint *); -long3 __ovld __purefn vload3(size_t, const __constant long *); -ulong3 __ovld __purefn vload3(size_t, const __constant ulong *); -float3 __ovld __purefn vload3(size_t, const __constant float *); -char4 __ovld __purefn vload4(size_t, const __constant char *); -uchar4 __ovld __purefn vload4(size_t, const __constant uchar *); -short4 __ovld __purefn vload4(size_t, const __constant short *); -ushort4 __ovld __purefn vload4(size_t, const __constant ushort *); -int4 __ovld __purefn vload4(size_t, const __constant int *); -uint4 __ovld __purefn vload4(size_t, const __constant uint *); -long4 __ovld __purefn vload4(size_t, const __constant long *); -ulong4 __ovld __purefn vload4(size_t, const __constant ulong *); -float4 __ovld __purefn vload4(size_t, const __constant float *); -char8 __ovld __purefn vload8(size_t, const __constant char *); -uchar8 __ovld __purefn vload8(size_t, const __constant uchar *); -short8 __ovld __purefn vload8(size_t, const __constant short *); -ushort8 __ovld __purefn vload8(size_t, const __constant ushort *); -int8 __ovld __purefn vload8(size_t, const __constant int *); -uint8 __ovld __purefn vload8(size_t, const __constant uint *); -long8 __ovld __purefn vload8(size_t, const __constant long *); -ulong8 __ovld __purefn vload8(size_t, const __constant ulong *); -float8 __ovld __purefn vload8(size_t, const __constant float *); -char16 __ovld __purefn vload16(size_t, const __constant char *); -uchar16 __ovld __purefn vload16(size_t, const __constant uchar *); -short16 __ovld __purefn vload16(size_t, const __constant short *); -ushort16 __ovld __purefn vload16(size_t, const __constant ushort *); -int16 __ovld __purefn vload16(size_t, const __constant int *); -uint16 __ovld __purefn vload16(size_t, const __constant uint *); -long16 __ovld __purefn vload16(size_t, const __constant long *); -ulong16 __ovld __purefn vload16(size_t, const __constant ulong *); -float16 __ovld __purefn vload16(size_t, const __constant float *); -#ifdef cl_khr_fp64 -double2 __ovld __purefn vload2(size_t, const __constant double *); -double3 __ovld __purefn vload3(size_t, const __constant double *); -double4 __ovld __purefn vload4(size_t, const __constant double *); -double8 __ovld __purefn vload8(size_t, const __constant double *); -double16 __ovld __purefn vload16(size_t, const __constant double *); -#endif //cl_khr_fp64 - -#ifdef cl_khr_fp16 -half2 __ovld __purefn vload2(size_t, const __constant half *); -half3 __ovld __purefn vload3(size_t, const __constant half *); -half4 __ovld __purefn vload4(size_t, const __constant half *); -half8 __ovld __purefn vload8(size_t, const __constant half *); -half16 __ovld __purefn vload16(size_t, const __constant half *); -#endif //cl_khr_fp16 - -#if defined(__opencl_c_generic_address_space) -char2 __ovld __purefn vload2(size_t, const char *); -uchar2 __ovld __purefn vload2(size_t, const uchar *); -short2 __ovld __purefn vload2(size_t, const short *); -ushort2 __ovld __purefn vload2(size_t, const ushort *); -int2 __ovld __purefn vload2(size_t, const int *); -uint2 __ovld __purefn vload2(size_t, const uint *); -long2 __ovld __purefn vload2(size_t, const long *); -ulong2 __ovld __purefn vload2(size_t, const ulong *); -float2 __ovld __purefn vload2(size_t, const float *); -char3 __ovld __purefn vload3(size_t, const char *); -uchar3 __ovld __purefn vload3(size_t, const uchar *); -short3 __ovld __purefn vload3(size_t, const short *); -ushort3 __ovld __purefn vload3(size_t, const ushort *); -int3 __ovld __purefn vload3(size_t, const int *); -uint3 __ovld __purefn vload3(size_t, const uint *); -long3 __ovld __purefn vload3(size_t, const long *); -ulong3 __ovld __purefn vload3(size_t, const ulong *); -float3 __ovld __purefn vload3(size_t, const float *); -char4 __ovld __purefn vload4(size_t, const char *); -uchar4 __ovld __purefn vload4(size_t, const uchar *); -short4 __ovld __purefn vload4(size_t, const short *); -ushort4 __ovld __purefn vload4(size_t, const ushort *); -int4 __ovld __purefn vload4(size_t, const int *); -uint4 __ovld __purefn vload4(size_t, const uint *); -long4 __ovld __purefn vload4(size_t, const long *); -ulong4 __ovld __purefn vload4(size_t, const ulong *); -float4 __ovld __purefn vload4(size_t, const float *); -char8 __ovld __purefn vload8(size_t, const char *); -uchar8 __ovld __purefn vload8(size_t, const uchar *); -short8 __ovld __purefn vload8(size_t, const short *); -ushort8 __ovld __purefn vload8(size_t, const ushort *); -int8 __ovld __purefn vload8(size_t, const int *); -uint8 __ovld __purefn vload8(size_t, const uint *); -long8 __ovld __purefn vload8(size_t, const long *); -ulong8 __ovld __purefn vload8(size_t, const ulong *); -float8 __ovld __purefn vload8(size_t, const float *); -char16 __ovld __purefn vload16(size_t, const char *); -uchar16 __ovld __purefn vload16(size_t, const uchar *); -short16 __ovld __purefn vload16(size_t, const short *); -ushort16 __ovld __purefn vload16(size_t, const ushort *); -int16 __ovld __purefn vload16(size_t, const int *); -uint16 __ovld __purefn vload16(size_t, const uint *); -long16 __ovld __purefn vload16(size_t, const long *); -ulong16 __ovld __purefn vload16(size_t, const ulong *); -float16 __ovld __purefn vload16(size_t, const float *); - -#ifdef cl_khr_fp64 -double2 __ovld __purefn vload2(size_t, const double *); -double3 __ovld __purefn vload3(size_t, const double *); -double4 __ovld __purefn vload4(size_t, const double *); -double8 __ovld __purefn vload8(size_t, const double *); -double16 __ovld __purefn vload16(size_t, const double *); -#endif //cl_khr_fp64 - -#ifdef cl_khr_fp16 -half2 __ovld __purefn vload2(size_t, const half *); -half3 __ovld __purefn vload3(size_t, const half *); -half4 __ovld __purefn vload4(size_t, const half *); -half8 __ovld __purefn vload8(size_t, const half *); -half16 __ovld __purefn vload16(size_t, const half *); -#endif //cl_khr_fp16 -#endif //defined(__opencl_c_generic_address_space) - -#if defined(__opencl_c_named_address_space_builtins) -char2 __ovld __purefn vload2(size_t, const __global char *); -uchar2 __ovld __purefn vload2(size_t, const __global uchar *); -short2 __ovld __purefn vload2(size_t, const __global short *); -ushort2 __ovld __purefn vload2(size_t, const __global ushort *); -int2 __ovld __purefn vload2(size_t, const __global int *); -uint2 __ovld __purefn vload2(size_t, const __global uint *); -long2 __ovld __purefn vload2(size_t, const __global long *); -ulong2 __ovld __purefn vload2(size_t, const __global ulong *); -float2 __ovld __purefn vload2(size_t, const __global float *); -char3 __ovld __purefn vload3(size_t, const __global char *); -uchar3 __ovld __purefn vload3(size_t, const __global uchar *); -short3 __ovld __purefn vload3(size_t, const __global short *); -ushort3 __ovld __purefn vload3(size_t, const __global ushort *); -int3 __ovld __purefn vload3(size_t, const __global int *); -uint3 __ovld __purefn vload3(size_t, const __global uint *); -long3 __ovld __purefn vload3(size_t, const __global long *); -ulong3 __ovld __purefn vload3(size_t, const __global ulong *); -float3 __ovld __purefn vload3(size_t, const __global float *); -char4 __ovld __purefn vload4(size_t, const __global char *); -uchar4 __ovld __purefn vload4(size_t, const __global uchar *); -short4 __ovld __purefn vload4(size_t, const __global short *); -ushort4 __ovld __purefn vload4(size_t, const __global ushort *); -int4 __ovld __purefn vload4(size_t, const __global int *); -uint4 __ovld __purefn vload4(size_t, const __global uint *); -long4 __ovld __purefn vload4(size_t, const __global long *); -ulong4 __ovld __purefn vload4(size_t, const __global ulong *); -float4 __ovld __purefn vload4(size_t, const __global float *); -char8 __ovld __purefn vload8(size_t, const __global char *); -uchar8 __ovld __purefn vload8(size_t, const __global uchar *); -short8 __ovld __purefn vload8(size_t, const __global short *); -ushort8 __ovld __purefn vload8(size_t, const __global ushort *); -int8 __ovld __purefn vload8(size_t, const __global int *); -uint8 __ovld __purefn vload8(size_t, const __global uint *); -long8 __ovld __purefn vload8(size_t, const __global long *); -ulong8 __ovld __purefn vload8(size_t, const __global ulong *); -float8 __ovld __purefn vload8(size_t, const __global float *); -char16 __ovld __purefn vload16(size_t, const __global char *); -uchar16 __ovld __purefn vload16(size_t, const __global uchar *); -short16 __ovld __purefn vload16(size_t, const __global short *); -ushort16 __ovld __purefn vload16(size_t, const __global ushort *); -int16 __ovld __purefn vload16(size_t, const __global int *); -uint16 __ovld __purefn vload16(size_t, const __global uint *); -long16 __ovld __purefn vload16(size_t, const __global long *); -ulong16 __ovld __purefn vload16(size_t, const __global ulong *); -float16 __ovld __purefn vload16(size_t, const __global float *); -char2 __ovld __purefn vload2(size_t, const __local char *); -uchar2 __ovld __purefn vload2(size_t, const __local uchar *); -short2 __ovld __purefn vload2(size_t, const __local short *); -ushort2 __ovld __purefn vload2(size_t, const __local ushort *); -int2 __ovld __purefn vload2(size_t, const __local int *); -uint2 __ovld __purefn vload2(size_t, const __local uint *); -long2 __ovld __purefn vload2(size_t, const __local long *); -ulong2 __ovld __purefn vload2(size_t, const __local ulong *); -float2 __ovld __purefn vload2(size_t, const __local float *); -char3 __ovld __purefn vload3(size_t, const __local char *); -uchar3 __ovld __purefn vload3(size_t, const __local uchar *); -short3 __ovld __purefn vload3(size_t, const __local short *); -ushort3 __ovld __purefn vload3(size_t, const __local ushort *); -int3 __ovld __purefn vload3(size_t, const __local int *); -uint3 __ovld __purefn vload3(size_t, const __local uint *); -long3 __ovld __purefn vload3(size_t, const __local long *); -ulong3 __ovld __purefn vload3(size_t, const __local ulong *); -float3 __ovld __purefn vload3(size_t, const __local float *); -char4 __ovld __purefn vload4(size_t, const __local char *); -uchar4 __ovld __purefn vload4(size_t, const __local uchar *); -short4 __ovld __purefn vload4(size_t, const __local short *); -ushort4 __ovld __purefn vload4(size_t, const __local ushort *); -int4 __ovld __purefn vload4(size_t, const __local int *); -uint4 __ovld __purefn vload4(size_t, const __local uint *); -long4 __ovld __purefn vload4(size_t, const __local long *); -ulong4 __ovld __purefn vload4(size_t, const __local ulong *); -float4 __ovld __purefn vload4(size_t, const __local float *); -char8 __ovld __purefn vload8(size_t, const __local char *); -uchar8 __ovld __purefn vload8(size_t, const __local uchar *); -short8 __ovld __purefn vload8(size_t, const __local short *); -ushort8 __ovld __purefn vload8(size_t, const __local ushort *); -int8 __ovld __purefn vload8(size_t, const __local int *); -uint8 __ovld __purefn vload8(size_t, const __local uint *); -long8 __ovld __purefn vload8(size_t, const __local long *); -ulong8 __ovld __purefn vload8(size_t, const __local ulong *); -float8 __ovld __purefn vload8(size_t, const __local float *); -char16 __ovld __purefn vload16(size_t, const __local char *); -uchar16 __ovld __purefn vload16(size_t, const __local uchar *); -short16 __ovld __purefn vload16(size_t, const __local short *); -ushort16 __ovld __purefn vload16(size_t, const __local ushort *); -int16 __ovld __purefn vload16(size_t, const __local int *); -uint16 __ovld __purefn vload16(size_t, const __local uint *); -long16 __ovld __purefn vload16(size_t, const __local long *); -ulong16 __ovld __purefn vload16(size_t, const __local ulong *); -float16 __ovld __purefn vload16(size_t, const __local float *); -char2 __ovld __purefn vload2(size_t, const __private char *); -uchar2 __ovld __purefn vload2(size_t, const __private uchar *); -short2 __ovld __purefn vload2(size_t, const __private short *); -ushort2 __ovld __purefn vload2(size_t, const __private ushort *); -int2 __ovld __purefn vload2(size_t, const __private int *); -uint2 __ovld __purefn vload2(size_t, const __private uint *); -long2 __ovld __purefn vload2(size_t, const __private long *); -ulong2 __ovld __purefn vload2(size_t, const __private ulong *); -float2 __ovld __purefn vload2(size_t, const __private float *); -char3 __ovld __purefn vload3(size_t, const __private char *); -uchar3 __ovld __purefn vload3(size_t, const __private uchar *); -short3 __ovld __purefn vload3(size_t, const __private short *); -ushort3 __ovld __purefn vload3(size_t, const __private ushort *); -int3 __ovld __purefn vload3(size_t, const __private int *); -uint3 __ovld __purefn vload3(size_t, const __private uint *); -long3 __ovld __purefn vload3(size_t, const __private long *); -ulong3 __ovld __purefn vload3(size_t, const __private ulong *); -float3 __ovld __purefn vload3(size_t, const __private float *); -char4 __ovld __purefn vload4(size_t, const __private char *); -uchar4 __ovld __purefn vload4(size_t, const __private uchar *); -short4 __ovld __purefn vload4(size_t, const __private short *); -ushort4 __ovld __purefn vload4(size_t, const __private ushort *); -int4 __ovld __purefn vload4(size_t, const __private int *); -uint4 __ovld __purefn vload4(size_t, const __private uint *); -long4 __ovld __purefn vload4(size_t, const __private long *); -ulong4 __ovld __purefn vload4(size_t, const __private ulong *); -float4 __ovld __purefn vload4(size_t, const __private float *); -char8 __ovld __purefn vload8(size_t, const __private char *); -uchar8 __ovld __purefn vload8(size_t, const __private uchar *); -short8 __ovld __purefn vload8(size_t, const __private short *); -ushort8 __ovld __purefn vload8(size_t, const __private ushort *); -int8 __ovld __purefn vload8(size_t, const __private int *); -uint8 __ovld __purefn vload8(size_t, const __private uint *); -long8 __ovld __purefn vload8(size_t, const __private long *); -ulong8 __ovld __purefn vload8(size_t, const __private ulong *); -float8 __ovld __purefn vload8(size_t, const __private float *); -char16 __ovld __purefn vload16(size_t, const __private char *); -uchar16 __ovld __purefn vload16(size_t, const __private uchar *); -short16 __ovld __purefn vload16(size_t, const __private short *); -ushort16 __ovld __purefn vload16(size_t, const __private ushort *); -int16 __ovld __purefn vload16(size_t, const __private int *); -uint16 __ovld __purefn vload16(size_t, const __private uint *); -long16 __ovld __purefn vload16(size_t, const __private long *); -ulong16 __ovld __purefn vload16(size_t, const __private ulong *); -float16 __ovld __purefn vload16(size_t, const __private float *); - -#ifdef cl_khr_fp64 -double2 __ovld __purefn vload2(size_t, const __global double *); -double3 __ovld __purefn vload3(size_t, const __global double *); -double4 __ovld __purefn vload4(size_t, const __global double *); -double8 __ovld __purefn vload8(size_t, const __global double *); -double16 __ovld __purefn vload16(size_t, const __global double *); -double2 __ovld __purefn vload2(size_t, const __local double *); -double3 __ovld __purefn vload3(size_t, const __local double *); -double4 __ovld __purefn vload4(size_t, const __local double *); -double8 __ovld __purefn vload8(size_t, const __local double *); -double16 __ovld __purefn vload16(size_t, const __local double *); -double2 __ovld __purefn vload2(size_t, const __private double *); -double3 __ovld __purefn vload3(size_t, const __private double *); -double4 __ovld __purefn vload4(size_t, const __private double *); -double8 __ovld __purefn vload8(size_t, const __private double *); -double16 __ovld __purefn vload16(size_t, const __private double *); -#endif //cl_khr_fp64 - -#ifdef cl_khr_fp16 -half2 __ovld __purefn vload2(size_t, const __global half *); -half3 __ovld __purefn vload3(size_t, const __global half *); -half4 __ovld __purefn vload4(size_t, const __global half *); -half8 __ovld __purefn vload8(size_t, const __global half *); -half16 __ovld __purefn vload16(size_t, const __global half *); -half2 __ovld __purefn vload2(size_t, const __local half *); -half3 __ovld __purefn vload3(size_t, const __local half *); -half4 __ovld __purefn vload4(size_t, const __local half *); -half8 __ovld __purefn vload8(size_t, const __local half *); -half16 __ovld __purefn vload16(size_t, const __local half *); -half2 __ovld __purefn vload2(size_t, const __private half *); -half3 __ovld __purefn vload3(size_t, const __private half *); -half4 __ovld __purefn vload4(size_t, const __private half *); -half8 __ovld __purefn vload8(size_t, const __private half *); -half16 __ovld __purefn vload16(size_t, const __private half *); -#endif //cl_khr_fp16 -#endif //defined(__opencl_c_named_address_space_builtins) - -#if defined(__opencl_c_generic_address_space) -void __ovld vstore2(char2, size_t, char *); -void __ovld vstore2(uchar2, size_t, uchar *); -void __ovld vstore2(short2, size_t, short *); -void __ovld vstore2(ushort2, size_t, ushort *); -void __ovld vstore2(int2, size_t, int *); -void __ovld vstore2(uint2, size_t, uint *); -void __ovld vstore2(long2, size_t, long *); -void __ovld vstore2(ulong2, size_t, ulong *); -void __ovld vstore2(float2, size_t, float *); -void __ovld vstore3(char3, size_t, char *); -void __ovld vstore3(uchar3, size_t, uchar *); -void __ovld vstore3(short3, size_t, short *); -void __ovld vstore3(ushort3, size_t, ushort *); -void __ovld vstore3(int3, size_t, int *); -void __ovld vstore3(uint3, size_t, uint *); -void __ovld vstore3(long3, size_t, long *); -void __ovld vstore3(ulong3, size_t, ulong *); -void __ovld vstore3(float3, size_t, float *); -void __ovld vstore4(char4, size_t, char *); -void __ovld vstore4(uchar4, size_t, uchar *); -void __ovld vstore4(short4, size_t, short *); -void __ovld vstore4(ushort4, size_t, ushort *); -void __ovld vstore4(int4, size_t, int *); -void __ovld vstore4(uint4, size_t, uint *); -void __ovld vstore4(long4, size_t, long *); -void __ovld vstore4(ulong4, size_t, ulong *); -void __ovld vstore4(float4, size_t, float *); -void __ovld vstore8(char8, size_t, char *); -void __ovld vstore8(uchar8, size_t, uchar *); -void __ovld vstore8(short8, size_t, short *); -void __ovld vstore8(ushort8, size_t, ushort *); -void __ovld vstore8(int8, size_t, int *); -void __ovld vstore8(uint8, size_t, uint *); -void __ovld vstore8(long8, size_t, long *); -void __ovld vstore8(ulong8, size_t, ulong *); -void __ovld vstore8(float8, size_t, float *); -void __ovld vstore16(char16, size_t, char *); -void __ovld vstore16(uchar16, size_t, uchar *); -void __ovld vstore16(short16, size_t, short *); -void __ovld vstore16(ushort16, size_t, ushort *); -void __ovld vstore16(int16, size_t, int *); -void __ovld vstore16(uint16, size_t, uint *); -void __ovld vstore16(long16, size_t, long *); -void __ovld vstore16(ulong16, size_t, ulong *); -void __ovld vstore16(float16, size_t, float *); -#ifdef cl_khr_fp64 -void __ovld vstore2(double2, size_t, double *); -void __ovld vstore3(double3, size_t, double *); -void __ovld vstore4(double4, size_t, double *); -void __ovld vstore8(double8, size_t, double *); -void __ovld vstore16(double16, size_t, double *); -#endif //cl_khr_fp64 -#ifdef cl_khr_fp16 -void __ovld vstore2(half2, size_t, half *); -void __ovld vstore3(half3, size_t, half *); -void __ovld vstore4(half4, size_t, half *); -void __ovld vstore8(half8, size_t, half *); -void __ovld vstore16(half16, size_t, half *); -#endif //cl_khr_fp16 -#endif //defined(__opencl_c_generic_address_space) - -#if defined(__opencl_c_named_address_space_builtins) -void __ovld vstore2(char2, size_t, __global char *); -void __ovld vstore2(uchar2, size_t, __global uchar *); -void __ovld vstore2(short2, size_t, __global short *); -void __ovld vstore2(ushort2, size_t, __global ushort *); -void __ovld vstore2(int2, size_t, __global int *); -void __ovld vstore2(uint2, size_t, __global uint *); -void __ovld vstore2(long2, size_t, __global long *); -void __ovld vstore2(ulong2, size_t, __global ulong *); -void __ovld vstore2(float2, size_t, __global float *); -void __ovld vstore3(char3, size_t, __global char *); -void __ovld vstore3(uchar3, size_t, __global uchar *); -void __ovld vstore3(short3, size_t, __global short *); -void __ovld vstore3(ushort3, size_t, __global ushort *); -void __ovld vstore3(int3, size_t, __global int *); -void __ovld vstore3(uint3, size_t, __global uint *); -void __ovld vstore3(long3, size_t, __global long *); -void __ovld vstore3(ulong3, size_t, __global ulong *); -void __ovld vstore3(float3, size_t, __global float *); -void __ovld vstore4(char4, size_t, __global char *); -void __ovld vstore4(uchar4, size_t, __global uchar *); -void __ovld vstore4(short4, size_t, __global short *); -void __ovld vstore4(ushort4, size_t, __global ushort *); -void __ovld vstore4(int4, size_t, __global int *); -void __ovld vstore4(uint4, size_t, __global uint *); -void __ovld vstore4(long4, size_t, __global long *); -void __ovld vstore4(ulong4, size_t, __global ulong *); -void __ovld vstore4(float4, size_t, __global float *); -void __ovld vstore8(char8, size_t, __global char *); -void __ovld vstore8(uchar8, size_t, __global uchar *); -void __ovld vstore8(short8, size_t, __global short *); -void __ovld vstore8(ushort8, size_t, __global ushort *); -void __ovld vstore8(int8, size_t, __global int *); -void __ovld vstore8(uint8, size_t, __global uint *); -void __ovld vstore8(long8, size_t, __global long *); -void __ovld vstore8(ulong8, size_t, __global ulong *); -void __ovld vstore8(float8, size_t, __global float *); -void __ovld vstore16(char16, size_t, __global char *); -void __ovld vstore16(uchar16, size_t, __global uchar *); -void __ovld vstore16(short16, size_t, __global short *); -void __ovld vstore16(ushort16, size_t, __global ushort *); -void __ovld vstore16(int16, size_t, __global int *); -void __ovld vstore16(uint16, size_t, __global uint *); -void __ovld vstore16(long16, size_t, __global long *); -void __ovld vstore16(ulong16, size_t, __global ulong *); -void __ovld vstore16(float16, size_t, __global float *); -void __ovld vstore2(char2, size_t, __local char *); -void __ovld vstore2(uchar2, size_t, __local uchar *); -void __ovld vstore2(short2, size_t, __local short *); -void __ovld vstore2(ushort2, size_t, __local ushort *); -void __ovld vstore2(int2, size_t, __local int *); -void __ovld vstore2(uint2, size_t, __local uint *); -void __ovld vstore2(long2, size_t, __local long *); -void __ovld vstore2(ulong2, size_t, __local ulong *); -void __ovld vstore2(float2, size_t, __local float *); -void __ovld vstore3(char3, size_t, __local char *); -void __ovld vstore3(uchar3, size_t, __local uchar *); -void __ovld vstore3(short3, size_t, __local short *); -void __ovld vstore3(ushort3, size_t, __local ushort *); -void __ovld vstore3(int3, size_t, __local int *); -void __ovld vstore3(uint3, size_t, __local uint *); -void __ovld vstore3(long3, size_t, __local long *); -void __ovld vstore3(ulong3, size_t, __local ulong *); -void __ovld vstore3(float3, size_t, __local float *); -void __ovld vstore4(char4, size_t, __local char *); -void __ovld vstore4(uchar4, size_t, __local uchar *); -void __ovld vstore4(short4, size_t, __local short *); -void __ovld vstore4(ushort4, size_t, __local ushort *); -void __ovld vstore4(int4, size_t, __local int *); -void __ovld vstore4(uint4, size_t, __local uint *); -void __ovld vstore4(long4, size_t, __local long *); -void __ovld vstore4(ulong4, size_t, __local ulong *); -void __ovld vstore4(float4, size_t, __local float *); -void __ovld vstore8(char8, size_t, __local char *); -void __ovld vstore8(uchar8, size_t, __local uchar *); -void __ovld vstore8(short8, size_t, __local short *); -void __ovld vstore8(ushort8, size_t, __local ushort *); -void __ovld vstore8(int8, size_t, __local int *); -void __ovld vstore8(uint8, size_t, __local uint *); -void __ovld vstore8(long8, size_t, __local long *); -void __ovld vstore8(ulong8, size_t, __local ulong *); -void __ovld vstore8(float8, size_t, __local float *); -void __ovld vstore16(char16, size_t, __local char *); -void __ovld vstore16(uchar16, size_t, __local uchar *); -void __ovld vstore16(short16, size_t, __local short *); -void __ovld vstore16(ushort16, size_t, __local ushort *); -void __ovld vstore16(int16, size_t, __local int *); -void __ovld vstore16(uint16, size_t, __local uint *); -void __ovld vstore16(long16, size_t, __local long *); -void __ovld vstore16(ulong16, size_t, __local ulong *); -void __ovld vstore16(float16, size_t, __local float *); -void __ovld vstore2(char2, size_t, __private char *); -void __ovld vstore2(uchar2, size_t, __private uchar *); -void __ovld vstore2(short2, size_t, __private short *); -void __ovld vstore2(ushort2, size_t, __private ushort *); -void __ovld vstore2(int2, size_t, __private int *); -void __ovld vstore2(uint2, size_t, __private uint *); -void __ovld vstore2(long2, size_t, __private long *); -void __ovld vstore2(ulong2, size_t, __private ulong *); -void __ovld vstore2(float2, size_t, __private float *); -void __ovld vstore3(char3, size_t, __private char *); -void __ovld vstore3(uchar3, size_t, __private uchar *); -void __ovld vstore3(short3, size_t, __private short *); -void __ovld vstore3(ushort3, size_t, __private ushort *); -void __ovld vstore3(int3, size_t, __private int *); -void __ovld vstore3(uint3, size_t, __private uint *); -void __ovld vstore3(long3, size_t, __private long *); -void __ovld vstore3(ulong3, size_t, __private ulong *); -void __ovld vstore3(float3, size_t, __private float *); -void __ovld vstore4(char4, size_t, __private char *); -void __ovld vstore4(uchar4, size_t, __private uchar *); -void __ovld vstore4(short4, size_t, __private short *); -void __ovld vstore4(ushort4, size_t, __private ushort *); -void __ovld vstore4(int4, size_t, __private int *); -void __ovld vstore4(uint4, size_t, __private uint *); -void __ovld vstore4(long4, size_t, __private long *); -void __ovld vstore4(ulong4, size_t, __private ulong *); -void __ovld vstore4(float4, size_t, __private float *); -void __ovld vstore8(char8, size_t, __private char *); -void __ovld vstore8(uchar8, size_t, __private uchar *); -void __ovld vstore8(short8, size_t, __private short *); -void __ovld vstore8(ushort8, size_t, __private ushort *); -void __ovld vstore8(int8, size_t, __private int *); -void __ovld vstore8(uint8, size_t, __private uint *); -void __ovld vstore8(long8, size_t, __private long *); -void __ovld vstore8(ulong8, size_t, __private ulong *); -void __ovld vstore8(float8, size_t, __private float *); -void __ovld vstore16(char16, size_t, __private char *); -void __ovld vstore16(uchar16, size_t, __private uchar *); -void __ovld vstore16(short16, size_t, __private short *); -void __ovld vstore16(ushort16, size_t, __private ushort *); -void __ovld vstore16(int16, size_t, __private int *); -void __ovld vstore16(uint16, size_t, __private uint *); -void __ovld vstore16(long16, size_t, __private long *); -void __ovld vstore16(ulong16, size_t, __private ulong *); -void __ovld vstore16(float16, size_t, __private float *); -#ifdef cl_khr_fp64 -void __ovld vstore2(double2, size_t, __global double *); -void __ovld vstore3(double3, size_t, __global double *); -void __ovld vstore4(double4, size_t, __global double *); -void __ovld vstore8(double8, size_t, __global double *); -void __ovld vstore16(double16, size_t, __global double *); -void __ovld vstore2(double2, size_t, __local double *); -void __ovld vstore3(double3, size_t, __local double *); -void __ovld vstore4(double4, size_t, __local double *); -void __ovld vstore8(double8, size_t, __local double *); -void __ovld vstore16(double16, size_t, __local double *); -void __ovld vstore2(double2, size_t, __private double *); -void __ovld vstore3(double3, size_t, __private double *); -void __ovld vstore4(double4, size_t, __private double *); -void __ovld vstore8(double8, size_t, __private double *); -void __ovld vstore16(double16, size_t, __private double *); -#endif //cl_khr_fp64 -#ifdef cl_khr_fp16 -void __ovld vstore2(half2, size_t, __global half *); -void __ovld vstore3(half3, size_t, __global half *); -void __ovld vstore4(half4, size_t, __global half *); -void __ovld vstore8(half8, size_t, __global half *); -void __ovld vstore16(half16, size_t, __global half *); -void __ovld vstore2(half2, size_t, __local half *); -void __ovld vstore3(half3, size_t, __local half *); -void __ovld vstore4(half4, size_t, __local half *); -void __ovld vstore8(half8, size_t, __local half *); -void __ovld vstore16(half16, size_t, __local half *); -void __ovld vstore2(half2, size_t, __private half *); -void __ovld vstore3(half3, size_t, __private half *); -void __ovld vstore4(half4, size_t, __private half *); -void __ovld vstore8(half8, size_t, __private half *); -void __ovld vstore16(half16, size_t, __private half *); -#endif //cl_khr_fp16 -#endif //defined(__opencl_c_named_address_space_builtins) - -/** - * Read sizeof (half) bytes of data from address - * (p + offset). The data read is interpreted as a - * half value. The half value is converted to a - * float value and the float value is returned. - * The read address computed as (p + offset) - * must be 16-bit aligned. - */ -float __ovld __purefn vload_half(size_t, const __constant half *); -#if defined(__opencl_c_generic_address_space) -float __ovld __purefn vload_half(size_t, const half *); -#endif //defined(__opencl_c_generic_address_space) - -#if defined(__opencl_c_named_address_space_builtins) -float __ovld __purefn vload_half(size_t, const __global half *); -float __ovld __purefn vload_half(size_t, const __local half *); -float __ovld __purefn vload_half(size_t, const __private half *); -#endif //defined(__opencl_c_named_address_space_builtins) - -/** - * Read sizeof (halfn) bytes of data from address - * (p + (offset * n)). The data read is interpreted - * as a halfn value. The halfn value read is - * converted to a floatn value and the floatn - * value is returned. The read address computed - * as (p + (offset * n)) must be 16-bit aligned. - */ -float2 __ovld __purefn vload_half2(size_t, const __constant half *); -float3 __ovld __purefn vload_half3(size_t, const __constant half *); -float4 __ovld __purefn vload_half4(size_t, const __constant half *); -float8 __ovld __purefn vload_half8(size_t, const __constant half *); -float16 __ovld __purefn vload_half16(size_t, const __constant half *); -#if defined(__opencl_c_generic_address_space) -float2 __ovld __purefn vload_half2(size_t, const half *); -float3 __ovld __purefn vload_half3(size_t, const half *); -float4 __ovld __purefn vload_half4(size_t, const half *); -float8 __ovld __purefn vload_half8(size_t, const half *); -float16 __ovld __purefn vload_half16(size_t, const half *); -#endif //defined(__opencl_c_generic_address_space) - -#if defined(__opencl_c_named_address_space_builtins) -float2 __ovld __purefn vload_half2(size_t, const __global half *); -float3 __ovld __purefn vload_half3(size_t, const __global half *); -float4 __ovld __purefn vload_half4(size_t, const __global half *); -float8 __ovld __purefn vload_half8(size_t, const __global half *); -float16 __ovld __purefn vload_half16(size_t, const __global half *); -float2 __ovld __purefn vload_half2(size_t, const __local half *); -float3 __ovld __purefn vload_half3(size_t, const __local half *); -float4 __ovld __purefn vload_half4(size_t, const __local half *); -float8 __ovld __purefn vload_half8(size_t, const __local half *); -float16 __ovld __purefn vload_half16(size_t, const __local half *); -float2 __ovld __purefn vload_half2(size_t, const __private half *); -float3 __ovld __purefn vload_half3(size_t, const __private half *); -float4 __ovld __purefn vload_half4(size_t, const __private half *); -float8 __ovld __purefn vload_half8(size_t, const __private half *); -float16 __ovld __purefn vload_half16(size_t, const __private half *); -#endif //defined(__opencl_c_named_address_space_builtins) - -/** - * The float value given by data is first - * converted to a half value using the appropriate - * rounding mode. The half value is then written - * to address computed as (p + offset). The - * address computed as (p + offset) must be 16- - * bit aligned. - * vstore_half use the current rounding mode. - * The default current rounding mode is round to - * nearest even. - */ -#if defined(__opencl_c_generic_address_space) -void __ovld vstore_half(float, size_t, half *); -void __ovld vstore_half_rte(float, size_t, half *); -void __ovld vstore_half_rtz(float, size_t, half *); -void __ovld vstore_half_rtp(float, size_t, half *); -void __ovld vstore_half_rtn(float, size_t, half *); -#ifdef cl_khr_fp64 -void __ovld vstore_half(double, size_t, half *); -void __ovld vstore_half_rte(double, size_t, half *); -void __ovld vstore_half_rtz(double, size_t, half *); -void __ovld vstore_half_rtp(double, size_t, half *); -void __ovld vstore_half_rtn(double, size_t, half *); -#endif //cl_khr_fp64 -#endif //defined(__opencl_c_generic_address_space) - -#if defined(__opencl_c_named_address_space_builtins) -void __ovld vstore_half(float, size_t, __global half *); -void __ovld vstore_half_rte(float, size_t, __global half *); -void __ovld vstore_half_rtz(float, size_t, __global half *); -void __ovld vstore_half_rtp(float, size_t, __global half *); -void __ovld vstore_half_rtn(float, size_t, __global half *); -void __ovld vstore_half(float, size_t, __local half *); -void __ovld vstore_half_rte(float, size_t, __local half *); -void __ovld vstore_half_rtz(float, size_t, __local half *); -void __ovld vstore_half_rtp(float, size_t, __local half *); -void __ovld vstore_half_rtn(float, size_t, __local half *); -void __ovld vstore_half(float, size_t, __private half *); -void __ovld vstore_half_rte(float, size_t, __private half *); -void __ovld vstore_half_rtz(float, size_t, __private half *); -void __ovld vstore_half_rtp(float, size_t, __private half *); -void __ovld vstore_half_rtn(float, size_t, __private half *); -#ifdef cl_khr_fp64 -void __ovld vstore_half(double, size_t, __global half *); -void __ovld vstore_half_rte(double, size_t, __global half *); -void __ovld vstore_half_rtz(double, size_t, __global half *); -void __ovld vstore_half_rtp(double, size_t, __global half *); -void __ovld vstore_half_rtn(double, size_t, __global half *); -void __ovld vstore_half(double, size_t, __local half *); -void __ovld vstore_half_rte(double, size_t, __local half *); -void __ovld vstore_half_rtz(double, size_t, __local half *); -void __ovld vstore_half_rtp(double, size_t, __local half *); -void __ovld vstore_half_rtn(double, size_t, __local half *); -void __ovld vstore_half(double, size_t, __private half *); -void __ovld vstore_half_rte(double, size_t, __private half *); -void __ovld vstore_half_rtz(double, size_t, __private half *); -void __ovld vstore_half_rtp(double, size_t, __private half *); -void __ovld vstore_half_rtn(double, size_t, __private half *); -#endif //cl_khr_fp64 -#endif //defined(__opencl_c_named_address_space_builtins) - -/** - * The floatn value given by data is converted to - * a halfn value using the appropriate rounding - * mode. The halfn value is then written to - * address computed as (p + (offset * n)). The - * address computed as (p + (offset * n)) must be - * 16-bit aligned. - * vstore_halfn uses the current rounding mode. - * The default current rounding mode is round to - * nearest even. - */ -#if defined(__opencl_c_generic_address_space) -void __ovld vstore_half2(float2, size_t, half *); -void __ovld vstore_half3(float3, size_t, half *); -void __ovld vstore_half4(float4, size_t, half *); -void __ovld vstore_half8(float8, size_t, half *); -void __ovld vstore_half16(float16, size_t, half *); -void __ovld vstore_half2_rte(float2, size_t, half *); -void __ovld vstore_half3_rte(float3, size_t, half *); -void __ovld vstore_half4_rte(float4, size_t, half *); -void __ovld vstore_half8_rte(float8, size_t, half *); -void __ovld vstore_half16_rte(float16, size_t, half *); -void __ovld vstore_half2_rtz(float2, size_t, half *); -void __ovld vstore_half3_rtz(float3, size_t, half *); -void __ovld vstore_half4_rtz(float4, size_t, half *); -void __ovld vstore_half8_rtz(float8, size_t, half *); -void __ovld vstore_half16_rtz(float16, size_t, half *); -void __ovld vstore_half2_rtp(float2, size_t, half *); -void __ovld vstore_half3_rtp(float3, size_t, half *); -void __ovld vstore_half4_rtp(float4, size_t, half *); -void __ovld vstore_half8_rtp(float8, size_t, half *); -void __ovld vstore_half16_rtp(float16, size_t, half *); -void __ovld vstore_half2_rtn(float2, size_t, half *); -void __ovld vstore_half3_rtn(float3, size_t, half *); -void __ovld vstore_half4_rtn(float4, size_t, half *); -void __ovld vstore_half8_rtn(float8, size_t, half *); -void __ovld vstore_half16_rtn(float16, size_t, half *); -#ifdef cl_khr_fp64 -void __ovld vstore_half2(double2, size_t, half *); -void __ovld vstore_half3(double3, size_t, half *); -void __ovld vstore_half4(double4, size_t, half *); -void __ovld vstore_half8(double8, size_t, half *); -void __ovld vstore_half16(double16, size_t, half *); -void __ovld vstore_half2_rte(double2, size_t, half *); -void __ovld vstore_half3_rte(double3, size_t, half *); -void __ovld vstore_half4_rte(double4, size_t, half *); -void __ovld vstore_half8_rte(double8, size_t, half *); -void __ovld vstore_half16_rte(double16, size_t, half *); -void __ovld vstore_half2_rtz(double2, size_t, half *); -void __ovld vstore_half3_rtz(double3, size_t, half *); -void __ovld vstore_half4_rtz(double4, size_t, half *); -void __ovld vstore_half8_rtz(double8, size_t, half *); -void __ovld vstore_half16_rtz(double16, size_t, half *); -void __ovld vstore_half2_rtp(double2, size_t, half *); -void __ovld vstore_half3_rtp(double3, size_t, half *); -void __ovld vstore_half4_rtp(double4, size_t, half *); -void __ovld vstore_half8_rtp(double8, size_t, half *); -void __ovld vstore_half16_rtp(double16, size_t, half *); -void __ovld vstore_half2_rtn(double2, size_t, half *); -void __ovld vstore_half3_rtn(double3, size_t, half *); -void __ovld vstore_half4_rtn(double4, size_t, half *); -void __ovld vstore_half8_rtn(double8, size_t, half *); -void __ovld vstore_half16_rtn(double16, size_t, half *); -#endif //cl_khr_fp64 -#endif //defined(__opencl_c_generic_address_space) - -#if defined(__opencl_c_named_address_space_builtins) -void __ovld vstore_half2(float2, size_t, __global half *); -void __ovld vstore_half3(float3, size_t, __global half *); -void __ovld vstore_half4(float4, size_t, __global half *); -void __ovld vstore_half8(float8, size_t, __global half *); -void __ovld vstore_half16(float16, size_t, __global half *); -void __ovld vstore_half2_rte(float2, size_t, __global half *); -void __ovld vstore_half3_rte(float3, size_t, __global half *); -void __ovld vstore_half4_rte(float4, size_t, __global half *); -void __ovld vstore_half8_rte(float8, size_t, __global half *); -void __ovld vstore_half16_rte(float16, size_t, __global half *); -void __ovld vstore_half2_rtz(float2, size_t, __global half *); -void __ovld vstore_half3_rtz(float3, size_t, __global half *); -void __ovld vstore_half4_rtz(float4, size_t, __global half *); -void __ovld vstore_half8_rtz(float8, size_t, __global half *); -void __ovld vstore_half16_rtz(float16, size_t, __global half *); -void __ovld vstore_half2_rtp(float2, size_t, __global half *); -void __ovld vstore_half3_rtp(float3, size_t, __global half *); -void __ovld vstore_half4_rtp(float4, size_t, __global half *); -void __ovld vstore_half8_rtp(float8, size_t, __global half *); -void __ovld vstore_half16_rtp(float16, size_t, __global half *); -void __ovld vstore_half2_rtn(float2, size_t, __global half *); -void __ovld vstore_half3_rtn(float3, size_t, __global half *); -void __ovld vstore_half4_rtn(float4, size_t, __global half *); -void __ovld vstore_half8_rtn(float8, size_t, __global half *); -void __ovld vstore_half16_rtn(float16, size_t, __global half *); -void __ovld vstore_half2(float2, size_t, __local half *); -void __ovld vstore_half3(float3, size_t, __local half *); -void __ovld vstore_half4(float4, size_t, __local half *); -void __ovld vstore_half8(float8, size_t, __local half *); -void __ovld vstore_half16(float16, size_t, __local half *); -void __ovld vstore_half2_rte(float2, size_t, __local half *); -void __ovld vstore_half3_rte(float3, size_t, __local half *); -void __ovld vstore_half4_rte(float4, size_t, __local half *); -void __ovld vstore_half8_rte(float8, size_t, __local half *); -void __ovld vstore_half16_rte(float16, size_t, __local half *); -void __ovld vstore_half2_rtz(float2, size_t, __local half *); -void __ovld vstore_half3_rtz(float3, size_t, __local half *); -void __ovld vstore_half4_rtz(float4, size_t, __local half *); -void __ovld vstore_half8_rtz(float8, size_t, __local half *); -void __ovld vstore_half16_rtz(float16, size_t, __local half *); -void __ovld vstore_half2_rtp(float2, size_t, __local half *); -void __ovld vstore_half3_rtp(float3, size_t, __local half *); -void __ovld vstore_half4_rtp(float4, size_t, __local half *); -void __ovld vstore_half8_rtp(float8, size_t, __local half *); -void __ovld vstore_half16_rtp(float16, size_t, __local half *); -void __ovld vstore_half2_rtn(float2, size_t, __local half *); -void __ovld vstore_half3_rtn(float3, size_t, __local half *); -void __ovld vstore_half4_rtn(float4, size_t, __local half *); -void __ovld vstore_half8_rtn(float8, size_t, __local half *); -void __ovld vstore_half16_rtn(float16, size_t, __local half *); -void __ovld vstore_half2(float2, size_t, __private half *); -void __ovld vstore_half3(float3, size_t, __private half *); -void __ovld vstore_half4(float4, size_t, __private half *); -void __ovld vstore_half8(float8, size_t, __private half *); -void __ovld vstore_half16(float16, size_t, __private half *); -void __ovld vstore_half2_rte(float2, size_t, __private half *); -void __ovld vstore_half3_rte(float3, size_t, __private half *); -void __ovld vstore_half4_rte(float4, size_t, __private half *); -void __ovld vstore_half8_rte(float8, size_t, __private half *); -void __ovld vstore_half16_rte(float16, size_t, __private half *); -void __ovld vstore_half2_rtz(float2, size_t, __private half *); -void __ovld vstore_half3_rtz(float3, size_t, __private half *); -void __ovld vstore_half4_rtz(float4, size_t, __private half *); -void __ovld vstore_half8_rtz(float8, size_t, __private half *); -void __ovld vstore_half16_rtz(float16, size_t, __private half *); -void __ovld vstore_half2_rtp(float2, size_t, __private half *); -void __ovld vstore_half3_rtp(float3, size_t, __private half *); -void __ovld vstore_half4_rtp(float4, size_t, __private half *); -void __ovld vstore_half8_rtp(float8, size_t, __private half *); -void __ovld vstore_half16_rtp(float16, size_t, __private half *); -void __ovld vstore_half2_rtn(float2, size_t, __private half *); -void __ovld vstore_half3_rtn(float3, size_t, __private half *); -void __ovld vstore_half4_rtn(float4, size_t, __private half *); -void __ovld vstore_half8_rtn(float8, size_t, __private half *); -void __ovld vstore_half16_rtn(float16, size_t, __private half *); -#ifdef cl_khr_fp64 -void __ovld vstore_half2(double2, size_t, __global half *); -void __ovld vstore_half3(double3, size_t, __global half *); -void __ovld vstore_half4(double4, size_t, __global half *); -void __ovld vstore_half8(double8, size_t, __global half *); -void __ovld vstore_half16(double16, size_t, __global half *); -void __ovld vstore_half2_rte(double2, size_t, __global half *); -void __ovld vstore_half3_rte(double3, size_t, __global half *); -void __ovld vstore_half4_rte(double4, size_t, __global half *); -void __ovld vstore_half8_rte(double8, size_t, __global half *); -void __ovld vstore_half16_rte(double16, size_t, __global half *); -void __ovld vstore_half2_rtz(double2, size_t, __global half *); -void __ovld vstore_half3_rtz(double3, size_t, __global half *); -void __ovld vstore_half4_rtz(double4, size_t, __global half *); -void __ovld vstore_half8_rtz(double8, size_t, __global half *); -void __ovld vstore_half16_rtz(double16, size_t, __global half *); -void __ovld vstore_half2_rtp(double2, size_t, __global half *); -void __ovld vstore_half3_rtp(double3, size_t, __global half *); -void __ovld vstore_half4_rtp(double4, size_t, __global half *); -void __ovld vstore_half8_rtp(double8, size_t, __global half *); -void __ovld vstore_half16_rtp(double16, size_t, __global half *); -void __ovld vstore_half2_rtn(double2, size_t, __global half *); -void __ovld vstore_half3_rtn(double3, size_t, __global half *); -void __ovld vstore_half4_rtn(double4, size_t, __global half *); -void __ovld vstore_half8_rtn(double8, size_t, __global half *); -void __ovld vstore_half16_rtn(double16, size_t, __global half *); -void __ovld vstore_half2(double2, size_t, __local half *); -void __ovld vstore_half3(double3, size_t, __local half *); -void __ovld vstore_half4(double4, size_t, __local half *); -void __ovld vstore_half8(double8, size_t, __local half *); -void __ovld vstore_half16(double16, size_t, __local half *); -void __ovld vstore_half2_rte(double2, size_t, __local half *); -void __ovld vstore_half3_rte(double3, size_t, __local half *); -void __ovld vstore_half4_rte(double4, size_t, __local half *); -void __ovld vstore_half8_rte(double8, size_t, __local half *); -void __ovld vstore_half16_rte(double16, size_t, __local half *); -void __ovld vstore_half2_rtz(double2, size_t, __local half *); -void __ovld vstore_half3_rtz(double3, size_t, __local half *); -void __ovld vstore_half4_rtz(double4, size_t, __local half *); -void __ovld vstore_half8_rtz(double8, size_t, __local half *); -void __ovld vstore_half16_rtz(double16, size_t, __local half *); -void __ovld vstore_half2_rtp(double2, size_t, __local half *); -void __ovld vstore_half3_rtp(double3, size_t, __local half *); -void __ovld vstore_half4_rtp(double4, size_t, __local half *); -void __ovld vstore_half8_rtp(double8, size_t, __local half *); -void __ovld vstore_half16_rtp(double16, size_t, __local half *); -void __ovld vstore_half2_rtn(double2, size_t, __local half *); -void __ovld vstore_half3_rtn(double3, size_t, __local half *); -void __ovld vstore_half4_rtn(double4, size_t, __local half *); -void __ovld vstore_half8_rtn(double8, size_t, __local half *); -void __ovld vstore_half16_rtn(double16, size_t, __local half *); -void __ovld vstore_half2(double2, size_t, __private half *); -void __ovld vstore_half3(double3, size_t, __private half *); -void __ovld vstore_half4(double4, size_t, __private half *); -void __ovld vstore_half8(double8, size_t, __private half *); -void __ovld vstore_half16(double16, size_t, __private half *); -void __ovld vstore_half2_rte(double2, size_t, __private half *); -void __ovld vstore_half3_rte(double3, size_t, __private half *); -void __ovld vstore_half4_rte(double4, size_t, __private half *); -void __ovld vstore_half8_rte(double8, size_t, __private half *); -void __ovld vstore_half16_rte(double16, size_t, __private half *); -void __ovld vstore_half2_rtz(double2, size_t, __private half *); -void __ovld vstore_half3_rtz(double3, size_t, __private half *); -void __ovld vstore_half4_rtz(double4, size_t, __private half *); -void __ovld vstore_half8_rtz(double8, size_t, __private half *); -void __ovld vstore_half16_rtz(double16, size_t, __private half *); -void __ovld vstore_half2_rtp(double2, size_t, __private half *); -void __ovld vstore_half3_rtp(double3, size_t, __private half *); -void __ovld vstore_half4_rtp(double4, size_t, __private half *); -void __ovld vstore_half8_rtp(double8, size_t, __private half *); -void __ovld vstore_half16_rtp(double16, size_t, __private half *); -void __ovld vstore_half2_rtn(double2, size_t, __private half *); -void __ovld vstore_half3_rtn(double3, size_t, __private half *); -void __ovld vstore_half4_rtn(double4, size_t, __private half *); -void __ovld vstore_half8_rtn(double8, size_t, __private half *); -void __ovld vstore_half16_rtn(double16, size_t, __private half *); -#endif //cl_khr_fp64 -#endif //defined(__opencl_c_named_address_space_builtins) - -/** - * For n = 1, 2, 4, 8 and 16 read sizeof (halfn) - * bytes of data from address (p + (offset * n)). - * The data read is interpreted as a halfn value. - * The halfn value read is converted to a floatn - * value and the floatn value is returned. - * The address computed as (p + (offset * n)) - * must be aligned to sizeof (halfn) bytes. - * For n = 3, vloada_half3 reads a half3 from - * address (p + (offset * 4)) and returns a float3. - * The address computed as (p + (offset * 4)) - * must be aligned to sizeof (half) * 4 bytes. - */ -float2 __ovld __purefn vloada_half2(size_t, const __constant half *); -float3 __ovld __purefn vloada_half3(size_t, const __constant half *); -float4 __ovld __purefn vloada_half4(size_t, const __constant half *); -float8 __ovld __purefn vloada_half8(size_t, const __constant half *); -float16 __ovld __purefn vloada_half16(size_t, const __constant half *); -#if defined(__opencl_c_generic_address_space) -float2 __ovld __purefn vloada_half2(size_t, const half *); -float3 __ovld __purefn vloada_half3(size_t, const half *); -float4 __ovld __purefn vloada_half4(size_t, const half *); -float8 __ovld __purefn vloada_half8(size_t, const half *); -float16 __ovld __purefn vloada_half16(size_t, const half *); -#endif //defined(__opencl_c_generic_address_space) - -#if defined(__opencl_c_named_address_space_builtins) -float2 __ovld __purefn vloada_half2(size_t, const __global half *); -float3 __ovld __purefn vloada_half3(size_t, const __global half *); -float4 __ovld __purefn vloada_half4(size_t, const __global half *); -float8 __ovld __purefn vloada_half8(size_t, const __global half *); -float16 __ovld __purefn vloada_half16(size_t, const __global half *); -float2 __ovld __purefn vloada_half2(size_t, const __local half *); -float3 __ovld __purefn vloada_half3(size_t, const __local half *); -float4 __ovld __purefn vloada_half4(size_t, const __local half *); -float8 __ovld __purefn vloada_half8(size_t, const __local half *); -float16 __ovld __purefn vloada_half16(size_t, const __local half *); -float2 __ovld __purefn vloada_half2(size_t, const __private half *); -float3 __ovld __purefn vloada_half3(size_t, const __private half *); -float4 __ovld __purefn vloada_half4(size_t, const __private half *); -float8 __ovld __purefn vloada_half8(size_t, const __private half *); -float16 __ovld __purefn vloada_half16(size_t, const __private half *); -#endif //defined(__opencl_c_named_address_space_builtins) - -/** - * The floatn value given by data is converted to - * a halfn value using the appropriate rounding - * mode. - * For n = 1, 2, 4, 8 and 16, the halfn value is - * written to the address computed as (p + (offset - * * n)). The address computed as (p + (offset * - * n)) must be aligned to sizeof (halfn) bytes. - * For n = 3, the half3 value is written to the - * address computed as (p + (offset * 4)). The - * address computed as (p + (offset * 4)) must be - * aligned to sizeof (half) * 4 bytes. - * vstorea_halfn uses the current rounding - * mode. The default current rounding mode is - * round to nearest even. - */ -#if defined(__opencl_c_generic_address_space) -void __ovld vstorea_half2(float2, size_t, half *); -void __ovld vstorea_half3(float3, size_t, half *); -void __ovld vstorea_half4(float4, size_t, half *); -void __ovld vstorea_half8(float8, size_t, half *); -void __ovld vstorea_half16(float16, size_t, half *); - -void __ovld vstorea_half2_rte(float2, size_t, half *); -void __ovld vstorea_half3_rte(float3, size_t, half *); -void __ovld vstorea_half4_rte(float4, size_t, half *); -void __ovld vstorea_half8_rte(float8, size_t, half *); -void __ovld vstorea_half16_rte(float16, size_t, half *); - -void __ovld vstorea_half2_rtz(float2, size_t, half *); -void __ovld vstorea_half3_rtz(float3, size_t, half *); -void __ovld vstorea_half4_rtz(float4, size_t, half *); -void __ovld vstorea_half8_rtz(float8, size_t, half *); -void __ovld vstorea_half16_rtz(float16, size_t, half *); - -void __ovld vstorea_half2_rtp(float2, size_t, half *); -void __ovld vstorea_half3_rtp(float3, size_t, half *); -void __ovld vstorea_half4_rtp(float4, size_t, half *); -void __ovld vstorea_half8_rtp(float8, size_t, half *); -void __ovld vstorea_half16_rtp(float16, size_t, half *); - -void __ovld vstorea_half2_rtn(float2, size_t, half *); -void __ovld vstorea_half3_rtn(float3, size_t, half *); -void __ovld vstorea_half4_rtn(float4, size_t, half *); -void __ovld vstorea_half8_rtn(float8, size_t, half *); -void __ovld vstorea_half16_rtn(float16, size_t, half *); - -#ifdef cl_khr_fp64 -void __ovld vstorea_half2(double2, size_t, half *); -void __ovld vstorea_half3(double3, size_t, half *); -void __ovld vstorea_half4(double4, size_t, half *); -void __ovld vstorea_half8(double8, size_t, half *); -void __ovld vstorea_half16(double16, size_t, half *); - -void __ovld vstorea_half2_rte(double2, size_t, half *); -void __ovld vstorea_half3_rte(double3, size_t, half *); -void __ovld vstorea_half4_rte(double4, size_t, half *); -void __ovld vstorea_half8_rte(double8, size_t, half *); -void __ovld vstorea_half16_rte(double16, size_t, half *); - -void __ovld vstorea_half2_rtz(double2, size_t, half *); -void __ovld vstorea_half3_rtz(double3, size_t, half *); -void __ovld vstorea_half4_rtz(double4, size_t, half *); -void __ovld vstorea_half8_rtz(double8, size_t, half *); -void __ovld vstorea_half16_rtz(double16, size_t, half *); - -void __ovld vstorea_half2_rtp(double2, size_t, half *); -void __ovld vstorea_half3_rtp(double3, size_t, half *); -void __ovld vstorea_half4_rtp(double4, size_t, half *); -void __ovld vstorea_half8_rtp(double8, size_t, half *); -void __ovld vstorea_half16_rtp(double16, size_t, half *); - -void __ovld vstorea_half2_rtn(double2, size_t, half *); -void __ovld vstorea_half3_rtn(double3, size_t, half *); -void __ovld vstorea_half4_rtn(double4, size_t, half *); -void __ovld vstorea_half8_rtn(double8, size_t, half *); -void __ovld vstorea_half16_rtn(double16, size_t, half *); -#endif //cl_khr_fp64 -#endif //defined(__opencl_c_generic_address_space) - -#if defined(__opencl_c_named_address_space_builtins) -void __ovld vstorea_half2(float2, size_t, __global half *); -void __ovld vstorea_half3(float3, size_t, __global half *); -void __ovld vstorea_half4(float4, size_t, __global half *); -void __ovld vstorea_half8(float8, size_t, __global half *); -void __ovld vstorea_half16(float16, size_t, __global half *); - -void __ovld vstorea_half2_rte(float2, size_t, __global half *); -void __ovld vstorea_half3_rte(float3, size_t, __global half *); -void __ovld vstorea_half4_rte(float4, size_t, __global half *); -void __ovld vstorea_half8_rte(float8, size_t, __global half *); -void __ovld vstorea_half16_rte(float16, size_t, __global half *); - -void __ovld vstorea_half2_rtz(float2, size_t, __global half *); -void __ovld vstorea_half3_rtz(float3, size_t, __global half *); -void __ovld vstorea_half4_rtz(float4, size_t, __global half *); -void __ovld vstorea_half8_rtz(float8, size_t, __global half *); -void __ovld vstorea_half16_rtz(float16, size_t, __global half *); - -void __ovld vstorea_half2_rtp(float2, size_t, __global half *); -void __ovld vstorea_half3_rtp(float3, size_t, __global half *); -void __ovld vstorea_half4_rtp(float4, size_t, __global half *); -void __ovld vstorea_half8_rtp(float8, size_t, __global half *); -void __ovld vstorea_half16_rtp(float16, size_t, __global half *); - -void __ovld vstorea_half2_rtn(float2, size_t, __global half *); -void __ovld vstorea_half3_rtn(float3, size_t, __global half *); -void __ovld vstorea_half4_rtn(float4, size_t, __global half *); -void __ovld vstorea_half8_rtn(float8, size_t, __global half *); -void __ovld vstorea_half16_rtn(float16, size_t, __global half *); - -void __ovld vstorea_half2(float2, size_t, __local half *); -void __ovld vstorea_half3(float3, size_t, __local half *); -void __ovld vstorea_half4(float4, size_t, __local half *); -void __ovld vstorea_half8(float8, size_t, __local half *); -void __ovld vstorea_half16(float16, size_t, __local half *); - -void __ovld vstorea_half2_rte(float2, size_t, __local half *); -void __ovld vstorea_half3_rte(float3, size_t, __local half *); -void __ovld vstorea_half4_rte(float4, size_t, __local half *); -void __ovld vstorea_half8_rte(float8, size_t, __local half *); -void __ovld vstorea_half16_rte(float16, size_t, __local half *); - -void __ovld vstorea_half2_rtz(float2, size_t, __local half *); -void __ovld vstorea_half3_rtz(float3, size_t, __local half *); -void __ovld vstorea_half4_rtz(float4, size_t, __local half *); -void __ovld vstorea_half8_rtz(float8, size_t, __local half *); -void __ovld vstorea_half16_rtz(float16, size_t, __local half *); - -void __ovld vstorea_half2_rtp(float2, size_t, __local half *); -void __ovld vstorea_half3_rtp(float3, size_t, __local half *); -void __ovld vstorea_half4_rtp(float4, size_t, __local half *); -void __ovld vstorea_half8_rtp(float8, size_t, __local half *); -void __ovld vstorea_half16_rtp(float16, size_t, __local half *); - -void __ovld vstorea_half2_rtn(float2, size_t, __local half *); -void __ovld vstorea_half3_rtn(float3, size_t, __local half *); -void __ovld vstorea_half4_rtn(float4, size_t, __local half *); -void __ovld vstorea_half8_rtn(float8, size_t, __local half *); -void __ovld vstorea_half16_rtn(float16, size_t, __local half *); - -void __ovld vstorea_half2(float2, size_t, __private half *); -void __ovld vstorea_half3(float3, size_t, __private half *); -void __ovld vstorea_half4(float4, size_t, __private half *); -void __ovld vstorea_half8(float8, size_t, __private half *); -void __ovld vstorea_half16(float16, size_t, __private half *); - -void __ovld vstorea_half2_rte(float2, size_t, __private half *); -void __ovld vstorea_half3_rte(float3, size_t, __private half *); -void __ovld vstorea_half4_rte(float4, size_t, __private half *); -void __ovld vstorea_half8_rte(float8, size_t, __private half *); -void __ovld vstorea_half16_rte(float16, size_t, __private half *); - -void __ovld vstorea_half2_rtz(float2, size_t, __private half *); -void __ovld vstorea_half3_rtz(float3, size_t, __private half *); -void __ovld vstorea_half4_rtz(float4, size_t, __private half *); -void __ovld vstorea_half8_rtz(float8, size_t, __private half *); -void __ovld vstorea_half16_rtz(float16, size_t, __private half *); - -void __ovld vstorea_half2_rtp(float2, size_t, __private half *); -void __ovld vstorea_half3_rtp(float3, size_t, __private half *); -void __ovld vstorea_half4_rtp(float4, size_t, __private half *); -void __ovld vstorea_half8_rtp(float8, size_t, __private half *); -void __ovld vstorea_half16_rtp(float16, size_t, __private half *); - -void __ovld vstorea_half2_rtn(float2, size_t, __private half *); -void __ovld vstorea_half3_rtn(float3, size_t, __private half *); -void __ovld vstorea_half4_rtn(float4, size_t, __private half *); -void __ovld vstorea_half8_rtn(float8, size_t, __private half *); -void __ovld vstorea_half16_rtn(float16, size_t, __private half *); - -#ifdef cl_khr_fp64 -void __ovld vstorea_half2(double2, size_t, __global half *); -void __ovld vstorea_half3(double3, size_t, __global half *); -void __ovld vstorea_half4(double4, size_t, __global half *); -void __ovld vstorea_half8(double8, size_t, __global half *); -void __ovld vstorea_half16(double16, size_t, __global half *); - -void __ovld vstorea_half2_rte(double2, size_t, __global half *); -void __ovld vstorea_half3_rte(double3, size_t, __global half *); -void __ovld vstorea_half4_rte(double4, size_t, __global half *); -void __ovld vstorea_half8_rte(double8, size_t, __global half *); -void __ovld vstorea_half16_rte(double16, size_t, __global half *); - -void __ovld vstorea_half2_rtz(double2, size_t, __global half *); -void __ovld vstorea_half3_rtz(double3, size_t, __global half *); -void __ovld vstorea_half4_rtz(double4, size_t, __global half *); -void __ovld vstorea_half8_rtz(double8, size_t, __global half *); -void __ovld vstorea_half16_rtz(double16, size_t, __global half *); - -void __ovld vstorea_half2_rtp(double2, size_t, __global half *); -void __ovld vstorea_half3_rtp(double3, size_t, __global half *); -void __ovld vstorea_half4_rtp(double4, size_t, __global half *); -void __ovld vstorea_half8_rtp(double8, size_t, __global half *); -void __ovld vstorea_half16_rtp(double16, size_t, __global half *); - -void __ovld vstorea_half2_rtn(double2, size_t, __global half *); -void __ovld vstorea_half3_rtn(double3, size_t, __global half *); -void __ovld vstorea_half4_rtn(double4, size_t, __global half *); -void __ovld vstorea_half8_rtn(double8, size_t, __global half *); -void __ovld vstorea_half16_rtn(double16, size_t, __global half *); - -void __ovld vstorea_half2(double2, size_t, __local half *); -void __ovld vstorea_half3(double3, size_t, __local half *); -void __ovld vstorea_half4(double4, size_t, __local half *); -void __ovld vstorea_half8(double8, size_t, __local half *); -void __ovld vstorea_half16(double16, size_t, __local half *); - -void __ovld vstorea_half2_rte(double2, size_t, __local half *); -void __ovld vstorea_half3_rte(double3, size_t, __local half *); -void __ovld vstorea_half4_rte(double4, size_t, __local half *); -void __ovld vstorea_half8_rte(double8, size_t, __local half *); -void __ovld vstorea_half16_rte(double16, size_t, __local half *); - -void __ovld vstorea_half2_rtz(double2, size_t, __local half *); -void __ovld vstorea_half3_rtz(double3, size_t, __local half *); -void __ovld vstorea_half4_rtz(double4, size_t, __local half *); -void __ovld vstorea_half8_rtz(double8, size_t, __local half *); -void __ovld vstorea_half16_rtz(double16, size_t, __local half *); - -void __ovld vstorea_half2_rtp(double2, size_t, __local half *); -void __ovld vstorea_half3_rtp(double3, size_t, __local half *); -void __ovld vstorea_half4_rtp(double4, size_t, __local half *); -void __ovld vstorea_half8_rtp(double8, size_t, __local half *); -void __ovld vstorea_half16_rtp(double16, size_t, __local half *); - -void __ovld vstorea_half2_rtn(double2, size_t, __local half *); -void __ovld vstorea_half3_rtn(double3, size_t, __local half *); -void __ovld vstorea_half4_rtn(double4, size_t, __local half *); -void __ovld vstorea_half8_rtn(double8, size_t, __local half *); -void __ovld vstorea_half16_rtn(double16, size_t, __local half *); - -void __ovld vstorea_half2(double2, size_t, __private half *); -void __ovld vstorea_half3(double3, size_t, __private half *); -void __ovld vstorea_half4(double4, size_t, __private half *); -void __ovld vstorea_half8(double8, size_t, __private half *); -void __ovld vstorea_half16(double16, size_t, __private half *); - -void __ovld vstorea_half2_rte(double2, size_t, __private half *); -void __ovld vstorea_half3_rte(double3, size_t, __private half *); -void __ovld vstorea_half4_rte(double4, size_t, __private half *); -void __ovld vstorea_half8_rte(double8, size_t, __private half *); -void __ovld vstorea_half16_rte(double16, size_t, __private half *); - -void __ovld vstorea_half2_rtz(double2, size_t, __private half *); -void __ovld vstorea_half3_rtz(double3, size_t, __private half *); -void __ovld vstorea_half4_rtz(double4, size_t, __private half *); -void __ovld vstorea_half8_rtz(double8, size_t, __private half *); -void __ovld vstorea_half16_rtz(double16, size_t, __private half *); - -void __ovld vstorea_half2_rtp(double2, size_t, __private half *); -void __ovld vstorea_half3_rtp(double3, size_t, __private half *); -void __ovld vstorea_half4_rtp(double4, size_t, __private half *); -void __ovld vstorea_half8_rtp(double8, size_t, __private half *); -void __ovld vstorea_half16_rtp(double16, size_t, __private half *); - -void __ovld vstorea_half2_rtn(double2, size_t, __private half *); -void __ovld vstorea_half3_rtn(double3, size_t, __private half *); -void __ovld vstorea_half4_rtn(double4, size_t, __private half *); -void __ovld vstorea_half8_rtn(double8, size_t, __private half *); -void __ovld vstorea_half16_rtn(double16, size_t, __private half *); -#endif //cl_khr_fp64 -#endif //defined(__opencl_c_named_address_space_builtins) - -// OpenCL v1.1 s6.11.8, v1.2 s6.12.8, v2.0 s6.13.8 - Synchronization Functions - -/** - * All work-items in a work-group executing the kernel - * on a processor must execute this function before any - * are allowed to continue execution beyond the barrier. - * This function must be encountered by all work-items in - * a work-group executing the kernel. - * If barrier is inside a conditional statement, then all - * work-items must enter the conditional if any work-item - * enters the conditional statement and executes the - * barrier. - * If barrer is inside a loop, all work-items must execute - * the barrier for each iteration of the loop before any are - * allowed to continue execution beyond the barrier. - * The barrier function also queues a memory fence - * (reads and writes) to ensure correct ordering of - * memory operations to local or global memory. - * The flags argument specifies the memory address space - * and can be set to a combination of the following literal - * values. - * CLK_LOCAL_MEM_FENCE - The barrier function - * will either flush any variables stored in local memory - * or queue a memory fence to ensure correct ordering of - * memory operations to local memory. - * CLK_GLOBAL_MEM_FENCE - The barrier function - * will queue a memory fence to ensure correct ordering - * of memory operations to global memory. This can be - * useful when work-items, for example, write to buffer or - * image objects and then want to read the updated data. - */ - -void __ovld __conv barrier(cl_mem_fence_flags); - -#if defined(__OPENCL_CPP_VERSION__) || (__OPENCL_C_VERSION__ >= CL_VERSION_2_0) -void __ovld __conv work_group_barrier(cl_mem_fence_flags, memory_scope); -void __ovld __conv work_group_barrier(cl_mem_fence_flags); -#endif //defined(__OPENCL_CPP_VERSION__) || (__OPENCL_C_VERSION__ >= CL_VERSION_2_0) - -// OpenCL v1.1 s6.11.9, v1.2 s6.12.9 - Explicit Memory Fence Functions - -/** - * Orders loads and stores of a work-item - * executing a kernel. This means that loads - * and stores preceding the mem_fence will - * be committed to memory before any loads - * and stores following the mem_fence. - * The flags argument specifies the memory - * address space and can be set to a - * combination of the following literal - * values: - * CLK_LOCAL_MEM_FENCE - * CLK_GLOBAL_MEM_FENCE. - */ -void __ovld mem_fence(cl_mem_fence_flags); - -/** - * Read memory barrier that orders only - * loads. - * The flags argument specifies the memory - * address space and can be set to a - * combination of the following literal - * values: - * CLK_LOCAL_MEM_FENCE - * CLK_GLOBAL_MEM_FENCE. - */ -void __ovld read_mem_fence(cl_mem_fence_flags); - -/** - * Write memory barrier that orders only - * stores. - * The flags argument specifies the memory - * address space and can be set to a - * combination of the following literal - * values: - * CLK_LOCAL_MEM_FENCE - * CLK_GLOBAL_MEM_FENCE. - */ -void __ovld write_mem_fence(cl_mem_fence_flags); - -// OpenCL v2.0 s6.13.9 - Address Space Qualifier Functions - -#if defined(__opencl_c_generic_address_space) -cl_mem_fence_flags __ovld get_fence(const void *ptr); -cl_mem_fence_flags __ovld get_fence(void *ptr); - -/** - * Builtin functions to_global, to_local, and to_private need to be declared as Clang builtin functions - * and checked in Sema since they should be declared as - * addr gentype* to_addr (gentype*); - * where gentype is builtin type or user defined type. - */ - -#endif //defined(__opencl_c_generic_address_space) - -// OpenCL v1.1 s6.11.10, v1.2 s6.12.10, v2.0 s6.13.10 - Async Copies from Global to Local Memory, Local to Global Memory, and Prefetch - -/** - * event_t async_work_group_copy ( - * __global gentype *dst, - * const __local gentype *src, - * size_t num_elements, - * event_t event) - * Perform an async copy of num_elements - * gentype elements from src to dst. The async - * copy is performed by all work-items in a workgroup - * and this built-in function must therefore - * be encountered by all work-items in a workgroup - * executing the kernel with the same - * argument values; otherwise the results are - * undefined. - * Returns an event object that can be used by - * wait_group_events to wait for the async copy - * to finish. The event argument can also be used - * to associate the async_work_group_copy with - * a previous async copy allowing an event to be - * shared by multiple async copies; otherwise event - * should be zero. - * If event argument is non-zero, the event object - * supplied in event argument will be returned. - * This function does not perform any implicit - * synchronization of source data such as using a - * barrier before performing the copy. - */ -event_t __ovld async_work_group_copy(__local char *, const __global char *, size_t, event_t); -event_t __ovld async_work_group_copy(__local uchar *, const __global uchar *, size_t, event_t); -event_t __ovld async_work_group_copy(__local short *, const __global short *, size_t, event_t); -event_t __ovld async_work_group_copy(__local ushort *, const __global ushort *, size_t, event_t); -event_t __ovld async_work_group_copy(__local int *, const __global int *, size_t, event_t); -event_t __ovld async_work_group_copy(__local uint *, const __global uint *, size_t, event_t); -event_t __ovld async_work_group_copy(__local long *, const __global long *, size_t, event_t); -event_t __ovld async_work_group_copy(__local ulong *, const __global ulong *, size_t, event_t); -event_t __ovld async_work_group_copy(__local float *, const __global float *, size_t, event_t); -event_t __ovld async_work_group_copy(__local char2 *, const __global char2 *, size_t, event_t); -event_t __ovld async_work_group_copy(__local uchar2 *, const __global uchar2 *, size_t, event_t); -event_t __ovld async_work_group_copy(__local short2 *, const __global short2 *, size_t, event_t); -event_t __ovld async_work_group_copy(__local ushort2 *, const __global ushort2 *, size_t, event_t); -event_t __ovld async_work_group_copy(__local int2 *, const __global int2 *, size_t, event_t); -event_t __ovld async_work_group_copy(__local uint2 *, const __global uint2 *, size_t, event_t); -event_t __ovld async_work_group_copy(__local long2 *, const __global long2 *, size_t, event_t); -event_t __ovld async_work_group_copy(__local ulong2 *, const __global ulong2 *, size_t, event_t); -event_t __ovld async_work_group_copy(__local float2 *, const __global float2 *, size_t, event_t); -event_t __ovld async_work_group_copy(__local char3 *, const __global char3 *, size_t, event_t); -event_t __ovld async_work_group_copy(__local uchar3 *, const __global uchar3 *, size_t, event_t); -event_t __ovld async_work_group_copy(__local short3 *, const __global short3 *, size_t, event_t); -event_t __ovld async_work_group_copy(__local ushort3 *, const __global ushort3 *, size_t, event_t); -event_t __ovld async_work_group_copy(__local int3 *, const __global int3 *, size_t, event_t); -event_t __ovld async_work_group_copy(__local uint3 *, const __global uint3 *, size_t, event_t); -event_t __ovld async_work_group_copy(__local long3 *, const __global long3 *, size_t, event_t); -event_t __ovld async_work_group_copy(__local ulong3 *, const __global ulong3 *, size_t, event_t); -event_t __ovld async_work_group_copy(__local float3 *, const __global float3 *, size_t, event_t); -event_t __ovld async_work_group_copy(__local char4 *, const __global char4 *, size_t, event_t); -event_t __ovld async_work_group_copy(__local uchar4 *, const __global uchar4 *, size_t, event_t); -event_t __ovld async_work_group_copy(__local short4 *, const __global short4 *, size_t, event_t); -event_t __ovld async_work_group_copy(__local ushort4 *, const __global ushort4 *, size_t, event_t); -event_t __ovld async_work_group_copy(__local int4 *, const __global int4 *, size_t, event_t); -event_t __ovld async_work_group_copy(__local uint4 *, const __global uint4 *, size_t, event_t); -event_t __ovld async_work_group_copy(__local long4 *, const __global long4 *, size_t, event_t); -event_t __ovld async_work_group_copy(__local ulong4 *, const __global ulong4 *, size_t, event_t); -event_t __ovld async_work_group_copy(__local float4 *, const __global float4 *, size_t, event_t); -event_t __ovld async_work_group_copy(__local char8 *, const __global char8 *, size_t, event_t); -event_t __ovld async_work_group_copy(__local uchar8 *, const __global uchar8 *, size_t, event_t); -event_t __ovld async_work_group_copy(__local short8 *, const __global short8 *, size_t, event_t); -event_t __ovld async_work_group_copy(__local ushort8 *, const __global ushort8 *, size_t, event_t); -event_t __ovld async_work_group_copy(__local int8 *, const __global int8 *, size_t, event_t); -event_t __ovld async_work_group_copy(__local uint8 *, const __global uint8 *, size_t, event_t); -event_t __ovld async_work_group_copy(__local long8 *, const __global long8 *, size_t, event_t); -event_t __ovld async_work_group_copy(__local ulong8 *, const __global ulong8 *, size_t, event_t); -event_t __ovld async_work_group_copy(__local float8 *, const __global float8 *, size_t, event_t); -event_t __ovld async_work_group_copy(__local char16 *, const __global char16 *, size_t, event_t); -event_t __ovld async_work_group_copy(__local uchar16 *, const __global uchar16 *, size_t, event_t); -event_t __ovld async_work_group_copy(__local short16 *, const __global short16 *, size_t, event_t); -event_t __ovld async_work_group_copy(__local ushort16 *, const __global ushort16 *, size_t, event_t); -event_t __ovld async_work_group_copy(__local int16 *, const __global int16 *, size_t, event_t); -event_t __ovld async_work_group_copy(__local uint16 *, const __global uint16 *, size_t, event_t); -event_t __ovld async_work_group_copy(__local long16 *, const __global long16 *, size_t, event_t); -event_t __ovld async_work_group_copy(__local ulong16 *, const __global ulong16 *, size_t, event_t); -event_t __ovld async_work_group_copy(__local float16 *, const __global float16 *, size_t, event_t); -event_t __ovld async_work_group_copy(__global char *, const __local char *, size_t, event_t); -event_t __ovld async_work_group_copy(__global uchar *, const __local uchar *, size_t, event_t); -event_t __ovld async_work_group_copy(__global short *, const __local short *, size_t, event_t); -event_t __ovld async_work_group_copy(__global ushort *, const __local ushort *, size_t, event_t); -event_t __ovld async_work_group_copy(__global int *, const __local int *, size_t, event_t); -event_t __ovld async_work_group_copy(__global uint *, const __local uint *, size_t, event_t); -event_t __ovld async_work_group_copy(__global long *, const __local long *, size_t, event_t); -event_t __ovld async_work_group_copy(__global ulong *, const __local ulong *, size_t, event_t); -event_t __ovld async_work_group_copy(__global float *, const __local float *, size_t, event_t); -event_t __ovld async_work_group_copy(__global char2 *, const __local char2 *, size_t, event_t); -event_t __ovld async_work_group_copy(__global uchar2 *, const __local uchar2 *, size_t, event_t); -event_t __ovld async_work_group_copy(__global short2 *, const __local short2 *, size_t, event_t); -event_t __ovld async_work_group_copy(__global ushort2 *, const __local ushort2 *, size_t, event_t); -event_t __ovld async_work_group_copy(__global int2 *, const __local int2 *, size_t, event_t); -event_t __ovld async_work_group_copy(__global uint2 *, const __local uint2 *, size_t, event_t); -event_t __ovld async_work_group_copy(__global long2 *, const __local long2 *, size_t, event_t); -event_t __ovld async_work_group_copy(__global ulong2 *, const __local ulong2 *, size_t, event_t); -event_t __ovld async_work_group_copy(__global float2 *, const __local float2 *, size_t, event_t); -event_t __ovld async_work_group_copy(__global char3 *, const __local char3 *, size_t, event_t); -event_t __ovld async_work_group_copy(__global uchar3 *, const __local uchar3 *, size_t, event_t); -event_t __ovld async_work_group_copy(__global short3 *, const __local short3 *, size_t, event_t); -event_t __ovld async_work_group_copy(__global ushort3 *, const __local ushort3 *, size_t, event_t); -event_t __ovld async_work_group_copy(__global int3 *, const __local int3 *, size_t, event_t); -event_t __ovld async_work_group_copy(__global uint3 *, const __local uint3 *, size_t, event_t); -event_t __ovld async_work_group_copy(__global long3 *, const __local long3 *, size_t, event_t); -event_t __ovld async_work_group_copy(__global ulong3 *, const __local ulong3 *, size_t, event_t); -event_t __ovld async_work_group_copy(__global float3 *, const __local float3 *, size_t, event_t); -event_t __ovld async_work_group_copy(__global char4 *, const __local char4 *, size_t, event_t); -event_t __ovld async_work_group_copy(__global uchar4 *, const __local uchar4 *, size_t, event_t); -event_t __ovld async_work_group_copy(__global short4 *, const __local short4 *, size_t, event_t); -event_t __ovld async_work_group_copy(__global ushort4 *, const __local ushort4 *, size_t, event_t); -event_t __ovld async_work_group_copy(__global int4 *, const __local int4 *, size_t, event_t); -event_t __ovld async_work_group_copy(__global uint4 *, const __local uint4 *, size_t, event_t); -event_t __ovld async_work_group_copy(__global long4 *, const __local long4 *, size_t, event_t); -event_t __ovld async_work_group_copy(__global ulong4 *, const __local ulong4 *, size_t, event_t); -event_t __ovld async_work_group_copy(__global float4 *, const __local float4 *, size_t, event_t); -event_t __ovld async_work_group_copy(__global char8 *, const __local char8 *, size_t, event_t); -event_t __ovld async_work_group_copy(__global uchar8 *, const __local uchar8 *, size_t, event_t); -event_t __ovld async_work_group_copy(__global short8 *, const __local short8 *, size_t, event_t); -event_t __ovld async_work_group_copy(__global ushort8 *, const __local ushort8 *, size_t, event_t); -event_t __ovld async_work_group_copy(__global int8 *, const __local int8 *, size_t, event_t); -event_t __ovld async_work_group_copy(__global uint8 *, const __local uint8 *, size_t, event_t); -event_t __ovld async_work_group_copy(__global long8 *, const __local long8 *, size_t, event_t); -event_t __ovld async_work_group_copy(__global ulong8 *, const __local ulong8 *, size_t, event_t); -event_t __ovld async_work_group_copy(__global float8 *, const __local float8 *, size_t, event_t); -event_t __ovld async_work_group_copy(__global char16 *, const __local char16 *, size_t, event_t); -event_t __ovld async_work_group_copy(__global uchar16 *, const __local uchar16 *, size_t, event_t); -event_t __ovld async_work_group_copy(__global short16 *, const __local short16 *, size_t, event_t); -event_t __ovld async_work_group_copy(__global ushort16 *, const __local ushort16 *, size_t, event_t); -event_t __ovld async_work_group_copy(__global int16 *, const __local int16 *, size_t, event_t); -event_t __ovld async_work_group_copy(__global uint16 *, const __local uint16 *, size_t, event_t); -event_t __ovld async_work_group_copy(__global long16 *, const __local long16 *, size_t, event_t); -event_t __ovld async_work_group_copy(__global ulong16 *, const __local ulong16 *, size_t, event_t); -event_t __ovld async_work_group_copy(__global float16 *, const __local float16 *, size_t, event_t); -#ifdef cl_khr_fp64 -event_t __ovld async_work_group_copy(__local double *, const __global double *, size_t, event_t); -event_t __ovld async_work_group_copy(__local double2 *, const __global double2 *, size_t, event_t); -event_t __ovld async_work_group_copy(__local double3 *, const __global double3 *, size_t, event_t); -event_t __ovld async_work_group_copy(__local double4 *, const __global double4 *, size_t, event_t); -event_t __ovld async_work_group_copy(__local double8 *, const __global double8 *, size_t, event_t); -event_t __ovld async_work_group_copy(__local double16 *, const __global double16 *, size_t, event_t); -event_t __ovld async_work_group_copy(__global double *, const __local double *, size_t, event_t); -event_t __ovld async_work_group_copy(__global double2 *, const __local double2 *, size_t, event_t); -event_t __ovld async_work_group_copy(__global double3 *, const __local double3 *, size_t, event_t); -event_t __ovld async_work_group_copy(__global double4 *, const __local double4 *, size_t, event_t); -event_t __ovld async_work_group_copy(__global double8 *, const __local double8 *, size_t, event_t); -event_t __ovld async_work_group_copy(__global double16 *, const __local double16 *, size_t, event_t); -#endif //cl_khr_fp64 -#ifdef cl_khr_fp16 -event_t __ovld async_work_group_copy(__local half *, const __global half *, size_t, event_t); -event_t __ovld async_work_group_copy(__local half2 *, const __global half2 *, size_t, event_t); -event_t __ovld async_work_group_copy(__local half3 *, const __global half3 *, size_t, event_t); -event_t __ovld async_work_group_copy(__local half4 *, const __global half4 *, size_t, event_t); -event_t __ovld async_work_group_copy(__local half8 *, const __global half8 *, size_t, event_t); -event_t __ovld async_work_group_copy(__local half16 *, const __global half16 *, size_t, event_t); -event_t __ovld async_work_group_copy(__global half *, const __local half *, size_t, event_t); -event_t __ovld async_work_group_copy(__global half2 *, const __local half2 *, size_t, event_t); -event_t __ovld async_work_group_copy(__global half3 *, const __local half3 *, size_t, event_t); -event_t __ovld async_work_group_copy(__global half4 *, const __local half4 *, size_t, event_t); -event_t __ovld async_work_group_copy(__global half8 *, const __local half8 *, size_t, event_t); -event_t __ovld async_work_group_copy(__global half16 *, const __local half16 *, size_t, event_t); -#endif //cl_khr_fp16 - -/** - * Perform an async gather of num_elements - * gentype elements from src to dst. The - * src_stride is the stride in elements for each - * gentype element read from src. The dst_stride - * is the stride in elements for each gentype - * element written to dst. The async gather is - * performed by all work-items in a work-group. - * This built-in function must therefore be - * encountered by all work-items in a work-group - * executing the kernel with the same argument - * values; otherwise the results are undefined. - * Returns an event object that can be used by - * wait_group_events to wait for the async copy - * to finish. The event argument can also be used - * to associate the - * async_work_group_strided_copy with a - * previous async copy allowing an event to be - * shared by multiple async copies; otherwise event - * should be zero. - * If event argument is non-zero, the event object - * supplied in event argument will be returned. - * This function does not perform any implicit - * synchronization of source data such as using a - * barrier before performing the copy. - */ -event_t __ovld async_work_group_strided_copy(__local char *, const __global char *, size_t, size_t, event_t); -event_t __ovld async_work_group_strided_copy(__local uchar *, const __global uchar *, size_t, size_t, event_t); -event_t __ovld async_work_group_strided_copy(__local short *, const __global short *, size_t, size_t, event_t); -event_t __ovld async_work_group_strided_copy(__local ushort *, const __global ushort *, size_t, size_t, event_t); -event_t __ovld async_work_group_strided_copy(__local int *, const __global int *, size_t, size_t, event_t); -event_t __ovld async_work_group_strided_copy(__local uint *, const __global uint *, size_t, size_t, event_t); -event_t __ovld async_work_group_strided_copy(__local long *, const __global long *, size_t, size_t, event_t); -event_t __ovld async_work_group_strided_copy(__local ulong *, const __global ulong *, size_t, size_t, event_t); -event_t __ovld async_work_group_strided_copy(__local float *, const __global float *, size_t, size_t, event_t); -event_t __ovld async_work_group_strided_copy(__local char2 *, const __global char2 *, size_t, size_t, event_t); -event_t __ovld async_work_group_strided_copy(__local uchar2 *, const __global uchar2 *, size_t, size_t, event_t); -event_t __ovld async_work_group_strided_copy(__local short2 *, const __global short2 *, size_t, size_t, event_t); -event_t __ovld async_work_group_strided_copy(__local ushort2 *, const __global ushort2 *, size_t, size_t, event_t); -event_t __ovld async_work_group_strided_copy(__local int2 *, const __global int2 *, size_t, size_t, event_t); -event_t __ovld async_work_group_strided_copy(__local uint2 *, const __global uint2 *, size_t, size_t, event_t); -event_t __ovld async_work_group_strided_copy(__local long2 *, const __global long2 *, size_t, size_t, event_t); -event_t __ovld async_work_group_strided_copy(__local ulong2 *, const __global ulong2 *, size_t, size_t, event_t); -event_t __ovld async_work_group_strided_copy(__local float2 *, const __global float2 *, size_t, size_t, event_t); -event_t __ovld async_work_group_strided_copy(__local char3 *, const __global char3 *, size_t, size_t, event_t); -event_t __ovld async_work_group_strided_copy(__local uchar3 *, const __global uchar3 *, size_t, size_t, event_t); -event_t __ovld async_work_group_strided_copy(__local short3 *, const __global short3 *, size_t, size_t, event_t); -event_t __ovld async_work_group_strided_copy(__local ushort3 *, const __global ushort3 *, size_t, size_t, event_t); -event_t __ovld async_work_group_strided_copy(__local int3 *, const __global int3 *, size_t, size_t, event_t); -event_t __ovld async_work_group_strided_copy(__local uint3 *, const __global uint3 *, size_t, size_t, event_t); -event_t __ovld async_work_group_strided_copy(__local long3 *, const __global long3 *, size_t, size_t, event_t); -event_t __ovld async_work_group_strided_copy(__local ulong3 *, const __global ulong3 *, size_t, size_t, event_t); -event_t __ovld async_work_group_strided_copy(__local float3 *, const __global float3 *, size_t, size_t, event_t); -event_t __ovld async_work_group_strided_copy(__local char4 *, const __global char4 *, size_t, size_t, event_t); -event_t __ovld async_work_group_strided_copy(__local uchar4 *, const __global uchar4 *, size_t, size_t, event_t); -event_t __ovld async_work_group_strided_copy(__local short4 *, const __global short4 *, size_t, size_t, event_t); -event_t __ovld async_work_group_strided_copy(__local ushort4 *, const __global ushort4 *, size_t, size_t, event_t); -event_t __ovld async_work_group_strided_copy(__local int4 *, const __global int4 *, size_t, size_t, event_t); -event_t __ovld async_work_group_strided_copy(__local uint4 *, const __global uint4 *, size_t, size_t, event_t); -event_t __ovld async_work_group_strided_copy(__local long4 *, const __global long4 *, size_t, size_t, event_t); -event_t __ovld async_work_group_strided_copy(__local ulong4 *, const __global ulong4 *, size_t, size_t, event_t); -event_t __ovld async_work_group_strided_copy(__local float4 *, const __global float4 *, size_t, size_t, event_t); -event_t __ovld async_work_group_strided_copy(__local char8 *, const __global char8 *, size_t, size_t, event_t); -event_t __ovld async_work_group_strided_copy(__local uchar8 *, const __global uchar8 *, size_t, size_t, event_t); -event_t __ovld async_work_group_strided_copy(__local short8 *, const __global short8 *, size_t, size_t, event_t); -event_t __ovld async_work_group_strided_copy(__local ushort8 *, const __global ushort8 *, size_t, size_t, event_t); -event_t __ovld async_work_group_strided_copy(__local int8 *, const __global int8 *, size_t, size_t, event_t); -event_t __ovld async_work_group_strided_copy(__local uint8 *, const __global uint8 *, size_t, size_t, event_t); -event_t __ovld async_work_group_strided_copy(__local long8 *, const __global long8 *, size_t, size_t, event_t); -event_t __ovld async_work_group_strided_copy(__local ulong8 *, const __global ulong8 *, size_t, size_t, event_t); -event_t __ovld async_work_group_strided_copy(__local float8 *, const __global float8 *, size_t, size_t, event_t); -event_t __ovld async_work_group_strided_copy(__local char16 *, const __global char16 *, size_t, size_t, event_t); -event_t __ovld async_work_group_strided_copy(__local uchar16 *, const __global uchar16 *, size_t, size_t, event_t); -event_t __ovld async_work_group_strided_copy(__local short16 *, const __global short16 *, size_t, size_t, event_t); -event_t __ovld async_work_group_strided_copy(__local ushort16 *, const __global ushort16 *, size_t, size_t, event_t); -event_t __ovld async_work_group_strided_copy(__local int16 *, const __global int16 *, size_t, size_t, event_t); -event_t __ovld async_work_group_strided_copy(__local uint16 *, const __global uint16 *, size_t, size_t, event_t); -event_t __ovld async_work_group_strided_copy(__local long16 *, const __global long16 *, size_t, size_t, event_t); -event_t __ovld async_work_group_strided_copy(__local ulong16 *, const __global ulong16 *, size_t, size_t, event_t); -event_t __ovld async_work_group_strided_copy(__local float16 *, const __global float16 *, size_t, size_t, event_t); -event_t __ovld async_work_group_strided_copy(__global char *, const __local char *, size_t, size_t, event_t); -event_t __ovld async_work_group_strided_copy(__global uchar *, const __local uchar *, size_t, size_t, event_t); -event_t __ovld async_work_group_strided_copy(__global short *, const __local short *, size_t, size_t, event_t); -event_t __ovld async_work_group_strided_copy(__global ushort *, const __local ushort *, size_t, size_t, event_t); -event_t __ovld async_work_group_strided_copy(__global int *, const __local int *, size_t, size_t, event_t); -event_t __ovld async_work_group_strided_copy(__global uint *, const __local uint *, size_t, size_t, event_t); -event_t __ovld async_work_group_strided_copy(__global long *, const __local long *, size_t, size_t, event_t); -event_t __ovld async_work_group_strided_copy(__global ulong *, const __local ulong *, size_t, size_t, event_t); -event_t __ovld async_work_group_strided_copy(__global float *, const __local float *, size_t, size_t, event_t); -event_t __ovld async_work_group_strided_copy(__global char2 *, const __local char2 *, size_t, size_t, event_t); -event_t __ovld async_work_group_strided_copy(__global uchar2 *, const __local uchar2 *, size_t, size_t, event_t); -event_t __ovld async_work_group_strided_copy(__global short2 *, const __local short2 *, size_t, size_t, event_t); -event_t __ovld async_work_group_strided_copy(__global ushort2 *, const __local ushort2 *, size_t, size_t, event_t); -event_t __ovld async_work_group_strided_copy(__global int2 *, const __local int2 *, size_t, size_t, event_t); -event_t __ovld async_work_group_strided_copy(__global uint2 *, const __local uint2 *, size_t, size_t, event_t); -event_t __ovld async_work_group_strided_copy(__global long2 *, const __local long2 *, size_t, size_t, event_t); -event_t __ovld async_work_group_strided_copy(__global ulong2 *, const __local ulong2 *, size_t, size_t, event_t); -event_t __ovld async_work_group_strided_copy(__global float2 *, const __local float2 *, size_t, size_t, event_t); -event_t __ovld async_work_group_strided_copy(__global char3 *, const __local char3 *, size_t, size_t, event_t); -event_t __ovld async_work_group_strided_copy(__global uchar3 *, const __local uchar3 *, size_t, size_t, event_t); -event_t __ovld async_work_group_strided_copy(__global short3 *, const __local short3 *, size_t, size_t, event_t); -event_t __ovld async_work_group_strided_copy(__global ushort3 *, const __local ushort3 *, size_t, size_t, event_t); -event_t __ovld async_work_group_strided_copy(__global int3 *, const __local int3 *, size_t, size_t, event_t); -event_t __ovld async_work_group_strided_copy(__global uint3 *, const __local uint3 *, size_t, size_t, event_t); -event_t __ovld async_work_group_strided_copy(__global long3 *, const __local long3 *, size_t, size_t, event_t); -event_t __ovld async_work_group_strided_copy(__global ulong3 *, const __local ulong3 *, size_t, size_t, event_t); -event_t __ovld async_work_group_strided_copy(__global float3 *, const __local float3 *, size_t, size_t, event_t); -event_t __ovld async_work_group_strided_copy(__global char4 *, const __local char4 *, size_t, size_t, event_t); -event_t __ovld async_work_group_strided_copy(__global uchar4 *, const __local uchar4 *, size_t, size_t, event_t); -event_t __ovld async_work_group_strided_copy(__global short4 *, const __local short4 *, size_t, size_t, event_t); -event_t __ovld async_work_group_strided_copy(__global ushort4 *, const __local ushort4 *, size_t, size_t, event_t); -event_t __ovld async_work_group_strided_copy(__global int4 *, const __local int4 *, size_t, size_t, event_t); -event_t __ovld async_work_group_strided_copy(__global uint4 *, const __local uint4 *, size_t, size_t, event_t); -event_t __ovld async_work_group_strided_copy(__global long4 *, const __local long4 *, size_t, size_t, event_t); -event_t __ovld async_work_group_strided_copy(__global ulong4 *, const __local ulong4 *, size_t, size_t, event_t); -event_t __ovld async_work_group_strided_copy(__global float4 *, const __local float4 *, size_t, size_t, event_t); -event_t __ovld async_work_group_strided_copy(__global char8 *, const __local char8 *, size_t, size_t, event_t); -event_t __ovld async_work_group_strided_copy(__global uchar8 *, const __local uchar8 *, size_t, size_t, event_t); -event_t __ovld async_work_group_strided_copy(__global short8 *, const __local short8 *, size_t, size_t, event_t); -event_t __ovld async_work_group_strided_copy(__global ushort8 *, const __local ushort8 *, size_t, size_t, event_t); -event_t __ovld async_work_group_strided_copy(__global int8 *, const __local int8 *, size_t, size_t, event_t); -event_t __ovld async_work_group_strided_copy(__global uint8 *, const __local uint8 *, size_t, size_t, event_t); -event_t __ovld async_work_group_strided_copy(__global long8 *, const __local long8 *, size_t, size_t, event_t); -event_t __ovld async_work_group_strided_copy(__global ulong8 *, const __local ulong8 *, size_t, size_t, event_t); -event_t __ovld async_work_group_strided_copy(__global float8 *, const __local float8 *, size_t, size_t, event_t); -event_t __ovld async_work_group_strided_copy(__global char16 *, const __local char16 *, size_t, size_t, event_t); -event_t __ovld async_work_group_strided_copy(__global uchar16 *, const __local uchar16 *, size_t, size_t, event_t); -event_t __ovld async_work_group_strided_copy(__global short16 *, const __local short16 *, size_t, size_t, event_t); -event_t __ovld async_work_group_strided_copy(__global ushort16 *, const __local ushort16 *, size_t, size_t, event_t); -event_t __ovld async_work_group_strided_copy(__global int16 *, const __local int16 *, size_t, size_t, event_t); -event_t __ovld async_work_group_strided_copy(__global uint16 *, const __local uint16 *, size_t, size_t, event_t); -event_t __ovld async_work_group_strided_copy(__global long16 *, const __local long16 *, size_t, size_t, event_t); -event_t __ovld async_work_group_strided_copy(__global ulong16 *, const __local ulong16 *, size_t, size_t, event_t); -event_t __ovld async_work_group_strided_copy(__global float16 *, const __local float16 *, size_t, size_t, event_t); -#ifdef cl_khr_fp64 -event_t __ovld async_work_group_strided_copy(__local double *, const __global double *, size_t, size_t, event_t); -event_t __ovld async_work_group_strided_copy(__local double2 *, const __global double2 *, size_t, size_t, event_t); -event_t __ovld async_work_group_strided_copy(__local double3 *, const __global double3 *, size_t, size_t, event_t); -event_t __ovld async_work_group_strided_copy(__local double4 *, const __global double4 *, size_t, size_t, event_t); -event_t __ovld async_work_group_strided_copy(__local double8 *, const __global double8 *, size_t, size_t, event_t); -event_t __ovld async_work_group_strided_copy(__local double16 *, const __global double16 *, size_t, size_t, event_t); -event_t __ovld async_work_group_strided_copy(__global double *, const __local double *, size_t, size_t, event_t); -event_t __ovld async_work_group_strided_copy(__global double2 *, const __local double2 *, size_t, size_t, event_t); -event_t __ovld async_work_group_strided_copy(__global double3 *, const __local double3 *, size_t, size_t, event_t); -event_t __ovld async_work_group_strided_copy(__global double4 *, const __local double4 *, size_t, size_t, event_t); -event_t __ovld async_work_group_strided_copy(__global double8 *, const __local double8 *, size_t, size_t, event_t); -event_t __ovld async_work_group_strided_copy(__global double16 *, const __local double16 *, size_t, size_t, event_t); -#endif //cl_khr_fp64 -#ifdef cl_khr_fp16 -event_t __ovld async_work_group_strided_copy(__local half *, const __global half *, size_t, size_t, event_t); -event_t __ovld async_work_group_strided_copy(__local half2 *, const __global half2 *, size_t, size_t, event_t); -event_t __ovld async_work_group_strided_copy(__local half3 *, const __global half3 *, size_t, size_t, event_t); -event_t __ovld async_work_group_strided_copy(__local half4 *, const __global half4 *, size_t, size_t, event_t); -event_t __ovld async_work_group_strided_copy(__local half8 *, const __global half8 *, size_t, size_t, event_t); -event_t __ovld async_work_group_strided_copy(__local half16 *, const __global half16 *, size_t, size_t, event_t); -event_t __ovld async_work_group_strided_copy(__global half *, const __local half *, size_t, size_t, event_t); -event_t __ovld async_work_group_strided_copy(__global half2 *, const __local half2 *, size_t, size_t, event_t); -event_t __ovld async_work_group_strided_copy(__global half3 *, const __local half3 *, size_t, size_t, event_t); -event_t __ovld async_work_group_strided_copy(__global half4 *, const __local half4 *, size_t, size_t, event_t); -event_t __ovld async_work_group_strided_copy(__global half8 *, const __local half8 *, size_t, size_t, event_t); -event_t __ovld async_work_group_strided_copy(__global half16 *, const __local half16 *, size_t, size_t, event_t); -#endif //cl_khr_fp16 - -/** - * Wait for events that identify the - * async_work_group_copy operations to - * complete. The event objects specified in - * event_list will be released after the wait is - * performed. - * This function must be encountered by all workitems - * in a work-group executing the kernel with - * the same num_events and event objects specified - * in event_list; otherwise the results are undefined. - */ -void __ovld wait_group_events(int, event_t *); - -/** - * Prefetch num_elements * sizeof(gentype) - * bytes into the global cache. The prefetch - * instruction is applied to a work-item in a workgroup - * and does not affect the functional - * behavior of the kernel. - */ -void __ovld prefetch(const __global char *, size_t); -void __ovld prefetch(const __global uchar *, size_t); -void __ovld prefetch(const __global short *, size_t); -void __ovld prefetch(const __global ushort *, size_t); -void __ovld prefetch(const __global int *, size_t); -void __ovld prefetch(const __global uint *, size_t); -void __ovld prefetch(const __global long *, size_t); -void __ovld prefetch(const __global ulong *, size_t); -void __ovld prefetch(const __global float *, size_t); -void __ovld prefetch(const __global char2 *, size_t); -void __ovld prefetch(const __global uchar2 *, size_t); -void __ovld prefetch(const __global short2 *, size_t); -void __ovld prefetch(const __global ushort2 *, size_t); -void __ovld prefetch(const __global int2 *, size_t); -void __ovld prefetch(const __global uint2 *, size_t); -void __ovld prefetch(const __global long2 *, size_t); -void __ovld prefetch(const __global ulong2 *, size_t); -void __ovld prefetch(const __global float2 *, size_t); -void __ovld prefetch(const __global char3 *, size_t); -void __ovld prefetch(const __global uchar3 *, size_t); -void __ovld prefetch(const __global short3 *, size_t); -void __ovld prefetch(const __global ushort3 *, size_t); -void __ovld prefetch(const __global int3 *, size_t); -void __ovld prefetch(const __global uint3 *, size_t); -void __ovld prefetch(const __global long3 *, size_t); -void __ovld prefetch(const __global ulong3 *, size_t); -void __ovld prefetch(const __global float3 *, size_t); -void __ovld prefetch(const __global char4 *, size_t); -void __ovld prefetch(const __global uchar4 *, size_t); -void __ovld prefetch(const __global short4 *, size_t); -void __ovld prefetch(const __global ushort4 *, size_t); -void __ovld prefetch(const __global int4 *, size_t); -void __ovld prefetch(const __global uint4 *, size_t); -void __ovld prefetch(const __global long4 *, size_t); -void __ovld prefetch(const __global ulong4 *, size_t); -void __ovld prefetch(const __global float4 *, size_t); -void __ovld prefetch(const __global char8 *, size_t); -void __ovld prefetch(const __global uchar8 *, size_t); -void __ovld prefetch(const __global short8 *, size_t); -void __ovld prefetch(const __global ushort8 *, size_t); -void __ovld prefetch(const __global int8 *, size_t); -void __ovld prefetch(const __global uint8 *, size_t); -void __ovld prefetch(const __global long8 *, size_t); -void __ovld prefetch(const __global ulong8 *, size_t); -void __ovld prefetch(const __global float8 *, size_t); -void __ovld prefetch(const __global char16 *, size_t); -void __ovld prefetch(const __global uchar16 *, size_t); -void __ovld prefetch(const __global short16 *, size_t); -void __ovld prefetch(const __global ushort16 *, size_t); -void __ovld prefetch(const __global int16 *, size_t); -void __ovld prefetch(const __global uint16 *, size_t); -void __ovld prefetch(const __global long16 *, size_t); -void __ovld prefetch(const __global ulong16 *, size_t); -void __ovld prefetch(const __global float16 *, size_t); -#ifdef cl_khr_fp64 -void __ovld prefetch(const __global double *, size_t); -void __ovld prefetch(const __global double2 *, size_t); -void __ovld prefetch(const __global double3 *, size_t); -void __ovld prefetch(const __global double4 *, size_t); -void __ovld prefetch(const __global double8 *, size_t); -void __ovld prefetch(const __global double16 *, size_t); -#endif //cl_khr_fp64 -#ifdef cl_khr_fp16 -void __ovld prefetch(const __global half *, size_t); -void __ovld prefetch(const __global half2 *, size_t); -void __ovld prefetch(const __global half3 *, size_t); -void __ovld prefetch(const __global half4 *, size_t); -void __ovld prefetch(const __global half8 *, size_t); -void __ovld prefetch(const __global half16 *, size_t); -#endif // cl_khr_fp16 - -// OpenCL v1.1 s6.11.1, v1.2 s6.12.11 - Atomic Functions - -#if defined(cl_khr_int64_base_atomics) && defined(cl_khr_int64_extended_atomics) -#pragma OPENCL EXTENSION cl_khr_int64_base_atomics : enable -#pragma OPENCL EXTENSION cl_khr_int64_extended_atomics : enable -#endif -/** - * Read the 32-bit value (referred to as old) - * stored at location pointed by p. Compute - * (old + val) and store result at location - * pointed by p. The function returns old. - */ -int __ovld atomic_add(volatile __global int *, int); -uint __ovld atomic_add(volatile __global uint *, uint); -int __ovld atomic_add(volatile __local int *, int); -uint __ovld atomic_add(volatile __local uint *, uint); -#ifdef __OPENCL_CPP_VERSION__ -int __ovld atomic_add(volatile int *, int); -uint __ovld atomic_add(volatile uint *, uint); -#endif - -#if defined(cl_khr_global_int32_base_atomics) -int __ovld atom_add(volatile __global int *, int); -uint __ovld atom_add(volatile __global uint *, uint); -#endif -#if defined(cl_khr_local_int32_base_atomics) -int __ovld atom_add(volatile __local int *, int); -uint __ovld atom_add(volatile __local uint *, uint); -#endif - -#if defined(cl_khr_int64_base_atomics) -long __ovld atom_add(volatile __global long *, long); -ulong __ovld atom_add(volatile __global ulong *, ulong); -long __ovld atom_add(volatile __local long *, long); -ulong __ovld atom_add(volatile __local ulong *, ulong); -#endif - -/** - * Read the 32-bit value (referred to as old) stored at location pointed by p. - * Compute (old - val) and store result at location pointed by p. The function - * returns old. - */ -int __ovld atomic_sub(volatile __global int *, int); -uint __ovld atomic_sub(volatile __global uint *, uint); -int __ovld atomic_sub(volatile __local int *, int); -uint __ovld atomic_sub(volatile __local uint *, uint); -#ifdef __OPENCL_CPP_VERSION__ -int __ovld atomic_sub(volatile int *, int); -uint __ovld atomic_sub(volatile uint *, uint); -#endif - -#if defined(cl_khr_global_int32_base_atomics) -int __ovld atom_sub(volatile __global int *, int); -uint __ovld atom_sub(volatile __global uint *, uint); -#endif -#if defined(cl_khr_local_int32_base_atomics) -int __ovld atom_sub(volatile __local int *, int); -uint __ovld atom_sub(volatile __local uint *, uint); -#endif - -#if defined(cl_khr_int64_base_atomics) -long __ovld atom_sub(volatile __global long *, long); -ulong __ovld atom_sub(volatile __global ulong *, ulong); -long __ovld atom_sub(volatile __local long *, long); -ulong __ovld atom_sub(volatile __local ulong *, ulong); -#endif - -/** - * Swaps the old value stored at location p - * with new value given by val. Returns old - * value. - */ -int __ovld atomic_xchg(volatile __global int *, int); -uint __ovld atomic_xchg(volatile __global uint *, uint); -int __ovld atomic_xchg(volatile __local int *, int); -uint __ovld atomic_xchg(volatile __local uint *, uint); -float __ovld atomic_xchg(volatile __global float *, float); -float __ovld atomic_xchg(volatile __local float *, float); -#ifdef __OPENCL_CPP_VERSION__ -int __ovld atomic_xchg(volatile int *, int); -uint __ovld atomic_xchg(volatile uint *, uint); -float __ovld atomic_xchg(volatile float *, float); -#endif - -#if defined(cl_khr_global_int32_base_atomics) -int __ovld atom_xchg(volatile __global int *, int); -uint __ovld atom_xchg(volatile __global uint *, uint); -#endif -#if defined(cl_khr_local_int32_base_atomics) -int __ovld atom_xchg(volatile __local int *, int); -uint __ovld atom_xchg(volatile __local uint *, uint); -#endif - -#if defined(cl_khr_int64_base_atomics) -long __ovld atom_xchg(volatile __global long *, long); -long __ovld atom_xchg(volatile __local long *, long); -ulong __ovld atom_xchg(volatile __global ulong *, ulong); -ulong __ovld atom_xchg(volatile __local ulong *, ulong); -#endif - -/** - * Read the 32-bit value (referred to as old) - * stored at location pointed by p. Compute - * (old + 1) and store result at location - * pointed by p. The function returns old. - */ -int __ovld atomic_inc(volatile __global int *); -uint __ovld atomic_inc(volatile __global uint *); -int __ovld atomic_inc(volatile __local int *); -uint __ovld atomic_inc(volatile __local uint *); -#ifdef __OPENCL_CPP_VERSION__ -int __ovld atomic_inc(volatile int *); -uint __ovld atomic_inc(volatile uint *); -#endif - -#if defined(cl_khr_global_int32_base_atomics) -int __ovld atom_inc(volatile __global int *); -uint __ovld atom_inc(volatile __global uint *); -#endif -#if defined(cl_khr_local_int32_base_atomics) -int __ovld atom_inc(volatile __local int *); -uint __ovld atom_inc(volatile __local uint *); -#endif - -#if defined(cl_khr_int64_base_atomics) -long __ovld atom_inc(volatile __global long *); -ulong __ovld atom_inc(volatile __global ulong *); -long __ovld atom_inc(volatile __local long *); -ulong __ovld atom_inc(volatile __local ulong *); -#endif - -/** - * Read the 32-bit value (referred to as old) - * stored at location pointed by p. Compute - * (old - 1) and store result at location - * pointed by p. The function returns old. - */ -int __ovld atomic_dec(volatile __global int *); -uint __ovld atomic_dec(volatile __global uint *); -int __ovld atomic_dec(volatile __local int *); -uint __ovld atomic_dec(volatile __local uint *); -#ifdef __OPENCL_CPP_VERSION__ -int __ovld atomic_dec(volatile int *); -uint __ovld atomic_dec(volatile uint *); -#endif - -#if defined(cl_khr_global_int32_base_atomics) -int __ovld atom_dec(volatile __global int *); -uint __ovld atom_dec(volatile __global uint *); -#endif -#if defined(cl_khr_local_int32_base_atomics) -int __ovld atom_dec(volatile __local int *); -uint __ovld atom_dec(volatile __local uint *); -#endif - -#if defined(cl_khr_int64_base_atomics) -long __ovld atom_dec(volatile __global long *); -ulong __ovld atom_dec(volatile __global ulong *); -long __ovld atom_dec(volatile __local long *); -ulong __ovld atom_dec(volatile __local ulong *); -#endif - -/** - * Read the 32-bit value (referred to as old) - * stored at location pointed by p. Compute - * (old == cmp) ? val : old and store result at - * location pointed by p. The function - * returns old. - */ -int __ovld atomic_cmpxchg(volatile __global int *, int, int); -uint __ovld atomic_cmpxchg(volatile __global uint *, uint, uint); -int __ovld atomic_cmpxchg(volatile __local int *, int, int); -uint __ovld atomic_cmpxchg(volatile __local uint *, uint, uint); -#ifdef __OPENCL_CPP_VERSION__ -int __ovld atomic_cmpxchg(volatile int *, int, int); -uint __ovld atomic_cmpxchg(volatile uint *, uint, uint); -#endif - -#if defined(cl_khr_global_int32_base_atomics) -int __ovld atom_cmpxchg(volatile __global int *, int, int); -uint __ovld atom_cmpxchg(volatile __global uint *, uint, uint); -#endif -#if defined(cl_khr_local_int32_base_atomics) -int __ovld atom_cmpxchg(volatile __local int *, int, int); -uint __ovld atom_cmpxchg(volatile __local uint *, uint, uint); -#endif - -#if defined(cl_khr_int64_base_atomics) -long __ovld atom_cmpxchg(volatile __global long *, long, long); -ulong __ovld atom_cmpxchg(volatile __global ulong *, ulong, ulong); -long __ovld atom_cmpxchg(volatile __local long *, long, long); -ulong __ovld atom_cmpxchg(volatile __local ulong *, ulong, ulong); -#endif - -/** - * Read the 32-bit value (referred to as old) - * stored at location pointed by p. Compute - * min(old, val) and store minimum value at - * location pointed by p. The function - * returns old. - */ -int __ovld atomic_min(volatile __global int *, int); -uint __ovld atomic_min(volatile __global uint *, uint); -int __ovld atomic_min(volatile __local int *, int); -uint __ovld atomic_min(volatile __local uint *, uint); -#ifdef __OPENCL_CPP_VERSION__ -int __ovld atomic_min(volatile int *, int); -uint __ovld atomic_min(volatile uint *, uint); -#endif - -#if defined(cl_khr_global_int32_extended_atomics) -int __ovld atom_min(volatile __global int *, int); -uint __ovld atom_min(volatile __global uint *, uint); -#endif -#if defined(cl_khr_local_int32_extended_atomics) -int __ovld atom_min(volatile __local int *, int); -uint __ovld atom_min(volatile __local uint *, uint); -#endif - -#if defined(cl_khr_int64_extended_atomics) -long __ovld atom_min(volatile __global long *, long); -ulong __ovld atom_min(volatile __global ulong *, ulong); -long __ovld atom_min(volatile __local long *, long); -ulong __ovld atom_min(volatile __local ulong *, ulong); -#endif - -/** - * Read the 32-bit value (referred to as old) - * stored at location pointed by p. Compute - * max(old, val) and store maximum value at - * location pointed by p. The function - * returns old. - */ -int __ovld atomic_max(volatile __global int *, int); -uint __ovld atomic_max(volatile __global uint *, uint); -int __ovld atomic_max(volatile __local int *, int); -uint __ovld atomic_max(volatile __local uint *, uint); -#ifdef __OPENCL_CPP_VERSION__ -int __ovld atomic_max(volatile int *, int); -uint __ovld atomic_max(volatile uint *, uint); -#endif - -#if defined(cl_khr_global_int32_extended_atomics) -int __ovld atom_max(volatile __global int *, int); -uint __ovld atom_max(volatile __global uint *, uint); -#endif -#if defined(cl_khr_local_int32_extended_atomics) -int __ovld atom_max(volatile __local int *, int); -uint __ovld atom_max(volatile __local uint *, uint); -#endif - -#if defined(cl_khr_int64_extended_atomics) -long __ovld atom_max(volatile __global long *, long); -ulong __ovld atom_max(volatile __global ulong *, ulong); -long __ovld atom_max(volatile __local long *, long); -ulong __ovld atom_max(volatile __local ulong *, ulong); -#endif - -/** - * Read the 32-bit value (referred to as old) - * stored at location pointed by p. Compute - * (old & val) and store result at location - * pointed by p. The function returns old. - */ -int __ovld atomic_and(volatile __global int *, int); -uint __ovld atomic_and(volatile __global uint *, uint); -int __ovld atomic_and(volatile __local int *, int); -uint __ovld atomic_and(volatile __local uint *, uint); -#ifdef __OPENCL_CPP_VERSION__ -int __ovld atomic_and(volatile int *, int); -uint __ovld atomic_and(volatile uint *, uint); -#endif - -#if defined(cl_khr_global_int32_extended_atomics) -int __ovld atom_and(volatile __global int *, int); -uint __ovld atom_and(volatile __global uint *, uint); -#endif -#if defined(cl_khr_local_int32_extended_atomics) -int __ovld atom_and(volatile __local int *, int); -uint __ovld atom_and(volatile __local uint *, uint); -#endif - -#if defined(cl_khr_int64_extended_atomics) -long __ovld atom_and(volatile __global long *, long); -ulong __ovld atom_and(volatile __global ulong *, ulong); -long __ovld atom_and(volatile __local long *, long); -ulong __ovld atom_and(volatile __local ulong *, ulong); -#endif - -/** - * Read the 32-bit value (referred to as old) - * stored at location pointed by p. Compute - * (old | val) and store result at location - * pointed by p. The function returns old. - */ -int __ovld atomic_or(volatile __global int *, int); -uint __ovld atomic_or(volatile __global uint *, uint); -int __ovld atomic_or(volatile __local int *, int); -uint __ovld atomic_or(volatile __local uint *, uint); -#ifdef __OPENCL_CPP_VERSION__ -int __ovld atomic_or(volatile int *, int); -uint __ovld atomic_or(volatile uint *, uint); -#endif - -#if defined(cl_khr_global_int32_extended_atomics) -int __ovld atom_or(volatile __global int *, int); -uint __ovld atom_or(volatile __global uint *, uint); -#endif -#if defined(cl_khr_local_int32_extended_atomics) -int __ovld atom_or(volatile __local int *, int); -uint __ovld atom_or(volatile __local uint *, uint); -#endif - -#if defined(cl_khr_int64_extended_atomics) -long __ovld atom_or(volatile __global long *, long); -ulong __ovld atom_or(volatile __global ulong *, ulong); -long __ovld atom_or(volatile __local long *, long); -ulong __ovld atom_or(volatile __local ulong *, ulong); -#endif - -/** - * Read the 32-bit value (referred to as old) - * stored at location pointed by p. Compute - * (old ^ val) and store result at location - * pointed by p. The function returns old. - */ -int __ovld atomic_xor(volatile __global int *, int); -uint __ovld atomic_xor(volatile __global uint *, uint); -int __ovld atomic_xor(volatile __local int *, int); -uint __ovld atomic_xor(volatile __local uint *, uint); -#ifdef __OPENCL_CPP_VERSION__ -int __ovld atomic_xor(volatile int *, int); -uint __ovld atomic_xor(volatile uint *, uint); -#endif - -#if defined(cl_khr_global_int32_extended_atomics) -int __ovld atom_xor(volatile __global int *, int); -uint __ovld atom_xor(volatile __global uint *, uint); -#endif -#if defined(cl_khr_local_int32_extended_atomics) -int __ovld atom_xor(volatile __local int *, int); -uint __ovld atom_xor(volatile __local uint *, uint); -#endif - -#if defined(cl_khr_int64_extended_atomics) -long __ovld atom_xor(volatile __global long *, long); -ulong __ovld atom_xor(volatile __global ulong *, ulong); -long __ovld atom_xor(volatile __local long *, long); -ulong __ovld atom_xor(volatile __local ulong *, ulong); -#endif - -#if defined(cl_khr_int64_base_atomics) && defined(cl_khr_int64_extended_atomics) -#pragma OPENCL EXTENSION cl_khr_int64_base_atomics : disable -#pragma OPENCL EXTENSION cl_khr_int64_extended_atomics : disable -#endif - -// OpenCL v2.0 s6.13.11 - Atomics Functions - -#if defined(__OPENCL_CPP_VERSION__) || (__OPENCL_C_VERSION__ >= CL_VERSION_2_0) - -// double atomics support requires extensions cl_khr_int64_base_atomics and cl_khr_int64_extended_atomics -#if defined(cl_khr_int64_base_atomics) && defined(cl_khr_int64_extended_atomics) -#pragma OPENCL EXTENSION cl_khr_int64_base_atomics : enable -#pragma OPENCL EXTENSION cl_khr_int64_extended_atomics : enable -#endif - -// atomic_init() -#if defined(__opencl_c_generic_address_space) -void __ovld atomic_init(volatile atomic_int *, int); -void __ovld atomic_init(volatile atomic_uint *, uint); -void __ovld atomic_init(volatile atomic_float *, float); -#if defined(cl_khr_int64_base_atomics) && defined(cl_khr_int64_extended_atomics) -void __ovld atomic_init(volatile atomic_long *, long); -void __ovld atomic_init(volatile atomic_ulong *, ulong); -#ifdef cl_khr_fp64 -void __ovld atomic_init(volatile atomic_double *, double); -#endif //cl_khr_fp64 -#endif -#endif //defined(__opencl_c_generic_address_space) -#if (__OPENCL_C_VERSION__ >= CL_VERSION_3_0 || __OPENCL_CPP_VERSION__ >= 202100) -void __ovld atomic_init(volatile __global atomic_int *, int); -void __ovld atomic_init(volatile __local atomic_int *, int); -void __ovld atomic_init(volatile __global atomic_uint *, uint); -void __ovld atomic_init(volatile __local atomic_uint *, uint); -void __ovld atomic_init(volatile __global atomic_float *, float); -void __ovld atomic_init(volatile __local atomic_float *, float); -#if defined(cl_khr_int64_base_atomics) && defined(cl_khr_int64_extended_atomics) -void __ovld atomic_init(volatile __global atomic_long *, long); -void __ovld atomic_init(volatile __local atomic_long *, long); -void __ovld atomic_init(volatile __global atomic_ulong *, ulong); -void __ovld atomic_init(volatile __local atomic_ulong *, ulong); -#ifdef cl_khr_fp64 -void __ovld atomic_init(volatile __global atomic_double *, double); -void __ovld atomic_init(volatile __local atomic_double *, double); -#endif //cl_khr_fp64 -#endif -#endif // (__OPENCL_C_VERSION__ >= CL_VERSION_3_0 || __OPENCL_CPP_VERSION__ >= 202100) - -// atomic_work_item_fence() -void __ovld atomic_work_item_fence(cl_mem_fence_flags, memory_order, memory_scope); - -// atomic_fetch() -// OpenCL v2.0 s6.13.11.7.5: -// add/sub: atomic type argument can be uintptr_t/intptr_t, value type argument can be ptrdiff_t. - -#if defined(__opencl_c_atomic_order_seq_cst) && defined(__opencl_c_atomic_scope_device) -#if defined(__opencl_c_generic_address_space) -int __ovld atomic_fetch_add(volatile atomic_int *, int); -uint __ovld atomic_fetch_add(volatile atomic_uint *, uint); -int __ovld atomic_fetch_sub(volatile atomic_int *, int); -uint __ovld atomic_fetch_sub(volatile atomic_uint *, uint); -int __ovld atomic_fetch_or(volatile atomic_int *, int); -uint __ovld atomic_fetch_or(volatile atomic_uint *, uint); -int __ovld atomic_fetch_xor(volatile atomic_int *, int); -uint __ovld atomic_fetch_xor(volatile atomic_uint *, uint); -int __ovld atomic_fetch_and(volatile atomic_int *, int); -uint __ovld atomic_fetch_and(volatile atomic_uint *, uint); -int __ovld atomic_fetch_min(volatile atomic_int *, int); -uint __ovld atomic_fetch_min(volatile atomic_uint *, uint); -int __ovld atomic_fetch_max(volatile atomic_int *, int); -uint __ovld atomic_fetch_max(volatile atomic_uint *, uint); -#if defined(cl_khr_int64_base_atomics) && defined(cl_khr_int64_extended_atomics) -long __ovld atomic_fetch_add(volatile atomic_long *, long); -ulong __ovld atomic_fetch_add(volatile atomic_ulong *, ulong); -long __ovld atomic_fetch_sub(volatile atomic_long *, long); -ulong __ovld atomic_fetch_sub(volatile atomic_ulong *, ulong); -long __ovld atomic_fetch_or(volatile atomic_long *, long); -ulong __ovld atomic_fetch_or(volatile atomic_ulong *, ulong); -long __ovld atomic_fetch_xor(volatile atomic_long *, long); -ulong __ovld atomic_fetch_xor(volatile atomic_ulong *, ulong); -long __ovld atomic_fetch_and(volatile atomic_long *, long); -ulong __ovld atomic_fetch_and(volatile atomic_ulong *, ulong); -long __ovld atomic_fetch_min(volatile atomic_long *, long); -ulong __ovld atomic_fetch_min(volatile atomic_ulong *, ulong); -long __ovld atomic_fetch_max(volatile atomic_long *, long); -ulong __ovld atomic_fetch_max(volatile atomic_ulong *, ulong); -uintptr_t __ovld atomic_fetch_add(volatile atomic_uintptr_t *, ptrdiff_t); -uintptr_t __ovld atomic_fetch_sub(volatile atomic_uintptr_t *, ptrdiff_t); -#endif //defined(cl_khr_int64_base_atomics) && defined(cl_khr_int64_extended_atomics) -#endif //defined(__opencl_c_generic_address_space) -#if (__OPENCL_C_VERSION__ >= CL_VERSION_3_0 || __OPENCL_CPP_VERSION__ >= 202100) -int __ovld atomic_fetch_add(volatile __global atomic_int *, int); -int __ovld atomic_fetch_add(volatile __local atomic_int *, int); -uint __ovld atomic_fetch_add(volatile __global atomic_uint *, uint); -uint __ovld atomic_fetch_add(volatile __local atomic_uint *, uint); -int __ovld atomic_fetch_sub(volatile __global atomic_int *, int); -int __ovld atomic_fetch_sub(volatile __local atomic_int *, int); -uint __ovld atomic_fetch_sub(volatile __global atomic_uint *, uint); -uint __ovld atomic_fetch_sub(volatile __local atomic_uint *, uint); -int __ovld atomic_fetch_or(volatile __global atomic_int *, int); -int __ovld atomic_fetch_or(volatile __local atomic_int *, int); -uint __ovld atomic_fetch_or(volatile __global atomic_uint *, uint); -uint __ovld atomic_fetch_or(volatile __local atomic_uint *, uint); -int __ovld atomic_fetch_xor(volatile __global atomic_int *, int); -int __ovld atomic_fetch_xor(volatile __local atomic_int *, int); -uint __ovld atomic_fetch_xor(volatile __global atomic_uint *, uint); -uint __ovld atomic_fetch_xor(volatile __local atomic_uint *, uint); -int __ovld atomic_fetch_and(volatile __global atomic_int *, int); -int __ovld atomic_fetch_and(volatile __local atomic_int *, int); -uint __ovld atomic_fetch_and(volatile __global atomic_uint *, uint); -uint __ovld atomic_fetch_and(volatile __local atomic_uint *, uint); -int __ovld atomic_fetch_min(volatile __global atomic_int *, int); -int __ovld atomic_fetch_min(volatile __local atomic_int *, int); -uint __ovld atomic_fetch_min(volatile __global atomic_uint *, uint); -uint __ovld atomic_fetch_min(volatile __local atomic_uint *, uint); -int __ovld atomic_fetch_max(volatile __global atomic_int *, int); -int __ovld atomic_fetch_max(volatile __local atomic_int *, int); -uint __ovld atomic_fetch_max(volatile __global atomic_uint *, uint); -uint __ovld atomic_fetch_max(volatile __local atomic_uint *, uint); -#if defined(cl_khr_int64_base_atomics) && defined(cl_khr_int64_extended_atomics) -long __ovld atomic_fetch_add(volatile __global atomic_long *, long); -long __ovld atomic_fetch_add(volatile __local atomic_long *, long); -ulong __ovld atomic_fetch_add(volatile __global atomic_ulong *, ulong); -ulong __ovld atomic_fetch_add(volatile __local atomic_ulong *, ulong); -uintptr_t __ovld atomic_fetch_add(volatile __global atomic_uintptr_t *, ptrdiff_t); -uintptr_t __ovld atomic_fetch_add(volatile __local atomic_uintptr_t *, ptrdiff_t); -long __ovld atomic_fetch_sub(volatile __global atomic_long *, long); -long __ovld atomic_fetch_sub(volatile __local atomic_long *, long); -ulong __ovld atomic_fetch_sub(volatile __global atomic_ulong *, ulong); -ulong __ovld atomic_fetch_sub(volatile __local atomic_ulong *, ulong); -uintptr_t __ovld atomic_fetch_sub(volatile __global atomic_uintptr_t *, ptrdiff_t); -uintptr_t __ovld atomic_fetch_sub(volatile __local atomic_uintptr_t *, ptrdiff_t); -long __ovld atomic_fetch_or(volatile __global atomic_long *, long); -long __ovld atomic_fetch_or(volatile __local atomic_long *, long); -ulong __ovld atomic_fetch_or(volatile __global atomic_ulong *, ulong); -ulong __ovld atomic_fetch_or(volatile __local atomic_ulong *, ulong); -uintptr_t __ovld atomic_fetch_or(volatile __global atomic_uintptr_t *, intptr_t); -uintptr_t __ovld atomic_fetch_or(volatile __local atomic_uintptr_t *, intptr_t); -intptr_t __ovld atomic_fetch_or(volatile __global atomic_intptr_t *, uintptr_t); -intptr_t __ovld atomic_fetch_or(volatile __local atomic_intptr_t *, uintptr_t); -long __ovld atomic_fetch_xor(volatile __global atomic_long *, long); -long __ovld atomic_fetch_xor(volatile __local atomic_long *, long); -ulong __ovld atomic_fetch_xor(volatile __global atomic_ulong *, ulong); -ulong __ovld atomic_fetch_xor(volatile __local atomic_ulong *, ulong); -uintptr_t __ovld atomic_fetch_xor(volatile __global atomic_uintptr_t *, intptr_t); -uintptr_t __ovld atomic_fetch_xor(volatile __local atomic_uintptr_t *, intptr_t); -intptr_t __ovld atomic_fetch_xor(volatile __global atomic_intptr_t *, uintptr_t); -intptr_t __ovld atomic_fetch_xor(volatile __local atomic_intptr_t *, uintptr_t); -long __ovld atomic_fetch_and(volatile __global atomic_long *, long); -long __ovld atomic_fetch_and(volatile __local atomic_long *, long); -ulong __ovld atomic_fetch_and(volatile __global atomic_ulong *, ulong); -ulong __ovld atomic_fetch_and(volatile __local atomic_ulong *, ulong); -uintptr_t __ovld atomic_fetch_and(volatile __global atomic_uintptr_t *, intptr_t); -uintptr_t __ovld atomic_fetch_and(volatile __local atomic_uintptr_t *, intptr_t); -intptr_t __ovld atomic_fetch_and(volatile __global atomic_intptr_t *, uintptr_t); -intptr_t __ovld atomic_fetch_and(volatile __local atomic_intptr_t *, uintptr_t); -long __ovld atomic_fetch_min(volatile __global atomic_long *, long); -long __ovld atomic_fetch_min(volatile __local atomic_long *, long); -ulong __ovld atomic_fetch_min(volatile __global atomic_ulong *, ulong); -ulong __ovld atomic_fetch_min(volatile __local atomic_ulong *, ulong); -uintptr_t __ovld atomic_fetch_min(volatile __global atomic_uintptr_t *, intptr_t); -uintptr_t __ovld atomic_fetch_min(volatile __local atomic_uintptr_t *, intptr_t); -intptr_t __ovld atomic_fetch_min(volatile __global atomic_intptr_t *, uintptr_t); -intptr_t __ovld atomic_fetch_min(volatile __local atomic_intptr_t *, uintptr_t); -long __ovld atomic_fetch_max(volatile __global atomic_long *, long); -long __ovld atomic_fetch_max(volatile __local atomic_long *, long); -ulong __ovld atomic_fetch_max(volatile __global atomic_ulong *, ulong); -ulong __ovld atomic_fetch_max(volatile __local atomic_ulong *, ulong); -uintptr_t __ovld atomic_fetch_max(volatile __global atomic_uintptr_t *, uintptr_t); -uintptr_t __ovld atomic_fetch_max(volatile __local atomic_uintptr_t *, uintptr_t); -#endif //defined(cl_khr_int64_base_atomics) && defined(cl_khr_int64_extended_atomics) -#endif // (__OPENCL_C_VERSION__ >= CL_VERSION_3_0 || __OPENCL_CPP_VERSION__ >= 202100) -#endif - -#if defined(__opencl_c_atomic_scope_device) -#if defined(__opencl_c_generic_address_space) -int __ovld atomic_fetch_add_explicit(volatile atomic_int *, int, memory_order); -uint __ovld atomic_fetch_add_explicit(volatile atomic_uint *, uint, memory_order); -int __ovld atomic_fetch_sub_explicit(volatile atomic_int *, int, memory_order); -uint __ovld atomic_fetch_sub_explicit(volatile atomic_uint *, uint, memory_order); -int __ovld atomic_fetch_or_explicit(volatile atomic_int *, int, memory_order); -uint __ovld atomic_fetch_or_explicit(volatile atomic_uint *, uint, memory_order); -int __ovld atomic_fetch_xor_explicit(volatile atomic_int *, int, memory_order); -uint __ovld atomic_fetch_xor_explicit(volatile atomic_uint *, uint, memory_order); -int __ovld atomic_fetch_and_explicit(volatile atomic_int *, int, memory_order); -uint __ovld atomic_fetch_and_explicit(volatile atomic_uint *, uint, memory_order); -int __ovld atomic_fetch_min_explicit(volatile atomic_int *, int, memory_order); -uint __ovld atomic_fetch_min_explicit(volatile atomic_uint *, uint, memory_order); -int __ovld atomic_fetch_max_explicit(volatile atomic_int *, int, memory_order); -uint __ovld atomic_fetch_max_explicit(volatile atomic_uint *, uint, memory_order); -#if defined(cl_khr_int64_base_atomics) && defined(cl_khr_int64_extended_atomics) -long __ovld atomic_fetch_add_explicit(volatile atomic_long *, long, memory_order); -ulong __ovld atomic_fetch_add_explicit(volatile atomic_ulong *, ulong, memory_order); -long __ovld atomic_fetch_sub_explicit(volatile atomic_long *, long, memory_order); -ulong __ovld atomic_fetch_sub_explicit(volatile atomic_ulong *, ulong, memory_order); -long __ovld atomic_fetch_or_explicit(volatile atomic_long *, long, memory_order); -ulong __ovld atomic_fetch_or_explicit(volatile atomic_ulong *, ulong, memory_order); -long __ovld atomic_fetch_xor_explicit(volatile atomic_long *, long, memory_order); -ulong __ovld atomic_fetch_xor_explicit(volatile atomic_ulong *, ulong, memory_order); -long __ovld atomic_fetch_and_explicit(volatile atomic_long *, long, memory_order); -ulong __ovld atomic_fetch_and_explicit(volatile atomic_ulong *, ulong, memory_order); -long __ovld atomic_fetch_min_explicit(volatile atomic_long *, long, memory_order); -ulong __ovld atomic_fetch_min_explicit(volatile atomic_ulong *, ulong, memory_order); -long __ovld atomic_fetch_max_explicit(volatile atomic_long *, long, memory_order); -ulong __ovld atomic_fetch_max_explicit(volatile atomic_ulong *, ulong, memory_order); -uintptr_t __ovld atomic_fetch_add_explicit(volatile atomic_uintptr_t *, ptrdiff_t, memory_order); -uintptr_t __ovld atomic_fetch_sub_explicit(volatile atomic_uintptr_t *, ptrdiff_t, memory_order); -#endif //defined(cl_khr_int64_base_atomics) && defined(cl_khr_int64_extended_atomics) -#endif //defined(__opencl_c_generic_address_space) -#if (__OPENCL_C_VERSION__ >= CL_VERSION_3_0 || __OPENCL_CPP_VERSION__ >= 202100) -int __ovld atomic_fetch_add_explicit(volatile __global atomic_int *, int, memory_order); -int __ovld atomic_fetch_add_explicit(volatile __local atomic_int *, int, memory_order); -uint __ovld atomic_fetch_add_explicit(volatile __global atomic_uint *, uint, memory_order); -uint __ovld atomic_fetch_add_explicit(volatile __local atomic_uint *, uint, memory_order); -int __ovld atomic_fetch_sub_explicit(volatile __global atomic_int *, int, memory_order); -int __ovld atomic_fetch_sub_explicit(volatile __local atomic_int *, int, memory_order); -uint __ovld atomic_fetch_sub_explicit(volatile __global atomic_uint *, uint, memory_order); -uint __ovld atomic_fetch_sub_explicit(volatile __local atomic_uint *, uint, memory_order); -int __ovld atomic_fetch_or_explicit(volatile __global atomic_int *, int, memory_order); -int __ovld atomic_fetch_or_explicit(volatile __local atomic_int *, int, memory_order); -uint __ovld atomic_fetch_or_explicit(volatile __global atomic_uint *, uint, memory_order); -uint __ovld atomic_fetch_or_explicit(volatile __local atomic_uint *, uint, memory_order); -int __ovld atomic_fetch_xor_explicit(volatile __global atomic_int *, int, memory_order); -int __ovld atomic_fetch_xor_explicit(volatile __local atomic_int *, int, memory_order); -uint __ovld atomic_fetch_xor_explicit(volatile __global atomic_uint *, uint, memory_order); -uint __ovld atomic_fetch_xor_explicit(volatile __local atomic_uint *, uint, memory_order); -int __ovld atomic_fetch_and_explicit(volatile __global atomic_int *, int, memory_order); -int __ovld atomic_fetch_and_explicit(volatile __local atomic_int *, int, memory_order); -uint __ovld atomic_fetch_and_explicit(volatile __global atomic_uint *, uint, memory_order); -uint __ovld atomic_fetch_and_explicit(volatile __local atomic_uint *, uint, memory_order); -int __ovld atomic_fetch_min_explicit(volatile __global atomic_int *, int, memory_order); -int __ovld atomic_fetch_min_explicit(volatile __local atomic_int *, int, memory_order); -uint __ovld atomic_fetch_min_explicit(volatile __global atomic_uint *, uint, memory_order); -uint __ovld atomic_fetch_min_explicit(volatile __local atomic_uint *, uint, memory_order); -int __ovld atomic_fetch_max_explicit(volatile __global atomic_int *, int, memory_order); -int __ovld atomic_fetch_max_explicit(volatile __local atomic_int *, int, memory_order); -uint __ovld atomic_fetch_max_explicit(volatile __global atomic_uint *, uint, memory_order); -uint __ovld atomic_fetch_max_explicit(volatile __local atomic_uint *, uint, memory_order); -#if defined(cl_khr_int64_base_atomics) && defined(cl_khr_int64_extended_atomics) -long __ovld atomic_fetch_add_explicit(volatile __global atomic_long *, long, memory_order); -long __ovld atomic_fetch_add_explicit(volatile __local atomic_long *, long, memory_order); -ulong __ovld atomic_fetch_add_explicit(volatile __global atomic_ulong *, ulong, memory_order); -ulong __ovld atomic_fetch_add_explicit(volatile __local atomic_ulong *, ulong, memory_order); -uintptr_t __ovld atomic_fetch_add_explicit(volatile __global atomic_uintptr_t *, ptrdiff_t, memory_order); -uintptr_t __ovld atomic_fetch_add_explicit(volatile __local atomic_uintptr_t *, ptrdiff_t, memory_order); -long __ovld atomic_fetch_sub_explicit(volatile __global atomic_long *, long, memory_order); -long __ovld atomic_fetch_sub_explicit(volatile __local atomic_long *, long, memory_order); -ulong __ovld atomic_fetch_sub_explicit(volatile __global atomic_ulong *, ulong, memory_order); -ulong __ovld atomic_fetch_sub_explicit(volatile __local atomic_ulong *, ulong, memory_order); -uintptr_t __ovld atomic_fetch_sub_explicit(volatile __global atomic_uintptr_t *, ptrdiff_t, memory_order); -uintptr_t __ovld atomic_fetch_sub_explicit(volatile __local atomic_uintptr_t *, ptrdiff_t, memory_order); -long __ovld atomic_fetch_or_explicit(volatile __global atomic_long *, long, memory_order); -long __ovld atomic_fetch_or_explicit(volatile __local atomic_long *, long, memory_order); -ulong __ovld atomic_fetch_or_explicit(volatile __global atomic_ulong *, ulong, memory_order); -ulong __ovld atomic_fetch_or_explicit(volatile __local atomic_ulong *, ulong, memory_order); -uintptr_t __ovld atomic_fetch_or_explicit(volatile __global atomic_uintptr_t *, intptr_t, memory_order); -uintptr_t __ovld atomic_fetch_or_explicit(volatile __local atomic_uintptr_t *, intptr_t, memory_order); -intptr_t __ovld atomic_fetch_or_explicit(volatile __global atomic_intptr_t *, uintptr_t, memory_order); -intptr_t __ovld atomic_fetch_or_explicit(volatile __local atomic_intptr_t *, uintptr_t, memory_order); -long __ovld atomic_fetch_xor_explicit(volatile __global atomic_long *, long, memory_order); -long __ovld atomic_fetch_xor_explicit(volatile __local atomic_long *, long, memory_order); -ulong __ovld atomic_fetch_xor_explicit(volatile __global atomic_ulong *, ulong, memory_order); -ulong __ovld atomic_fetch_xor_explicit(volatile __local atomic_ulong *, ulong, memory_order); -uintptr_t __ovld atomic_fetch_xor_explicit(volatile __global atomic_uintptr_t *, intptr_t, memory_order); -uintptr_t __ovld atomic_fetch_xor_explicit(volatile __local atomic_uintptr_t *, intptr_t, memory_order); -intptr_t __ovld atomic_fetch_xor_explicit(volatile __global atomic_intptr_t *, uintptr_t, memory_order); -intptr_t __ovld atomic_fetch_xor_explicit(volatile __local atomic_intptr_t *, uintptr_t, memory_order); -long __ovld atomic_fetch_and_explicit(volatile __global atomic_long *, long, memory_order); -long __ovld atomic_fetch_and_explicit(volatile __local atomic_long *, long, memory_order); -ulong __ovld atomic_fetch_and_explicit(volatile __global atomic_ulong *, ulong, memory_order); -ulong __ovld atomic_fetch_and_explicit(volatile __local atomic_ulong *, ulong, memory_order); -uintptr_t __ovld atomic_fetch_and_explicit(volatile __global atomic_uintptr_t *, intptr_t, memory_order); -uintptr_t __ovld atomic_fetch_and_explicit(volatile __local atomic_uintptr_t *, intptr_t, memory_order); -intptr_t __ovld atomic_fetch_and_explicit(volatile __global atomic_intptr_t *, uintptr_t, memory_order); -intptr_t __ovld atomic_fetch_and_explicit(volatile __local atomic_intptr_t *, uintptr_t, memory_order); -long __ovld atomic_fetch_min_explicit(volatile __global atomic_long *, long, memory_order); -long __ovld atomic_fetch_min_explicit(volatile __local atomic_long *, long, memory_order); -ulong __ovld atomic_fetch_min_explicit(volatile __global atomic_ulong *, ulong, memory_order); -ulong __ovld atomic_fetch_min_explicit(volatile __local atomic_ulong *, ulong, memory_order); -uintptr_t __ovld atomic_fetch_min_explicit(volatile __global atomic_uintptr_t *, intptr_t, memory_order); -uintptr_t __ovld atomic_fetch_min_explicit(volatile __local atomic_uintptr_t *, intptr_t, memory_order); -intptr_t __ovld atomic_fetch_min_explicit(volatile __global atomic_intptr_t *, uintptr_t, memory_order); -intptr_t __ovld atomic_fetch_min_explicit(volatile __local atomic_intptr_t *, uintptr_t, memory_order); -long __ovld atomic_fetch_max_explicit(volatile __global atomic_long *, long, memory_order); -long __ovld atomic_fetch_max_explicit(volatile __local atomic_long *, long, memory_order); -ulong __ovld atomic_fetch_max_explicit(volatile __global atomic_ulong *, ulong, memory_order); -ulong __ovld atomic_fetch_max_explicit(volatile __local atomic_ulong *, ulong, memory_order); -uintptr_t __ovld atomic_fetch_max_explicit(volatile __global atomic_uintptr_t *, uintptr_t, memory_order); -uintptr_t __ovld atomic_fetch_max_explicit(volatile __local atomic_uintptr_t *, uintptr_t, memory_order); -#endif //defined(cl_khr_int64_base_atomics) && defined(cl_khr_int64_extended_atomics) -#endif // (__OPENCL_C_VERSION__ >= CL_VERSION_3_0 || __OPENCL_CPP_VERSION__ >= 202100) -#endif - -#if defined(__opencl_c_generic_address_space) -int __ovld atomic_fetch_add_explicit(volatile atomic_int *, int, memory_order, memory_scope); -uint __ovld atomic_fetch_add_explicit(volatile atomic_uint *, uint, memory_order, memory_scope); -int __ovld atomic_fetch_sub_explicit(volatile atomic_int *, int, memory_order, memory_scope); -uint __ovld atomic_fetch_sub_explicit(volatile atomic_uint *, uint, memory_order, memory_scope); -int __ovld atomic_fetch_or_explicit(volatile atomic_int *, int, memory_order, memory_scope); -uint __ovld atomic_fetch_or_explicit(volatile atomic_uint *, uint, memory_order, memory_scope); -int __ovld atomic_fetch_xor_explicit(volatile atomic_int *, int, memory_order, memory_scope); -uint __ovld atomic_fetch_xor_explicit(volatile atomic_uint *, uint, memory_order, memory_scope); -int __ovld atomic_fetch_and_explicit(volatile atomic_int *, int, memory_order, memory_scope); -uint __ovld atomic_fetch_and_explicit(volatile atomic_uint *, uint, memory_order, memory_scope); -int __ovld atomic_fetch_min_explicit(volatile atomic_int *, int, memory_order, memory_scope); -uint __ovld atomic_fetch_min_explicit(volatile atomic_uint *, uint, memory_order, memory_scope); -int __ovld atomic_fetch_max_explicit(volatile atomic_int *, int, memory_order, memory_scope); -uint __ovld atomic_fetch_max_explicit(volatile atomic_uint *, uint, memory_order, memory_scope); -#if defined(cl_khr_int64_base_atomics) && defined(cl_khr_int64_extended_atomics) -long __ovld atomic_fetch_add_explicit(volatile atomic_long *, long, memory_order, memory_scope); -ulong __ovld atomic_fetch_add_explicit(volatile atomic_ulong *, ulong, memory_order, memory_scope); -long __ovld atomic_fetch_sub_explicit(volatile atomic_long *, long, memory_order, memory_scope); -ulong __ovld atomic_fetch_sub_explicit(volatile atomic_ulong *, ulong, memory_order, memory_scope); -long __ovld atomic_fetch_or_explicit(volatile atomic_long *, long, memory_order, memory_scope); -ulong __ovld atomic_fetch_or_explicit(volatile atomic_ulong *, ulong, memory_order, memory_scope); -long __ovld atomic_fetch_xor_explicit(volatile atomic_long *, long, memory_order, memory_scope); -ulong __ovld atomic_fetch_xor_explicit(volatile atomic_ulong *, ulong, memory_order, memory_scope); -long __ovld atomic_fetch_and_explicit(volatile atomic_long *, long, memory_order, memory_scope); -ulong __ovld atomic_fetch_and_explicit(volatile atomic_ulong *, ulong, memory_order, memory_scope); -long __ovld atomic_fetch_min_explicit(volatile atomic_long *, long, memory_order, memory_scope); -ulong __ovld atomic_fetch_min_explicit(volatile atomic_ulong *, ulong, memory_order, memory_scope); -long __ovld atomic_fetch_max_explicit(volatile atomic_long *, long, memory_order, memory_scope); -ulong __ovld atomic_fetch_max_explicit(volatile atomic_ulong *, ulong, memory_order, memory_scope); -uintptr_t __ovld atomic_fetch_add_explicit(volatile atomic_uintptr_t *, ptrdiff_t, memory_order, memory_scope); -uintptr_t __ovld atomic_fetch_sub_explicit(volatile atomic_uintptr_t *, ptrdiff_t, memory_order, memory_scope); -#endif -#endif //defined(__opencl_c_generic_address_space) -#if (__OPENCL_C_VERSION__ >= CL_VERSION_3_0 || __OPENCL_CPP_VERSION__ >= 202100) -int __ovld atomic_fetch_add_explicit(volatile __global atomic_int *, int, memory_order, memory_scope); -int __ovld atomic_fetch_add_explicit(volatile __local atomic_int *, int, memory_order, memory_scope); -uint __ovld atomic_fetch_add_explicit(volatile __global atomic_uint *, uint, memory_order, memory_scope); -uint __ovld atomic_fetch_add_explicit(volatile __local atomic_uint *, uint, memory_order, memory_scope); -int __ovld atomic_fetch_sub_explicit(volatile __global atomic_int *, int, memory_order, memory_scope); -int __ovld atomic_fetch_sub_explicit(volatile __local atomic_int *, int, memory_order, memory_scope); -uint __ovld atomic_fetch_sub_explicit(volatile __global atomic_uint *, uint, memory_order, memory_scope); -uint __ovld atomic_fetch_sub_explicit(volatile __local atomic_uint *, uint, memory_order, memory_scope); -int __ovld atomic_fetch_or_explicit(volatile __global atomic_int *, int, memory_order, memory_scope); -int __ovld atomic_fetch_or_explicit(volatile __local atomic_int *, int, memory_order, memory_scope); -uint __ovld atomic_fetch_or_explicit(volatile __global atomic_uint *, uint, memory_order, memory_scope); -uint __ovld atomic_fetch_or_explicit(volatile __local atomic_uint *, uint, memory_order, memory_scope); -int __ovld atomic_fetch_xor_explicit(volatile __global atomic_int *, int, memory_order, memory_scope); -int __ovld atomic_fetch_xor_explicit(volatile __local atomic_int *, int, memory_order, memory_scope); -uint __ovld atomic_fetch_xor_explicit(volatile __global atomic_uint *, uint, memory_order, memory_scope); -uint __ovld atomic_fetch_xor_explicit(volatile __local atomic_uint *, uint, memory_order, memory_scope); -int __ovld atomic_fetch_and_explicit(volatile __global atomic_int *, int, memory_order, memory_scope); -int __ovld atomic_fetch_and_explicit(volatile __local atomic_int *, int, memory_order, memory_scope); -uint __ovld atomic_fetch_and_explicit(volatile __global atomic_uint *, uint, memory_order, memory_scope); -uint __ovld atomic_fetch_and_explicit(volatile __local atomic_uint *, uint, memory_order, memory_scope); -int __ovld atomic_fetch_min_explicit(volatile __global atomic_int *, int, memory_order, memory_scope); -int __ovld atomic_fetch_min_explicit(volatile __local atomic_int *, int, memory_order, memory_scope); -uint __ovld atomic_fetch_min_explicit(volatile __global atomic_uint *, uint, memory_order, memory_scope); -uint __ovld atomic_fetch_min_explicit(volatile __local atomic_uint *, uint, memory_order, memory_scope); -int __ovld atomic_fetch_max_explicit(volatile __global atomic_int *, int, memory_order, memory_scope); -int __ovld atomic_fetch_max_explicit(volatile __local atomic_int *, int, memory_order, memory_scope); -uint __ovld atomic_fetch_max_explicit(volatile __global atomic_uint *, uint, memory_order, memory_scope); -uint __ovld atomic_fetch_max_explicit(volatile __local atomic_uint *, uint, memory_order, memory_scope); -#if defined(cl_khr_int64_base_atomics) && defined(cl_khr_int64_extended_atomics) -long __ovld atomic_fetch_add_explicit(volatile __global atomic_long *, long, memory_order, memory_scope); -long __ovld atomic_fetch_add_explicit(volatile __local atomic_long *, long, memory_order, memory_scope); -uintptr_t __ovld atomic_fetch_add_explicit(volatile __global atomic_uintptr_t *, ptrdiff_t, memory_order, memory_scope); -uintptr_t __ovld atomic_fetch_add_explicit(volatile __local atomic_uintptr_t *, ptrdiff_t, memory_order, memory_scope); -ulong __ovld atomic_fetch_add_explicit(volatile __global atomic_ulong *, ulong, memory_order, memory_scope); -ulong __ovld atomic_fetch_add_explicit(volatile __local atomic_ulong *, ulong, memory_order, memory_scope); -long __ovld atomic_fetch_sub_explicit(volatile __global atomic_long *, long, memory_order, memory_scope); -long __ovld atomic_fetch_sub_explicit(volatile __local atomic_long *, long, memory_order, memory_scope); -ulong __ovld atomic_fetch_sub_explicit(volatile __global atomic_ulong *, ulong, memory_order, memory_scope); -ulong __ovld atomic_fetch_sub_explicit(volatile __local atomic_ulong *, ulong, memory_order, memory_scope); -uintptr_t __ovld atomic_fetch_sub_explicit(volatile __global atomic_uintptr_t *, ptrdiff_t, memory_order, memory_scope); -uintptr_t __ovld atomic_fetch_sub_explicit(volatile __local atomic_uintptr_t *, ptrdiff_t, memory_order, memory_scope); -long __ovld atomic_fetch_or_explicit(volatile __global atomic_long *, long, memory_order, memory_scope); -long __ovld atomic_fetch_or_explicit(volatile __local atomic_long *, long, memory_order, memory_scope); -ulong __ovld atomic_fetch_or_explicit(volatile __global atomic_ulong *, ulong, memory_order, memory_scope); -ulong __ovld atomic_fetch_or_explicit(volatile __local atomic_ulong *, ulong, memory_order, memory_scope); -uintptr_t __ovld atomic_fetch_or_explicit(volatile __global atomic_uintptr_t *, intptr_t, memory_order, memory_scope); -uintptr_t __ovld atomic_fetch_or_explicit(volatile __local atomic_uintptr_t *, intptr_t, memory_order, memory_scope); -intptr_t __ovld atomic_fetch_or_explicit(volatile __global atomic_intptr_t *, uintptr_t, memory_order, memory_scope); -intptr_t __ovld atomic_fetch_or_explicit(volatile __local atomic_intptr_t *, uintptr_t, memory_order, memory_scope); -long __ovld atomic_fetch_xor_explicit(volatile __global atomic_long *, long, memory_order, memory_scope); -long __ovld atomic_fetch_xor_explicit(volatile __local atomic_long *, long, memory_order, memory_scope); -ulong __ovld atomic_fetch_xor_explicit(volatile __global atomic_ulong *, ulong, memory_order, memory_scope); -ulong __ovld atomic_fetch_xor_explicit(volatile __local atomic_ulong *, ulong, memory_order, memory_scope); -uintptr_t __ovld atomic_fetch_xor_explicit(volatile __global atomic_uintptr_t *, intptr_t, memory_order, memory_scope); -uintptr_t __ovld atomic_fetch_xor_explicit(volatile __local atomic_uintptr_t *, intptr_t, memory_order, memory_scope); -intptr_t __ovld atomic_fetch_xor_explicit(volatile __global atomic_intptr_t *, uintptr_t, memory_order, memory_scope); -intptr_t __ovld atomic_fetch_xor_explicit(volatile __local atomic_intptr_t *, uintptr_t, memory_order, memory_scope); -long __ovld atomic_fetch_and_explicit(volatile __global atomic_long *, long, memory_order, memory_scope); -long __ovld atomic_fetch_and_explicit(volatile __local atomic_long *, long, memory_order, memory_scope); -ulong __ovld atomic_fetch_and_explicit(volatile __global atomic_ulong *, ulong, memory_order, memory_scope); -ulong __ovld atomic_fetch_and_explicit(volatile __local atomic_ulong *, ulong, memory_order, memory_scope); -uintptr_t __ovld atomic_fetch_and_explicit(volatile __global atomic_uintptr_t *, intptr_t, memory_order, memory_scope); -uintptr_t __ovld atomic_fetch_and_explicit(volatile __local atomic_uintptr_t *, intptr_t, memory_order, memory_scope); -intptr_t __ovld atomic_fetch_and_explicit(volatile __global atomic_intptr_t *, uintptr_t, memory_order, memory_scope); -intptr_t __ovld atomic_fetch_and_explicit(volatile __local atomic_intptr_t *, uintptr_t, memory_order, memory_scope); -long __ovld atomic_fetch_min_explicit(volatile __global atomic_long *, long, memory_order, memory_scope); -long __ovld atomic_fetch_min_explicit(volatile __local atomic_long *, long, memory_order, memory_scope); -ulong __ovld atomic_fetch_min_explicit(volatile __global atomic_ulong *, ulong, memory_order, memory_scope); -ulong __ovld atomic_fetch_min_explicit(volatile __local atomic_ulong *, ulong, memory_order, memory_scope); -uintptr_t __ovld atomic_fetch_min_explicit(volatile __global atomic_uintptr_t *, intptr_t, memory_order, memory_scope); -uintptr_t __ovld atomic_fetch_min_explicit(volatile __local atomic_uintptr_t *, intptr_t, memory_order, memory_scope); -intptr_t __ovld atomic_fetch_min_explicit(volatile __global atomic_intptr_t *, uintptr_t, memory_order, memory_scope); -intptr_t __ovld atomic_fetch_min_explicit(volatile __local atomic_intptr_t *, uintptr_t, memory_order, memory_scope); -long __ovld atomic_fetch_max_explicit(volatile __global atomic_long *, long, memory_order, memory_scope); -long __ovld atomic_fetch_max_explicit(volatile __local atomic_long *, long, memory_order, memory_scope); -ulong __ovld atomic_fetch_max_explicit(volatile __global atomic_ulong *, ulong, memory_order, memory_scope); -ulong __ovld atomic_fetch_max_explicit(volatile __local atomic_ulong *, ulong, memory_order, memory_scope); -uintptr_t __ovld atomic_fetch_max_explicit(volatile __global atomic_uintptr_t *, uintptr_t, memory_order, memory_scope); -uintptr_t __ovld atomic_fetch_max_explicit(volatile __local atomic_uintptr_t *, uintptr_t, memory_order, memory_scope); -#endif //defined(cl_khr_int64_base_atomics) && defined(cl_khr_int64_extended_atomics) -#endif // (__OPENCL_C_VERSION__ >= CL_VERSION_3_0 || __OPENCL_CPP_VERSION__ >= 202100) - -// The functionality added by cl_ext_float_atomics extension -#if defined(cl_ext_float_atomics) - -#if defined(__opencl_c_ext_fp16_global_atomic_load_store) -void __ovld atomic_store(volatile __global atomic_half *, half); -void __ovld atomic_store_explicit(volatile __global atomic_half *, - half, memory_order); -void __ovld atomic_store_explicit(volatile __global atomic_half *, - half, memory_order, memory_scope); -half __ovld atomic_load(volatile __global atomic_half *); -half __ovld atomic_load_explicit(volatile __global atomic_half *, - memory_order); -half __ovld atomic_load_explicit(volatile __global atomic_half *, - memory_order, memory_scope); -half __ovld atomic_exchange(volatile __global atomic_half *, half); -half __ovld atomic_exchange_explicit(volatile __global atomic_half *, - half, memory_order); -half __ovld atomic_exchange_explicit(volatile __global atomic_half *, - half, memory_order, memory_scope); -#endif // defined(__opencl_c_ext_fp16_global_atomic_load_store) - -#if defined(__opencl_c_ext_fp16_local_atomic_load_store) -void __ovld atomic_store(volatile __local atomic_half *, half); -void __ovld atomic_store_explicit(volatile __local atomic_half *, - half, memory_order); -void __ovld atomic_store_explicit(volatile __local atomic_half *, - half, memory_order, memory_scope); -half __ovld atomic_load(volatile __local atomic_half *); -half __ovld atomic_load_explicit(volatile __local atomic_half *, - memory_order); -half __ovld atomic_load_explicit(volatile __local atomic_half *, - memory_order, memory_scope); -half __ovld atomic_exchange(volatile __local atomic_half *, half); -half __ovld atomic_exchange_explicit(volatile __local atomic_half *, - half, memory_order); -half __ovld atomic_exchange_explicit(volatile __local atomic_half *, - half, memory_order, memory_scope); -#endif // defined(__opencl_c_ext_fp16_local_atomic_load_store) - -#if defined(__opencl_c_ext_fp16_global_atomic_load_store) && \ - defined(__opencl_c_ext_fp16_local_atomic_load_store) -void __ovld atomic_store(volatile atomic_half *, half); -void __ovld atomic_store_explicit(volatile atomic_half *, half, - memory_order); -void __ovld atomic_store_explicit(volatile atomic_half *, half, - memory_order, memory_scope); -half __ovld atomic_load(volatile atomic_half *); -half __ovld atomic_load_explicit(volatile atomic_half *, - memory_order); -half __ovld atomic_load_explicit(volatile atomic_half *, - memory_order, memory_scope); -half __ovld atomic_exchange(volatile atomic_half *, half); -half __ovld atomic_exchange_explicit(volatile atomic_half *, half, - memory_order); -half __ovld atomic_exchange_explicit(volatile atomic_half *, half, - memory_order, memory_scope); -#endif // defined(__opencl_c_ext_fp16_global_atomic_load_store) && - // defined(__opencl_c_ext_fp16_local_atomic_load_store) - -#if defined(__opencl_c_ext_fp16_global_atomic_min_max) -half __ovld atomic_fetch_min(volatile __global atomic_half *, half); -half __ovld atomic_fetch_max(volatile __global atomic_half *, half); -half __ovld atomic_fetch_min_explicit(volatile __global atomic_half *, - half, memory_order); -half __ovld atomic_fetch_max_explicit(volatile __global atomic_half *, - half, memory_order); -half __ovld atomic_fetch_min_explicit(volatile __global atomic_half *, - half, memory_order, memory_scope); -half __ovld atomic_fetch_max_explicit(volatile __global atomic_half *, - half, memory_order, memory_scope); -#endif // defined(__opencl_c_ext_fp16_global_atomic_min_max) - -#if defined(__opencl_c_ext_fp16_local_atomic_min_max) -half __ovld atomic_fetch_min(volatile __local atomic_half *, half); -half __ovld atomic_fetch_max(volatile __local atomic_half *, half); -half __ovld atomic_fetch_min_explicit(volatile __local atomic_half *, - half, memory_order); -half __ovld atomic_fetch_max_explicit(volatile __local atomic_half *, - half, memory_order); -half __ovld atomic_fetch_min_explicit(volatile __local atomic_half *, - half, memory_order, memory_scope); -half __ovld atomic_fetch_max_explicit(volatile __local atomic_half *, - half, memory_order, memory_scope); -#endif // defined(__opencl_c_ext_fp16_local_atomic_min_max) - -#if defined(__opencl_c_ext_fp16_global_atomic_min_max) && \ - defined(__opencl_c_ext_fp16_local_atomic_min_max) -half __ovld atomic_fetch_min(volatile atomic_half *, half); -half __ovld atomic_fetch_max(volatile atomic_half *, half); -half __ovld atomic_fetch_min_explicit(volatile atomic_half *, - half, memory_order); -half __ovld atomic_fetch_max_explicit(volatile atomic_half *, - half, memory_order); -half __ovld atomic_fetch_min_explicit(volatile atomic_half *, - half, memory_order, memory_scope); -half __ovld atomic_fetch_max_explicit(volatile atomic_half *, - half, memory_order, memory_scope); -#endif -// defined(__opencl_c_ext_fp16_global_atomic_min_max) && \ -// defined(__opencl_c_ext_fp16_local_atomic_min_max) - -#if defined(__opencl_c_ext_fp32_global_atomic_min_max) -float __ovld atomic_fetch_min(volatile __global atomic_float *, float); -float __ovld atomic_fetch_max(volatile __global atomic_float *, float); -float __ovld atomic_fetch_min_explicit(volatile __global atomic_float *, - float, memory_order); -float __ovld atomic_fetch_max_explicit(volatile __global atomic_float *, - float, memory_order); -float __ovld atomic_fetch_min_explicit(volatile __global atomic_float *, - float, memory_order, memory_scope); -float __ovld atomic_fetch_max_explicit(volatile __global atomic_float *, - float, memory_order, memory_scope); -#endif // defined(__opencl_c_ext_fp32_global_atomic_min_max) - -#if defined(__opencl_c_ext_fp32_local_atomic_min_max) -float __ovld atomic_fetch_min(volatile __local atomic_float *, float); -float __ovld atomic_fetch_max(volatile __local atomic_float *, float); -float __ovld atomic_fetch_min_explicit(volatile __local atomic_float *, - float, memory_order); -float __ovld atomic_fetch_max_explicit(volatile __local atomic_float *, - float, memory_order); -float __ovld atomic_fetch_min_explicit(volatile __local atomic_float *, - float, memory_order, memory_scope); -float __ovld atomic_fetch_max_explicit(volatile __local atomic_float *, - float, memory_order, memory_scope); -#endif // defined(__opencl_c_ext_fp32_local_atomic_min_max) - -#if defined(__opencl_c_ext_fp32_global_atomic_min_max) && \ - defined(__opencl_c_ext_fp32_local_atomic_min_max) -float __ovld atomic_fetch_min(volatile atomic_float *, float); -float __ovld atomic_fetch_max(volatile atomic_float *, float); -float __ovld atomic_fetch_min_explicit(volatile atomic_float *, - float, memory_order); -float __ovld atomic_fetch_max_explicit(volatile atomic_float *, - float, memory_order); -float __ovld atomic_fetch_min_explicit(volatile atomic_float *, - float, memory_order, memory_scope); -float __ovld atomic_fetch_max_explicit(volatile atomic_float *, - float, memory_order, memory_scope); -#endif -// defined(__opencl_c_ext_fp32_global_atomic_min_max) && -// defined(__opencl_c_ext_fp32_local_atomic_min_max) - -#if defined(cl_khr_int64_base_atomics) && defined(cl_khr_int64_extended_atomics) -#if defined(__opencl_c_ext_fp64_global_atomic_min_max) -double __ovld atomic_fetch_min(volatile __global atomic_double *, double); -double __ovld atomic_fetch_max(volatile __global atomic_double *, double); -double __ovld atomic_fetch_min_explicit(volatile __global atomic_double *, - double, memory_order); -double __ovld atomic_fetch_max_explicit(volatile __global atomic_double *, - double, memory_order); -double __ovld atomic_fetch_min_explicit(volatile __global atomic_double *, - double, memory_order, memory_scope); -double __ovld atomic_fetch_max_explicit(volatile __global atomic_double *, - double, memory_order, memory_scope); -#endif // defined(__opencl_c_ext_fp64_global_atomic_min_max) - -#if defined(__opencl_c_ext_fp64_local_atomic_min_max) -double __ovld atomic_fetch_min(volatile __local atomic_double *, double); -double __ovld atomic_fetch_max(volatile __local atomic_double *, double); -double __ovld atomic_fetch_min_explicit(volatile __local atomic_double *, - double, memory_order); -double __ovld atomic_fetch_max_explicit(volatile __local atomic_double *, - double, memory_order); -double __ovld atomic_fetch_min_explicit(volatile __local atomic_double *, - double, memory_order, memory_scope); -double __ovld atomic_fetch_max_explicit(volatile __local atomic_double *, - double, memory_order, memory_scope); -#endif // defined(__opencl_c_ext_fp64_local_atomic_min_max) - -#if defined(__opencl_c_ext_fp64_global_atomic_min_max) && \ - defined(__opencl_c_ext_fp64_local_atomic_min_max) -double __ovld atomic_fetch_min(volatile atomic_double *, double); -double __ovld atomic_fetch_max(volatile atomic_double *, double); -double __ovld atomic_fetch_min_explicit(volatile atomic_double *, - double, memory_order); -double __ovld atomic_fetch_max_explicit(volatile atomic_double *, - double, memory_order); -double __ovld atomic_fetch_min_explicit(volatile atomic_double *, - double, memory_order, memory_scope); -double __ovld atomic_fetch_max_explicit(volatile atomic_double *, - double, memory_order, memory_scope); -#endif -/* defined(__opencl_c_ext_fp64_global_atomic_min_max) && - defined(__opencl_c_ext_fp64_local_atomic_min_max) */ - -#endif -/* defined(cl_khr_int64_base_atomics) && - defined(cl_khr_int64_extended_atomics) */ - -#if defined(__opencl_c_ext_fp16_global_atomic_add) -half __ovld atomic_fetch_add(volatile __global atomic_half *, half); -half __ovld atomic_fetch_sub(volatile __global atomic_half *, half); -half __ovld atomic_fetch_add_explicit(volatile __global atomic_half *, - half, memory_order); -half __ovld atomic_fetch_sub_explicit(volatile __global atomic_half *, - half, memory_order); -half __ovld atomic_fetch_add_explicit(volatile __global atomic_half *, - half, memory_order, memory_scope); -half __ovld atomic_fetch_sub_explicit(volatile __global atomic_half *, - half, memory_order, memory_scope); -#endif // defined(__opencl_c_ext_fp16_global_atomic_add) - -#if defined(__opencl_c_ext_fp16_local_atomic_add) -half __ovld atomic_fetch_add(volatile __local atomic_half *, half); -half __ovld atomic_fetch_sub(volatile __local atomic_half *, half); -half __ovld atomic_fetch_add_explicit(volatile __local atomic_half *, - half, memory_order); -half __ovld atomic_fetch_sub_explicit(volatile __local atomic_half *, - half, memory_order); -half __ovld atomic_fetch_add_explicit(volatile __local atomic_half *, - half, memory_order, memory_scope); -half __ovld atomic_fetch_sub_explicit(volatile __local atomic_half *, - half, memory_order, memory_scope); -#endif // defined(__opencl_c_ext_fp16_local_atomic_add) - -#if defined(__opencl_c_ext_fp16_global_atomic_add) && \ - defined(__opencl_c_ext_fp16_local_atomic_add) -half __ovld atomic_fetch_add(volatile atomic_half *, half); -half __ovld atomic_fetch_sub(volatile atomic_half *, half); -half __ovld atomic_fetch_add_explicit(volatile atomic_half *, - half, memory_order); -half __ovld atomic_fetch_sub_explicit(volatile atomic_half *, - half, memory_order); -half __ovld atomic_fetch_add_explicit(volatile atomic_half *, - half, memory_order, memory_scope); -half __ovld atomic_fetch_sub_explicit(volatile atomic_half *, - half, memory_order, memory_scope); -#endif - -/* defined(__opencl_c_ext_fp16_global_atomic_add) && - defined(__opencl_c_ext_fp16_local_atomic_add) */ - -#if defined(__opencl_c_ext_fp32_global_atomic_add) -float __ovld atomic_fetch_add(volatile __global atomic_float *, float); -float __ovld atomic_fetch_sub(volatile __global atomic_float *, float); -float __ovld atomic_fetch_add_explicit(volatile __global atomic_float *, - float, memory_order); -float __ovld atomic_fetch_sub_explicit(volatile __global atomic_float *, - float, memory_order); -float __ovld atomic_fetch_add_explicit(volatile __global atomic_float *, - float, memory_order, memory_scope); -float __ovld atomic_fetch_sub_explicit(volatile __global atomic_float *, - float, memory_order, memory_scope); -#endif // defined(__opencl_c_ext_fp32_global_atomic_add) - -#if defined(__opencl_c_ext_fp32_local_atomic_add) -float __ovld atomic_fetch_add(volatile __local atomic_float *, float); -float __ovld atomic_fetch_sub(volatile __local atomic_float *, float); -float __ovld atomic_fetch_add_explicit(volatile __local atomic_float *, - float, memory_order); -float __ovld atomic_fetch_sub_explicit(volatile __local atomic_float *, - float, memory_order); -float __ovld atomic_fetch_add_explicit(volatile __local atomic_float *, - float, memory_order, memory_scope); -float __ovld atomic_fetch_sub_explicit(volatile __local atomic_float *, - float, memory_order, memory_scope); -#endif // defined(__opencl_c_ext_fp32_local_atomic_add) - -#if defined(__opencl_c_ext_fp32_global_atomic_add) && \ - defined(__opencl_c_ext_fp32_local_atomic_add) -float __ovld atomic_fetch_add(volatile atomic_float *, float); -float __ovld atomic_fetch_sub(volatile atomic_float *, float); -float __ovld atomic_fetch_add_explicit(volatile atomic_float *, - float, memory_order); -float __ovld atomic_fetch_sub_explicit(volatile atomic_float *, - float, memory_order); -float __ovld atomic_fetch_add_explicit(volatile atomic_float *, - float, memory_order, memory_scope); -float __ovld atomic_fetch_sub_explicit(volatile atomic_float *, - float, memory_order, memory_scope); -#endif - -/* defined(__opencl_c_ext_fp32_global_atomic_add) && - defined(__opencl_c_ext_fp32_local_atomic_add) */ - -#if defined(cl_khr_int64_base_atomics) && defined(cl_khr_int64_extended_atomics) -#if defined(__opencl_c_ext_fp64_global_atomic_add) -double __ovld atomic_fetch_add(volatile __global atomic_double *, double); -double __ovld atomic_fetch_sub(volatile __global atomic_double *, double); -double __ovld atomic_fetch_add_explicit(volatile __global atomic_double *, - double, memory_order); -double __ovld atomic_fetch_sub_explicit(volatile __global atomic_double *, - double, memory_order); -double __ovld atomic_fetch_add_explicit(volatile __global atomic_double *, - double, memory_order, memory_scope); -double __ovld atomic_fetch_sub_explicit(volatile __global atomic_double *, - double, memory_order, memory_scope); -#endif // defined(__opencl_c_ext_fp64_global_atomic_add) - -#if defined(__opencl_c_ext_fp64_local_atomic_add) -double __ovld atomic_fetch_add(volatile __local atomic_double *, double); -double __ovld atomic_fetch_sub(volatile __local atomic_double *, double); -double __ovld atomic_fetch_add_explicit(volatile __local atomic_double *, - double, memory_order); -double __ovld atomic_fetch_sub_explicit(volatile __local atomic_double *, - double, memory_order); -double __ovld atomic_fetch_add_explicit(volatile __local atomic_double *, - double, memory_order, memory_scope); -double __ovld atomic_fetch_sub_explicit(volatile __local atomic_double *, - double, memory_order, memory_scope); -#endif // defined(__opencl_c_ext_fp64_local_atomic_add) - -#if defined(__opencl_c_ext_fp64_global_atomic_add) && \ - defined(__opencl_c_ext_fp64_local_atomic_add) -double __ovld atomic_fetch_add(volatile atomic_double *, double); -double __ovld atomic_fetch_sub(volatile atomic_double *, double); -double __ovld atomic_fetch_add_explicit(volatile atomic_double *, - double, memory_order); -double __ovld atomic_fetch_sub_explicit(volatile atomic_double *, - double, memory_order); -double __ovld atomic_fetch_add_explicit(volatile atomic_double *, - double, memory_order, memory_scope); -double __ovld atomic_fetch_sub_explicit(volatile atomic_double *, - double, memory_order, memory_scope); -#endif - -/* defined(__opencl_c_ext_fp64_global_atomic_add) && - defined(__opencl_c_ext_fp64_local_atomic_add) */ - -#endif - -/* defined(cl_khr_int64_base_atomics) && - defined(cl_khr_int64_extended_atomics) */ - -#endif // cl_ext_float_atomics - -// atomic_store() - -#if defined(__opencl_c_atomic_order_seq_cst) && defined(__opencl_c_atomic_scope_device) -#if defined(__opencl_c_generic_address_space) -void __ovld atomic_store(volatile atomic_int *, int); -void __ovld atomic_store(volatile atomic_uint *, uint); -void __ovld atomic_store(volatile atomic_float *, float); - -#if defined(cl_khr_int64_base_atomics) && defined(cl_khr_int64_extended_atomics) -#ifdef cl_khr_fp64 -void __ovld atomic_store(volatile atomic_double *, double); -#endif //cl_khr_fp64 -void __ovld atomic_store(volatile atomic_long *, long); -void __ovld atomic_store(volatile atomic_ulong *, ulong); -#endif -#endif //defined(__opencl_c_generic_address_space) -#if (__OPENCL_C_VERSION__ >= CL_VERSION_3_0 || __OPENCL_CPP_VERSION__ >= 202100) -void __ovld atomic_store(volatile __global atomic_int *, int); -void __ovld atomic_store(volatile __local atomic_int *, int); -void __ovld atomic_store(volatile __global atomic_uint *, uint); -void __ovld atomic_store(volatile __local atomic_uint *, uint); -void __ovld atomic_store(volatile __global atomic_float *, float); -void __ovld atomic_store(volatile __local atomic_float *, float); -#if defined(cl_khr_int64_base_atomics) && defined(cl_khr_int64_extended_atomics) -#ifdef cl_khr_fp64 -void __ovld atomic_store(volatile __global atomic_double *, double); -void __ovld atomic_store(volatile __local atomic_double *, double); -#endif //cl_khr_fp64 -void __ovld atomic_store(volatile __global atomic_long *, long); -void __ovld atomic_store(volatile __local atomic_long *, long); -void __ovld atomic_store(volatile __global atomic_ulong *, ulong); -void __ovld atomic_store(volatile __local atomic_ulong *, ulong); -#endif //defined(cl_khr_int64_base_atomics) && defined(cl_khr_int64_extended_atomics) -#endif // (__OPENCL_C_VERSION__ >= CL_VERSION_3_0 || __OPENCL_CPP_VERSION__ >= 202100) -#endif - -#if defined(__opencl_c_atomic_scope_device) -#if defined(__opencl_c_generic_address_space) -void __ovld atomic_store_explicit(volatile atomic_int *, int, memory_order); -void __ovld atomic_store_explicit(volatile atomic_uint *, uint, memory_order); -void __ovld atomic_store_explicit(volatile atomic_float *, float, memory_order); -#if defined(cl_khr_int64_base_atomics) && defined(cl_khr_int64_extended_atomics) -#ifdef cl_khr_fp64 -void __ovld atomic_store_explicit(volatile atomic_double *, double, memory_order); -#endif //cl_khr_fp64 -void __ovld atomic_store_explicit(volatile atomic_long *, long, memory_order); -void __ovld atomic_store_explicit(volatile atomic_ulong *, ulong, memory_order); -#endif -#endif //defined(__opencl_c_generic_address_space) -#if (__OPENCL_C_VERSION__ >= CL_VERSION_3_0 || __OPENCL_CPP_VERSION__ >= 202100) -void __ovld atomic_store_explicit(volatile __global atomic_int *, int, memory_order); -void __ovld atomic_store_explicit(volatile __local atomic_int *, int, memory_order); -void __ovld atomic_store_explicit(volatile __global atomic_uint *, uint, memory_order); -void __ovld atomic_store_explicit(volatile __local atomic_uint *, uint, memory_order); -void __ovld atomic_store_explicit(volatile __global atomic_float *, float, memory_order); -void __ovld atomic_store_explicit(volatile __local atomic_float *, float, memory_order); -#if defined(cl_khr_int64_base_atomics) && defined(cl_khr_int64_extended_atomics) -#ifdef cl_khr_fp64 -void __ovld atomic_store_explicit(volatile __global atomic_double *, double, memory_order); -void __ovld atomic_store_explicit(volatile __local atomic_double *, double, memory_order); -#endif -void __ovld atomic_store_explicit(volatile __global atomic_long *, long, memory_order); -void __ovld atomic_store_explicit(volatile __local atomic_long *, long, memory_order); -void __ovld atomic_store_explicit(volatile __global atomic_ulong *, ulong, memory_order); -void __ovld atomic_store_explicit(volatile __local atomic_ulong *, ulong, memory_order); -#endif //defined(cl_khr_int64_base_atomics) && defined(cl_khr_int64_extended_atomics) -#endif // (__OPENCL_C_VERSION__ >= CL_VERSION_3_0 || __OPENCL_CPP_VERSION__ >= 202100) -#endif - -#if defined(__opencl_c_generic_address_space) -void __ovld atomic_store_explicit(volatile atomic_int *, int, memory_order, memory_scope); -void __ovld atomic_store_explicit(volatile atomic_uint *, uint, memory_order, memory_scope); -void __ovld atomic_store_explicit(volatile atomic_float *, float, memory_order, memory_scope); -#if defined(cl_khr_int64_base_atomics) && defined(cl_khr_int64_extended_atomics) -#ifdef cl_khr_fp64 -void __ovld atomic_store_explicit(volatile atomic_double *, double, memory_order, memory_scope); -#endif //cl_khr_fp64 -void __ovld atomic_store_explicit(volatile atomic_long *, long, memory_order, memory_scope); -void __ovld atomic_store_explicit(volatile atomic_ulong *, ulong, memory_order, memory_scope); -#endif -#endif //defined(__opencl_c_generic_address_space) -#if (__OPENCL_C_VERSION__ >= CL_VERSION_3_0 || __OPENCL_CPP_VERSION__ >= 202100) -void __ovld atomic_store_explicit(volatile __global atomic_int *, int, memory_order, memory_scope); -void __ovld atomic_store_explicit(volatile __local atomic_int *, int, memory_order, memory_scope); -void __ovld atomic_store_explicit(volatile __global atomic_uint *, uint, memory_order, memory_scope); -void __ovld atomic_store_explicit(volatile __local atomic_uint *, uint, memory_order, memory_scope); -void __ovld atomic_store_explicit(volatile __global atomic_float *, float, memory_order, memory_scope); -void __ovld atomic_store_explicit(volatile __local atomic_float *, float, memory_order, memory_scope); -#if defined(cl_khr_int64_base_atomics) && defined(cl_khr_int64_extended_atomics) -#ifdef cl_khr_fp64 -void __ovld atomic_store_explicit(volatile __global atomic_double *, double, memory_order, memory_scope); -void __ovld atomic_store_explicit(volatile __local atomic_double *, double, memory_order, memory_scope); -#endif //cl_khr_fp64 -void __ovld atomic_store_explicit(volatile __global atomic_long *, long, memory_order, memory_scope); -void __ovld atomic_store_explicit(volatile __local atomic_long *, long, memory_order, memory_scope); -void __ovld atomic_store_explicit(volatile __global atomic_ulong *, ulong, memory_order, memory_scope); -void __ovld atomic_store_explicit(volatile __local atomic_ulong *, ulong, memory_order, memory_scope); -#endif //defined(cl_khr_int64_base_atomics) && defined(cl_khr_int64_extended_atomics) -#endif // (__OPENCL_C_VERSION__ >= CL_VERSION_3_0 || __OPENCL_CPP_VERSION__ >= 202100) - -// atomic_load() -#if defined(__opencl_c_atomic_order_seq_cst) && defined(__opencl_c_atomic_scope_device) -#if defined(__opencl_c_generic_address_space) -int __ovld atomic_load(volatile atomic_int *); -uint __ovld atomic_load(volatile atomic_uint *); -float __ovld atomic_load(volatile atomic_float *); -#if defined(cl_khr_int64_base_atomics) && defined(cl_khr_int64_extended_atomics) -#ifdef cl_khr_fp64 -double __ovld atomic_load(volatile atomic_double *); -#endif //cl_khr_fp64 -long __ovld atomic_load(volatile atomic_long *); -ulong __ovld atomic_load(volatile atomic_ulong *); -#endif -#endif //defined(__opencl_c_generic_address_space) -#if (__OPENCL_C_VERSION__ >= CL_VERSION_3_0 || __OPENCL_CPP_VERSION__ >= 202100) -int __ovld atomic_load(volatile __global atomic_int *); -int __ovld atomic_load(volatile __local atomic_int *); -uint __ovld atomic_load(volatile __global atomic_uint *); -uint __ovld atomic_load(volatile __local atomic_uint *); -float __ovld atomic_load(volatile __global atomic_float *); -float __ovld atomic_load(volatile __local atomic_float *); -#if defined(cl_khr_int64_base_atomics) && defined(cl_khr_int64_extended_atomics) -#ifdef cl_khr_fp64 -double __ovld atomic_load(volatile __global atomic_double *); -double __ovld atomic_load(volatile __local atomic_double *); -#endif //cl_khr_fp64 -long __ovld atomic_load(volatile __global atomic_long *); -long __ovld atomic_load(volatile __local atomic_long *); -ulong __ovld atomic_load(volatile __global atomic_ulong *); -ulong __ovld atomic_load(volatile __local atomic_ulong *); -#endif //defined(cl_khr_int64_base_atomics) && defined(cl_khr_int64_extended_atomics) -#endif // (__OPENCL_C_VERSION__ >= CL_VERSION_3_0 || __OPENCL_CPP_VERSION__ >= 202100) -#endif - -#if defined(__opencl_c_atomic_scope_device) -#if defined(__opencl_c_generic_address_space) -int __ovld atomic_load_explicit(volatile atomic_int *, memory_order); -uint __ovld atomic_load_explicit(volatile atomic_uint *, memory_order); -float __ovld atomic_load_explicit(volatile atomic_float *, memory_order); -#if defined(cl_khr_int64_base_atomics) && defined(cl_khr_int64_extended_atomics) -#ifdef cl_khr_fp64 -double __ovld atomic_load_explicit(volatile atomic_double *, memory_order); -#endif //cl_khr_fp64 -long __ovld atomic_load_explicit(volatile atomic_long *, memory_order); -ulong __ovld atomic_load_explicit(volatile atomic_ulong *, memory_order); -#endif -#endif //defined(__opencl_c_generic_address_space) -#if (__OPENCL_C_VERSION__ >= CL_VERSION_3_0 || __OPENCL_CPP_VERSION__ >= 202100) -int __ovld atomic_load_explicit(volatile __global atomic_int *, memory_order); -int __ovld atomic_load_explicit(volatile __local atomic_int *, memory_order); -uint __ovld atomic_load_explicit(volatile __global atomic_uint *, memory_order); -uint __ovld atomic_load_explicit(volatile __local atomic_uint *, memory_order); -float __ovld atomic_load_explicit(volatile __global atomic_float *, memory_order); -float __ovld atomic_load_explicit(volatile __local atomic_float *, memory_order); -#if defined(cl_khr_int64_base_atomics) && defined(cl_khr_int64_extended_atomics) -#ifdef cl_khr_fp64 -double __ovld atomic_load_explicit(volatile __global atomic_double *, memory_order); -double __ovld atomic_load_explicit(volatile __local atomic_double *, memory_order); -#endif //cl_khr_fp64 -long __ovld atomic_load_explicit(volatile __global atomic_long *, memory_order); -long __ovld atomic_load_explicit(volatile __local atomic_long *, memory_order); -ulong __ovld atomic_load_explicit(volatile __global atomic_ulong *, memory_order); -ulong __ovld atomic_load_explicit(volatile __local atomic_ulong *, memory_order); -#endif //defined(cl_khr_int64_base_atomics) && defined(cl_khr_int64_extended_atomics) -#endif // (__OPENCL_C_VERSION__ >= CL_VERSION_3_0 || __OPENCL_CPP_VERSION__ >= 202100) -#endif - -#if defined(__opencl_c_generic_address_space) -int __ovld atomic_load_explicit(volatile atomic_int *, memory_order, memory_scope); -uint __ovld atomic_load_explicit(volatile atomic_uint *, memory_order, memory_scope); -float __ovld atomic_load_explicit(volatile atomic_float *, memory_order, memory_scope); -#if defined(cl_khr_int64_base_atomics) && defined(cl_khr_int64_extended_atomics) -#ifdef cl_khr_fp64 -double __ovld atomic_load_explicit(volatile atomic_double *, memory_order, memory_scope); -#endif //cl_khr_fp64 -long __ovld atomic_load_explicit(volatile atomic_long *, memory_order, memory_scope); -ulong __ovld atomic_load_explicit(volatile atomic_ulong *, memory_order, memory_scope); -#endif -#endif //defined(__opencl_c_generic_address_space) -#if (__OPENCL_C_VERSION__ >= CL_VERSION_3_0 || __OPENCL_CPP_VERSION__ >= 202100) -int __ovld atomic_load_explicit(volatile __global atomic_int *, memory_order, memory_scope); -int __ovld atomic_load_explicit(volatile __local atomic_int *, memory_order, memory_scope); -uint __ovld atomic_load_explicit(volatile __global atomic_uint *, memory_order, memory_scope); -uint __ovld atomic_load_explicit(volatile __local atomic_uint *, memory_order, memory_scope); -float __ovld atomic_load_explicit(volatile __global atomic_float *, memory_order, memory_scope); -float __ovld atomic_load_explicit(volatile __local atomic_float *, memory_order, memory_scope); -#if defined(cl_khr_int64_base_atomics) && defined(cl_khr_int64_extended_atomics) -#ifdef cl_khr_fp64 -double __ovld atomic_load_explicit(volatile __global atomic_double *, memory_order, memory_scope); -double __ovld atomic_load_explicit(volatile __local atomic_double *, memory_order, memory_scope); -#endif -long __ovld atomic_load_explicit(volatile __global atomic_long *, memory_order, memory_scope); -long __ovld atomic_load_explicit(volatile __local atomic_long *, memory_order, memory_scope); -ulong __ovld atomic_load_explicit(volatile __global atomic_ulong *, memory_order, memory_scope); -ulong __ovld atomic_load_explicit(volatile __local atomic_ulong *, memory_order, memory_scope); -#endif //defined(cl_khr_int64_base_atomics) && defined(cl_khr_int64_extended_atomics) -#endif // (__OPENCL_C_VERSION__ >= CL_VERSION_3_0 || __OPENCL_CPP_VERSION__ >= 202100) - -// atomic_exchange() - -#if defined(__opencl_c_atomic_order_seq_cst) && defined(__opencl_c_atomic_scope_device) -#if defined(__opencl_c_generic_address_space) -int __ovld atomic_exchange(volatile atomic_int *, int); -uint __ovld atomic_exchange(volatile atomic_uint *, uint); -float __ovld atomic_exchange(volatile atomic_float *, float); -#if defined(cl_khr_int64_base_atomics) && defined(cl_khr_int64_extended_atomics) -#ifdef cl_khr_fp64 -double __ovld atomic_exchange(volatile atomic_double *, double); -#endif //cl_khr_fp64 -long __ovld atomic_exchange(volatile atomic_long *, long); -ulong __ovld atomic_exchange(volatile atomic_ulong *, ulong); -#endif -#endif //defined(__opencl_c_generic_address_space) -#if (__OPENCL_C_VERSION__ >= CL_VERSION_3_0 || __OPENCL_CPP_VERSION__ >= 202100) -int __ovld atomic_exchange(volatile __global atomic_int *, int); -int __ovld atomic_exchange(volatile __local atomic_int *, int); -uint __ovld atomic_exchange(volatile __global atomic_uint *, uint); -uint __ovld atomic_exchange(volatile __local atomic_uint *, uint); -float __ovld atomic_exchange(volatile __global atomic_float *, float); -float __ovld atomic_exchange(volatile __local atomic_float *, float); -#if defined(cl_khr_int64_base_atomics) && defined(cl_khr_int64_extended_atomics) -#ifdef cl_khr_fp64 -double __ovld atomic_exchange(volatile __global atomic_double *, double); -double __ovld atomic_exchange(volatile __local atomic_double *, double); -#endif //cl_khr_fp64 -long __ovld atomic_exchange(volatile __global atomic_long *, long); -long __ovld atomic_exchange(volatile __local atomic_long *, long); -ulong __ovld atomic_exchange(volatile __global atomic_ulong *, ulong); -ulong __ovld atomic_exchange(volatile __local atomic_ulong *, ulong); -#endif //defined(cl_khr_int64_base_atomics) && defined(cl_khr_int64_extended_atomics) -#endif // (__OPENCL_C_VERSION__ >= CL_VERSION_3_0 || __OPENCL_CPP_VERSION__ >= 202100) -#endif - -#if defined(__opencl_c_atomic_scope_device) -#if defined(__opencl_c_generic_address_space) -int __ovld atomic_exchange_explicit(volatile atomic_int *, int, memory_order); -uint __ovld atomic_exchange_explicit(volatile atomic_uint *, uint, memory_order); -float __ovld atomic_exchange_explicit(volatile atomic_float *, float, memory_order); -#if defined(cl_khr_int64_base_atomics) && defined(cl_khr_int64_extended_atomics) -#ifdef cl_khr_fp64 -double __ovld atomic_exchange_explicit(volatile atomic_double *, double, memory_order); -#endif //cl_khr_fp64 -long __ovld atomic_exchange_explicit(volatile atomic_long *, long, memory_order); -ulong __ovld atomic_exchange_explicit(volatile atomic_ulong *, ulong, memory_order); -#endif -#endif //defined(__opencl_c_generic_address_space) -#if (__OPENCL_C_VERSION__ >= CL_VERSION_3_0 || __OPENCL_CPP_VERSION__ >= 202100) -int __ovld atomic_exchange_explicit(volatile __global atomic_int *, int, memory_order); -int __ovld atomic_exchange_explicit(volatile __local atomic_int *, int, memory_order); -uint __ovld atomic_exchange_explicit(volatile __global atomic_uint *, uint, memory_order); -uint __ovld atomic_exchange_explicit(volatile __local atomic_uint *, uint, memory_order); -float __ovld atomic_exchange_explicit(volatile __global atomic_float *, float, memory_order); -float __ovld atomic_exchange_explicit(volatile __local atomic_float *, float, memory_order); -#if defined(cl_khr_int64_base_atomics) && defined(cl_khr_int64_extended_atomics) -#ifdef cl_khr_fp64 -double __ovld atomic_exchange_explicit(volatile __global atomic_double *, double, memory_order); -double __ovld atomic_exchange_explicit(volatile __local atomic_double *, double, memory_order); -#endif //cl_khr_fp64 -long __ovld atomic_exchange_explicit(volatile __global atomic_long *, long, memory_order); -long __ovld atomic_exchange_explicit(volatile __local atomic_long *, long, memory_order); -ulong __ovld atomic_exchange_explicit(volatile __global atomic_ulong *, ulong, memory_order); -ulong __ovld atomic_exchange_explicit(volatile __local atomic_ulong *, ulong, memory_order); -#endif //defined(cl_khr_int64_base_atomics) && defined(cl_khr_int64_extended_atomics)wi -#endif // (__OPENCL_C_VERSION__ >= CL_VERSION_3_0 || __OPENCL_CPP_VERSION__ >= 202100) -#endif - -#if defined(__opencl_c_generic_address_space) -int __ovld atomic_exchange_explicit(volatile atomic_int *, int, memory_order, memory_scope); -uint __ovld atomic_exchange_explicit(volatile atomic_uint *, uint, memory_order, memory_scope); -float __ovld atomic_exchange_explicit(volatile atomic_float *, float, memory_order, memory_scope); -#if defined(cl_khr_int64_base_atomics) && defined(cl_khr_int64_extended_atomics) -#ifdef cl_khr_fp64 -double __ovld atomic_exchange_explicit(volatile atomic_double *, double, memory_order, memory_scope); -#endif //cl_khr_fp64 -long __ovld atomic_exchange_explicit(volatile atomic_long *, long, memory_order, memory_scope); -ulong __ovld atomic_exchange_explicit(volatile atomic_ulong *, ulong, memory_order, memory_scope); -#endif -#endif //defined(__opencl_c_generic_address_space) -#if (__OPENCL_C_VERSION__ >= CL_VERSION_3_0 || __OPENCL_CPP_VERSION__ >= 202100) -int __ovld atomic_exchange_explicit(volatile __global atomic_int *, int, memory_order, memory_scope); -int __ovld atomic_exchange_explicit(volatile __local atomic_int *, int, memory_order, memory_scope); -uint __ovld atomic_exchange_explicit(volatile __global atomic_uint *, uint, memory_order, memory_scope); -uint __ovld atomic_exchange_explicit(volatile __local atomic_uint *, uint, memory_order, memory_scope); -float __ovld atomic_exchange_explicit(volatile __global atomic_float *, float, memory_order, memory_scope); -float __ovld atomic_exchange_explicit(volatile __local atomic_float *, float, memory_order, memory_scope); -#if defined(cl_khr_int64_base_atomics) && defined(cl_khr_int64_extended_atomics) -#ifdef cl_khr_fp64 -double __ovld atomic_exchange_explicit(volatile __global atomic_double *, double, memory_order, memory_scope); -double __ovld atomic_exchange_explicit(volatile __local atomic_double *, double, memory_order, memory_scope); -#endif //cl_khr_fp64 -long __ovld atomic_exchange_explicit(volatile __global atomic_long *, long, memory_order, memory_scope); -long __ovld atomic_exchange_explicit(volatile __local atomic_long *, long, memory_order, memory_scope); -ulong __ovld atomic_exchange_explicit(volatile __global atomic_ulong *, ulong, memory_order, memory_scope); -ulong __ovld atomic_exchange_explicit(volatile __local atomic_ulong *, ulong, memory_order, memory_scope); -#endif //defined(cl_khr_int64_base_atomics) && defined(cl_khr_int64_extended_atomics) -#endif // (__OPENCL_C_VERSION__ >= CL_VERSION_3_0 || __OPENCL_CPP_VERSION__ >= 202100) - -// atomic_compare_exchange_strong() and atomic_compare_exchange_weak() -#if defined(__opencl_c_atomic_order_seq_cst) && defined(__opencl_c_atomic_scope_device) -#if defined(__opencl_c_generic_address_space) -bool __ovld atomic_compare_exchange_strong(volatile atomic_int *, int *, int); -bool __ovld atomic_compare_exchange_strong(volatile atomic_uint *, uint *, uint); -bool __ovld atomic_compare_exchange_weak(volatile atomic_int *, int *, int); -bool __ovld atomic_compare_exchange_weak(volatile atomic_uint *, uint *, uint); -bool __ovld atomic_compare_exchange_strong(volatile atomic_float *, float *, float); -bool __ovld atomic_compare_exchange_weak(volatile atomic_float *, float *, float); -#if defined(cl_khr_int64_base_atomics) && defined(cl_khr_int64_extended_atomics) -#ifdef cl_khr_fp64 -bool __ovld atomic_compare_exchange_strong(volatile atomic_double *, double *, double); -bool __ovld atomic_compare_exchange_weak(volatile atomic_double *, double *, double); -#endif //cl_khr_fp64 -bool __ovld atomic_compare_exchange_strong(volatile atomic_long *, long *, long); -bool __ovld atomic_compare_exchange_weak(volatile atomic_long *, long *, long); -bool __ovld atomic_compare_exchange_strong(volatile atomic_ulong *, ulong *, ulong); -bool __ovld atomic_compare_exchange_weak(volatile atomic_ulong *, ulong *, ulong); -#endif -#endif //defined(__opencl_c_generic_address_space) -#if (__OPENCL_C_VERSION__ >= CL_VERSION_3_0 || __OPENCL_CPP_VERSION__ >= 202100) -bool __ovld atomic_compare_exchange_strong(volatile __global atomic_int *, __global int *, int); -bool __ovld atomic_compare_exchange_strong(volatile __global atomic_int *, __local int *, int); -bool __ovld atomic_compare_exchange_strong(volatile __global atomic_int *, __private int *, int); -bool __ovld atomic_compare_exchange_strong(volatile __local atomic_int *, __global int *, int); -bool __ovld atomic_compare_exchange_strong(volatile __local atomic_int *, __local int *, int); -bool __ovld atomic_compare_exchange_strong(volatile __local atomic_int *, __private int *, int); -bool __ovld atomic_compare_exchange_strong(volatile __global atomic_uint *, __global uint *, uint); -bool __ovld atomic_compare_exchange_strong(volatile __global atomic_uint *, __local uint *, uint); -bool __ovld atomic_compare_exchange_strong(volatile __global atomic_uint *, __private uint *, uint); -bool __ovld atomic_compare_exchange_strong(volatile __local atomic_uint *, __global uint *, uint); -bool __ovld atomic_compare_exchange_strong(volatile __local atomic_uint *, __local uint *, uint); -bool __ovld atomic_compare_exchange_strong(volatile __local atomic_uint *, __private uint *, uint); -bool __ovld atomic_compare_exchange_strong(volatile __global atomic_float *, __global float *, float); -bool __ovld atomic_compare_exchange_strong(volatile __global atomic_float *, __local float *, float); -bool __ovld atomic_compare_exchange_strong(volatile __global atomic_float *, __private float *, float); -bool __ovld atomic_compare_exchange_strong(volatile __local atomic_float *, __global float *, float); -bool __ovld atomic_compare_exchange_strong(volatile __local atomic_float *, __local float *, float); -bool __ovld atomic_compare_exchange_strong(volatile __local atomic_float *, __private float *, float); -bool __ovld atomic_compare_exchange_weak(volatile __global atomic_int *, __global int *, int); -bool __ovld atomic_compare_exchange_weak(volatile __global atomic_int *, __local int *, int); -bool __ovld atomic_compare_exchange_weak(volatile __global atomic_int *, __private int *, int); -bool __ovld atomic_compare_exchange_weak(volatile __local atomic_int *, __global int *, int); -bool __ovld atomic_compare_exchange_weak(volatile __local atomic_int *, __local int *, int); -bool __ovld atomic_compare_exchange_weak(volatile __local atomic_int *, __private int *, int); -bool __ovld atomic_compare_exchange_weak(volatile __global atomic_uint *, __global uint *, uint); -bool __ovld atomic_compare_exchange_weak(volatile __global atomic_uint *, __local uint *, uint); -bool __ovld atomic_compare_exchange_weak(volatile __global atomic_uint *, __private uint *, uint); -bool __ovld atomic_compare_exchange_weak(volatile __local atomic_uint *, __global uint *, uint); -bool __ovld atomic_compare_exchange_weak(volatile __local atomic_uint *, __local uint *, uint); -bool __ovld atomic_compare_exchange_weak(volatile __local atomic_uint *, __private uint *, uint); -bool __ovld atomic_compare_exchange_weak(volatile __global atomic_float *, __global float *, float); -bool __ovld atomic_compare_exchange_weak(volatile __global atomic_float *, __local float *, float); -bool __ovld atomic_compare_exchange_weak(volatile __global atomic_float *, __private float *, float); -bool __ovld atomic_compare_exchange_weak(volatile __local atomic_float *, __global float *, float); -bool __ovld atomic_compare_exchange_weak(volatile __local atomic_float *, __local float *, float); -bool __ovld atomic_compare_exchange_weak(volatile __local atomic_float *, __private float *, float); -#if defined(cl_khr_int64_base_atomics) && defined(cl_khr_int64_extended_atomics) -#ifdef cl_khr_fp64 -bool __ovld atomic_compare_exchange_strong(volatile __global atomic_double *, __global double *, double); -bool __ovld atomic_compare_exchange_strong(volatile __global atomic_double *, __local double *, double); -bool __ovld atomic_compare_exchange_strong(volatile __global atomic_double *, __private double *, double); -bool __ovld atomic_compare_exchange_strong(volatile __local atomic_double *, __global double *, double); -bool __ovld atomic_compare_exchange_strong(volatile __local atomic_double *, __local double *, double); -bool __ovld atomic_compare_exchange_strong(volatile __local atomic_double *, __private double *, double); -bool __ovld atomic_compare_exchange_weak(volatile __global atomic_double *, __global double *, double); -bool __ovld atomic_compare_exchange_weak(volatile __global atomic_double *, __local double *, double); -bool __ovld atomic_compare_exchange_weak(volatile __global atomic_double *, __private double *, double); -bool __ovld atomic_compare_exchange_weak(volatile __local atomic_double *, __global double *, double); -bool __ovld atomic_compare_exchange_weak(volatile __local atomic_double *, __local double *, double); -bool __ovld atomic_compare_exchange_weak(volatile __local atomic_double *, __private double *, double); -#endif //cl_khr_fp64 -bool __ovld atomic_compare_exchange_strong(volatile __global atomic_long *, __global long *, long); -bool __ovld atomic_compare_exchange_strong(volatile __global atomic_long *, __local long *, long); -bool __ovld atomic_compare_exchange_strong(volatile __global atomic_long *, __private long *, long); -bool __ovld atomic_compare_exchange_strong(volatile __local atomic_long *, __global long *, long); -bool __ovld atomic_compare_exchange_strong(volatile __local atomic_long *, __local long *, long); -bool __ovld atomic_compare_exchange_strong(volatile __local atomic_long *, __private long *, long); -bool __ovld atomic_compare_exchange_strong(volatile __global atomic_ulong *, __global ulong *, ulong); -bool __ovld atomic_compare_exchange_strong(volatile __global atomic_ulong *, __local ulong *, ulong); -bool __ovld atomic_compare_exchange_strong(volatile __global atomic_ulong *, __private ulong *, ulong); -bool __ovld atomic_compare_exchange_strong(volatile __local atomic_ulong *, __global ulong *, ulong); -bool __ovld atomic_compare_exchange_strong(volatile __local atomic_ulong *, __local ulong *, ulong); -bool __ovld atomic_compare_exchange_strong(volatile __local atomic_ulong *, __private ulong *, ulong); -bool __ovld atomic_compare_exchange_weak(volatile __global atomic_long *, __global long *, long); -bool __ovld atomic_compare_exchange_weak(volatile __global atomic_long *, __local long *, long); -bool __ovld atomic_compare_exchange_weak(volatile __global atomic_long *, __private long *, long); -bool __ovld atomic_compare_exchange_weak(volatile __local atomic_long *, __global long *, long); -bool __ovld atomic_compare_exchange_weak(volatile __local atomic_long *, __local long *, long); -bool __ovld atomic_compare_exchange_weak(volatile __local atomic_long *, __private long *, long); -bool __ovld atomic_compare_exchange_weak(volatile __global atomic_ulong *, __global ulong *, ulong); -bool __ovld atomic_compare_exchange_weak(volatile __global atomic_ulong *, __local ulong *, ulong); -bool __ovld atomic_compare_exchange_weak(volatile __global atomic_ulong *, __private ulong *, ulong); -bool __ovld atomic_compare_exchange_weak(volatile __local atomic_ulong *, __global ulong *, ulong); -bool __ovld atomic_compare_exchange_weak(volatile __local atomic_ulong *, __local ulong *, ulong); -bool __ovld atomic_compare_exchange_weak(volatile __local atomic_ulong *, __private ulong *, ulong); -#endif //defined(cl_khr_int64_base_atomics) && defined(cl_khr_int64_extended_atomics) -#endif // (__OPENCL_C_VERSION__ >= CL_VERSION_3_0 || __OPENCL_CPP_VERSION__ >= 202100) -#endif - -#if defined(__opencl_c_atomic_scope_device) -#if defined(__opencl_c_generic_address_space) -bool __ovld atomic_compare_exchange_strong_explicit(volatile atomic_int *, int *, int, memory_order, memory_order); -bool __ovld atomic_compare_exchange_strong_explicit(volatile atomic_uint *, uint *, uint, memory_order, memory_order); -bool __ovld atomic_compare_exchange_weak_explicit(volatile atomic_int *, int *, int, memory_order, memory_order); -bool __ovld atomic_compare_exchange_weak_explicit(volatile atomic_uint *, uint *, uint, memory_order, memory_order); -bool __ovld atomic_compare_exchange_strong_explicit(volatile atomic_float *, float *, float, memory_order, memory_order); -bool __ovld atomic_compare_exchange_weak_explicit(volatile atomic_float *, float *, float, memory_order, memory_order); -#if defined(cl_khr_int64_base_atomics) && defined(cl_khr_int64_extended_atomics) -#ifdef cl_khr_fp64 -bool __ovld atomic_compare_exchange_strong_explicit(volatile atomic_double *, double *, double, memory_order, memory_order); -bool __ovld atomic_compare_exchange_weak_explicit(volatile atomic_double *, double *, double, memory_order, memory_order); -#endif //cl_khr_fp64 -bool __ovld atomic_compare_exchange_strong_explicit(volatile atomic_long *, long *, long, memory_order, memory_order); -bool __ovld atomic_compare_exchange_weak_explicit(volatile atomic_long *, long *, long, memory_order, memory_order); -bool __ovld atomic_compare_exchange_strong_explicit(volatile atomic_ulong *, ulong *, ulong, memory_order, memory_order); -bool __ovld atomic_compare_exchange_weak_explicit(volatile atomic_ulong *, ulong *, ulong, memory_order, memory_order); -#endif -#endif //defined(__opencl_c_generic_address_space) -#if (__OPENCL_C_VERSION__ >= CL_VERSION_3_0 || __OPENCL_CPP_VERSION__ >= 202100) -bool __ovld atomic_compare_exchange_strong_explicit(volatile __global atomic_int *, __global int *, int, memory_order, memory_order); -bool __ovld atomic_compare_exchange_strong_explicit(volatile __global atomic_int *, __local int *, int, memory_order, memory_order); -bool __ovld atomic_compare_exchange_strong_explicit(volatile __global atomic_int *, __private int *, int, memory_order, memory_order); -bool __ovld atomic_compare_exchange_strong_explicit(volatile __local atomic_int *, __global int *, int, memory_order, memory_order); -bool __ovld atomic_compare_exchange_strong_explicit(volatile __local atomic_int *, __local int *, int, memory_order, memory_order); -bool __ovld atomic_compare_exchange_strong_explicit(volatile __local atomic_int *, __private int *, int, memory_order, memory_order); -bool __ovld atomic_compare_exchange_strong_explicit(volatile __global atomic_uint *, __global uint *, uint, memory_order, memory_order); -bool __ovld atomic_compare_exchange_strong_explicit(volatile __global atomic_uint *, __local uint *, uint, memory_order, memory_order); -bool __ovld atomic_compare_exchange_strong_explicit(volatile __global atomic_uint *, __private uint *, uint, memory_order, memory_order); -bool __ovld atomic_compare_exchange_strong_explicit(volatile __local atomic_uint *, __global uint *, uint, memory_order, memory_order); -bool __ovld atomic_compare_exchange_strong_explicit(volatile __local atomic_uint *, __local uint *, uint, memory_order, memory_order); -bool __ovld atomic_compare_exchange_strong_explicit(volatile __local atomic_uint *, __private uint *, uint, memory_order, memory_order); -bool __ovld atomic_compare_exchange_strong_explicit(volatile __global atomic_float *, __global float *, float, memory_order, memory_order); -bool __ovld atomic_compare_exchange_strong_explicit(volatile __global atomic_float *, __local float *, float, memory_order, memory_order); -bool __ovld atomic_compare_exchange_strong_explicit(volatile __global atomic_float *, __private float *, float, memory_order, memory_order); -bool __ovld atomic_compare_exchange_strong_explicit(volatile __local atomic_float *, __global float *, float, memory_order, memory_order); -bool __ovld atomic_compare_exchange_strong_explicit(volatile __local atomic_float *, __local float *, float, memory_order, memory_order); -bool __ovld atomic_compare_exchange_strong_explicit(volatile __local atomic_float *, __private float *, float, memory_order, memory_order); -bool __ovld atomic_compare_exchange_weak_explicit(volatile __global atomic_int *, __global int *, int, memory_order, memory_order); -bool __ovld atomic_compare_exchange_weak_explicit(volatile __global atomic_int *, __local int *, int, memory_order, memory_order); -bool __ovld atomic_compare_exchange_weak_explicit(volatile __global atomic_int *, __private int *, int, memory_order, memory_order); -bool __ovld atomic_compare_exchange_weak_explicit(volatile __local atomic_int *, __global int *, int, memory_order, memory_order); -bool __ovld atomic_compare_exchange_weak_explicit(volatile __local atomic_int *, __local int *, int, memory_order, memory_order); -bool __ovld atomic_compare_exchange_weak_explicit(volatile __local atomic_int *, __private int *, int, memory_order, memory_order); -bool __ovld atomic_compare_exchange_weak_explicit(volatile __global atomic_uint *, __global uint *, uint, memory_order, memory_order); -bool __ovld atomic_compare_exchange_weak_explicit(volatile __global atomic_uint *, __local uint *, uint, memory_order, memory_order); -bool __ovld atomic_compare_exchange_weak_explicit(volatile __global atomic_uint *, __private uint *, uint, memory_order, memory_order); -bool __ovld atomic_compare_exchange_weak_explicit(volatile __local atomic_uint *, __global uint *, uint, memory_order, memory_order); -bool __ovld atomic_compare_exchange_weak_explicit(volatile __local atomic_uint *, __local uint *, uint, memory_order, memory_order); -bool __ovld atomic_compare_exchange_weak_explicit(volatile __local atomic_uint *, __private uint *, uint, memory_order, memory_order); -bool __ovld atomic_compare_exchange_weak_explicit(volatile __global atomic_float *, __global float *, float, memory_order, memory_order); -bool __ovld atomic_compare_exchange_weak_explicit(volatile __global atomic_float *, __local float *, float, memory_order, memory_order); -bool __ovld atomic_compare_exchange_weak_explicit(volatile __global atomic_float *, __private float *, float, memory_order, memory_order); -bool __ovld atomic_compare_exchange_weak_explicit(volatile __local atomic_float *, __global float *, float, memory_order, memory_order); -bool __ovld atomic_compare_exchange_weak_explicit(volatile __local atomic_float *, __local float *, float, memory_order, memory_order); -bool __ovld atomic_compare_exchange_weak_explicit(volatile __local atomic_float *, __private float *, float, memory_order, memory_order); -#if defined(cl_khr_int64_base_atomics) && defined(cl_khr_int64_extended_atomics) -#ifdef cl_khr_fp64 -bool __ovld atomic_compare_exchange_strong_explicit(volatile __global atomic_double *, __global double *, double, memory_order, memory_order); -bool __ovld atomic_compare_exchange_strong_explicit(volatile __global atomic_double *, __local double *, double, memory_order, memory_order); -bool __ovld atomic_compare_exchange_strong_explicit(volatile __global atomic_double *, __private double *, double, memory_order, memory_order); -bool __ovld atomic_compare_exchange_strong_explicit(volatile __local atomic_double *, __global double *, double, memory_order, memory_order); -bool __ovld atomic_compare_exchange_strong_explicit(volatile __local atomic_double *, __local double *, double, memory_order, memory_order); -bool __ovld atomic_compare_exchange_strong_explicit(volatile __local atomic_double *, __private double *, double, memory_order, memory_order); -bool __ovld atomic_compare_exchange_weak_explicit(volatile __global atomic_double *, __global double *, double, memory_order, memory_order); -bool __ovld atomic_compare_exchange_weak_explicit(volatile __global atomic_double *, __local double *, double, memory_order, memory_order); -bool __ovld atomic_compare_exchange_weak_explicit(volatile __global atomic_double *, __private double *, double, memory_order, memory_order); -bool __ovld atomic_compare_exchange_weak_explicit(volatile __local atomic_double *, __global double *, double, memory_order, memory_order); -bool __ovld atomic_compare_exchange_weak_explicit(volatile __local atomic_double *, __local double *, double, memory_order, memory_order); -bool __ovld atomic_compare_exchange_weak_explicit(volatile __local atomic_double *, __private double *, double, memory_order, memory_order); -#endif //cl_khr_fp64 -bool __ovld atomic_compare_exchange_strong_explicit(volatile __global atomic_long *, __global long *, long, memory_order, memory_order); -bool __ovld atomic_compare_exchange_strong_explicit(volatile __global atomic_long *, __local long *, long, memory_order, memory_order); -bool __ovld atomic_compare_exchange_strong_explicit(volatile __global atomic_long *, __private long *, long, memory_order, memory_order); -bool __ovld atomic_compare_exchange_strong_explicit(volatile __local atomic_long *, __global long *, long, memory_order, memory_order); -bool __ovld atomic_compare_exchange_strong_explicit(volatile __local atomic_long *, __local long *, long, memory_order, memory_order); -bool __ovld atomic_compare_exchange_strong_explicit(volatile __local atomic_long *, __private long *, long, memory_order, memory_order); -bool __ovld atomic_compare_exchange_strong_explicit(volatile __global atomic_ulong *, __global ulong *, ulong, memory_order, memory_order); -bool __ovld atomic_compare_exchange_strong_explicit(volatile __global atomic_ulong *, __local ulong *, ulong, memory_order, memory_order); -bool __ovld atomic_compare_exchange_strong_explicit(volatile __global atomic_ulong *, __private ulong *, ulong, memory_order, memory_order); -bool __ovld atomic_compare_exchange_strong_explicit(volatile __local atomic_ulong *, __global ulong *, ulong, memory_order, memory_order); -bool __ovld atomic_compare_exchange_strong_explicit(volatile __local atomic_ulong *, __local ulong *, ulong, memory_order, memory_order); -bool __ovld atomic_compare_exchange_strong_explicit(volatile __local atomic_ulong *, __private ulong *, ulong, memory_order, memory_order); -bool __ovld atomic_compare_exchange_weak_explicit(volatile __global atomic_long *, __global long *, long, memory_order, memory_order); -bool __ovld atomic_compare_exchange_weak_explicit(volatile __global atomic_long *, __local long *, long, memory_order, memory_order); -bool __ovld atomic_compare_exchange_weak_explicit(volatile __global atomic_long *, __private long *, long, memory_order, memory_order); -bool __ovld atomic_compare_exchange_weak_explicit(volatile __local atomic_long *, __global long *, long, memory_order, memory_order); -bool __ovld atomic_compare_exchange_weak_explicit(volatile __local atomic_long *, __local long *, long, memory_order, memory_order); -bool __ovld atomic_compare_exchange_weak_explicit(volatile __local atomic_long *, __private long *, long, memory_order, memory_order); -bool __ovld atomic_compare_exchange_weak_explicit(volatile __global atomic_ulong *, __global ulong *, ulong, memory_order, memory_order); -bool __ovld atomic_compare_exchange_weak_explicit(volatile __global atomic_ulong *, __local ulong *, ulong, memory_order, memory_order); -bool __ovld atomic_compare_exchange_weak_explicit(volatile __global atomic_ulong *, __private ulong *, ulong, memory_order, memory_order); -bool __ovld atomic_compare_exchange_weak_explicit(volatile __local atomic_ulong *, __global ulong *, ulong, memory_order, memory_order); -bool __ovld atomic_compare_exchange_weak_explicit(volatile __local atomic_ulong *, __local ulong *, ulong, memory_order, memory_order); -bool __ovld atomic_compare_exchange_weak_explicit(volatile __local atomic_ulong *, __private ulong *, ulong, memory_order, memory_order); -#endif //defined(cl_khr_int64_base_atomics) && defined(cl_khr_int64_extended_atomics) -#endif // (__OPENCL_C_VERSION__ >= CL_VERSION_3_0 || __OPENCL_CPP_VERSION__ >= 202100) -#endif //defined(__opencl_c_atomic_scope_device) - -#if defined(__opencl_c_generic_address_space) -bool __ovld atomic_compare_exchange_strong_explicit(volatile atomic_int *, int *, int, memory_order, memory_order, memory_scope); -bool __ovld atomic_compare_exchange_strong_explicit(volatile atomic_uint *, uint *, uint, memory_order, memory_order, memory_scope); -bool __ovld atomic_compare_exchange_weak_explicit(volatile atomic_int *, int *, int, memory_order, memory_order, memory_scope); -bool __ovld atomic_compare_exchange_weak_explicit(volatile atomic_uint *, uint *, uint, memory_order, memory_order, memory_scope); -bool __ovld atomic_compare_exchange_strong_explicit(volatile atomic_float *, float *, float, memory_order, memory_order, memory_scope); -bool __ovld atomic_compare_exchange_weak_explicit(volatile atomic_float *, float *, float, memory_order, memory_order, memory_scope); -#if defined(cl_khr_int64_base_atomics) && defined(cl_khr_int64_extended_atomics) -#ifdef cl_khr_fp64 -bool __ovld atomic_compare_exchange_strong_explicit(volatile atomic_double *, double *, double, memory_order, memory_order, memory_scope); -bool __ovld atomic_compare_exchange_weak_explicit(volatile atomic_double *, double *, double, memory_order, memory_order, memory_scope); -#endif //cl_khr_fp64 -bool __ovld atomic_compare_exchange_strong_explicit(volatile atomic_long *, long *, long, memory_order, memory_order, memory_scope); -bool __ovld atomic_compare_exchange_weak_explicit(volatile atomic_long *, long *, long, memory_order, memory_order, memory_scope); -bool __ovld atomic_compare_exchange_strong_explicit(volatile atomic_ulong *, ulong *, ulong, memory_order, memory_order, memory_scope); -bool __ovld atomic_compare_exchange_weak_explicit(volatile atomic_ulong *, ulong *, ulong, memory_order, memory_order, memory_scope); -#endif -#endif //defined(__opencl_c_generic_address_space) -#if (__OPENCL_C_VERSION__ >= CL_VERSION_3_0 || __OPENCL_CPP_VERSION__ >= 202100) -bool __ovld atomic_compare_exchange_strong_explicit(volatile __global atomic_int *, __global int *, int, memory_order, memory_order, memory_scope); -bool __ovld atomic_compare_exchange_strong_explicit(volatile __global atomic_int *, __local int *, int, memory_order, memory_order, memory_scope); -bool __ovld atomic_compare_exchange_strong_explicit(volatile __global atomic_int *, __private int *, int, memory_order, memory_order, memory_scope); -bool __ovld atomic_compare_exchange_strong_explicit(volatile __local atomic_int *, __global int *, int, memory_order, memory_order, memory_scope); -bool __ovld atomic_compare_exchange_strong_explicit(volatile __local atomic_int *, __local int *, int, memory_order, memory_order, memory_scope); -bool __ovld atomic_compare_exchange_strong_explicit(volatile __local atomic_int *, __private int *, int, memory_order, memory_order, memory_scope); -bool __ovld atomic_compare_exchange_strong_explicit(volatile __global atomic_uint *, __global uint *, uint, memory_order, memory_order, memory_scope); -bool __ovld atomic_compare_exchange_strong_explicit(volatile __global atomic_uint *, __local uint *, uint, memory_order, memory_order, memory_scope); -bool __ovld atomic_compare_exchange_strong_explicit(volatile __global atomic_uint *, __private uint *, uint, memory_order, memory_order, memory_scope); -bool __ovld atomic_compare_exchange_strong_explicit(volatile __local atomic_uint *, __global uint *, uint, memory_order, memory_order, memory_scope); -bool __ovld atomic_compare_exchange_strong_explicit(volatile __local atomic_uint *, __local uint *, uint, memory_order, memory_order, memory_scope); -bool __ovld atomic_compare_exchange_strong_explicit(volatile __local atomic_uint *, __private uint *, uint, memory_order, memory_order, memory_scope); -bool __ovld atomic_compare_exchange_strong_explicit(volatile __global atomic_float *, __global float *, float, memory_order, memory_order, memory_scope); -bool __ovld atomic_compare_exchange_strong_explicit(volatile __global atomic_float *, __local float *, float, memory_order, memory_order, memory_scope); -bool __ovld atomic_compare_exchange_strong_explicit(volatile __global atomic_float *, __private float *, float, memory_order, memory_order, memory_scope); -bool __ovld atomic_compare_exchange_strong_explicit(volatile __local atomic_float *, __global float *, float, memory_order, memory_order, memory_scope); -bool __ovld atomic_compare_exchange_strong_explicit(volatile __local atomic_float *, __local float *, float, memory_order, memory_order, memory_scope); -bool __ovld atomic_compare_exchange_strong_explicit(volatile __local atomic_float *, __private float *, float, memory_order, memory_order, memory_scope); -bool __ovld atomic_compare_exchange_weak_explicit(volatile __global atomic_int *, __global int *, int, memory_order, memory_order, memory_scope); -bool __ovld atomic_compare_exchange_weak_explicit(volatile __global atomic_int *, __local int *, int, memory_order, memory_order, memory_scope); -bool __ovld atomic_compare_exchange_weak_explicit(volatile __global atomic_int *, __private int *, int, memory_order, memory_order, memory_scope); -bool __ovld atomic_compare_exchange_weak_explicit(volatile __local atomic_int *, __global int *, int, memory_order, memory_order, memory_scope); -bool __ovld atomic_compare_exchange_weak_explicit(volatile __local atomic_int *, __local int *, int, memory_order, memory_order, memory_scope); -bool __ovld atomic_compare_exchange_weak_explicit(volatile __local atomic_int *, __private int *, int, memory_order, memory_order, memory_scope); -bool __ovld atomic_compare_exchange_weak_explicit(volatile __global atomic_uint *, __global uint *, uint, memory_order, memory_order, memory_scope); -bool __ovld atomic_compare_exchange_weak_explicit(volatile __global atomic_uint *, __local uint *, uint, memory_order, memory_order, memory_scope); -bool __ovld atomic_compare_exchange_weak_explicit(volatile __global atomic_uint *, __private uint *, uint, memory_order, memory_order, memory_scope); -bool __ovld atomic_compare_exchange_weak_explicit(volatile __local atomic_uint *, __global uint *, uint, memory_order, memory_order, memory_scope); -bool __ovld atomic_compare_exchange_weak_explicit(volatile __local atomic_uint *, __local uint *, uint, memory_order, memory_order, memory_scope); -bool __ovld atomic_compare_exchange_weak_explicit(volatile __local atomic_uint *, __private uint *, uint, memory_order, memory_order, memory_scope); -bool __ovld atomic_compare_exchange_weak_explicit(volatile __global atomic_float *, __global float *, float, memory_order, memory_order, memory_scope); -bool __ovld atomic_compare_exchange_weak_explicit(volatile __global atomic_float *, __local float *, float, memory_order, memory_order, memory_scope); -bool __ovld atomic_compare_exchange_weak_explicit(volatile __global atomic_float *, __private float *, float, memory_order, memory_order, memory_scope); -bool __ovld atomic_compare_exchange_weak_explicit(volatile __local atomic_float *, __global float *, float, memory_order, memory_order, memory_scope); -bool __ovld atomic_compare_exchange_weak_explicit(volatile __local atomic_float *, __local float *, float, memory_order, memory_order, memory_scope); -bool __ovld atomic_compare_exchange_weak_explicit(volatile __local atomic_float *, __private float *, float, memory_order, memory_order, memory_scope); -#if defined(cl_khr_int64_base_atomics) && defined(cl_khr_int64_extended_atomics) -#ifdef cl_khr_fp64 -bool __ovld atomic_compare_exchange_strong_explicit(volatile __global atomic_double *, __global double *, double, memory_order, memory_order, memory_scope); -bool __ovld atomic_compare_exchange_strong_explicit(volatile __global atomic_double *, __local double *, double, memory_order, memory_order, memory_scope); -bool __ovld atomic_compare_exchange_strong_explicit(volatile __global atomic_double *, __private double *, double, memory_order, memory_order, memory_scope); -bool __ovld atomic_compare_exchange_strong_explicit(volatile __local atomic_double *, __global double *, double, memory_order, memory_order, memory_scope); -bool __ovld atomic_compare_exchange_strong_explicit(volatile __local atomic_double *, __local double *, double, memory_order, memory_order, memory_scope); -bool __ovld atomic_compare_exchange_strong_explicit(volatile __local atomic_double *, __private double *, double, memory_order, memory_order, memory_scope); -bool __ovld atomic_compare_exchange_weak_explicit(volatile __global atomic_double *, __global double *, double, memory_order, memory_order, memory_scope); -bool __ovld atomic_compare_exchange_weak_explicit(volatile __global atomic_double *, __local double *, double, memory_order, memory_order, memory_scope); -bool __ovld atomic_compare_exchange_weak_explicit(volatile __global atomic_double *, __private double *, double, memory_order, memory_order, memory_scope); -bool __ovld atomic_compare_exchange_weak_explicit(volatile __local atomic_double *, __global double *, double, memory_order, memory_order, memory_scope); -bool __ovld atomic_compare_exchange_weak_explicit(volatile __local atomic_double *, __local double *, double, memory_order, memory_order, memory_scope); -bool __ovld atomic_compare_exchange_weak_explicit(volatile __local atomic_double *, __private double *, double, memory_order, memory_order, memory_scope); -#endif //cl_khr_fp64 -bool __ovld atomic_compare_exchange_strong_explicit(volatile __global atomic_long *, __global long *, long, memory_order, memory_order, memory_scope); -bool __ovld atomic_compare_exchange_strong_explicit(volatile __global atomic_long *, __local long *, long, memory_order, memory_order, memory_scope); -bool __ovld atomic_compare_exchange_strong_explicit(volatile __global atomic_long *, __private long *, long, memory_order, memory_order, memory_scope); -bool __ovld atomic_compare_exchange_strong_explicit(volatile __local atomic_long *, __global long *, long, memory_order, memory_order, memory_scope); -bool __ovld atomic_compare_exchange_strong_explicit(volatile __local atomic_long *, __local long *, long, memory_order, memory_order, memory_scope); -bool __ovld atomic_compare_exchange_strong_explicit(volatile __local atomic_long *, __private long *, long, memory_order, memory_order, memory_scope); -bool __ovld atomic_compare_exchange_strong_explicit(volatile __global atomic_ulong *, __global ulong *, ulong, memory_order, memory_order, memory_scope); -bool __ovld atomic_compare_exchange_strong_explicit(volatile __global atomic_ulong *, __local ulong *, ulong, memory_order, memory_order, memory_scope); -bool __ovld atomic_compare_exchange_strong_explicit(volatile __global atomic_ulong *, __private ulong *, ulong, memory_order, memory_order, memory_scope); -bool __ovld atomic_compare_exchange_strong_explicit(volatile __local atomic_ulong *, __global ulong *, ulong, memory_order, memory_order, memory_scope); -bool __ovld atomic_compare_exchange_strong_explicit(volatile __local atomic_ulong *, __local ulong *, ulong, memory_order, memory_order, memory_scope); -bool __ovld atomic_compare_exchange_strong_explicit(volatile __local atomic_ulong *, __private ulong *, ulong, memory_order, memory_order, memory_scope); -bool __ovld atomic_compare_exchange_weak_explicit(volatile __global atomic_long *, __global long *, long, memory_order, memory_order, memory_scope); -bool __ovld atomic_compare_exchange_weak_explicit(volatile __global atomic_long *, __local long *, long, memory_order, memory_order, memory_scope); -bool __ovld atomic_compare_exchange_weak_explicit(volatile __global atomic_long *, __private long *, long, memory_order, memory_order, memory_scope); -bool __ovld atomic_compare_exchange_weak_explicit(volatile __local atomic_long *, __global long *, long, memory_order, memory_order, memory_scope); -bool __ovld atomic_compare_exchange_weak_explicit(volatile __local atomic_long *, __local long *, long, memory_order, memory_order, memory_scope); -bool __ovld atomic_compare_exchange_weak_explicit(volatile __local atomic_long *, __private long *, long, memory_order, memory_order, memory_scope); -bool __ovld atomic_compare_exchange_weak_explicit(volatile __global atomic_ulong *, __global ulong *, ulong, memory_order, memory_order, memory_scope); -bool __ovld atomic_compare_exchange_weak_explicit(volatile __global atomic_ulong *, __local ulong *, ulong, memory_order, memory_order, memory_scope); -bool __ovld atomic_compare_exchange_weak_explicit(volatile __global atomic_ulong *, __private ulong *, ulong, memory_order, memory_order, memory_scope); -bool __ovld atomic_compare_exchange_weak_explicit(volatile __local atomic_ulong *, __global ulong *, ulong, memory_order, memory_order, memory_scope); -bool __ovld atomic_compare_exchange_weak_explicit(volatile __local atomic_ulong *, __local ulong *, ulong, memory_order, memory_order, memory_scope); -bool __ovld atomic_compare_exchange_weak_explicit(volatile __local atomic_ulong *, __private ulong *, ulong, memory_order, memory_order, memory_scope); -#endif //defined(cl_khr_int64_base_atomics) && defined(cl_khr_int64_extended_atomics) -#endif // (__OPENCL_C_VERSION__ >= CL_VERSION_3_0 || __OPENCL_CPP_VERSION__ >= 202100) - -// atomic_flag_test_and_set() and atomic_flag_clear() -#if defined(__opencl_c_atomic_order_seq_cst) && defined(__opencl_c_atomic_scope_device) -#if defined(__opencl_c_generic_address_space) -bool __ovld atomic_flag_test_and_set(volatile atomic_flag *); -void __ovld atomic_flag_clear(volatile atomic_flag *); -#endif //defined(__opencl_c_generic_address_space) -#if (__OPENCL_C_VERSION__ >= CL_VERSION_3_0 || __OPENCL_CPP_VERSION__ >= 202100) -bool __ovld atomic_flag_test_and_set(volatile __global atomic_flag *); -bool __ovld atomic_flag_test_and_set(volatile __local atomic_flag *); -void __ovld atomic_flag_clear(volatile __global atomic_flag *); -void __ovld atomic_flag_clear(volatile __local atomic_flag *); -#endif // (__OPENCL_C_VERSION__ >= CL_VERSION_3_0 || __OPENCL_CPP_VERSION__ >= 202100) -#endif - -#if defined(__opencl_c_atomic_scope_device) -#if defined(__opencl_c_generic_address_space) -bool __ovld atomic_flag_test_and_set_explicit(volatile atomic_flag *, memory_order); -void __ovld atomic_flag_clear_explicit(volatile atomic_flag *, memory_order); -#endif //defined(__opencl_c_generic_address_space) -#if (__OPENCL_C_VERSION__ >= CL_VERSION_3_0 || __OPENCL_CPP_VERSION__ >= 202100) -bool __ovld atomic_flag_test_and_set_explicit(volatile __global atomic_flag *, memory_order); -bool __ovld atomic_flag_test_and_set_explicit(volatile __local atomic_flag *, memory_order); -void __ovld atomic_flag_clear_explicit(volatile __global atomic_flag *, memory_order); -void __ovld atomic_flag_clear_explicit(volatile __local atomic_flag *, memory_order); -#endif // (__OPENCL_C_VERSION__ >= CL_VERSION_3_0 || __OPENCL_CPP_VERSION__ >= 202100) -#endif - -#if defined(__opencl_c_generic_address_space) -bool __ovld atomic_flag_test_and_set_explicit(volatile atomic_flag *, memory_order, memory_scope); -void __ovld atomic_flag_clear_explicit(volatile atomic_flag *, memory_order, memory_scope); -#endif //defined(__opencl_c_generic_address_space) -#if (__OPENCL_C_VERSION__ >= CL_VERSION_3_0 || __OPENCL_CPP_VERSION__ >= 202100) -bool __ovld atomic_flag_test_and_set_explicit(volatile __global atomic_flag *, memory_order, memory_scope); -bool __ovld atomic_flag_test_and_set_explicit(volatile __local atomic_flag *, memory_order, memory_scope); -void __ovld atomic_flag_clear_explicit(volatile __global atomic_flag *, memory_order, memory_scope); -void __ovld atomic_flag_clear_explicit(volatile __local atomic_flag *, memory_order, memory_scope); -#endif // (__OPENCL_C_VERSION__ >= CL_VERSION_3_0 || __OPENCL_CPP_VERSION__ >= 202100) -#endif //defined(__OPENCL_CPP_VERSION__) || (__OPENCL_C_VERSION__ >= CL_VERSION_2_0) - -// OpenCL v1.1 s6.11.12, v1.2 s6.12.12, v2.0 s6.13.12 - Miscellaneous Vector Functions - -/** - * The shuffle and shuffle2 built-in functions construct - * a permutation of elements from one or two input - * vectors respectively that are of the same type, - * returning a vector with the same element type as the - * input and length that is the same as the shuffle mask. - * The size of each element in the mask must match the - * size of each element in the result. For shuffle, only - * the ilogb(2m-1) least significant bits of each mask - * element are considered. For shuffle2, only the - * ilogb(2m-1)+1 least significant bits of each mask - * element are considered. Other bits in the mask shall - * be ignored. - * The elements of the input vectors are numbered from - * left to right across one or both of the vectors. For this - * purpose, the number of elements in a vector is given - * by vec_step(gentypem). The shuffle mask operand - * specifies, for each element of the result vector, which - * element of the one or two input vectors the result - * element gets. - * Examples: - * uint4 mask = (uint4)(3, 2, - * 1, 0); - * float4 a; - * float4 r = shuffle(a, mask); - * // r.s0123 = a.wzyx - * uint8 mask = (uint8)(0, 1, 2, 3, - * 4, 5, 6, 7); - * float4 a, b; - * float8 r = shuffle2(a, b, mask); - * // r.s0123 = a.xyzw - * // r.s4567 = b.xyzw - * uint4 mask; - * float8 a; - * float4 b; - * b = shuffle(a, mask); - * Examples that are not valid are: - * uint8 mask; - * short16 a; - * short8 b; - * b = shuffle(a, mask); <- not valid - */ -char2 __ovld __cnfn shuffle(char2, uchar2); -char2 __ovld __cnfn shuffle(char4, uchar2); -char2 __ovld __cnfn shuffle(char8, uchar2); -char2 __ovld __cnfn shuffle(char16, uchar2); - -uchar2 __ovld __cnfn shuffle(uchar2, uchar2); -uchar2 __ovld __cnfn shuffle(uchar4, uchar2); -uchar2 __ovld __cnfn shuffle(uchar8, uchar2); -uchar2 __ovld __cnfn shuffle(uchar16, uchar2); - -short2 __ovld __cnfn shuffle(short2, ushort2); -short2 __ovld __cnfn shuffle(short4, ushort2); -short2 __ovld __cnfn shuffle(short8, ushort2); -short2 __ovld __cnfn shuffle(short16, ushort2); - -ushort2 __ovld __cnfn shuffle(ushort2, ushort2); -ushort2 __ovld __cnfn shuffle(ushort4, ushort2); -ushort2 __ovld __cnfn shuffle(ushort8, ushort2); -ushort2 __ovld __cnfn shuffle(ushort16, ushort2); - -int2 __ovld __cnfn shuffle(int2, uint2); -int2 __ovld __cnfn shuffle(int4, uint2); -int2 __ovld __cnfn shuffle(int8, uint2); -int2 __ovld __cnfn shuffle(int16, uint2); - -uint2 __ovld __cnfn shuffle(uint2, uint2); -uint2 __ovld __cnfn shuffle(uint4, uint2); -uint2 __ovld __cnfn shuffle(uint8, uint2); -uint2 __ovld __cnfn shuffle(uint16, uint2); - -long2 __ovld __cnfn shuffle(long2, ulong2); -long2 __ovld __cnfn shuffle(long4, ulong2); -long2 __ovld __cnfn shuffle(long8, ulong2); -long2 __ovld __cnfn shuffle(long16, ulong2); - -ulong2 __ovld __cnfn shuffle(ulong2, ulong2); -ulong2 __ovld __cnfn shuffle(ulong4, ulong2); -ulong2 __ovld __cnfn shuffle(ulong8, ulong2); -ulong2 __ovld __cnfn shuffle(ulong16, ulong2); - -float2 __ovld __cnfn shuffle(float2, uint2); -float2 __ovld __cnfn shuffle(float4, uint2); -float2 __ovld __cnfn shuffle(float8, uint2); -float2 __ovld __cnfn shuffle(float16, uint2); - -char4 __ovld __cnfn shuffle(char2, uchar4); -char4 __ovld __cnfn shuffle(char4, uchar4); -char4 __ovld __cnfn shuffle(char8, uchar4); -char4 __ovld __cnfn shuffle(char16, uchar4); - -uchar4 __ovld __cnfn shuffle(uchar2, uchar4); -uchar4 __ovld __cnfn shuffle(uchar4, uchar4); -uchar4 __ovld __cnfn shuffle(uchar8, uchar4); -uchar4 __ovld __cnfn shuffle(uchar16, uchar4); - -short4 __ovld __cnfn shuffle(short2, ushort4); -short4 __ovld __cnfn shuffle(short4, ushort4); -short4 __ovld __cnfn shuffle(short8, ushort4); -short4 __ovld __cnfn shuffle(short16, ushort4); - -ushort4 __ovld __cnfn shuffle(ushort2, ushort4); -ushort4 __ovld __cnfn shuffle(ushort4, ushort4); -ushort4 __ovld __cnfn shuffle(ushort8, ushort4); -ushort4 __ovld __cnfn shuffle(ushort16, ushort4); - -int4 __ovld __cnfn shuffle(int2, uint4); -int4 __ovld __cnfn shuffle(int4, uint4); -int4 __ovld __cnfn shuffle(int8, uint4); -int4 __ovld __cnfn shuffle(int16, uint4); - -uint4 __ovld __cnfn shuffle(uint2, uint4); -uint4 __ovld __cnfn shuffle(uint4, uint4); -uint4 __ovld __cnfn shuffle(uint8, uint4); -uint4 __ovld __cnfn shuffle(uint16, uint4); - -long4 __ovld __cnfn shuffle(long2, ulong4); -long4 __ovld __cnfn shuffle(long4, ulong4); -long4 __ovld __cnfn shuffle(long8, ulong4); -long4 __ovld __cnfn shuffle(long16, ulong4); - -ulong4 __ovld __cnfn shuffle(ulong2, ulong4); -ulong4 __ovld __cnfn shuffle(ulong4, ulong4); -ulong4 __ovld __cnfn shuffle(ulong8, ulong4); -ulong4 __ovld __cnfn shuffle(ulong16, ulong4); - -float4 __ovld __cnfn shuffle(float2, uint4); -float4 __ovld __cnfn shuffle(float4, uint4); -float4 __ovld __cnfn shuffle(float8, uint4); -float4 __ovld __cnfn shuffle(float16, uint4); - -char8 __ovld __cnfn shuffle(char2, uchar8); -char8 __ovld __cnfn shuffle(char4, uchar8); -char8 __ovld __cnfn shuffle(char8, uchar8); -char8 __ovld __cnfn shuffle(char16, uchar8); - -uchar8 __ovld __cnfn shuffle(uchar2, uchar8); -uchar8 __ovld __cnfn shuffle(uchar4, uchar8); -uchar8 __ovld __cnfn shuffle(uchar8, uchar8); -uchar8 __ovld __cnfn shuffle(uchar16, uchar8); - -short8 __ovld __cnfn shuffle(short2, ushort8); -short8 __ovld __cnfn shuffle(short4, ushort8); -short8 __ovld __cnfn shuffle(short8, ushort8); -short8 __ovld __cnfn shuffle(short16, ushort8); - -ushort8 __ovld __cnfn shuffle(ushort2, ushort8); -ushort8 __ovld __cnfn shuffle(ushort4, ushort8); -ushort8 __ovld __cnfn shuffle(ushort8, ushort8); -ushort8 __ovld __cnfn shuffle(ushort16, ushort8); - -int8 __ovld __cnfn shuffle(int2, uint8); -int8 __ovld __cnfn shuffle(int4, uint8); -int8 __ovld __cnfn shuffle(int8, uint8); -int8 __ovld __cnfn shuffle(int16, uint8); - -uint8 __ovld __cnfn shuffle(uint2, uint8); -uint8 __ovld __cnfn shuffle(uint4, uint8); -uint8 __ovld __cnfn shuffle(uint8, uint8); -uint8 __ovld __cnfn shuffle(uint16, uint8); - -long8 __ovld __cnfn shuffle(long2, ulong8); -long8 __ovld __cnfn shuffle(long4, ulong8); -long8 __ovld __cnfn shuffle(long8, ulong8); -long8 __ovld __cnfn shuffle(long16, ulong8); - -ulong8 __ovld __cnfn shuffle(ulong2, ulong8); -ulong8 __ovld __cnfn shuffle(ulong4, ulong8); -ulong8 __ovld __cnfn shuffle(ulong8, ulong8); -ulong8 __ovld __cnfn shuffle(ulong16, ulong8); - -float8 __ovld __cnfn shuffle(float2, uint8); -float8 __ovld __cnfn shuffle(float4, uint8); -float8 __ovld __cnfn shuffle(float8, uint8); -float8 __ovld __cnfn shuffle(float16, uint8); - -char16 __ovld __cnfn shuffle(char2, uchar16); -char16 __ovld __cnfn shuffle(char4, uchar16); -char16 __ovld __cnfn shuffle(char8, uchar16); -char16 __ovld __cnfn shuffle(char16, uchar16); - -uchar16 __ovld __cnfn shuffle(uchar2, uchar16); -uchar16 __ovld __cnfn shuffle(uchar4, uchar16); -uchar16 __ovld __cnfn shuffle(uchar8, uchar16); -uchar16 __ovld __cnfn shuffle(uchar16, uchar16); - -short16 __ovld __cnfn shuffle(short2, ushort16); -short16 __ovld __cnfn shuffle(short4, ushort16); -short16 __ovld __cnfn shuffle(short8, ushort16); -short16 __ovld __cnfn shuffle(short16, ushort16); - -ushort16 __ovld __cnfn shuffle(ushort2, ushort16); -ushort16 __ovld __cnfn shuffle(ushort4, ushort16); -ushort16 __ovld __cnfn shuffle(ushort8, ushort16); -ushort16 __ovld __cnfn shuffle(ushort16, ushort16); - -int16 __ovld __cnfn shuffle(int2, uint16); -int16 __ovld __cnfn shuffle(int4, uint16); -int16 __ovld __cnfn shuffle(int8, uint16); -int16 __ovld __cnfn shuffle(int16, uint16); - -uint16 __ovld __cnfn shuffle(uint2, uint16); -uint16 __ovld __cnfn shuffle(uint4, uint16); -uint16 __ovld __cnfn shuffle(uint8, uint16); -uint16 __ovld __cnfn shuffle(uint16, uint16); - -long16 __ovld __cnfn shuffle(long2, ulong16); -long16 __ovld __cnfn shuffle(long4, ulong16); -long16 __ovld __cnfn shuffle(long8, ulong16); -long16 __ovld __cnfn shuffle(long16, ulong16); - -ulong16 __ovld __cnfn shuffle(ulong2, ulong16); -ulong16 __ovld __cnfn shuffle(ulong4, ulong16); -ulong16 __ovld __cnfn shuffle(ulong8, ulong16); -ulong16 __ovld __cnfn shuffle(ulong16, ulong16); - -float16 __ovld __cnfn shuffle(float2, uint16); -float16 __ovld __cnfn shuffle(float4, uint16); -float16 __ovld __cnfn shuffle(float8, uint16); -float16 __ovld __cnfn shuffle(float16, uint16); - -#ifdef cl_khr_fp64 -double2 __ovld __cnfn shuffle(double2, ulong2); -double2 __ovld __cnfn shuffle(double4, ulong2); -double2 __ovld __cnfn shuffle(double8, ulong2); -double2 __ovld __cnfn shuffle(double16, ulong2); - -double4 __ovld __cnfn shuffle(double2, ulong4); -double4 __ovld __cnfn shuffle(double4, ulong4); -double4 __ovld __cnfn shuffle(double8, ulong4); -double4 __ovld __cnfn shuffle(double16, ulong4); - -double8 __ovld __cnfn shuffle(double2, ulong8); -double8 __ovld __cnfn shuffle(double4, ulong8); -double8 __ovld __cnfn shuffle(double8, ulong8); -double8 __ovld __cnfn shuffle(double16, ulong8); - -double16 __ovld __cnfn shuffle(double2, ulong16); -double16 __ovld __cnfn shuffle(double4, ulong16); -double16 __ovld __cnfn shuffle(double8, ulong16); -double16 __ovld __cnfn shuffle(double16, ulong16); -#endif //cl_khr_fp64 - -#ifdef cl_khr_fp16 -half2 __ovld __cnfn shuffle(half2, ushort2); -half2 __ovld __cnfn shuffle(half4, ushort2); -half2 __ovld __cnfn shuffle(half8, ushort2); -half2 __ovld __cnfn shuffle(half16, ushort2); - -half4 __ovld __cnfn shuffle(half2, ushort4); -half4 __ovld __cnfn shuffle(half4, ushort4); -half4 __ovld __cnfn shuffle(half8, ushort4); -half4 __ovld __cnfn shuffle(half16, ushort4); - -half8 __ovld __cnfn shuffle(half2, ushort8); -half8 __ovld __cnfn shuffle(half4, ushort8); -half8 __ovld __cnfn shuffle(half8, ushort8); -half8 __ovld __cnfn shuffle(half16, ushort8); - -half16 __ovld __cnfn shuffle(half2, ushort16); -half16 __ovld __cnfn shuffle(half4, ushort16); -half16 __ovld __cnfn shuffle(half8, ushort16); -half16 __ovld __cnfn shuffle(half16, ushort16); -#endif //cl_khr_fp16 - -char2 __ovld __cnfn shuffle2(char2, char2, uchar2); -char2 __ovld __cnfn shuffle2(char4, char4, uchar2); -char2 __ovld __cnfn shuffle2(char8, char8, uchar2); -char2 __ovld __cnfn shuffle2(char16, char16, uchar2); - -uchar2 __ovld __cnfn shuffle2(uchar2, uchar2, uchar2); -uchar2 __ovld __cnfn shuffle2(uchar4, uchar4, uchar2); -uchar2 __ovld __cnfn shuffle2(uchar8, uchar8, uchar2); -uchar2 __ovld __cnfn shuffle2(uchar16, uchar16, uchar2); - -short2 __ovld __cnfn shuffle2(short2, short2, ushort2); -short2 __ovld __cnfn shuffle2(short4, short4, ushort2); -short2 __ovld __cnfn shuffle2(short8, short8, ushort2); -short2 __ovld __cnfn shuffle2(short16, short16, ushort2); - -ushort2 __ovld __cnfn shuffle2(ushort2, ushort2, ushort2); -ushort2 __ovld __cnfn shuffle2(ushort4, ushort4, ushort2); -ushort2 __ovld __cnfn shuffle2(ushort8, ushort8, ushort2); -ushort2 __ovld __cnfn shuffle2(ushort16, ushort16, ushort2); - -int2 __ovld __cnfn shuffle2(int2, int2, uint2); -int2 __ovld __cnfn shuffle2(int4, int4, uint2); -int2 __ovld __cnfn shuffle2(int8, int8, uint2); -int2 __ovld __cnfn shuffle2(int16, int16, uint2); - -uint2 __ovld __cnfn shuffle2(uint2, uint2, uint2); -uint2 __ovld __cnfn shuffle2(uint4, uint4, uint2); -uint2 __ovld __cnfn shuffle2(uint8, uint8, uint2); -uint2 __ovld __cnfn shuffle2(uint16, uint16, uint2); - -long2 __ovld __cnfn shuffle2(long2, long2, ulong2); -long2 __ovld __cnfn shuffle2(long4, long4, ulong2); -long2 __ovld __cnfn shuffle2(long8, long8, ulong2); -long2 __ovld __cnfn shuffle2(long16, long16, ulong2); - -ulong2 __ovld __cnfn shuffle2(ulong2, ulong2, ulong2); -ulong2 __ovld __cnfn shuffle2(ulong4, ulong4, ulong2); -ulong2 __ovld __cnfn shuffle2(ulong8, ulong8, ulong2); -ulong2 __ovld __cnfn shuffle2(ulong16, ulong16, ulong2); - -float2 __ovld __cnfn shuffle2(float2, float2, uint2); -float2 __ovld __cnfn shuffle2(float4, float4, uint2); -float2 __ovld __cnfn shuffle2(float8, float8, uint2); -float2 __ovld __cnfn shuffle2(float16, float16, uint2); - -char4 __ovld __cnfn shuffle2(char2, char2, uchar4); -char4 __ovld __cnfn shuffle2(char4, char4, uchar4); -char4 __ovld __cnfn shuffle2(char8, char8, uchar4); -char4 __ovld __cnfn shuffle2(char16, char16, uchar4); - -uchar4 __ovld __cnfn shuffle2(uchar2, uchar2, uchar4); -uchar4 __ovld __cnfn shuffle2(uchar4, uchar4, uchar4); -uchar4 __ovld __cnfn shuffle2(uchar8, uchar8, uchar4); -uchar4 __ovld __cnfn shuffle2(uchar16, uchar16, uchar4); - -short4 __ovld __cnfn shuffle2(short2, short2, ushort4); -short4 __ovld __cnfn shuffle2(short4, short4, ushort4); -short4 __ovld __cnfn shuffle2(short8, short8, ushort4); -short4 __ovld __cnfn shuffle2(short16, short16, ushort4); - -ushort4 __ovld __cnfn shuffle2(ushort2, ushort2, ushort4); -ushort4 __ovld __cnfn shuffle2(ushort4, ushort4, ushort4); -ushort4 __ovld __cnfn shuffle2(ushort8, ushort8, ushort4); -ushort4 __ovld __cnfn shuffle2(ushort16, ushort16, ushort4); - -int4 __ovld __cnfn shuffle2(int2, int2, uint4); -int4 __ovld __cnfn shuffle2(int4, int4, uint4); -int4 __ovld __cnfn shuffle2(int8, int8, uint4); -int4 __ovld __cnfn shuffle2(int16, int16, uint4); - -uint4 __ovld __cnfn shuffle2(uint2, uint2, uint4); -uint4 __ovld __cnfn shuffle2(uint4, uint4, uint4); -uint4 __ovld __cnfn shuffle2(uint8, uint8, uint4); -uint4 __ovld __cnfn shuffle2(uint16, uint16, uint4); - -long4 __ovld __cnfn shuffle2(long2, long2, ulong4); -long4 __ovld __cnfn shuffle2(long4, long4, ulong4); -long4 __ovld __cnfn shuffle2(long8, long8, ulong4); -long4 __ovld __cnfn shuffle2(long16, long16, ulong4); - -ulong4 __ovld __cnfn shuffle2(ulong2, ulong2, ulong4); -ulong4 __ovld __cnfn shuffle2(ulong4, ulong4, ulong4); -ulong4 __ovld __cnfn shuffle2(ulong8, ulong8, ulong4); -ulong4 __ovld __cnfn shuffle2(ulong16, ulong16, ulong4); - -float4 __ovld __cnfn shuffle2(float2, float2, uint4); -float4 __ovld __cnfn shuffle2(float4, float4, uint4); -float4 __ovld __cnfn shuffle2(float8, float8, uint4); -float4 __ovld __cnfn shuffle2(float16, float16, uint4); - -char8 __ovld __cnfn shuffle2(char2, char2, uchar8); -char8 __ovld __cnfn shuffle2(char4, char4, uchar8); -char8 __ovld __cnfn shuffle2(char8, char8, uchar8); -char8 __ovld __cnfn shuffle2(char16, char16, uchar8); - -uchar8 __ovld __cnfn shuffle2(uchar2, uchar2, uchar8); -uchar8 __ovld __cnfn shuffle2(uchar4, uchar4, uchar8); -uchar8 __ovld __cnfn shuffle2(uchar8, uchar8, uchar8); -uchar8 __ovld __cnfn shuffle2(uchar16, uchar16, uchar8); - -short8 __ovld __cnfn shuffle2(short2, short2, ushort8); -short8 __ovld __cnfn shuffle2(short4, short4, ushort8); -short8 __ovld __cnfn shuffle2(short8, short8, ushort8); -short8 __ovld __cnfn shuffle2(short16, short16, ushort8); - -ushort8 __ovld __cnfn shuffle2(ushort2, ushort2, ushort8); -ushort8 __ovld __cnfn shuffle2(ushort4, ushort4, ushort8); -ushort8 __ovld __cnfn shuffle2(ushort8, ushort8, ushort8); -ushort8 __ovld __cnfn shuffle2(ushort16, ushort16, ushort8); - -int8 __ovld __cnfn shuffle2(int2, int2, uint8); -int8 __ovld __cnfn shuffle2(int4, int4, uint8); -int8 __ovld __cnfn shuffle2(int8, int8, uint8); -int8 __ovld __cnfn shuffle2(int16, int16, uint8); - -uint8 __ovld __cnfn shuffle2(uint2, uint2, uint8); -uint8 __ovld __cnfn shuffle2(uint4, uint4, uint8); -uint8 __ovld __cnfn shuffle2(uint8, uint8, uint8); -uint8 __ovld __cnfn shuffle2(uint16, uint16, uint8); - -long8 __ovld __cnfn shuffle2(long2, long2, ulong8); -long8 __ovld __cnfn shuffle2(long4, long4, ulong8); -long8 __ovld __cnfn shuffle2(long8, long8, ulong8); -long8 __ovld __cnfn shuffle2(long16, long16, ulong8); - -ulong8 __ovld __cnfn shuffle2(ulong2, ulong2, ulong8); -ulong8 __ovld __cnfn shuffle2(ulong4, ulong4, ulong8); -ulong8 __ovld __cnfn shuffle2(ulong8, ulong8, ulong8); -ulong8 __ovld __cnfn shuffle2(ulong16, ulong16, ulong8); - -float8 __ovld __cnfn shuffle2(float2, float2, uint8); -float8 __ovld __cnfn shuffle2(float4, float4, uint8); -float8 __ovld __cnfn shuffle2(float8, float8, uint8); -float8 __ovld __cnfn shuffle2(float16, float16, uint8); - -char16 __ovld __cnfn shuffle2(char2, char2, uchar16); -char16 __ovld __cnfn shuffle2(char4, char4, uchar16); -char16 __ovld __cnfn shuffle2(char8, char8, uchar16); -char16 __ovld __cnfn shuffle2(char16, char16, uchar16); - -uchar16 __ovld __cnfn shuffle2(uchar2, uchar2, uchar16); -uchar16 __ovld __cnfn shuffle2(uchar4, uchar4, uchar16); -uchar16 __ovld __cnfn shuffle2(uchar8, uchar8, uchar16); -uchar16 __ovld __cnfn shuffle2(uchar16, uchar16, uchar16); - -short16 __ovld __cnfn shuffle2(short2, short2, ushort16); -short16 __ovld __cnfn shuffle2(short4, short4, ushort16); -short16 __ovld __cnfn shuffle2(short8, short8, ushort16); -short16 __ovld __cnfn shuffle2(short16, short16, ushort16); - -ushort16 __ovld __cnfn shuffle2(ushort2, ushort2, ushort16); -ushort16 __ovld __cnfn shuffle2(ushort4, ushort4, ushort16); -ushort16 __ovld __cnfn shuffle2(ushort8, ushort8, ushort16); -ushort16 __ovld __cnfn shuffle2(ushort16, ushort16, ushort16); - -int16 __ovld __cnfn shuffle2(int2, int2, uint16); -int16 __ovld __cnfn shuffle2(int4, int4, uint16); -int16 __ovld __cnfn shuffle2(int8, int8, uint16); -int16 __ovld __cnfn shuffle2(int16, int16, uint16); - -uint16 __ovld __cnfn shuffle2(uint2, uint2, uint16); -uint16 __ovld __cnfn shuffle2(uint4, uint4, uint16); -uint16 __ovld __cnfn shuffle2(uint8, uint8, uint16); -uint16 __ovld __cnfn shuffle2(uint16, uint16, uint16); - -long16 __ovld __cnfn shuffle2(long2, long2, ulong16); -long16 __ovld __cnfn shuffle2(long4, long4, ulong16); -long16 __ovld __cnfn shuffle2(long8, long8, ulong16); -long16 __ovld __cnfn shuffle2(long16, long16, ulong16); - -ulong16 __ovld __cnfn shuffle2(ulong2, ulong2, ulong16); -ulong16 __ovld __cnfn shuffle2(ulong4, ulong4, ulong16); -ulong16 __ovld __cnfn shuffle2(ulong8, ulong8, ulong16); -ulong16 __ovld __cnfn shuffle2(ulong16, ulong16, ulong16); - -float16 __ovld __cnfn shuffle2(float2, float2, uint16); -float16 __ovld __cnfn shuffle2(float4, float4, uint16); -float16 __ovld __cnfn shuffle2(float8, float8, uint16); -float16 __ovld __cnfn shuffle2(float16, float16, uint16); - -#ifdef cl_khr_fp64 -double2 __ovld __cnfn shuffle2(double2, double2, ulong2); -double2 __ovld __cnfn shuffle2(double4, double4, ulong2); -double2 __ovld __cnfn shuffle2(double8, double8, ulong2); -double2 __ovld __cnfn shuffle2(double16, double16, ulong2); - -double4 __ovld __cnfn shuffle2(double2, double2, ulong4); -double4 __ovld __cnfn shuffle2(double4, double4, ulong4); -double4 __ovld __cnfn shuffle2(double8, double8, ulong4); -double4 __ovld __cnfn shuffle2(double16, double16, ulong4); - -double8 __ovld __cnfn shuffle2(double2, double2, ulong8); -double8 __ovld __cnfn shuffle2(double4, double4, ulong8); -double8 __ovld __cnfn shuffle2(double8, double8, ulong8); -double8 __ovld __cnfn shuffle2(double16, double16, ulong8); - -double16 __ovld __cnfn shuffle2(double2, double2, ulong16); -double16 __ovld __cnfn shuffle2(double4, double4, ulong16); -double16 __ovld __cnfn shuffle2(double8, double8, ulong16); -double16 __ovld __cnfn shuffle2(double16, double16, ulong16); -#endif //cl_khr_fp64 - -#ifdef cl_khr_fp16 -half2 __ovld __cnfn shuffle2(half2, half2, ushort2); -half2 __ovld __cnfn shuffle2(half4, half4, ushort2); -half2 __ovld __cnfn shuffle2(half8, half8, ushort2); -half2 __ovld __cnfn shuffle2(half16, half16, ushort2); - -half4 __ovld __cnfn shuffle2(half2, half2, ushort4); -half4 __ovld __cnfn shuffle2(half4, half4, ushort4); -half4 __ovld __cnfn shuffle2(half8, half8, ushort4); -half4 __ovld __cnfn shuffle2(half16, half16, ushort4); - -half8 __ovld __cnfn shuffle2(half2, half2, ushort8); -half8 __ovld __cnfn shuffle2(half4, half4, ushort8); -half8 __ovld __cnfn shuffle2(half8, half8, ushort8); -half8 __ovld __cnfn shuffle2(half16, half16, ushort8); - -half16 __ovld __cnfn shuffle2(half2, half2, ushort16); -half16 __ovld __cnfn shuffle2(half4, half4, ushort16); -half16 __ovld __cnfn shuffle2(half8, half8, ushort16); -half16 __ovld __cnfn shuffle2(half16, half16, ushort16); -#endif //cl_khr_fp16 - -// OpenCL v1.1 s6.11.3, v1.2 s6.12.14, v2.0 s6.13.14 - Image Read and Write Functions -#ifdef __opencl_c_images - -#ifdef cl_khr_gl_msaa_sharing -#pragma OPENCL EXTENSION cl_khr_gl_msaa_sharing : enable -#endif //cl_khr_gl_msaa_sharing - -/** - * Use the coordinate (coord.xy) to do an element lookup in - * the 2D image object specified by image. - * - * Use the coordinate (coord.x, coord.y, coord.z) to do - * an element lookup in the 3D image object specified - * by image. coord.w is ignored. - * - * Use the coordinate (coord.z) to index into the - * 2D image array object specified by image_array - * and (coord.x, coord.y) to do an element lookup in - * the 2D image object specified by image. - * - * Use the coordinate (x) to do an element lookup in - * the 1D image object specified by image. - * - * Use the coordinate (coord.y) to index into the - * 1D image array object specified by image_array - * and (coord.x) to do an element lookup in - * the 1D image object specified by image. - * - * Use the coordinate (cood.xy) and sample to do an - * element lookup in the 2D multi-sample image specified - * by image. - * - * Use coord.xy and sample to do an element - * lookup in the 2D multi-sample image layer - * identified by index coord.z in the 2D multi-sample - * image array specified by image. - * - * For mipmap images, use the mip-level specified by - * the Level-of-Detail (lod) or use gradients for LOD - * computation. - * - * read_imagef returns floating-point values in the - * range [0.0 ... 1.0] for image objects created with - * image_channel_data_type set to one of the predefined - * packed formats or CL_UNORM_INT8, or - * CL_UNORM_INT16. - * - * read_imagef returns floating-point values in the - * range [-1.0 ... 1.0] for image objects created with - * image_channel_data_type set to CL_SNORM_INT8, - * or CL_SNORM_INT16. - * - * read_imagef returns floating-point values for image - * objects created with image_channel_data_type set to - * CL_HALF_FLOAT or CL_FLOAT. - * - * read_imagei and read_imageui return - * unnormalized signed integer and unsigned integer - * values respectively. Each channel will be stored in a - * 32-bit integer. - * - * read_imagei can only be used with image objects - * created with image_channel_data_type set to one of - * the following values: - * CL_SIGNED_INT8, - * CL_SIGNED_INT16 and - * CL_SIGNED_INT32. - * If the image_channel_data_type is not one of the - * above values, the values returned by read_imagei - * are undefined. - * - * read_imageui can only be used with image objects - * created with image_channel_data_type set to one of - * the following values: - * CL_UNSIGNED_INT8, - * CL_UNSIGNED_INT16 and - * CL_UNSIGNED_INT32. - * If the image_channel_data_type is not one of the - * above values, the values returned by read_imageui - * are undefined. - * - * The read_image{i|ui} calls support a nearest filter - * only. The filter_mode specified in sampler - * must be set to CLK_FILTER_NEAREST; otherwise - * the values returned are undefined. - - * The read_image{f|i|ui} calls that take - * integer coordinates must use a sampler with - * normalized coordinates set to - * CLK_NORMALIZED_COORDS_FALSE and - * addressing mode set to - * CLK_ADDRESS_CLAMP_TO_EDGE, - * CLK_ADDRESS_CLAMP or CLK_ADDRESS_NONE; - * otherwise the values returned are undefined. - * - * Values returned by read_imagef for image objects - * with image_channel_data_type values not specified - * in the description above are undefined. - */ - -float4 __ovld __purefn read_imagef(read_only image2d_t, sampler_t, int2); -float4 __ovld __purefn read_imagef(read_only image2d_t, sampler_t, float2); - -int4 __ovld __purefn read_imagei(read_only image2d_t, sampler_t, int2); -int4 __ovld __purefn read_imagei(read_only image2d_t, sampler_t, float2); -uint4 __ovld __purefn read_imageui(read_only image2d_t, sampler_t, int2); -uint4 __ovld __purefn read_imageui(read_only image2d_t, sampler_t, float2); - -float4 __ovld __purefn read_imagef(read_only image3d_t, sampler_t, int4); -float4 __ovld __purefn read_imagef(read_only image3d_t, sampler_t, float4); - -int4 __ovld __purefn read_imagei(read_only image3d_t, sampler_t, int4); -int4 __ovld __purefn read_imagei(read_only image3d_t, sampler_t, float4); -uint4 __ovld __purefn read_imageui(read_only image3d_t, sampler_t, int4); -uint4 __ovld __purefn read_imageui(read_only image3d_t, sampler_t, float4); - -#if defined(__OPENCL_CPP_VERSION__) || (__OPENCL_C_VERSION__ >= CL_VERSION_1_2) -float4 __ovld __purefn read_imagef(read_only image2d_array_t, sampler_t, int4); -float4 __ovld __purefn read_imagef(read_only image2d_array_t, sampler_t, float4); - -int4 __ovld __purefn read_imagei(read_only image2d_array_t, sampler_t, int4); -int4 __ovld __purefn read_imagei(read_only image2d_array_t, sampler_t, float4); -uint4 __ovld __purefn read_imageui(read_only image2d_array_t, sampler_t, int4); -uint4 __ovld __purefn read_imageui(read_only image2d_array_t, sampler_t, float4); -#endif // defined(__OPENCL_CPP_VERSION__) || (__OPENCL_C_VERSION__ >= CL_VERSION_1_2) - -float4 __ovld __purefn read_imagef(read_only image1d_t, sampler_t, int); -float4 __ovld __purefn read_imagef(read_only image1d_t, sampler_t, float); - -int4 __ovld __purefn read_imagei(read_only image1d_t, sampler_t, int); -int4 __ovld __purefn read_imagei(read_only image1d_t, sampler_t, float); -uint4 __ovld __purefn read_imageui(read_only image1d_t, sampler_t, int); -uint4 __ovld __purefn read_imageui(read_only image1d_t, sampler_t, float); - -#if defined(__OPENCL_CPP_VERSION__) || (__OPENCL_C_VERSION__ >= CL_VERSION_1_2) -float4 __ovld __purefn read_imagef(read_only image1d_array_t, sampler_t, int2); -float4 __ovld __purefn read_imagef(read_only image1d_array_t, sampler_t, float2); - -int4 __ovld __purefn read_imagei(read_only image1d_array_t, sampler_t, int2); -int4 __ovld __purefn read_imagei(read_only image1d_array_t, sampler_t, float2); -uint4 __ovld __purefn read_imageui(read_only image1d_array_t, sampler_t, int2); -uint4 __ovld __purefn read_imageui(read_only image1d_array_t, sampler_t, float2); -#endif // defined(__OPENCL_CPP_VERSION__) || (__OPENCL_C_VERSION__ >= CL_VERSION_1_2) - -#ifdef cl_khr_depth_images -float __ovld __purefn read_imagef(read_only image2d_depth_t, sampler_t, float2); -float __ovld __purefn read_imagef(read_only image2d_depth_t, sampler_t, int2); - -float __ovld __purefn read_imagef(read_only image2d_array_depth_t, sampler_t, float4); -float __ovld __purefn read_imagef(read_only image2d_array_depth_t, sampler_t, int4); -#endif //cl_khr_depth_images - -#if defined(cl_khr_gl_msaa_sharing) -float4 __ovld __purefn read_imagef(read_only image2d_msaa_t, int2, int); -int4 __ovld __purefn read_imagei(read_only image2d_msaa_t, int2, int); -uint4 __ovld __purefn read_imageui(read_only image2d_msaa_t, int2, int); - -float __ovld __purefn read_imagef(read_only image2d_msaa_depth_t, int2, int); - -float4 __ovld __purefn read_imagef(read_only image2d_array_msaa_t, int4, int); -int4 __ovld __purefn read_imagei(read_only image2d_array_msaa_t, int4, int); -uint4 __ovld __purefn read_imageui(read_only image2d_array_msaa_t, int4, int); - -float __ovld __purefn read_imagef(read_only image2d_array_msaa_depth_t, int4, int); -#endif //cl_khr_gl_msaa_sharing - -// OpenCL Extension v2.0 s9.18 - Mipmaps -#if defined(__OPENCL_CPP_VERSION__) || (__OPENCL_C_VERSION__ >= CL_VERSION_2_0) -#ifdef cl_khr_mipmap_image - -float4 __ovld __purefn read_imagef(read_only image1d_t, sampler_t, float, float); -int4 __ovld __purefn read_imagei(read_only image1d_t, sampler_t, float, float); -uint4 __ovld __purefn read_imageui(read_only image1d_t, sampler_t, float, float); - -float4 __ovld __purefn read_imagef(read_only image1d_array_t, sampler_t, float2, float); -int4 __ovld __purefn read_imagei(read_only image1d_array_t, sampler_t, float2, float); -uint4 __ovld __purefn read_imageui(read_only image1d_array_t, sampler_t, float2, float); - -float4 __ovld __purefn read_imagef(read_only image2d_t, sampler_t, float2, float); -int4 __ovld __purefn read_imagei(read_only image2d_t, sampler_t, float2, float); -uint4 __ovld __purefn read_imageui(read_only image2d_t, sampler_t, float2, float); - -#ifdef cl_khr_depth_images -float __ovld __purefn read_imagef(read_only image2d_depth_t, sampler_t, float2, float); -#endif // cl_khr_depth_images - -float4 __ovld __purefn read_imagef(read_only image2d_array_t, sampler_t, float4, float); -int4 __ovld __purefn read_imagei(read_only image2d_array_t, sampler_t, float4, float); -uint4 __ovld __purefn read_imageui(read_only image2d_array_t, sampler_t, float4, float); - -#ifdef cl_khr_depth_images -float __ovld __purefn read_imagef(read_only image2d_array_depth_t, sampler_t, float4, float); -#endif // cl_khr_depth_images - -float4 __ovld __purefn read_imagef(read_only image3d_t, sampler_t, float4, float); -int4 __ovld __purefn read_imagei(read_only image3d_t, sampler_t, float4, float); -uint4 __ovld __purefn read_imageui(read_only image3d_t, sampler_t, float4, float); - -float4 __ovld __purefn read_imagef(read_only image1d_t, sampler_t, float, float, float); -int4 __ovld __purefn read_imagei(read_only image1d_t, sampler_t, float, float, float); -uint4 __ovld __purefn read_imageui(read_only image1d_t, sampler_t, float, float, float); - -float4 __ovld __purefn read_imagef(read_only image1d_array_t, sampler_t, float2, float, float); -int4 __ovld __purefn read_imagei(read_only image1d_array_t, sampler_t, float2, float, float); -uint4 __ovld __purefn read_imageui(read_only image1d_array_t, sampler_t, float2, float, float); - -float4 __ovld __purefn read_imagef(read_only image2d_t, sampler_t, float2, float2, float2); -int4 __ovld __purefn read_imagei(read_only image2d_t, sampler_t, float2, float2, float2); -uint4 __ovld __purefn read_imageui(read_only image2d_t, sampler_t, float2, float2, float2); - -#ifdef cl_khr_depth_images -float __ovld __purefn read_imagef(read_only image2d_depth_t, sampler_t, float2, float2, float2); -#endif // cl_khr_depth_images - -float4 __ovld __purefn read_imagef(read_only image2d_array_t, sampler_t, float4, float2, float2); -int4 __ovld __purefn read_imagei(read_only image2d_array_t, sampler_t, float4, float2, float2); -uint4 __ovld __purefn read_imageui(read_only image2d_array_t, sampler_t, float4, float2, float2); - -#ifdef cl_khr_depth_images -float __ovld __purefn read_imagef(read_only image2d_array_depth_t, sampler_t, float4, float2, float2); -#endif // cl_khr_depth_images - -float4 __ovld __purefn read_imagef(read_only image3d_t, sampler_t, float4, float4, float4); -int4 __ovld __purefn read_imagei(read_only image3d_t, sampler_t, float4, float4, float4); -uint4 __ovld __purefn read_imageui(read_only image3d_t, sampler_t, float4, float4, float4); - -#endif //cl_khr_mipmap_image -#endif //defined(__OPENCL_CPP_VERSION__) || (__OPENCL_C_VERSION__ >= CL_VERSION_2_0) - -#if defined(__OPENCL_CPP_VERSION__) || (__OPENCL_C_VERSION__ >= CL_VERSION_1_2) - -/** -* Sampler-less Image Access -*/ - -float4 __ovld __purefn read_imagef(read_only image1d_t, int); -int4 __ovld __purefn read_imagei(read_only image1d_t, int); -uint4 __ovld __purefn read_imageui(read_only image1d_t, int); - -float4 __ovld __purefn read_imagef(read_only image1d_buffer_t, int); -int4 __ovld __purefn read_imagei(read_only image1d_buffer_t, int); -uint4 __ovld __purefn read_imageui(read_only image1d_buffer_t, int); - -float4 __ovld __purefn read_imagef(read_only image1d_array_t, int2); -int4 __ovld __purefn read_imagei(read_only image1d_array_t, int2); -uint4 __ovld __purefn read_imageui(read_only image1d_array_t, int2); - -float4 __ovld __purefn read_imagef(read_only image2d_t, int2); -int4 __ovld __purefn read_imagei(read_only image2d_t, int2); -uint4 __ovld __purefn read_imageui(read_only image2d_t, int2); - -float4 __ovld __purefn read_imagef(read_only image2d_array_t, int4); -int4 __ovld __purefn read_imagei(read_only image2d_array_t, int4); -uint4 __ovld __purefn read_imageui(read_only image2d_array_t, int4); - -#ifdef cl_khr_depth_images -float __ovld __purefn read_imagef(read_only image2d_depth_t, int2); -float __ovld __purefn read_imagef(read_only image2d_array_depth_t, int4); -#endif //cl_khr_depth_images - -float4 __ovld __purefn read_imagef(read_only image3d_t, int4); -int4 __ovld __purefn read_imagei(read_only image3d_t, int4); -uint4 __ovld __purefn read_imageui(read_only image3d_t, int4); - -#endif // defined(__OPENCL_CPP_VERSION__) || (__OPENCL_C_VERSION__ >= CL_VERSION_1_2) - -// Image read functions returning half4 type -#ifdef cl_khr_fp16 -half4 __ovld __purefn read_imageh(read_only image1d_t, sampler_t, int); -half4 __ovld __purefn read_imageh(read_only image1d_t, sampler_t, float); -half4 __ovld __purefn read_imageh(read_only image2d_t, sampler_t, int2); -half4 __ovld __purefn read_imageh(read_only image2d_t, sampler_t, float2); -half4 __ovld __purefn read_imageh(read_only image3d_t, sampler_t, int4); -half4 __ovld __purefn read_imageh(read_only image3d_t, sampler_t, float4); -#if defined(__OPENCL_CPP_VERSION__) || (__OPENCL_C_VERSION__ >= CL_VERSION_1_2) -half4 __ovld __purefn read_imageh(read_only image1d_array_t, sampler_t, int2); -half4 __ovld __purefn read_imageh(read_only image1d_array_t, sampler_t, float2); -half4 __ovld __purefn read_imageh(read_only image2d_array_t, sampler_t, int4); -half4 __ovld __purefn read_imageh(read_only image2d_array_t, sampler_t, float4); -/** - * Sampler-less Image Access - */ -half4 __ovld __purefn read_imageh(read_only image1d_t, int); -half4 __ovld __purefn read_imageh(read_only image2d_t, int2); -half4 __ovld __purefn read_imageh(read_only image3d_t, int4); -half4 __ovld __purefn read_imageh(read_only image1d_array_t, int2); -half4 __ovld __purefn read_imageh(read_only image2d_array_t, int4); -half4 __ovld __purefn read_imageh(read_only image1d_buffer_t, int); -#endif // defined(__OPENCL_CPP_VERSION__) || (__OPENCL_C_VERSION__ >= CL_VERSION_1_2) -#endif //cl_khr_fp16 - -// Image read functions for read_write images -#if defined(__opencl_c_read_write_images) -float4 __ovld __purefn read_imagef(read_write image1d_t, int); -int4 __ovld __purefn read_imagei(read_write image1d_t, int); -uint4 __ovld __purefn read_imageui(read_write image1d_t, int); - -float4 __ovld __purefn read_imagef(read_write image1d_buffer_t, int); -int4 __ovld __purefn read_imagei(read_write image1d_buffer_t, int); -uint4 __ovld __purefn read_imageui(read_write image1d_buffer_t, int); - -float4 __ovld __purefn read_imagef(read_write image1d_array_t, int2); -int4 __ovld __purefn read_imagei(read_write image1d_array_t, int2); -uint4 __ovld __purefn read_imageui(read_write image1d_array_t, int2); - -float4 __ovld __purefn read_imagef(read_write image2d_t, int2); -int4 __ovld __purefn read_imagei(read_write image2d_t, int2); -uint4 __ovld __purefn read_imageui(read_write image2d_t, int2); - -float4 __ovld __purefn read_imagef(read_write image2d_array_t, int4); -int4 __ovld __purefn read_imagei(read_write image2d_array_t, int4); -uint4 __ovld __purefn read_imageui(read_write image2d_array_t, int4); - -#ifdef cl_khr_3d_image_writes -float4 __ovld __purefn read_imagef(read_write image3d_t, int4); -int4 __ovld __purefn read_imagei(read_write image3d_t, int4); -uint4 __ovld __purefn read_imageui(read_write image3d_t, int4); -#endif // cl_khr_3d_image_writes - -#ifdef cl_khr_depth_images -float __ovld __purefn read_imagef(read_write image2d_depth_t, int2); -float __ovld __purefn read_imagef(read_write image2d_array_depth_t, int4); -#endif //cl_khr_depth_images - -#if cl_khr_gl_msaa_sharing -float4 __ovld __purefn read_imagef(read_write image2d_msaa_t, int2, int); -int4 __ovld __purefn read_imagei(read_write image2d_msaa_t, int2, int); -uint4 __ovld __purefn read_imageui(read_write image2d_msaa_t, int2, int); - -float4 __ovld __purefn read_imagef(read_write image2d_array_msaa_t, int4, int); -int4 __ovld __purefn read_imagei(read_write image2d_array_msaa_t, int4, int); -uint4 __ovld __purefn read_imageui(read_write image2d_array_msaa_t, int4, int); - -float __ovld __purefn read_imagef(read_write image2d_msaa_depth_t, int2, int); -float __ovld __purefn read_imagef(read_write image2d_array_msaa_depth_t, int4, int); -#endif //cl_khr_gl_msaa_sharing - -#ifdef cl_khr_mipmap_image -float4 __ovld __purefn read_imagef(read_write image1d_t, sampler_t, float, float); -int4 __ovld __purefn read_imagei(read_write image1d_t, sampler_t, float, float); -uint4 __ovld __purefn read_imageui(read_write image1d_t, sampler_t, float, float); - -float4 __ovld __purefn read_imagef(read_write image1d_array_t, sampler_t, float2, float); -int4 __ovld __purefn read_imagei(read_write image1d_array_t, sampler_t, float2, float); -uint4 __ovld __purefn read_imageui(read_write image1d_array_t, sampler_t, float2, float); - -float4 __ovld __purefn read_imagef(read_write image2d_t, sampler_t, float2, float); -int4 __ovld __purefn read_imagei(read_write image2d_t, sampler_t, float2, float); -uint4 __ovld __purefn read_imageui(read_write image2d_t, sampler_t, float2, float); - -float __ovld __purefn read_imagef(read_write image2d_depth_t, sampler_t, float2, float); - -float4 __ovld __purefn read_imagef(read_write image2d_array_t, sampler_t, float4, float); -int4 __ovld __purefn read_imagei(read_write image2d_array_t, sampler_t, float4, float); -uint4 __ovld __purefn read_imageui(read_write image2d_array_t, sampler_t, float4, float); - -float __ovld __purefn read_imagef(read_write image2d_array_depth_t, sampler_t, float4, float); - -#ifdef cl_khr_3d_image_writes -float4 __ovld __purefn read_imagef(read_write image3d_t, sampler_t, float4, float); -int4 __ovld __purefn read_imagei(read_write image3d_t, sampler_t, float4, float); -uint4 __ovld __purefn read_imageui(read_write image3d_t, sampler_t, float4, float); -#endif // cl_khr_3d_image_writes - -float4 __ovld __purefn read_imagef(read_write image1d_t, sampler_t, float, float, float); -int4 __ovld __purefn read_imagei(read_write image1d_t, sampler_t, float, float, float); -uint4 __ovld __purefn read_imageui(read_write image1d_t, sampler_t, float, float, float); - -float4 __ovld __purefn read_imagef(read_write image1d_array_t, sampler_t, float2, float, float); -int4 __ovld __purefn read_imagei(read_write image1d_array_t, sampler_t, float2, float, float); -uint4 __ovld __purefn read_imageui(read_write image1d_array_t, sampler_t, float2, float, float); - -float4 __ovld __purefn read_imagef(read_write image2d_t, sampler_t, float2, float2, float2); -int4 __ovld __purefn read_imagei(read_write image2d_t, sampler_t, float2, float2, float2); -uint4 __ovld __purefn read_imageui(read_write image2d_t, sampler_t, float2, float2, float2); - -float __ovld __purefn read_imagef(read_write image2d_depth_t, sampler_t, float2, float2, float2); - -float4 __ovld __purefn read_imagef(read_write image2d_array_t, sampler_t, float4, float2, float2); -int4 __ovld __purefn read_imagei(read_write image2d_array_t, sampler_t, float4, float2, float2); -uint4 __ovld __purefn read_imageui(read_write image2d_array_t, sampler_t, float4, float2, float2); - -float __ovld __purefn read_imagef(read_write image2d_array_depth_t, sampler_t, float4, float2, float2); - -#ifdef cl_khr_3d_image_writes -float4 __ovld __purefn read_imagef(read_write image3d_t, sampler_t, float4, float4, float4); -int4 __ovld __purefn read_imagei(read_write image3d_t, sampler_t, float4, float4, float4); -uint4 __ovld __purefn read_imageui(read_write image3d_t, sampler_t, float4, float4, float4); -#endif // cl_khr_3d_image_writes - -#endif //cl_khr_mipmap_image - -// Image read functions returning half4 type -#ifdef cl_khr_fp16 -half4 __ovld __purefn read_imageh(read_write image1d_t, int); -half4 __ovld __purefn read_imageh(read_write image2d_t, int2); -#ifdef cl_khr_3d_image_writes -half4 __ovld __purefn read_imageh(read_write image3d_t, int4); -#endif // cl_khr_3d_image_writes -half4 __ovld __purefn read_imageh(read_write image1d_array_t, int2); -half4 __ovld __purefn read_imageh(read_write image2d_array_t, int4); -half4 __ovld __purefn read_imageh(read_write image1d_buffer_t, int); -#endif //cl_khr_fp16 -#endif //defined(__opencl_c_read_write_images) - -/** - * Write color value to location specified by coordinate - * (coord.x, coord.y) in the 2D image object specified by image. - * (coord.x, coord.y) are considered to be unnormalized coordinates - * and must be in the range 0 ... image width - 1, and 0 - * ... image height - 1. - - * Write color value to location specified by coordinate - * (coord.x, coord.y) in the 2D image object specified by index - * (coord.z) of the 2D image array object image_array. - * (coord.x, coord.y) are considered to be unnormalized - * coordinates and must be in the range 0 ... image width - * - 1. - * - * Write color value to location specified by coordinate - * (coord) in the 1D image (buffer) object specified by image. - * coord is considered to be unnormalized coordinates - * and must be in the range 0 ... image width - 1. - * - * Write color value to location specified by coordinate - * (coord.x) in the 1D image object specified by index - * (coord.y) of the 1D image array object image_array. - * x is considered to be unnormalized coordinates - * and must be in the range 0 ... image width - 1. - * - * Write color value to location specified by coordinate - * (coord.x, coord.y, coord.z) in the 3D image object specified by image. - * coord.x & coord.y are considered to be unnormalized coordinates - * and must be in the range 0 ... image width - 1, and 0 - * ... image height - 1. - * - * For mipmap images, use mip-level specified by lod. - * - * Appropriate data format conversion to the specified - * image format is done before writing the color value. - * - * write_imagef can only be used with image objects - * created with image_channel_data_type set to one of - * the pre-defined packed formats or set to - * CL_SNORM_INT8, CL_UNORM_INT8, - * CL_SNORM_INT16, CL_UNORM_INT16, - * CL_HALF_FLOAT or CL_FLOAT. Appropriate data - * format conversion will be done to convert channel - * data from a floating-point value to actual data format - * in which the channels are stored. - * - * write_imagei can only be used with image objects - * created with image_channel_data_type set to one of - * the following values: - * CL_SIGNED_INT8, - * CL_SIGNED_INT16 and - * CL_SIGNED_INT32. - * - * write_imageui can only be used with image objects - * created with image_channel_data_type set to one of - * the following values: - * CL_UNSIGNED_INT8, - * CL_UNSIGNED_INT16 and - * CL_UNSIGNED_INT32. - * - * The behavior of write_imagef, write_imagei and - * write_imageui for image objects created with - * image_channel_data_type values not specified in - * the description above or with (x, y) coordinate - * values that are not in the range (0 ... image width -1, - * 0 ... image height - 1), respectively, is undefined. - */ -void __ovld write_imagef(write_only image2d_t, int2, float4); -void __ovld write_imagei(write_only image2d_t, int2, int4); -void __ovld write_imageui(write_only image2d_t, int2, uint4); - -void __ovld write_imagef(write_only image2d_array_t, int4, float4); -void __ovld write_imagei(write_only image2d_array_t, int4, int4); -void __ovld write_imageui(write_only image2d_array_t, int4, uint4); - -void __ovld write_imagef(write_only image1d_t, int, float4); -void __ovld write_imagei(write_only image1d_t, int, int4); -void __ovld write_imageui(write_only image1d_t, int, uint4); - -void __ovld write_imagef(write_only image1d_buffer_t, int, float4); -void __ovld write_imagei(write_only image1d_buffer_t, int, int4); -void __ovld write_imageui(write_only image1d_buffer_t, int, uint4); - -void __ovld write_imagef(write_only image1d_array_t, int2, float4); -void __ovld write_imagei(write_only image1d_array_t, int2, int4); -void __ovld write_imageui(write_only image1d_array_t, int2, uint4); - -#ifdef cl_khr_3d_image_writes -void __ovld write_imagef(write_only image3d_t, int4, float4); -void __ovld write_imagei(write_only image3d_t, int4, int4); -void __ovld write_imageui(write_only image3d_t, int4, uint4); -#endif - -#ifdef cl_khr_depth_images -void __ovld write_imagef(write_only image2d_depth_t, int2, float); -void __ovld write_imagef(write_only image2d_array_depth_t, int4, float); -#endif //cl_khr_depth_images - -// OpenCL Extension v2.0 s9.18 - Mipmaps -#if defined(__OPENCL_CPP_VERSION__) || (__OPENCL_C_VERSION__ >= CL_VERSION_2_0) -#if defined(cl_khr_mipmap_image_writes) -void __ovld write_imagef(write_only image1d_t, int, int, float4); -void __ovld write_imagei(write_only image1d_t, int, int, int4); -void __ovld write_imageui(write_only image1d_t, int, int, uint4); - -void __ovld write_imagef(write_only image1d_array_t, int2, int, float4); -void __ovld write_imagei(write_only image1d_array_t, int2, int, int4); -void __ovld write_imageui(write_only image1d_array_t, int2, int, uint4); - -void __ovld write_imagef(write_only image2d_t, int2, int, float4); -void __ovld write_imagei(write_only image2d_t, int2, int, int4); -void __ovld write_imageui(write_only image2d_t, int2, int, uint4); - -void __ovld write_imagef(write_only image2d_array_t, int4, int, float4); -void __ovld write_imagei(write_only image2d_array_t, int4, int, int4); -void __ovld write_imageui(write_only image2d_array_t, int4, int, uint4); - -void __ovld write_imagef(write_only image2d_depth_t, int2, int, float); -void __ovld write_imagef(write_only image2d_array_depth_t, int4, int, float); - -#ifdef cl_khr_3d_image_writes -void __ovld write_imagef(write_only image3d_t, int4, int, float4); -void __ovld write_imagei(write_only image3d_t, int4, int, int4); -void __ovld write_imageui(write_only image3d_t, int4, int, uint4); -#endif //cl_khr_3d_image_writes - -#endif //defined(cl_khr_mipmap_image_writes) -#endif //defined(__OPENCL_CPP_VERSION__) || (__OPENCL_C_VERSION__ >= CL_VERSION_2_0) - -// Image write functions for half4 type -#ifdef cl_khr_fp16 -void __ovld write_imageh(write_only image1d_t, int, half4); -void __ovld write_imageh(write_only image2d_t, int2, half4); -#ifdef cl_khr_3d_image_writes -void __ovld write_imageh(write_only image3d_t, int4, half4); -#endif -void __ovld write_imageh(write_only image1d_array_t, int2, half4); -void __ovld write_imageh(write_only image2d_array_t, int4, half4); -void __ovld write_imageh(write_only image1d_buffer_t, int, half4); -#endif //cl_khr_fp16 - -// Image write functions for read_write images -#if defined(__opencl_c_read_write_images) -void __ovld write_imagef(read_write image2d_t, int2, float4); -void __ovld write_imagei(read_write image2d_t, int2, int4); -void __ovld write_imageui(read_write image2d_t, int2, uint4); - -void __ovld write_imagef(read_write image2d_array_t, int4, float4); -void __ovld write_imagei(read_write image2d_array_t, int4, int4); -void __ovld write_imageui(read_write image2d_array_t, int4, uint4); - -void __ovld write_imagef(read_write image1d_t, int, float4); -void __ovld write_imagei(read_write image1d_t, int, int4); -void __ovld write_imageui(read_write image1d_t, int, uint4); - -void __ovld write_imagef(read_write image1d_buffer_t, int, float4); -void __ovld write_imagei(read_write image1d_buffer_t, int, int4); -void __ovld write_imageui(read_write image1d_buffer_t, int, uint4); - -void __ovld write_imagef(read_write image1d_array_t, int2, float4); -void __ovld write_imagei(read_write image1d_array_t, int2, int4); -void __ovld write_imageui(read_write image1d_array_t, int2, uint4); - -#ifdef cl_khr_3d_image_writes -void __ovld write_imagef(read_write image3d_t, int4, float4); -void __ovld write_imagei(read_write image3d_t, int4, int4); -void __ovld write_imageui(read_write image3d_t, int4, uint4); -#endif - -#ifdef cl_khr_depth_images -void __ovld write_imagef(read_write image2d_depth_t, int2, float); -void __ovld write_imagef(read_write image2d_array_depth_t, int4, float); -#endif //cl_khr_depth_images - -#if defined(cl_khr_mipmap_image_writes) -void __ovld write_imagef(read_write image1d_t, int, int, float4); -void __ovld write_imagei(read_write image1d_t, int, int, int4); -void __ovld write_imageui(read_write image1d_t, int, int, uint4); - -void __ovld write_imagef(read_write image1d_array_t, int2, int, float4); -void __ovld write_imagei(read_write image1d_array_t, int2, int, int4); -void __ovld write_imageui(read_write image1d_array_t, int2, int, uint4); - -void __ovld write_imagef(read_write image2d_t, int2, int, float4); -void __ovld write_imagei(read_write image2d_t, int2, int, int4); -void __ovld write_imageui(read_write image2d_t, int2, int, uint4); - -void __ovld write_imagef(read_write image2d_array_t, int4, int, float4); -void __ovld write_imagei(read_write image2d_array_t, int4, int, int4); -void __ovld write_imageui(read_write image2d_array_t, int4, int, uint4); - -void __ovld write_imagef(read_write image2d_depth_t, int2, int, float); -void __ovld write_imagef(read_write image2d_array_depth_t, int4, int, float); - -#ifdef cl_khr_3d_image_writes -void __ovld write_imagef(read_write image3d_t, int4, int, float4); -void __ovld write_imagei(read_write image3d_t, int4, int, int4); -void __ovld write_imageui(read_write image3d_t, int4, int, uint4); -#endif //cl_khr_3d_image_writes - -#endif //cl_khr_mipmap_image_writes - -// Image write functions for half4 type -#ifdef cl_khr_fp16 -void __ovld write_imageh(read_write image1d_t, int, half4); -void __ovld write_imageh(read_write image2d_t, int2, half4); -#ifdef cl_khr_3d_image_writes -void __ovld write_imageh(read_write image3d_t, int4, half4); -#endif -void __ovld write_imageh(read_write image1d_array_t, int2, half4); -void __ovld write_imageh(read_write image2d_array_t, int4, half4); -void __ovld write_imageh(read_write image1d_buffer_t, int, half4); -#endif //cl_khr_fp16 -#endif //defined(__opencl_c_read_write_images) - -// Note: In OpenCL v1.0/1.1/1.2, image argument of image query builtin functions does not have -// access qualifier, which by default assume read_only access qualifier. Image query builtin -// functions with write_only image argument should also be declared. - -/** - * Return the image width in pixels. - * - */ -int __ovld __cnfn get_image_width(read_only image1d_t); -int __ovld __cnfn get_image_width(read_only image1d_buffer_t); -int __ovld __cnfn get_image_width(read_only image2d_t); -int __ovld __cnfn get_image_width(read_only image3d_t); -int __ovld __cnfn get_image_width(read_only image1d_array_t); -int __ovld __cnfn get_image_width(read_only image2d_array_t); -#ifdef cl_khr_depth_images -int __ovld __cnfn get_image_width(read_only image2d_depth_t); -int __ovld __cnfn get_image_width(read_only image2d_array_depth_t); -#endif //cl_khr_depth_images -#if defined(cl_khr_gl_msaa_sharing) -int __ovld __cnfn get_image_width(read_only image2d_msaa_t); -int __ovld __cnfn get_image_width(read_only image2d_msaa_depth_t); -int __ovld __cnfn get_image_width(read_only image2d_array_msaa_t); -int __ovld __cnfn get_image_width(read_only image2d_array_msaa_depth_t); -#endif //cl_khr_gl_msaa_sharing - -int __ovld __cnfn get_image_width(write_only image1d_t); -int __ovld __cnfn get_image_width(write_only image1d_buffer_t); -int __ovld __cnfn get_image_width(write_only image2d_t); -#ifdef cl_khr_3d_image_writes -int __ovld __cnfn get_image_width(write_only image3d_t); -#endif -int __ovld __cnfn get_image_width(write_only image1d_array_t); -int __ovld __cnfn get_image_width(write_only image2d_array_t); -#ifdef cl_khr_depth_images -int __ovld __cnfn get_image_width(write_only image2d_depth_t); -int __ovld __cnfn get_image_width(write_only image2d_array_depth_t); -#endif //cl_khr_depth_images -#if defined(cl_khr_gl_msaa_sharing) -int __ovld __cnfn get_image_width(write_only image2d_msaa_t); -int __ovld __cnfn get_image_width(write_only image2d_msaa_depth_t); -int __ovld __cnfn get_image_width(write_only image2d_array_msaa_t); -int __ovld __cnfn get_image_width(write_only image2d_array_msaa_depth_t); -#endif //cl_khr_gl_msaa_sharing - -#if defined(__opencl_c_read_write_images) -int __ovld __cnfn get_image_width(read_write image1d_t); -int __ovld __cnfn get_image_width(read_write image1d_buffer_t); -int __ovld __cnfn get_image_width(read_write image2d_t); -#ifdef cl_khr_3d_image_writes -int __ovld __cnfn get_image_width(read_write image3d_t); -#endif // cl_khr_3d_image_writes -int __ovld __cnfn get_image_width(read_write image1d_array_t); -int __ovld __cnfn get_image_width(read_write image2d_array_t); -#ifdef cl_khr_depth_images -int __ovld __cnfn get_image_width(read_write image2d_depth_t); -int __ovld __cnfn get_image_width(read_write image2d_array_depth_t); -#endif //cl_khr_depth_images -#if defined(cl_khr_gl_msaa_sharing) -int __ovld __cnfn get_image_width(read_write image2d_msaa_t); -int __ovld __cnfn get_image_width(read_write image2d_msaa_depth_t); -int __ovld __cnfn get_image_width(read_write image2d_array_msaa_t); -int __ovld __cnfn get_image_width(read_write image2d_array_msaa_depth_t); -#endif //cl_khr_gl_msaa_sharing -#endif //defined(__opencl_c_read_write_images) - -/** - * Return the image height in pixels. - */ -int __ovld __cnfn get_image_height(read_only image2d_t); -int __ovld __cnfn get_image_height(read_only image3d_t); -int __ovld __cnfn get_image_height(read_only image2d_array_t); -#ifdef cl_khr_depth_images -int __ovld __cnfn get_image_height(read_only image2d_depth_t); -int __ovld __cnfn get_image_height(read_only image2d_array_depth_t); -#endif //cl_khr_depth_images -#if defined(cl_khr_gl_msaa_sharing) -int __ovld __cnfn get_image_height(read_only image2d_msaa_t); -int __ovld __cnfn get_image_height(read_only image2d_msaa_depth_t); -int __ovld __cnfn get_image_height(read_only image2d_array_msaa_t); -int __ovld __cnfn get_image_height(read_only image2d_array_msaa_depth_t); -#endif //cl_khr_gl_msaa_sharing - -int __ovld __cnfn get_image_height(write_only image2d_t); -#ifdef cl_khr_3d_image_writes -int __ovld __cnfn get_image_height(write_only image3d_t); -#endif -int __ovld __cnfn get_image_height(write_only image2d_array_t); -#ifdef cl_khr_depth_images -int __ovld __cnfn get_image_height(write_only image2d_depth_t); -int __ovld __cnfn get_image_height(write_only image2d_array_depth_t); -#endif //cl_khr_depth_images -#if defined(cl_khr_gl_msaa_sharing) -int __ovld __cnfn get_image_height(write_only image2d_msaa_t); -int __ovld __cnfn get_image_height(write_only image2d_msaa_depth_t); -int __ovld __cnfn get_image_height(write_only image2d_array_msaa_t); -int __ovld __cnfn get_image_height(write_only image2d_array_msaa_depth_t); -#endif //cl_khr_gl_msaa_sharing - -#if defined(__opencl_c_read_write_images) -int __ovld __cnfn get_image_height(read_write image2d_t); -#ifdef cl_khr_3d_image_writes -int __ovld __cnfn get_image_height(read_write image3d_t); -#endif // cl_khr_3d_image_writes -int __ovld __cnfn get_image_height(read_write image2d_array_t); -#ifdef cl_khr_depth_images -int __ovld __cnfn get_image_height(read_write image2d_depth_t); -int __ovld __cnfn get_image_height(read_write image2d_array_depth_t); -#endif //cl_khr_depth_images -#if defined(cl_khr_gl_msaa_sharing) -int __ovld __cnfn get_image_height(read_write image2d_msaa_t); -int __ovld __cnfn get_image_height(read_write image2d_msaa_depth_t); -int __ovld __cnfn get_image_height(read_write image2d_array_msaa_t); -int __ovld __cnfn get_image_height(read_write image2d_array_msaa_depth_t); -#endif //cl_khr_gl_msaa_sharing -#endif //defined(__opencl_c_read_write_images) - -/** - * Return the image depth in pixels. - */ -int __ovld __cnfn get_image_depth(read_only image3d_t); - -#ifdef cl_khr_3d_image_writes -int __ovld __cnfn get_image_depth(write_only image3d_t); - -#if defined(__opencl_c_read_write_images) -int __ovld __cnfn get_image_depth(read_write image3d_t); -#endif //defined(__opencl_c_read_write_images) -#endif // cl_khr_3d_image_writes - -// OpenCL Extension v2.0 s9.18 - Mipmaps -#if defined(__OPENCL_CPP_VERSION__) || (__OPENCL_C_VERSION__ >= CL_VERSION_2_0) -#ifdef cl_khr_mipmap_image -/** - * Return the image miplevels. - */ - -int __ovld get_image_num_mip_levels(read_only image1d_t); -int __ovld get_image_num_mip_levels(read_only image2d_t); -int __ovld get_image_num_mip_levels(read_only image3d_t); - -int __ovld get_image_num_mip_levels(write_only image1d_t); -int __ovld get_image_num_mip_levels(write_only image2d_t); -#ifdef cl_khr_3d_image_writes -int __ovld get_image_num_mip_levels(write_only image3d_t); -#endif - -#if defined(__opencl_c_read_write_images) -int __ovld get_image_num_mip_levels(read_write image1d_t); -int __ovld get_image_num_mip_levels(read_write image2d_t); -#ifdef cl_khr_3d_image_writes -int __ovld get_image_num_mip_levels(read_write image3d_t); -#endif // cl_khr_3d_image_writes -#endif //defined(__opencl_c_read_write_images) - -int __ovld get_image_num_mip_levels(read_only image1d_array_t); -int __ovld get_image_num_mip_levels(read_only image2d_array_t); -#ifdef cl_khr_depth_images -int __ovld get_image_num_mip_levels(read_only image2d_array_depth_t); -int __ovld get_image_num_mip_levels(read_only image2d_depth_t); -#endif // cl_khr_depth_images - -int __ovld get_image_num_mip_levels(write_only image1d_array_t); -int __ovld get_image_num_mip_levels(write_only image2d_array_t); -#ifdef cl_khr_depth_images -int __ovld get_image_num_mip_levels(write_only image2d_array_depth_t); -int __ovld get_image_num_mip_levels(write_only image2d_depth_t); -#endif // cl_khr_depth_images - -#if defined(__opencl_c_read_write_images) -int __ovld get_image_num_mip_levels(read_write image1d_array_t); -int __ovld get_image_num_mip_levels(read_write image2d_array_t); -#ifdef cl_khr_depth_images -int __ovld get_image_num_mip_levels(read_write image2d_array_depth_t); -int __ovld get_image_num_mip_levels(read_write image2d_depth_t); -#endif // cl_khr_depth_images -#endif //defined(__opencl_c_read_write_images) - -#endif //cl_khr_mipmap_image -#endif //defined(__OPENCL_CPP_VERSION__) || (__OPENCL_C_VERSION__ >= CL_VERSION_2_0) - -/** - * Return the channel data type. Valid values are: - * CLK_SNORM_INT8 - * CLK_SNORM_INT16 - * CLK_UNORM_INT8 - * CLK_UNORM_INT16 - * CLK_UNORM_SHORT_565 - * CLK_UNORM_SHORT_555 - * CLK_UNORM_SHORT_101010 - * CLK_SIGNED_INT8 - * CLK_SIGNED_INT16 - * CLK_SIGNED_INT32 - * CLK_UNSIGNED_INT8 - * CLK_UNSIGNED_INT16 - * CLK_UNSIGNED_INT32 - * CLK_HALF_FLOAT - * CLK_FLOAT - */ - -int __ovld __cnfn get_image_channel_data_type(read_only image1d_t); -int __ovld __cnfn get_image_channel_data_type(read_only image1d_buffer_t); -int __ovld __cnfn get_image_channel_data_type(read_only image2d_t); -int __ovld __cnfn get_image_channel_data_type(read_only image3d_t); -int __ovld __cnfn get_image_channel_data_type(read_only image1d_array_t); -int __ovld __cnfn get_image_channel_data_type(read_only image2d_array_t); -#ifdef cl_khr_depth_images -int __ovld __cnfn get_image_channel_data_type(read_only image2d_depth_t); -int __ovld __cnfn get_image_channel_data_type(read_only image2d_array_depth_t); -#endif //cl_khr_depth_images -#if defined(cl_khr_gl_msaa_sharing) -int __ovld __cnfn get_image_channel_data_type(read_only image2d_msaa_t); -int __ovld __cnfn get_image_channel_data_type(read_only image2d_msaa_depth_t); -int __ovld __cnfn get_image_channel_data_type(read_only image2d_array_msaa_t); -int __ovld __cnfn get_image_channel_data_type(read_only image2d_array_msaa_depth_t); -#endif //cl_khr_gl_msaa_sharing - -int __ovld __cnfn get_image_channel_data_type(write_only image1d_t); -int __ovld __cnfn get_image_channel_data_type(write_only image1d_buffer_t); -int __ovld __cnfn get_image_channel_data_type(write_only image2d_t); -#ifdef cl_khr_3d_image_writes -int __ovld __cnfn get_image_channel_data_type(write_only image3d_t); -#endif -int __ovld __cnfn get_image_channel_data_type(write_only image1d_array_t); -int __ovld __cnfn get_image_channel_data_type(write_only image2d_array_t); -#ifdef cl_khr_depth_images -int __ovld __cnfn get_image_channel_data_type(write_only image2d_depth_t); -int __ovld __cnfn get_image_channel_data_type(write_only image2d_array_depth_t); -#endif //cl_khr_depth_images -#if defined(cl_khr_gl_msaa_sharing) -int __ovld __cnfn get_image_channel_data_type(write_only image2d_msaa_t); -int __ovld __cnfn get_image_channel_data_type(write_only image2d_msaa_depth_t); -int __ovld __cnfn get_image_channel_data_type(write_only image2d_array_msaa_t); -int __ovld __cnfn get_image_channel_data_type(write_only image2d_array_msaa_depth_t); -#endif //cl_khr_gl_msaa_sharing - -#if defined(__opencl_c_read_write_images) -int __ovld __cnfn get_image_channel_data_type(read_write image1d_t); -int __ovld __cnfn get_image_channel_data_type(read_write image1d_buffer_t); -int __ovld __cnfn get_image_channel_data_type(read_write image2d_t); -#ifdef cl_khr_3d_image_writes -int __ovld __cnfn get_image_channel_data_type(read_write image3d_t); -#endif // cl_khr_3d_image_writes -int __ovld __cnfn get_image_channel_data_type(read_write image1d_array_t); -int __ovld __cnfn get_image_channel_data_type(read_write image2d_array_t); -#ifdef cl_khr_depth_images -int __ovld __cnfn get_image_channel_data_type(read_write image2d_depth_t); -int __ovld __cnfn get_image_channel_data_type(read_write image2d_array_depth_t); -#endif //cl_khr_depth_images -#if defined(cl_khr_gl_msaa_sharing) -int __ovld __cnfn get_image_channel_data_type(read_write image2d_msaa_t); -int __ovld __cnfn get_image_channel_data_type(read_write image2d_msaa_depth_t); -int __ovld __cnfn get_image_channel_data_type(read_write image2d_array_msaa_t); -int __ovld __cnfn get_image_channel_data_type(read_write image2d_array_msaa_depth_t); -#endif //cl_khr_gl_msaa_sharing -#endif //defined(__opencl_c_read_write_images) - -/** - * Return the image channel order. Valid values are: - * CLK_A - * CLK_R - * CLK_Rx - * CLK_RG - * CLK_RGx - * CLK_RA - * CLK_RGB - * CLK_RGBx - * CLK_RGBA - * CLK_ARGB - * CLK_BGRA - * CLK_INTENSITY - * CLK_LUMINANCE - */ - -int __ovld __cnfn get_image_channel_order(read_only image1d_t); -int __ovld __cnfn get_image_channel_order(read_only image1d_buffer_t); -int __ovld __cnfn get_image_channel_order(read_only image2d_t); -int __ovld __cnfn get_image_channel_order(read_only image3d_t); -int __ovld __cnfn get_image_channel_order(read_only image1d_array_t); -int __ovld __cnfn get_image_channel_order(read_only image2d_array_t); -#ifdef cl_khr_depth_images -int __ovld __cnfn get_image_channel_order(read_only image2d_depth_t); -int __ovld __cnfn get_image_channel_order(read_only image2d_array_depth_t); -#endif //cl_khr_depth_images -#if defined(cl_khr_gl_msaa_sharing) -int __ovld __cnfn get_image_channel_order(read_only image2d_msaa_t); -int __ovld __cnfn get_image_channel_order(read_only image2d_msaa_depth_t); -int __ovld __cnfn get_image_channel_order(read_only image2d_array_msaa_t); -int __ovld __cnfn get_image_channel_order(read_only image2d_array_msaa_depth_t); -#endif //cl_khr_gl_msaa_sharing - -int __ovld __cnfn get_image_channel_order(write_only image1d_t); -int __ovld __cnfn get_image_channel_order(write_only image1d_buffer_t); -int __ovld __cnfn get_image_channel_order(write_only image2d_t); -#ifdef cl_khr_3d_image_writes -int __ovld __cnfn get_image_channel_order(write_only image3d_t); -#endif -int __ovld __cnfn get_image_channel_order(write_only image1d_array_t); -int __ovld __cnfn get_image_channel_order(write_only image2d_array_t); -#ifdef cl_khr_depth_images -int __ovld __cnfn get_image_channel_order(write_only image2d_depth_t); -int __ovld __cnfn get_image_channel_order(write_only image2d_array_depth_t); -#endif //cl_khr_depth_images -#if defined(cl_khr_gl_msaa_sharing) -int __ovld __cnfn get_image_channel_order(write_only image2d_msaa_t); -int __ovld __cnfn get_image_channel_order(write_only image2d_msaa_depth_t); -int __ovld __cnfn get_image_channel_order(write_only image2d_array_msaa_t); -int __ovld __cnfn get_image_channel_order(write_only image2d_array_msaa_depth_t); -#endif //cl_khr_gl_msaa_sharing - -#if defined(__opencl_c_read_write_images) -int __ovld __cnfn get_image_channel_order(read_write image1d_t); -int __ovld __cnfn get_image_channel_order(read_write image1d_buffer_t); -int __ovld __cnfn get_image_channel_order(read_write image2d_t); -#ifdef cl_khr_3d_image_writes -int __ovld __cnfn get_image_channel_order(read_write image3d_t); -#endif // cl_khr_3d_image_writes -int __ovld __cnfn get_image_channel_order(read_write image1d_array_t); -int __ovld __cnfn get_image_channel_order(read_write image2d_array_t); -#ifdef cl_khr_depth_images -int __ovld __cnfn get_image_channel_order(read_write image2d_depth_t); -int __ovld __cnfn get_image_channel_order(read_write image2d_array_depth_t); -#endif //cl_khr_depth_images -#if defined(cl_khr_gl_msaa_sharing) -int __ovld __cnfn get_image_channel_order(read_write image2d_msaa_t); -int __ovld __cnfn get_image_channel_order(read_write image2d_msaa_depth_t); -int __ovld __cnfn get_image_channel_order(read_write image2d_array_msaa_t); -int __ovld __cnfn get_image_channel_order(read_write image2d_array_msaa_depth_t); -#endif //cl_khr_gl_msaa_sharing -#endif //defined(__opencl_c_read_write_images) - -/** - * Return the 2D image width and height as an int2 - * type. The width is returned in the x component, and - * the height in the y component. - */ -int2 __ovld __cnfn get_image_dim(read_only image2d_t); -int2 __ovld __cnfn get_image_dim(read_only image2d_array_t); -#ifdef cl_khr_depth_images -int2 __ovld __cnfn get_image_dim(read_only image2d_array_depth_t); -int2 __ovld __cnfn get_image_dim(read_only image2d_depth_t); -#endif //cl_khr_depth_images -#if defined(cl_khr_gl_msaa_sharing) -int2 __ovld __cnfn get_image_dim(read_only image2d_msaa_t); -int2 __ovld __cnfn get_image_dim(read_only image2d_msaa_depth_t); -int2 __ovld __cnfn get_image_dim(read_only image2d_array_msaa_t); -int2 __ovld __cnfn get_image_dim(read_only image2d_array_msaa_depth_t); -#endif //cl_khr_gl_msaa_sharing - -int2 __ovld __cnfn get_image_dim(write_only image2d_t); -int2 __ovld __cnfn get_image_dim(write_only image2d_array_t); -#ifdef cl_khr_depth_images -int2 __ovld __cnfn get_image_dim(write_only image2d_array_depth_t); -int2 __ovld __cnfn get_image_dim(write_only image2d_depth_t); -#endif //cl_khr_depth_images -#if defined(cl_khr_gl_msaa_sharing) -int2 __ovld __cnfn get_image_dim(write_only image2d_msaa_t); -int2 __ovld __cnfn get_image_dim(write_only image2d_msaa_depth_t); -int2 __ovld __cnfn get_image_dim(write_only image2d_array_msaa_t); -int2 __ovld __cnfn get_image_dim(write_only image2d_array_msaa_depth_t); -#endif //cl_khr_gl_msaa_sharing - -#if defined(__opencl_c_read_write_images) -int2 __ovld __cnfn get_image_dim(read_write image2d_t); -int2 __ovld __cnfn get_image_dim(read_write image2d_array_t); -#ifdef cl_khr_depth_images -int2 __ovld __cnfn get_image_dim(read_write image2d_array_depth_t); -int2 __ovld __cnfn get_image_dim(read_write image2d_depth_t); -#endif //cl_khr_depth_images -#if defined(cl_khr_gl_msaa_sharing) -int2 __ovld __cnfn get_image_dim(read_write image2d_msaa_t); -int2 __ovld __cnfn get_image_dim(read_write image2d_msaa_depth_t); -int2 __ovld __cnfn get_image_dim(read_write image2d_array_msaa_t); -int2 __ovld __cnfn get_image_dim(read_write image2d_array_msaa_depth_t); -#endif //cl_khr_gl_msaa_sharing -#endif //defined(__opencl_c_read_write_images) - -/** - * Return the 3D image width, height, and depth as an - * int4 type. The width is returned in the x - * component, height in the y component, depth in the z - * component and the w component is 0. - */ -int4 __ovld __cnfn get_image_dim(read_only image3d_t); -#ifdef cl_khr_3d_image_writes -int4 __ovld __cnfn get_image_dim(write_only image3d_t); -#if defined(__opencl_c_read_write_images) -int4 __ovld __cnfn get_image_dim(read_write image3d_t); -#endif //defined(__opencl_c_read_write_images) -#endif // cl_khr_3d_image_writes - -/** - * Return the image array size. - */ - -size_t __ovld __cnfn get_image_array_size(read_only image1d_array_t); -size_t __ovld __cnfn get_image_array_size(read_only image2d_array_t); -#ifdef cl_khr_depth_images -size_t __ovld __cnfn get_image_array_size(read_only image2d_array_depth_t); -#endif //cl_khr_depth_images -#if defined(cl_khr_gl_msaa_sharing) -size_t __ovld __cnfn get_image_array_size(read_only image2d_array_msaa_t); -size_t __ovld __cnfn get_image_array_size(read_only image2d_array_msaa_depth_t); -#endif //cl_khr_gl_msaa_sharing - -size_t __ovld __cnfn get_image_array_size(write_only image1d_array_t); -size_t __ovld __cnfn get_image_array_size(write_only image2d_array_t); -#ifdef cl_khr_depth_images -size_t __ovld __cnfn get_image_array_size(write_only image2d_array_depth_t); -#endif //cl_khr_depth_images -#if defined(cl_khr_gl_msaa_sharing) -size_t __ovld __cnfn get_image_array_size(write_only image2d_array_msaa_t); -size_t __ovld __cnfn get_image_array_size(write_only image2d_array_msaa_depth_t); -#endif //cl_khr_gl_msaa_sharing - -#if defined(__opencl_c_read_write_images) -size_t __ovld __cnfn get_image_array_size(read_write image1d_array_t); -size_t __ovld __cnfn get_image_array_size(read_write image2d_array_t); -#ifdef cl_khr_depth_images -size_t __ovld __cnfn get_image_array_size(read_write image2d_array_depth_t); -#endif //cl_khr_depth_images -#if defined(cl_khr_gl_msaa_sharing) -size_t __ovld __cnfn get_image_array_size(read_write image2d_array_msaa_t); -size_t __ovld __cnfn get_image_array_size(read_write image2d_array_msaa_depth_t); -#endif //cl_khr_gl_msaa_sharing -#endif //defined(__opencl_c_read_write_images) - -/** -* Return the number of samples associated with image -*/ -#if defined(cl_khr_gl_msaa_sharing) -int __ovld __cnfn get_image_num_samples(read_only image2d_msaa_t); -int __ovld __cnfn get_image_num_samples(read_only image2d_msaa_depth_t); -int __ovld __cnfn get_image_num_samples(read_only image2d_array_msaa_t); -int __ovld __cnfn get_image_num_samples(read_only image2d_array_msaa_depth_t); - -int __ovld __cnfn get_image_num_samples(write_only image2d_msaa_t); -int __ovld __cnfn get_image_num_samples(write_only image2d_msaa_depth_t); -int __ovld __cnfn get_image_num_samples(write_only image2d_array_msaa_t); -int __ovld __cnfn get_image_num_samples(write_only image2d_array_msaa_depth_t); - -#if defined(__opencl_c_read_write_images) -int __ovld __cnfn get_image_num_samples(read_write image2d_msaa_t); -int __ovld __cnfn get_image_num_samples(read_write image2d_msaa_depth_t); -int __ovld __cnfn get_image_num_samples(read_write image2d_array_msaa_t); -int __ovld __cnfn get_image_num_samples(read_write image2d_array_msaa_depth_t); -#endif //defined(__opencl_c_read_write_images) -#endif - -#endif // __opencl_c_images - -// OpenCL v2.0 s6.13.15 - Work-group Functions - -#if defined(__opencl_c_work_group_collective_functions) -int __ovld __conv work_group_all(int predicate); -int __ovld __conv work_group_any(int predicate); - -#ifdef cl_khr_fp16 -half __ovld __conv work_group_broadcast(half, size_t local_id); -half __ovld __conv work_group_broadcast(half, size_t, size_t); -half __ovld __conv work_group_broadcast(half, size_t, size_t, size_t); -#endif -int __ovld __conv work_group_broadcast(int, size_t local_id); -int __ovld __conv work_group_broadcast(int, size_t, size_t); -int __ovld __conv work_group_broadcast(int, size_t, size_t, size_t); -uint __ovld __conv work_group_broadcast(uint, size_t local_id); -uint __ovld __conv work_group_broadcast(uint, size_t, size_t); -uint __ovld __conv work_group_broadcast(uint, size_t, size_t, size_t); -long __ovld __conv work_group_broadcast(long, size_t local_id); -long __ovld __conv work_group_broadcast(long, size_t, size_t); -long __ovld __conv work_group_broadcast(long, size_t, size_t, size_t); -ulong __ovld __conv work_group_broadcast(ulong, size_t local_id); -ulong __ovld __conv work_group_broadcast(ulong, size_t, size_t); -ulong __ovld __conv work_group_broadcast(ulong, size_t, size_t, size_t); -float __ovld __conv work_group_broadcast(float, size_t local_id); -float __ovld __conv work_group_broadcast(float, size_t, size_t); -float __ovld __conv work_group_broadcast(float, size_t, size_t, size_t); -#ifdef cl_khr_fp64 -double __ovld __conv work_group_broadcast(double, size_t local_id); -double __ovld __conv work_group_broadcast(double, size_t, size_t); -double __ovld __conv work_group_broadcast(double, size_t, size_t, size_t); -#endif //cl_khr_fp64 - -#ifdef cl_khr_fp16 -half __ovld __conv work_group_reduce_add(half); -half __ovld __conv work_group_reduce_min(half); -half __ovld __conv work_group_reduce_max(half); -half __ovld __conv work_group_scan_exclusive_add(half); -half __ovld __conv work_group_scan_exclusive_min(half); -half __ovld __conv work_group_scan_exclusive_max(half); -half __ovld __conv work_group_scan_inclusive_add(half); -half __ovld __conv work_group_scan_inclusive_min(half); -half __ovld __conv work_group_scan_inclusive_max(half); -#endif -int __ovld __conv work_group_reduce_add(int); -int __ovld __conv work_group_reduce_min(int); -int __ovld __conv work_group_reduce_max(int); -int __ovld __conv work_group_scan_exclusive_add(int); -int __ovld __conv work_group_scan_exclusive_min(int); -int __ovld __conv work_group_scan_exclusive_max(int); -int __ovld __conv work_group_scan_inclusive_add(int); -int __ovld __conv work_group_scan_inclusive_min(int); -int __ovld __conv work_group_scan_inclusive_max(int); -uint __ovld __conv work_group_reduce_add(uint); -uint __ovld __conv work_group_reduce_min(uint); -uint __ovld __conv work_group_reduce_max(uint); -uint __ovld __conv work_group_scan_exclusive_add(uint); -uint __ovld __conv work_group_scan_exclusive_min(uint); -uint __ovld __conv work_group_scan_exclusive_max(uint); -uint __ovld __conv work_group_scan_inclusive_add(uint); -uint __ovld __conv work_group_scan_inclusive_min(uint); -uint __ovld __conv work_group_scan_inclusive_max(uint); -long __ovld __conv work_group_reduce_add(long); -long __ovld __conv work_group_reduce_min(long); -long __ovld __conv work_group_reduce_max(long); -long __ovld __conv work_group_scan_exclusive_add(long); -long __ovld __conv work_group_scan_exclusive_min(long); -long __ovld __conv work_group_scan_exclusive_max(long); -long __ovld __conv work_group_scan_inclusive_add(long); -long __ovld __conv work_group_scan_inclusive_min(long); -long __ovld __conv work_group_scan_inclusive_max(long); -ulong __ovld __conv work_group_reduce_add(ulong); -ulong __ovld __conv work_group_reduce_min(ulong); -ulong __ovld __conv work_group_reduce_max(ulong); -ulong __ovld __conv work_group_scan_exclusive_add(ulong); -ulong __ovld __conv work_group_scan_exclusive_min(ulong); -ulong __ovld __conv work_group_scan_exclusive_max(ulong); -ulong __ovld __conv work_group_scan_inclusive_add(ulong); -ulong __ovld __conv work_group_scan_inclusive_min(ulong); -ulong __ovld __conv work_group_scan_inclusive_max(ulong); -float __ovld __conv work_group_reduce_add(float); -float __ovld __conv work_group_reduce_min(float); -float __ovld __conv work_group_reduce_max(float); -float __ovld __conv work_group_scan_exclusive_add(float); -float __ovld __conv work_group_scan_exclusive_min(float); -float __ovld __conv work_group_scan_exclusive_max(float); -float __ovld __conv work_group_scan_inclusive_add(float); -float __ovld __conv work_group_scan_inclusive_min(float); -float __ovld __conv work_group_scan_inclusive_max(float); -#ifdef cl_khr_fp64 -double __ovld __conv work_group_reduce_add(double); -double __ovld __conv work_group_reduce_min(double); -double __ovld __conv work_group_reduce_max(double); -double __ovld __conv work_group_scan_exclusive_add(double); -double __ovld __conv work_group_scan_exclusive_min(double); -double __ovld __conv work_group_scan_exclusive_max(double); -double __ovld __conv work_group_scan_inclusive_add(double); -double __ovld __conv work_group_scan_inclusive_min(double); -double __ovld __conv work_group_scan_inclusive_max(double); -#endif //cl_khr_fp64 - -#endif //defined(__opencl_c_work_group_collective_functions) - -// OpenCL v2.0 s6.13.16 - Pipe Functions -#if defined(__opencl_c_pipes) -bool __ovld is_valid_reserve_id(reserve_id_t reserve_id); -#endif //defined(__opencl_c_pipes) - - -// OpenCL v2.0 s6.13.17 - Enqueue Kernels -#if defined(__OPENCL_CPP_VERSION__) || (__OPENCL_C_VERSION__ >= CL_VERSION_2_0) - -#ifdef __opencl_c_device_enqueue -ndrange_t __ovld ndrange_1D(size_t); -ndrange_t __ovld ndrange_1D(size_t, size_t); -ndrange_t __ovld ndrange_1D(size_t, size_t, size_t); - -ndrange_t __ovld ndrange_2D(const size_t[2]); -ndrange_t __ovld ndrange_2D(const size_t[2], const size_t[2]); -ndrange_t __ovld ndrange_2D(const size_t[2], const size_t[2], const size_t[2]); - -ndrange_t __ovld ndrange_3D(const size_t[3]); -ndrange_t __ovld ndrange_3D(const size_t[3], const size_t[3]); -ndrange_t __ovld ndrange_3D(const size_t[3], const size_t[3], const size_t[3]); - -int __ovld enqueue_marker(queue_t, uint, const clk_event_t*, clk_event_t*); - -void __ovld retain_event(clk_event_t); - -void __ovld release_event(clk_event_t); - -clk_event_t __ovld create_user_event(void); - -void __ovld set_user_event_status(clk_event_t e, int state); - -bool __ovld is_valid_event (clk_event_t event); - -void __ovld capture_event_profiling_info(clk_event_t, clk_profiling_info, __global void*); - -queue_t __ovld get_default_queue(void); -#endif //__opencl_c_device_enqueue -#endif //defined(__OPENCL_CPP_VERSION__) || (__OPENCL_C_VERSION__ >= CL_VERSION_2_0) - -// OpenCL Extension v2.0 s9.17 - Sub-groups - -#if defined(__opencl_subgroup_builtins) -// Shared Sub Group Functions -uint __ovld get_sub_group_size(void); -uint __ovld get_max_sub_group_size(void); -uint __ovld get_num_sub_groups(void); -#if defined(__OPENCL_CPP_VERSION__) || (__OPENCL_C_VERSION__ >= CL_VERSION_2_0) -uint __ovld get_enqueued_num_sub_groups(void); -#endif //defined(__OPENCL_CPP_VERSION__) || (__OPENCL_C_VERSION__ >= CL_VERSION_2_0) -uint __ovld get_sub_group_id(void); -uint __ovld get_sub_group_local_id(void); - -void __ovld __conv sub_group_barrier(cl_mem_fence_flags); -#if defined(__OPENCL_CPP_VERSION__) || (__OPENCL_C_VERSION__ >= CL_VERSION_2_0) -void __ovld __conv sub_group_barrier(cl_mem_fence_flags, memory_scope); -#endif //defined(__OPENCL_CPP_VERSION__) || (__OPENCL_C_VERSION__ >= CL_VERSION_2_0) - -int __ovld __conv sub_group_all(int predicate); -int __ovld __conv sub_group_any(int predicate); - -int __ovld __conv sub_group_broadcast(int , uint sub_group_local_id); -uint __ovld __conv sub_group_broadcast(uint , uint sub_group_local_id); -long __ovld __conv sub_group_broadcast(long , uint sub_group_local_id); -ulong __ovld __conv sub_group_broadcast(ulong, uint sub_group_local_id); -float __ovld __conv sub_group_broadcast(float, uint sub_group_local_id); - -int __ovld __conv sub_group_reduce_add(int ); -uint __ovld __conv sub_group_reduce_add(uint ); -long __ovld __conv sub_group_reduce_add(long ); -ulong __ovld __conv sub_group_reduce_add(ulong); -float __ovld __conv sub_group_reduce_add(float); -int __ovld __conv sub_group_reduce_min(int ); -uint __ovld __conv sub_group_reduce_min(uint ); -long __ovld __conv sub_group_reduce_min(long ); -ulong __ovld __conv sub_group_reduce_min(ulong); -float __ovld __conv sub_group_reduce_min(float); -int __ovld __conv sub_group_reduce_max(int ); -uint __ovld __conv sub_group_reduce_max(uint ); -long __ovld __conv sub_group_reduce_max(long ); -ulong __ovld __conv sub_group_reduce_max(ulong); -float __ovld __conv sub_group_reduce_max(float); - -int __ovld __conv sub_group_scan_exclusive_add(int ); -uint __ovld __conv sub_group_scan_exclusive_add(uint ); -long __ovld __conv sub_group_scan_exclusive_add(long ); -ulong __ovld __conv sub_group_scan_exclusive_add(ulong); -float __ovld __conv sub_group_scan_exclusive_add(float); -int __ovld __conv sub_group_scan_exclusive_min(int ); -uint __ovld __conv sub_group_scan_exclusive_min(uint ); -long __ovld __conv sub_group_scan_exclusive_min(long ); -ulong __ovld __conv sub_group_scan_exclusive_min(ulong); -float __ovld __conv sub_group_scan_exclusive_min(float); -int __ovld __conv sub_group_scan_exclusive_max(int ); -uint __ovld __conv sub_group_scan_exclusive_max(uint ); -long __ovld __conv sub_group_scan_exclusive_max(long ); -ulong __ovld __conv sub_group_scan_exclusive_max(ulong); -float __ovld __conv sub_group_scan_exclusive_max(float); - -int __ovld __conv sub_group_scan_inclusive_add(int ); -uint __ovld __conv sub_group_scan_inclusive_add(uint ); -long __ovld __conv sub_group_scan_inclusive_add(long ); -ulong __ovld __conv sub_group_scan_inclusive_add(ulong); -float __ovld __conv sub_group_scan_inclusive_add(float); -int __ovld __conv sub_group_scan_inclusive_min(int ); -uint __ovld __conv sub_group_scan_inclusive_min(uint ); -long __ovld __conv sub_group_scan_inclusive_min(long ); -ulong __ovld __conv sub_group_scan_inclusive_min(ulong); -float __ovld __conv sub_group_scan_inclusive_min(float); -int __ovld __conv sub_group_scan_inclusive_max(int ); -uint __ovld __conv sub_group_scan_inclusive_max(uint ); -long __ovld __conv sub_group_scan_inclusive_max(long ); -ulong __ovld __conv sub_group_scan_inclusive_max(ulong); -float __ovld __conv sub_group_scan_inclusive_max(float); - -#ifdef cl_khr_fp16 -half __ovld __conv sub_group_broadcast(half, uint sub_group_local_id); -half __ovld __conv sub_group_reduce_add(half); -half __ovld __conv sub_group_reduce_min(half); -half __ovld __conv sub_group_reduce_max(half); -half __ovld __conv sub_group_scan_exclusive_add(half); -half __ovld __conv sub_group_scan_exclusive_min(half); -half __ovld __conv sub_group_scan_exclusive_max(half); -half __ovld __conv sub_group_scan_inclusive_add(half); -half __ovld __conv sub_group_scan_inclusive_min(half); -half __ovld __conv sub_group_scan_inclusive_max(half); -#endif //cl_khr_fp16 - -#ifdef cl_khr_fp64 -double __ovld __conv sub_group_broadcast(double, uint sub_group_local_id); -double __ovld __conv sub_group_reduce_add(double); -double __ovld __conv sub_group_reduce_min(double); -double __ovld __conv sub_group_reduce_max(double); -double __ovld __conv sub_group_scan_exclusive_add(double); -double __ovld __conv sub_group_scan_exclusive_min(double); -double __ovld __conv sub_group_scan_exclusive_max(double); -double __ovld __conv sub_group_scan_inclusive_add(double); -double __ovld __conv sub_group_scan_inclusive_min(double); -double __ovld __conv sub_group_scan_inclusive_max(double); -#endif //cl_khr_fp64 - -#endif // __opencl_subgroup_builtins - -#if defined(cl_khr_subgroup_extended_types) -char __ovld __conv sub_group_broadcast( char value, uint index ); -char2 __ovld __conv sub_group_broadcast( char2 value, uint index ); -char3 __ovld __conv sub_group_broadcast( char3 value, uint index ); -char4 __ovld __conv sub_group_broadcast( char4 value, uint index ); -char8 __ovld __conv sub_group_broadcast( char8 value, uint index ); -char16 __ovld __conv sub_group_broadcast( char16 value, uint index ); - -uchar __ovld __conv sub_group_broadcast( uchar value, uint index ); -uchar2 __ovld __conv sub_group_broadcast( uchar2 value, uint index ); -uchar3 __ovld __conv sub_group_broadcast( uchar3 value, uint index ); -uchar4 __ovld __conv sub_group_broadcast( uchar4 value, uint index ); -uchar8 __ovld __conv sub_group_broadcast( uchar8 value, uint index ); -uchar16 __ovld __conv sub_group_broadcast( uchar16 value, uint index ); - -short __ovld __conv sub_group_broadcast( short value, uint index ); -short2 __ovld __conv sub_group_broadcast( short2 value, uint index ); -short3 __ovld __conv sub_group_broadcast( short3 value, uint index ); -short4 __ovld __conv sub_group_broadcast( short4 value, uint index ); -short8 __ovld __conv sub_group_broadcast( short8 value, uint index ); -short16 __ovld __conv sub_group_broadcast( short16 value, uint index ); - -ushort __ovld __conv sub_group_broadcast( ushort value, uint index ); -ushort2 __ovld __conv sub_group_broadcast( ushort2 value, uint index ); -ushort3 __ovld __conv sub_group_broadcast( ushort3 value, uint index ); -ushort4 __ovld __conv sub_group_broadcast( ushort4 value, uint index ); -ushort8 __ovld __conv sub_group_broadcast( ushort8 value, uint index ); -ushort16 __ovld __conv sub_group_broadcast( ushort16 value, uint index ); - -// scalar int broadcast is part of cl_khr_subgroups -int2 __ovld __conv sub_group_broadcast( int2 value, uint index ); -int3 __ovld __conv sub_group_broadcast( int3 value, uint index ); -int4 __ovld __conv sub_group_broadcast( int4 value, uint index ); -int8 __ovld __conv sub_group_broadcast( int8 value, uint index ); -int16 __ovld __conv sub_group_broadcast( int16 value, uint index ); - -// scalar uint broadcast is part of cl_khr_subgroups -uint2 __ovld __conv sub_group_broadcast( uint2 value, uint index ); -uint3 __ovld __conv sub_group_broadcast( uint3 value, uint index ); -uint4 __ovld __conv sub_group_broadcast( uint4 value, uint index ); -uint8 __ovld __conv sub_group_broadcast( uint8 value, uint index ); -uint16 __ovld __conv sub_group_broadcast( uint16 value, uint index ); - -// scalar long broadcast is part of cl_khr_subgroups -long2 __ovld __conv sub_group_broadcast( long2 value, uint index ); -long3 __ovld __conv sub_group_broadcast( long3 value, uint index ); -long4 __ovld __conv sub_group_broadcast( long4 value, uint index ); -long8 __ovld __conv sub_group_broadcast( long8 value, uint index ); -long16 __ovld __conv sub_group_broadcast( long16 value, uint index ); - -// scalar ulong broadcast is part of cl_khr_subgroups -ulong2 __ovld __conv sub_group_broadcast( ulong2 value, uint index ); -ulong3 __ovld __conv sub_group_broadcast( ulong3 value, uint index ); -ulong4 __ovld __conv sub_group_broadcast( ulong4 value, uint index ); -ulong8 __ovld __conv sub_group_broadcast( ulong8 value, uint index ); -ulong16 __ovld __conv sub_group_broadcast( ulong16 value, uint index ); - -// scalar float broadcast is part of cl_khr_subgroups -float2 __ovld __conv sub_group_broadcast( float2 value, uint index ); -float3 __ovld __conv sub_group_broadcast( float3 value, uint index ); -float4 __ovld __conv sub_group_broadcast( float4 value, uint index ); -float8 __ovld __conv sub_group_broadcast( float8 value, uint index ); -float16 __ovld __conv sub_group_broadcast( float16 value, uint index ); - -char __ovld __conv sub_group_reduce_add( char value ); -uchar __ovld __conv sub_group_reduce_add( uchar value ); -short __ovld __conv sub_group_reduce_add( short value ); -ushort __ovld __conv sub_group_reduce_add( ushort value ); - -char __ovld __conv sub_group_reduce_min( char value ); -uchar __ovld __conv sub_group_reduce_min( uchar value ); -short __ovld __conv sub_group_reduce_min( short value ); -ushort __ovld __conv sub_group_reduce_min( ushort value ); - -char __ovld __conv sub_group_reduce_max( char value ); -uchar __ovld __conv sub_group_reduce_max( uchar value ); -short __ovld __conv sub_group_reduce_max( short value ); -ushort __ovld __conv sub_group_reduce_max( ushort value ); - -char __ovld __conv sub_group_scan_inclusive_add( char value ); -uchar __ovld __conv sub_group_scan_inclusive_add( uchar value ); -short __ovld __conv sub_group_scan_inclusive_add( short value ); -ushort __ovld __conv sub_group_scan_inclusive_add( ushort value ); - -char __ovld __conv sub_group_scan_inclusive_min( char value ); -uchar __ovld __conv sub_group_scan_inclusive_min( uchar value ); -short __ovld __conv sub_group_scan_inclusive_min( short value ); -ushort __ovld __conv sub_group_scan_inclusive_min( ushort value ); - -char __ovld __conv sub_group_scan_inclusive_max( char value ); -uchar __ovld __conv sub_group_scan_inclusive_max( uchar value ); -short __ovld __conv sub_group_scan_inclusive_max( short value ); -ushort __ovld __conv sub_group_scan_inclusive_max( ushort value ); - -char __ovld __conv sub_group_scan_exclusive_add( char value ); -uchar __ovld __conv sub_group_scan_exclusive_add( uchar value ); -short __ovld __conv sub_group_scan_exclusive_add( short value ); -ushort __ovld __conv sub_group_scan_exclusive_add( ushort value ); - -char __ovld __conv sub_group_scan_exclusive_min( char value ); -uchar __ovld __conv sub_group_scan_exclusive_min( uchar value ); -short __ovld __conv sub_group_scan_exclusive_min( short value ); -ushort __ovld __conv sub_group_scan_exclusive_min( ushort value ); - -char __ovld __conv sub_group_scan_exclusive_max( char value ); -uchar __ovld __conv sub_group_scan_exclusive_max( uchar value ); -short __ovld __conv sub_group_scan_exclusive_max( short value ); -ushort __ovld __conv sub_group_scan_exclusive_max( ushort value ); - -#if defined(cl_khr_fp16) -// scalar half broadcast is part of cl_khr_subgroups -half2 __ovld __conv sub_group_broadcast( half2 value, uint index ); -half3 __ovld __conv sub_group_broadcast( half3 value, uint index ); -half4 __ovld __conv sub_group_broadcast( half4 value, uint index ); -half8 __ovld __conv sub_group_broadcast( half8 value, uint index ); -half16 __ovld __conv sub_group_broadcast( half16 value, uint index ); -#endif // cl_khr_fp16 - -#if defined(cl_khr_fp64) -// scalar double broadcast is part of cl_khr_subgroups -double2 __ovld __conv sub_group_broadcast( double2 value, uint index ); -double3 __ovld __conv sub_group_broadcast( double3 value, uint index ); -double4 __ovld __conv sub_group_broadcast( double4 value, uint index ); -double8 __ovld __conv sub_group_broadcast( double8 value, uint index ); -double16 __ovld __conv sub_group_broadcast( double16 value, uint index ); -#endif // cl_khr_fp64 - -#endif // cl_khr_subgroup_extended_types - -#if defined(cl_khr_subgroup_non_uniform_vote) -int __ovld sub_group_elect(void); -int __ovld sub_group_non_uniform_all( int predicate ); -int __ovld sub_group_non_uniform_any( int predicate ); - -int __ovld sub_group_non_uniform_all_equal( char value ); -int __ovld sub_group_non_uniform_all_equal( uchar value ); -int __ovld sub_group_non_uniform_all_equal( short value ); -int __ovld sub_group_non_uniform_all_equal( ushort value ); -int __ovld sub_group_non_uniform_all_equal( int value ); -int __ovld sub_group_non_uniform_all_equal( uint value ); -int __ovld sub_group_non_uniform_all_equal( long value ); -int __ovld sub_group_non_uniform_all_equal( ulong value ); -int __ovld sub_group_non_uniform_all_equal( float value ); - -#if defined(cl_khr_fp16) -int __ovld sub_group_non_uniform_all_equal( half value ); -#endif // cl_khr_fp16 - -#if defined(cl_khr_fp64) -int __ovld sub_group_non_uniform_all_equal( double value ); -#endif // cl_khr_fp64 - -#endif // cl_khr_subgroup_non_uniform_vote - -#if defined(cl_khr_subgroup_ballot) -char __ovld sub_group_non_uniform_broadcast( char value, uint index ); -char2 __ovld sub_group_non_uniform_broadcast( char2 value, uint index ); -char3 __ovld sub_group_non_uniform_broadcast( char3 value, uint index ); -char4 __ovld sub_group_non_uniform_broadcast( char4 value, uint index ); -char8 __ovld sub_group_non_uniform_broadcast( char8 value, uint index ); -char16 __ovld sub_group_non_uniform_broadcast( char16 value, uint index ); - -uchar __ovld sub_group_non_uniform_broadcast( uchar value, uint index ); -uchar2 __ovld sub_group_non_uniform_broadcast( uchar2 value, uint index ); -uchar3 __ovld sub_group_non_uniform_broadcast( uchar3 value, uint index ); -uchar4 __ovld sub_group_non_uniform_broadcast( uchar4 value, uint index ); -uchar8 __ovld sub_group_non_uniform_broadcast( uchar8 value, uint index ); -uchar16 __ovld sub_group_non_uniform_broadcast( uchar16 value, uint index ); - -short __ovld sub_group_non_uniform_broadcast( short value, uint index ); -short2 __ovld sub_group_non_uniform_broadcast( short2 value, uint index ); -short3 __ovld sub_group_non_uniform_broadcast( short3 value, uint index ); -short4 __ovld sub_group_non_uniform_broadcast( short4 value, uint index ); -short8 __ovld sub_group_non_uniform_broadcast( short8 value, uint index ); -short16 __ovld sub_group_non_uniform_broadcast( short16 value, uint index ); - -ushort __ovld sub_group_non_uniform_broadcast( ushort value, uint index ); -ushort2 __ovld sub_group_non_uniform_broadcast( ushort2 value, uint index ); -ushort3 __ovld sub_group_non_uniform_broadcast( ushort3 value, uint index ); -ushort4 __ovld sub_group_non_uniform_broadcast( ushort4 value, uint index ); -ushort8 __ovld sub_group_non_uniform_broadcast( ushort8 value, uint index ); -ushort16 __ovld sub_group_non_uniform_broadcast( ushort16 value, uint index ); - -int __ovld sub_group_non_uniform_broadcast( int value, uint index ); -int2 __ovld sub_group_non_uniform_broadcast( int2 value, uint index ); -int3 __ovld sub_group_non_uniform_broadcast( int3 value, uint index ); -int4 __ovld sub_group_non_uniform_broadcast( int4 value, uint index ); -int8 __ovld sub_group_non_uniform_broadcast( int8 value, uint index ); -int16 __ovld sub_group_non_uniform_broadcast( int16 value, uint index ); - -uint __ovld sub_group_non_uniform_broadcast( uint value, uint index ); -uint2 __ovld sub_group_non_uniform_broadcast( uint2 value, uint index ); -uint3 __ovld sub_group_non_uniform_broadcast( uint3 value, uint index ); -uint4 __ovld sub_group_non_uniform_broadcast( uint4 value, uint index ); -uint8 __ovld sub_group_non_uniform_broadcast( uint8 value, uint index ); -uint16 __ovld sub_group_non_uniform_broadcast( uint16 value, uint index ); - -long __ovld sub_group_non_uniform_broadcast( long value, uint index ); -long2 __ovld sub_group_non_uniform_broadcast( long2 value, uint index ); -long3 __ovld sub_group_non_uniform_broadcast( long3 value, uint index ); -long4 __ovld sub_group_non_uniform_broadcast( long4 value, uint index ); -long8 __ovld sub_group_non_uniform_broadcast( long8 value, uint index ); -long16 __ovld sub_group_non_uniform_broadcast( long16 value, uint index ); - -ulong __ovld sub_group_non_uniform_broadcast( ulong value, uint index ); -ulong2 __ovld sub_group_non_uniform_broadcast( ulong2 value, uint index ); -ulong3 __ovld sub_group_non_uniform_broadcast( ulong3 value, uint index ); -ulong4 __ovld sub_group_non_uniform_broadcast( ulong4 value, uint index ); -ulong8 __ovld sub_group_non_uniform_broadcast( ulong8 value, uint index ); -ulong16 __ovld sub_group_non_uniform_broadcast( ulong16 value, uint index ); - -float __ovld sub_group_non_uniform_broadcast( float value, uint index ); -float2 __ovld sub_group_non_uniform_broadcast( float2 value, uint index ); -float3 __ovld sub_group_non_uniform_broadcast( float3 value, uint index ); -float4 __ovld sub_group_non_uniform_broadcast( float4 value, uint index ); -float8 __ovld sub_group_non_uniform_broadcast( float8 value, uint index ); -float16 __ovld sub_group_non_uniform_broadcast( float16 value, uint index ); - -char __ovld sub_group_broadcast_first( char value ); -uchar __ovld sub_group_broadcast_first( uchar value ); -short __ovld sub_group_broadcast_first( short value ); -ushort __ovld sub_group_broadcast_first( ushort value ); -int __ovld sub_group_broadcast_first( int value ); -uint __ovld sub_group_broadcast_first( uint value ); -long __ovld sub_group_broadcast_first( long value ); -ulong __ovld sub_group_broadcast_first( ulong value ); -float __ovld sub_group_broadcast_first( float value ); - -uint4 __ovld sub_group_ballot( int predicate ); -int __ovld __cnfn sub_group_inverse_ballot( uint4 value ); -int __ovld __cnfn sub_group_ballot_bit_extract( uint4 value, uint index ); -uint __ovld __cnfn sub_group_ballot_bit_count( uint4 value ); - -uint __ovld sub_group_ballot_inclusive_scan( uint4 value ); -uint __ovld sub_group_ballot_exclusive_scan( uint4 value ); -uint __ovld sub_group_ballot_find_lsb( uint4 value ); -uint __ovld sub_group_ballot_find_msb( uint4 value ); - -uint4 __ovld __cnfn get_sub_group_eq_mask(void); -uint4 __ovld __cnfn get_sub_group_ge_mask(void); -uint4 __ovld __cnfn get_sub_group_gt_mask(void); -uint4 __ovld __cnfn get_sub_group_le_mask(void); -uint4 __ovld __cnfn get_sub_group_lt_mask(void); - -#if defined(cl_khr_fp16) -half __ovld sub_group_non_uniform_broadcast( half value, uint index ); -half2 __ovld sub_group_non_uniform_broadcast( half2 value, uint index ); -half3 __ovld sub_group_non_uniform_broadcast( half3 value, uint index ); -half4 __ovld sub_group_non_uniform_broadcast( half4 value, uint index ); -half8 __ovld sub_group_non_uniform_broadcast( half8 value, uint index ); -half16 __ovld sub_group_non_uniform_broadcast( half16 value, uint index ); - -half __ovld sub_group_broadcast_first( half value ); -#endif // cl_khr_fp16 - -#if defined(cl_khr_fp64) -double __ovld sub_group_non_uniform_broadcast( double value, uint index ); -double2 __ovld sub_group_non_uniform_broadcast( double2 value, uint index ); -double3 __ovld sub_group_non_uniform_broadcast( double3 value, uint index ); -double4 __ovld sub_group_non_uniform_broadcast( double4 value, uint index ); -double8 __ovld sub_group_non_uniform_broadcast( double8 value, uint index ); -double16 __ovld sub_group_non_uniform_broadcast( double16 value, uint index ); - -double __ovld sub_group_broadcast_first( double value ); -#endif // cl_khr_fp64 - -#endif // cl_khr_subgroup_ballot - -#if defined(cl_khr_subgroup_non_uniform_arithmetic) -char __ovld sub_group_non_uniform_reduce_add( char value ); -uchar __ovld sub_group_non_uniform_reduce_add( uchar value ); -short __ovld sub_group_non_uniform_reduce_add( short value ); -ushort __ovld sub_group_non_uniform_reduce_add( ushort value ); -int __ovld sub_group_non_uniform_reduce_add( int value ); -uint __ovld sub_group_non_uniform_reduce_add( uint value ); -long __ovld sub_group_non_uniform_reduce_add( long value ); -ulong __ovld sub_group_non_uniform_reduce_add( ulong value ); -float __ovld sub_group_non_uniform_reduce_add( float value ); - -char __ovld sub_group_non_uniform_reduce_mul( char value ); -uchar __ovld sub_group_non_uniform_reduce_mul( uchar value ); -short __ovld sub_group_non_uniform_reduce_mul( short value ); -ushort __ovld sub_group_non_uniform_reduce_mul( ushort value ); -int __ovld sub_group_non_uniform_reduce_mul( int value ); -uint __ovld sub_group_non_uniform_reduce_mul( uint value ); -long __ovld sub_group_non_uniform_reduce_mul( long value ); -ulong __ovld sub_group_non_uniform_reduce_mul( ulong value ); -float __ovld sub_group_non_uniform_reduce_mul( float value ); - -char __ovld sub_group_non_uniform_reduce_min( char value ); -uchar __ovld sub_group_non_uniform_reduce_min( uchar value ); -short __ovld sub_group_non_uniform_reduce_min( short value ); -ushort __ovld sub_group_non_uniform_reduce_min( ushort value ); -int __ovld sub_group_non_uniform_reduce_min( int value ); -uint __ovld sub_group_non_uniform_reduce_min( uint value ); -long __ovld sub_group_non_uniform_reduce_min( long value ); -ulong __ovld sub_group_non_uniform_reduce_min( ulong value ); -float __ovld sub_group_non_uniform_reduce_min( float value ); - -char __ovld sub_group_non_uniform_reduce_max( char value ); -uchar __ovld sub_group_non_uniform_reduce_max( uchar value ); -short __ovld sub_group_non_uniform_reduce_max( short value ); -ushort __ovld sub_group_non_uniform_reduce_max( ushort value ); -int __ovld sub_group_non_uniform_reduce_max( int value ); -uint __ovld sub_group_non_uniform_reduce_max( uint value ); -long __ovld sub_group_non_uniform_reduce_max( long value ); -ulong __ovld sub_group_non_uniform_reduce_max( ulong value ); -float __ovld sub_group_non_uniform_reduce_max( float value ); - -char __ovld sub_group_non_uniform_scan_inclusive_add( char value ); -uchar __ovld sub_group_non_uniform_scan_inclusive_add( uchar value ); -short __ovld sub_group_non_uniform_scan_inclusive_add( short value ); -ushort __ovld sub_group_non_uniform_scan_inclusive_add( ushort value ); -int __ovld sub_group_non_uniform_scan_inclusive_add( int value ); -uint __ovld sub_group_non_uniform_scan_inclusive_add( uint value ); -long __ovld sub_group_non_uniform_scan_inclusive_add( long value ); -ulong __ovld sub_group_non_uniform_scan_inclusive_add( ulong value ); -float __ovld sub_group_non_uniform_scan_inclusive_add( float value ); - -char __ovld sub_group_non_uniform_scan_inclusive_mul( char value ); -uchar __ovld sub_group_non_uniform_scan_inclusive_mul( uchar value ); -short __ovld sub_group_non_uniform_scan_inclusive_mul( short value ); -ushort __ovld sub_group_non_uniform_scan_inclusive_mul( ushort value ); -int __ovld sub_group_non_uniform_scan_inclusive_mul( int value ); -uint __ovld sub_group_non_uniform_scan_inclusive_mul( uint value ); -long __ovld sub_group_non_uniform_scan_inclusive_mul( long value ); -ulong __ovld sub_group_non_uniform_scan_inclusive_mul( ulong value ); -float __ovld sub_group_non_uniform_scan_inclusive_mul( float value ); - -char __ovld sub_group_non_uniform_scan_inclusive_min( char value ); -uchar __ovld sub_group_non_uniform_scan_inclusive_min( uchar value ); -short __ovld sub_group_non_uniform_scan_inclusive_min( short value ); -ushort __ovld sub_group_non_uniform_scan_inclusive_min( ushort value ); -int __ovld sub_group_non_uniform_scan_inclusive_min( int value ); -uint __ovld sub_group_non_uniform_scan_inclusive_min( uint value ); -long __ovld sub_group_non_uniform_scan_inclusive_min( long value ); -ulong __ovld sub_group_non_uniform_scan_inclusive_min( ulong value ); -float __ovld sub_group_non_uniform_scan_inclusive_min( float value ); - -char __ovld sub_group_non_uniform_scan_inclusive_max( char value ); -uchar __ovld sub_group_non_uniform_scan_inclusive_max( uchar value ); -short __ovld sub_group_non_uniform_scan_inclusive_max( short value ); -ushort __ovld sub_group_non_uniform_scan_inclusive_max( ushort value ); -int __ovld sub_group_non_uniform_scan_inclusive_max( int value ); -uint __ovld sub_group_non_uniform_scan_inclusive_max( uint value ); -long __ovld sub_group_non_uniform_scan_inclusive_max( long value ); -ulong __ovld sub_group_non_uniform_scan_inclusive_max( ulong value ); -float __ovld sub_group_non_uniform_scan_inclusive_max( float value ); - -char __ovld sub_group_non_uniform_scan_exclusive_add( char value ); -uchar __ovld sub_group_non_uniform_scan_exclusive_add( uchar value ); -short __ovld sub_group_non_uniform_scan_exclusive_add( short value ); -ushort __ovld sub_group_non_uniform_scan_exclusive_add( ushort value ); -int __ovld sub_group_non_uniform_scan_exclusive_add( int value ); -uint __ovld sub_group_non_uniform_scan_exclusive_add( uint value ); -long __ovld sub_group_non_uniform_scan_exclusive_add( long value ); -ulong __ovld sub_group_non_uniform_scan_exclusive_add( ulong value ); -float __ovld sub_group_non_uniform_scan_exclusive_add( float value ); - -char __ovld sub_group_non_uniform_scan_exclusive_mul( char value ); -uchar __ovld sub_group_non_uniform_scan_exclusive_mul( uchar value ); -short __ovld sub_group_non_uniform_scan_exclusive_mul( short value ); -ushort __ovld sub_group_non_uniform_scan_exclusive_mul( ushort value ); -int __ovld sub_group_non_uniform_scan_exclusive_mul( int value ); -uint __ovld sub_group_non_uniform_scan_exclusive_mul( uint value ); -long __ovld sub_group_non_uniform_scan_exclusive_mul( long value ); -ulong __ovld sub_group_non_uniform_scan_exclusive_mul( ulong value ); -float __ovld sub_group_non_uniform_scan_exclusive_mul( float value ); - -char __ovld sub_group_non_uniform_scan_exclusive_min( char value ); -uchar __ovld sub_group_non_uniform_scan_exclusive_min( uchar value ); -short __ovld sub_group_non_uniform_scan_exclusive_min( short value ); -ushort __ovld sub_group_non_uniform_scan_exclusive_min( ushort value ); -int __ovld sub_group_non_uniform_scan_exclusive_min( int value ); -uint __ovld sub_group_non_uniform_scan_exclusive_min( uint value ); -long __ovld sub_group_non_uniform_scan_exclusive_min( long value ); -ulong __ovld sub_group_non_uniform_scan_exclusive_min( ulong value ); -float __ovld sub_group_non_uniform_scan_exclusive_min( float value ); - -char __ovld sub_group_non_uniform_scan_exclusive_max( char value ); -uchar __ovld sub_group_non_uniform_scan_exclusive_max( uchar value ); -short __ovld sub_group_non_uniform_scan_exclusive_max( short value ); -ushort __ovld sub_group_non_uniform_scan_exclusive_max( ushort value ); -int __ovld sub_group_non_uniform_scan_exclusive_max( int value ); -uint __ovld sub_group_non_uniform_scan_exclusive_max( uint value ); -long __ovld sub_group_non_uniform_scan_exclusive_max( long value ); -ulong __ovld sub_group_non_uniform_scan_exclusive_max( ulong value ); -float __ovld sub_group_non_uniform_scan_exclusive_max( float value ); - -char __ovld sub_group_non_uniform_reduce_and( char value ); -uchar __ovld sub_group_non_uniform_reduce_and( uchar value ); -short __ovld sub_group_non_uniform_reduce_and( short value ); -ushort __ovld sub_group_non_uniform_reduce_and( ushort value ); -int __ovld sub_group_non_uniform_reduce_and( int value ); -uint __ovld sub_group_non_uniform_reduce_and( uint value ); -long __ovld sub_group_non_uniform_reduce_and( long value ); -ulong __ovld sub_group_non_uniform_reduce_and( ulong value ); - -char __ovld sub_group_non_uniform_reduce_or( char value ); -uchar __ovld sub_group_non_uniform_reduce_or( uchar value ); -short __ovld sub_group_non_uniform_reduce_or( short value ); -ushort __ovld sub_group_non_uniform_reduce_or( ushort value ); -int __ovld sub_group_non_uniform_reduce_or( int value ); -uint __ovld sub_group_non_uniform_reduce_or( uint value ); -long __ovld sub_group_non_uniform_reduce_or( long value ); -ulong __ovld sub_group_non_uniform_reduce_or( ulong value ); - -char __ovld sub_group_non_uniform_reduce_xor( char value ); -uchar __ovld sub_group_non_uniform_reduce_xor( uchar value ); -short __ovld sub_group_non_uniform_reduce_xor( short value ); -ushort __ovld sub_group_non_uniform_reduce_xor( ushort value ); -int __ovld sub_group_non_uniform_reduce_xor( int value ); -uint __ovld sub_group_non_uniform_reduce_xor( uint value ); -long __ovld sub_group_non_uniform_reduce_xor( long value ); -ulong __ovld sub_group_non_uniform_reduce_xor( ulong value ); - -char __ovld sub_group_non_uniform_scan_inclusive_and( char value ); -uchar __ovld sub_group_non_uniform_scan_inclusive_and( uchar value ); -short __ovld sub_group_non_uniform_scan_inclusive_and( short value ); -ushort __ovld sub_group_non_uniform_scan_inclusive_and( ushort value ); -int __ovld sub_group_non_uniform_scan_inclusive_and( int value ); -uint __ovld sub_group_non_uniform_scan_inclusive_and( uint value ); -long __ovld sub_group_non_uniform_scan_inclusive_and( long value ); -ulong __ovld sub_group_non_uniform_scan_inclusive_and( ulong value ); - -char __ovld sub_group_non_uniform_scan_inclusive_or( char value ); -uchar __ovld sub_group_non_uniform_scan_inclusive_or( uchar value ); -short __ovld sub_group_non_uniform_scan_inclusive_or( short value ); -ushort __ovld sub_group_non_uniform_scan_inclusive_or( ushort value ); -int __ovld sub_group_non_uniform_scan_inclusive_or( int value ); -uint __ovld sub_group_non_uniform_scan_inclusive_or( uint value ); -long __ovld sub_group_non_uniform_scan_inclusive_or( long value ); -ulong __ovld sub_group_non_uniform_scan_inclusive_or( ulong value ); - -char __ovld sub_group_non_uniform_scan_inclusive_xor( char value ); -uchar __ovld sub_group_non_uniform_scan_inclusive_xor( uchar value ); -short __ovld sub_group_non_uniform_scan_inclusive_xor( short value ); -ushort __ovld sub_group_non_uniform_scan_inclusive_xor( ushort value ); -int __ovld sub_group_non_uniform_scan_inclusive_xor( int value ); -uint __ovld sub_group_non_uniform_scan_inclusive_xor( uint value ); -long __ovld sub_group_non_uniform_scan_inclusive_xor( long value ); -ulong __ovld sub_group_non_uniform_scan_inclusive_xor( ulong value ); - -char __ovld sub_group_non_uniform_scan_exclusive_and( char value ); -uchar __ovld sub_group_non_uniform_scan_exclusive_and( uchar value ); -short __ovld sub_group_non_uniform_scan_exclusive_and( short value ); -ushort __ovld sub_group_non_uniform_scan_exclusive_and( ushort value ); -int __ovld sub_group_non_uniform_scan_exclusive_and( int value ); -uint __ovld sub_group_non_uniform_scan_exclusive_and( uint value ); -long __ovld sub_group_non_uniform_scan_exclusive_and( long value ); -ulong __ovld sub_group_non_uniform_scan_exclusive_and( ulong value ); - -char __ovld sub_group_non_uniform_scan_exclusive_or( char value ); -uchar __ovld sub_group_non_uniform_scan_exclusive_or( uchar value ); -short __ovld sub_group_non_uniform_scan_exclusive_or( short value ); -ushort __ovld sub_group_non_uniform_scan_exclusive_or( ushort value ); -int __ovld sub_group_non_uniform_scan_exclusive_or( int value ); -uint __ovld sub_group_non_uniform_scan_exclusive_or( uint value ); -long __ovld sub_group_non_uniform_scan_exclusive_or( long value ); -ulong __ovld sub_group_non_uniform_scan_exclusive_or( ulong value ); - -char __ovld sub_group_non_uniform_scan_exclusive_xor( char value ); -uchar __ovld sub_group_non_uniform_scan_exclusive_xor( uchar value ); -short __ovld sub_group_non_uniform_scan_exclusive_xor( short value ); -ushort __ovld sub_group_non_uniform_scan_exclusive_xor( ushort value ); -int __ovld sub_group_non_uniform_scan_exclusive_xor( int value ); -uint __ovld sub_group_non_uniform_scan_exclusive_xor( uint value ); -long __ovld sub_group_non_uniform_scan_exclusive_xor( long value ); -ulong __ovld sub_group_non_uniform_scan_exclusive_xor( ulong value ); - -int __ovld sub_group_non_uniform_reduce_logical_and( int predicate ); -int __ovld sub_group_non_uniform_reduce_logical_or( int predicate ); -int __ovld sub_group_non_uniform_reduce_logical_xor( int predicate ); - -int __ovld sub_group_non_uniform_scan_inclusive_logical_and( int predicate ); -int __ovld sub_group_non_uniform_scan_inclusive_logical_or( int predicate ); -int __ovld sub_group_non_uniform_scan_inclusive_logical_xor( int predicate ); - -int __ovld sub_group_non_uniform_scan_exclusive_logical_and( int predicate ); -int __ovld sub_group_non_uniform_scan_exclusive_logical_or( int predicate ); -int __ovld sub_group_non_uniform_scan_exclusive_logical_xor( int predicate ); - -#if defined(cl_khr_fp16) -half __ovld sub_group_non_uniform_reduce_add( half value ); -half __ovld sub_group_non_uniform_reduce_mul( half value ); -half __ovld sub_group_non_uniform_reduce_min( half value ); -half __ovld sub_group_non_uniform_reduce_max( half value ); -half __ovld sub_group_non_uniform_scan_inclusive_add( half value ); -half __ovld sub_group_non_uniform_scan_inclusive_mul( half value ); -half __ovld sub_group_non_uniform_scan_inclusive_min( half value ); -half __ovld sub_group_non_uniform_scan_inclusive_max( half value ); -half __ovld sub_group_non_uniform_scan_exclusive_add( half value ); -half __ovld sub_group_non_uniform_scan_exclusive_mul( half value ); -half __ovld sub_group_non_uniform_scan_exclusive_min( half value ); -half __ovld sub_group_non_uniform_scan_exclusive_max( half value ); -#endif // cl_khr_fp16 - -#if defined(cl_khr_fp64) -double __ovld sub_group_non_uniform_reduce_add( double value ); -double __ovld sub_group_non_uniform_reduce_mul( double value ); -double __ovld sub_group_non_uniform_reduce_min( double value ); -double __ovld sub_group_non_uniform_reduce_max( double value ); -double __ovld sub_group_non_uniform_scan_inclusive_add( double value ); -double __ovld sub_group_non_uniform_scan_inclusive_mul( double value ); -double __ovld sub_group_non_uniform_scan_inclusive_min( double value ); -double __ovld sub_group_non_uniform_scan_inclusive_max( double value ); -double __ovld sub_group_non_uniform_scan_exclusive_add( double value ); -double __ovld sub_group_non_uniform_scan_exclusive_mul( double value ); -double __ovld sub_group_non_uniform_scan_exclusive_min( double value ); -double __ovld sub_group_non_uniform_scan_exclusive_max( double value ); -#endif // cl_khr_fp64 - -#endif // cl_khr_subgroup_non_uniform_arithmetic - -#if defined(cl_khr_subgroup_shuffle) -char __ovld sub_group_shuffle( char value, uint index ); -uchar __ovld sub_group_shuffle( uchar value, uint index ); -short __ovld sub_group_shuffle( short value, uint index ); -ushort __ovld sub_group_shuffle( ushort value, uint index ); -int __ovld sub_group_shuffle( int value, uint index ); -uint __ovld sub_group_shuffle( uint value, uint index ); -long __ovld sub_group_shuffle( long value, uint index ); -ulong __ovld sub_group_shuffle( ulong value, uint index ); -float __ovld sub_group_shuffle( float value, uint index ); - -char __ovld sub_group_shuffle_xor( char value, uint mask ); -uchar __ovld sub_group_shuffle_xor( uchar value, uint mask ); -short __ovld sub_group_shuffle_xor( short value, uint mask ); -ushort __ovld sub_group_shuffle_xor( ushort value, uint mask ); -int __ovld sub_group_shuffle_xor( int value, uint mask ); -uint __ovld sub_group_shuffle_xor( uint value, uint mask ); -long __ovld sub_group_shuffle_xor( long value, uint mask ); -ulong __ovld sub_group_shuffle_xor( ulong value, uint mask ); -float __ovld sub_group_shuffle_xor( float value, uint mask ); - -#if defined(cl_khr_fp16) -half __ovld sub_group_shuffle( half value, uint index ); -half __ovld sub_group_shuffle_xor( half value, uint mask ); -#endif // cl_khr_fp16 - -#if defined(cl_khr_fp64) -double __ovld sub_group_shuffle( double value, uint index ); -double __ovld sub_group_shuffle_xor( double value, uint mask ); -#endif // cl_khr_fp64 - -#endif // cl_khr_subgroup_shuffle - -#if defined(cl_khr_subgroup_shuffle_relative) -char __ovld sub_group_shuffle_up( char value, uint delta ); -uchar __ovld sub_group_shuffle_up( uchar value, uint delta ); -short __ovld sub_group_shuffle_up( short value, uint delta ); -ushort __ovld sub_group_shuffle_up( ushort value, uint delta ); -int __ovld sub_group_shuffle_up( int value, uint delta ); -uint __ovld sub_group_shuffle_up( uint value, uint delta ); -long __ovld sub_group_shuffle_up( long value, uint delta ); -ulong __ovld sub_group_shuffle_up( ulong value, uint delta ); -float __ovld sub_group_shuffle_up( float value, uint delta ); - -char __ovld sub_group_shuffle_down( char value, uint delta ); -uchar __ovld sub_group_shuffle_down( uchar value, uint delta ); -short __ovld sub_group_shuffle_down( short value, uint delta ); -ushort __ovld sub_group_shuffle_down( ushort value, uint delta ); -int __ovld sub_group_shuffle_down( int value, uint delta ); -uint __ovld sub_group_shuffle_down( uint value, uint delta ); -long __ovld sub_group_shuffle_down( long value, uint delta ); -ulong __ovld sub_group_shuffle_down( ulong value, uint delta ); -float __ovld sub_group_shuffle_down( float value, uint delta ); - -#if defined(cl_khr_fp16) -half __ovld sub_group_shuffle_up( half value, uint delta ); -half __ovld sub_group_shuffle_down( half value, uint delta ); -#endif // cl_khr_fp16 - -#if defined(cl_khr_fp64) -double __ovld sub_group_shuffle_up( double value, uint delta ); -double __ovld sub_group_shuffle_down( double value, uint delta ); -#endif // cl_khr_fp64 - -#endif // cl_khr_subgroup_shuffle_relative - -#if defined(cl_khr_subgroup_clustered_reduce) -char __ovld sub_group_clustered_reduce_add( char value, uint clustersize ); -uchar __ovld sub_group_clustered_reduce_add( uchar value, uint clustersize ); -short __ovld sub_group_clustered_reduce_add( short value, uint clustersize ); -ushort __ovld sub_group_clustered_reduce_add( ushort value, uint clustersize ); -int __ovld sub_group_clustered_reduce_add( int value, uint clustersize ); -uint __ovld sub_group_clustered_reduce_add( uint value, uint clustersize ); -long __ovld sub_group_clustered_reduce_add( long value, uint clustersize ); -ulong __ovld sub_group_clustered_reduce_add( ulong value, uint clustersize ); -float __ovld sub_group_clustered_reduce_add( float value, uint clustersize ); - -char __ovld sub_group_clustered_reduce_mul( char value, uint clustersize ); -uchar __ovld sub_group_clustered_reduce_mul( uchar value, uint clustersize ); -short __ovld sub_group_clustered_reduce_mul( short value, uint clustersize ); -ushort __ovld sub_group_clustered_reduce_mul( ushort value, uint clustersize ); -int __ovld sub_group_clustered_reduce_mul( int value, uint clustersize ); -uint __ovld sub_group_clustered_reduce_mul( uint value, uint clustersize ); -long __ovld sub_group_clustered_reduce_mul( long value, uint clustersize ); -ulong __ovld sub_group_clustered_reduce_mul( ulong value, uint clustersize ); -float __ovld sub_group_clustered_reduce_mul( float value, uint clustersize ); - -char __ovld sub_group_clustered_reduce_min( char value, uint clustersize ); -uchar __ovld sub_group_clustered_reduce_min( uchar value, uint clustersize ); -short __ovld sub_group_clustered_reduce_min( short value, uint clustersize ); -ushort __ovld sub_group_clustered_reduce_min( ushort value, uint clustersize ); -int __ovld sub_group_clustered_reduce_min( int value, uint clustersize ); -uint __ovld sub_group_clustered_reduce_min( uint value, uint clustersize ); -long __ovld sub_group_clustered_reduce_min( long value, uint clustersize ); -ulong __ovld sub_group_clustered_reduce_min( ulong value, uint clustersize ); -float __ovld sub_group_clustered_reduce_min( float value, uint clustersize ); - -char __ovld sub_group_clustered_reduce_max( char value, uint clustersize ); -uchar __ovld sub_group_clustered_reduce_max( uchar value, uint clustersize ); -short __ovld sub_group_clustered_reduce_max( short value, uint clustersize ); -ushort __ovld sub_group_clustered_reduce_max( ushort value, uint clustersize ); -int __ovld sub_group_clustered_reduce_max( int value, uint clustersize ); -uint __ovld sub_group_clustered_reduce_max( uint value, uint clustersize ); -long __ovld sub_group_clustered_reduce_max( long value, uint clustersize ); -ulong __ovld sub_group_clustered_reduce_max( ulong value, uint clustersize ); -float __ovld sub_group_clustered_reduce_max( float value, uint clustersize ); - -char __ovld sub_group_clustered_reduce_and( char value, uint clustersize ); -uchar __ovld sub_group_clustered_reduce_and( uchar value, uint clustersize ); -short __ovld sub_group_clustered_reduce_and( short value, uint clustersize ); -ushort __ovld sub_group_clustered_reduce_and( ushort value, uint clustersize ); -int __ovld sub_group_clustered_reduce_and( int value, uint clustersize ); -uint __ovld sub_group_clustered_reduce_and( uint value, uint clustersize ); -long __ovld sub_group_clustered_reduce_and( long value, uint clustersize ); -ulong __ovld sub_group_clustered_reduce_and( ulong value, uint clustersize ); - -char __ovld sub_group_clustered_reduce_or( char value, uint clustersize ); -uchar __ovld sub_group_clustered_reduce_or( uchar value, uint clustersize ); -short __ovld sub_group_clustered_reduce_or( short value, uint clustersize ); -ushort __ovld sub_group_clustered_reduce_or( ushort value, uint clustersize ); -int __ovld sub_group_clustered_reduce_or( int value, uint clustersize ); -uint __ovld sub_group_clustered_reduce_or( uint value, uint clustersize ); -long __ovld sub_group_clustered_reduce_or( long value, uint clustersize ); -ulong __ovld sub_group_clustered_reduce_or( ulong value, uint clustersize ); - -char __ovld sub_group_clustered_reduce_xor( char value, uint clustersize ); -uchar __ovld sub_group_clustered_reduce_xor( uchar value, uint clustersize ); -short __ovld sub_group_clustered_reduce_xor( short value, uint clustersize ); -ushort __ovld sub_group_clustered_reduce_xor( ushort value, uint clustersize ); -int __ovld sub_group_clustered_reduce_xor( int value, uint clustersize ); -uint __ovld sub_group_clustered_reduce_xor( uint value, uint clustersize ); -long __ovld sub_group_clustered_reduce_xor( long value, uint clustersize ); -ulong __ovld sub_group_clustered_reduce_xor( ulong value, uint clustersize ); - -int __ovld sub_group_clustered_reduce_logical_and( int predicate, uint clustersize ); -int __ovld sub_group_clustered_reduce_logical_or( int predicate, uint clustersize ); -int __ovld sub_group_clustered_reduce_logical_xor( int predicate, uint clustersize ); - -#if defined(cl_khr_fp16) -half __ovld sub_group_clustered_reduce_add( half value, uint clustersize ); -half __ovld sub_group_clustered_reduce_mul( half value, uint clustersize ); -half __ovld sub_group_clustered_reduce_min( half value, uint clustersize ); -half __ovld sub_group_clustered_reduce_max( half value, uint clustersize ); -#endif // cl_khr_fp16 - -#if defined(cl_khr_fp64) -double __ovld sub_group_clustered_reduce_add( double value, uint clustersize ); -double __ovld sub_group_clustered_reduce_mul( double value, uint clustersize ); -double __ovld sub_group_clustered_reduce_min( double value, uint clustersize ); -double __ovld sub_group_clustered_reduce_max( double value, uint clustersize ); -#endif // cl_khr_fp64 - -#endif // cl_khr_subgroup_clustered_reduce - -#if defined(cl_khr_extended_bit_ops) -char __ovld __cnfn bitfield_insert(char, char, uint, uint); -uchar __ovld __cnfn bitfield_insert(uchar, uchar, uint, uint); -short __ovld __cnfn bitfield_insert(short, short, uint, uint); -ushort __ovld __cnfn bitfield_insert(ushort, ushort, uint, uint); -int __ovld __cnfn bitfield_insert(int, int, uint, uint); -uint __ovld __cnfn bitfield_insert(uint, uint, uint, uint); -long __ovld __cnfn bitfield_insert(long, long, uint, uint); -ulong __ovld __cnfn bitfield_insert(ulong, ulong, uint, uint); -char2 __ovld __cnfn bitfield_insert(char2, char2, uint, uint); -uchar2 __ovld __cnfn bitfield_insert(uchar2, uchar2, uint, uint); -short2 __ovld __cnfn bitfield_insert(short2, short2, uint, uint); -ushort2 __ovld __cnfn bitfield_insert(ushort2, ushort2, uint, uint); -int2 __ovld __cnfn bitfield_insert(int2, int2, uint, uint); -uint2 __ovld __cnfn bitfield_insert(uint2, uint2, uint, uint); -long2 __ovld __cnfn bitfield_insert(long2, long2, uint, uint); -ulong2 __ovld __cnfn bitfield_insert(ulong2, ulong2, uint, uint); -char3 __ovld __cnfn bitfield_insert(char3, char3, uint, uint); -uchar3 __ovld __cnfn bitfield_insert(uchar3, uchar3, uint, uint); -short3 __ovld __cnfn bitfield_insert(short3, short3, uint, uint); -ushort3 __ovld __cnfn bitfield_insert(ushort3, ushort3, uint, uint); -int3 __ovld __cnfn bitfield_insert(int3, int3, uint, uint); -uint3 __ovld __cnfn bitfield_insert(uint3, uint3, uint, uint); -long3 __ovld __cnfn bitfield_insert(long3, long3, uint, uint); -ulong3 __ovld __cnfn bitfield_insert(ulong3, ulong3, uint, uint); -char4 __ovld __cnfn bitfield_insert(char4, char4, uint, uint); -uchar4 __ovld __cnfn bitfield_insert(uchar4, uchar4, uint, uint); -short4 __ovld __cnfn bitfield_insert(short4, short4, uint, uint); -ushort4 __ovld __cnfn bitfield_insert(ushort4, ushort4, uint, uint); -int4 __ovld __cnfn bitfield_insert(int4, int4, uint, uint); -uint4 __ovld __cnfn bitfield_insert(uint4, uint4, uint, uint); -long4 __ovld __cnfn bitfield_insert(long4, long4, uint, uint); -ulong4 __ovld __cnfn bitfield_insert(ulong4, ulong4, uint, uint); -char8 __ovld __cnfn bitfield_insert(char8, char8, uint, uint); -uchar8 __ovld __cnfn bitfield_insert(uchar8, uchar8, uint, uint); -short8 __ovld __cnfn bitfield_insert(short8, short8, uint, uint); -ushort8 __ovld __cnfn bitfield_insert(ushort8, ushort8, uint, uint); -int8 __ovld __cnfn bitfield_insert(int8, int8, uint, uint); -uint8 __ovld __cnfn bitfield_insert(uint8, uint8, uint, uint); -long8 __ovld __cnfn bitfield_insert(long8, long8, uint, uint); -ulong8 __ovld __cnfn bitfield_insert(ulong8, ulong8, uint, uint); -char16 __ovld __cnfn bitfield_insert(char16, char16, uint, uint); -uchar16 __ovld __cnfn bitfield_insert(uchar16, uchar16, uint, uint); -short16 __ovld __cnfn bitfield_insert(short16, short16, uint, uint); -ushort16 __ovld __cnfn bitfield_insert(ushort16, ushort16, uint, uint); -int16 __ovld __cnfn bitfield_insert(int16, int16, uint, uint); -uint16 __ovld __cnfn bitfield_insert(uint16, uint16, uint, uint); -long16 __ovld __cnfn bitfield_insert(long16, long16, uint, uint); -ulong16 __ovld __cnfn bitfield_insert(ulong16, ulong16, uint, uint); - -char __ovld __cnfn bitfield_extract_signed(char, uint, uint); -short __ovld __cnfn bitfield_extract_signed(short, uint, uint); -int __ovld __cnfn bitfield_extract_signed(int, uint, uint); -long __ovld __cnfn bitfield_extract_signed(long, uint, uint); -char2 __ovld __cnfn bitfield_extract_signed(char2, uint, uint); -short2 __ovld __cnfn bitfield_extract_signed(short2, uint, uint); -int2 __ovld __cnfn bitfield_extract_signed(int2, uint, uint); -long2 __ovld __cnfn bitfield_extract_signed(long2, uint, uint); -char3 __ovld __cnfn bitfield_extract_signed(char3, uint, uint); -short3 __ovld __cnfn bitfield_extract_signed(short3, uint, uint); -int3 __ovld __cnfn bitfield_extract_signed(int3, uint, uint); -long3 __ovld __cnfn bitfield_extract_signed(long3, uint, uint); -char4 __ovld __cnfn bitfield_extract_signed(char4, uint, uint); -short4 __ovld __cnfn bitfield_extract_signed(short4, uint, uint); -int4 __ovld __cnfn bitfield_extract_signed(int4, uint, uint); -long4 __ovld __cnfn bitfield_extract_signed(long4, uint, uint); -char8 __ovld __cnfn bitfield_extract_signed(char8, uint, uint); -short8 __ovld __cnfn bitfield_extract_signed(short8, uint, uint); -int8 __ovld __cnfn bitfield_extract_signed(int8, uint, uint); -long8 __ovld __cnfn bitfield_extract_signed(long8, uint, uint); -char16 __ovld __cnfn bitfield_extract_signed(char16, uint, uint); -short16 __ovld __cnfn bitfield_extract_signed(short16, uint, uint); -int16 __ovld __cnfn bitfield_extract_signed(int16, uint, uint); -long16 __ovld __cnfn bitfield_extract_signed(long16, uint, uint); - -char __ovld __cnfn bitfield_extract_signed(uchar, uint, uint); -short __ovld __cnfn bitfield_extract_signed(ushort, uint, uint); -int __ovld __cnfn bitfield_extract_signed(uint, uint, uint); -long __ovld __cnfn bitfield_extract_signed(ulong, uint, uint); -char2 __ovld __cnfn bitfield_extract_signed(uchar2, uint, uint); -short2 __ovld __cnfn bitfield_extract_signed(ushort2, uint, uint); -int2 __ovld __cnfn bitfield_extract_signed(uint2, uint, uint); -long2 __ovld __cnfn bitfield_extract_signed(ulong2, uint, uint); -char3 __ovld __cnfn bitfield_extract_signed(uchar3, uint, uint); -short3 __ovld __cnfn bitfield_extract_signed(ushort3, uint, uint); -int3 __ovld __cnfn bitfield_extract_signed(uint3, uint, uint); -long3 __ovld __cnfn bitfield_extract_signed(ulong3, uint, uint); -char4 __ovld __cnfn bitfield_extract_signed(uchar4, uint, uint); -short4 __ovld __cnfn bitfield_extract_signed(ushort4, uint, uint); -int4 __ovld __cnfn bitfield_extract_signed(uint4, uint, uint); -long4 __ovld __cnfn bitfield_extract_signed(ulong4, uint, uint); -char8 __ovld __cnfn bitfield_extract_signed(uchar8, uint, uint); -short8 __ovld __cnfn bitfield_extract_signed(ushort8, uint, uint); -int8 __ovld __cnfn bitfield_extract_signed(uint8, uint, uint); -long8 __ovld __cnfn bitfield_extract_signed(ulong8, uint, uint); -char16 __ovld __cnfn bitfield_extract_signed(uchar16, uint, uint); -short16 __ovld __cnfn bitfield_extract_signed(ushort16, uint, uint); -int16 __ovld __cnfn bitfield_extract_signed(uint16, uint, uint); -long16 __ovld __cnfn bitfield_extract_signed(ulong16, uint, uint); - -uchar __ovld __cnfn bitfield_extract_unsigned(char, uint, uint); -ushort __ovld __cnfn bitfield_extract_unsigned(short, uint, uint); -uint __ovld __cnfn bitfield_extract_unsigned(int, uint, uint); -ulong __ovld __cnfn bitfield_extract_unsigned(long, uint, uint); -uchar2 __ovld __cnfn bitfield_extract_unsigned(char2, uint, uint); -ushort2 __ovld __cnfn bitfield_extract_unsigned(short2, uint, uint); -uint2 __ovld __cnfn bitfield_extract_unsigned(int2, uint, uint); -ulong2 __ovld __cnfn bitfield_extract_unsigned(long2, uint, uint); -uchar3 __ovld __cnfn bitfield_extract_unsigned(char3, uint, uint); -ushort3 __ovld __cnfn bitfield_extract_unsigned(short3, uint, uint); -uint3 __ovld __cnfn bitfield_extract_unsigned(int3, uint, uint); -ulong3 __ovld __cnfn bitfield_extract_unsigned(long3, uint, uint); -uchar4 __ovld __cnfn bitfield_extract_unsigned(char4, uint, uint); -ushort4 __ovld __cnfn bitfield_extract_unsigned(short4, uint, uint); -uint4 __ovld __cnfn bitfield_extract_unsigned(int4, uint, uint); -ulong4 __ovld __cnfn bitfield_extract_unsigned(long4, uint, uint); -uchar8 __ovld __cnfn bitfield_extract_unsigned(char8, uint, uint); -ushort8 __ovld __cnfn bitfield_extract_unsigned(short8, uint, uint); -uint8 __ovld __cnfn bitfield_extract_unsigned(int8, uint, uint); -ulong8 __ovld __cnfn bitfield_extract_unsigned(long8, uint, uint); -uchar16 __ovld __cnfn bitfield_extract_unsigned(char16, uint, uint); -ushort16 __ovld __cnfn bitfield_extract_unsigned(short16, uint, uint); -uint16 __ovld __cnfn bitfield_extract_unsigned(int16, uint, uint); -ulong16 __ovld __cnfn bitfield_extract_unsigned(long16, uint, uint); - -uchar __ovld __cnfn bitfield_extract_unsigned(uchar, uint, uint); -ushort __ovld __cnfn bitfield_extract_unsigned(ushort, uint, uint); -uint __ovld __cnfn bitfield_extract_unsigned(uint, uint, uint); -ulong __ovld __cnfn bitfield_extract_unsigned(ulong, uint, uint); -uchar2 __ovld __cnfn bitfield_extract_unsigned(uchar2, uint, uint); -ushort2 __ovld __cnfn bitfield_extract_unsigned(ushort2, uint, uint); -uint2 __ovld __cnfn bitfield_extract_unsigned(uint2, uint, uint); -ulong2 __ovld __cnfn bitfield_extract_unsigned(ulong2, uint, uint); -uchar3 __ovld __cnfn bitfield_extract_unsigned(uchar3, uint, uint); -ushort3 __ovld __cnfn bitfield_extract_unsigned(ushort3, uint, uint); -uint3 __ovld __cnfn bitfield_extract_unsigned(uint3, uint, uint); -ulong3 __ovld __cnfn bitfield_extract_unsigned(ulong3, uint, uint); -uchar4 __ovld __cnfn bitfield_extract_unsigned(uchar4, uint, uint); -ushort4 __ovld __cnfn bitfield_extract_unsigned(ushort4, uint, uint); -uint4 __ovld __cnfn bitfield_extract_unsigned(uint4, uint, uint); -ulong4 __ovld __cnfn bitfield_extract_unsigned(ulong4, uint, uint); -uchar8 __ovld __cnfn bitfield_extract_unsigned(uchar8, uint, uint); -ushort8 __ovld __cnfn bitfield_extract_unsigned(ushort8, uint, uint); -uint8 __ovld __cnfn bitfield_extract_unsigned(uint8, uint, uint); -ulong8 __ovld __cnfn bitfield_extract_unsigned(ulong8, uint, uint); -uchar16 __ovld __cnfn bitfield_extract_unsigned(uchar16, uint, uint); -ushort16 __ovld __cnfn bitfield_extract_unsigned(ushort16, uint, uint); -uint16 __ovld __cnfn bitfield_extract_unsigned(uint16, uint, uint); -ulong16 __ovld __cnfn bitfield_extract_unsigned(ulong16, uint, uint); - -char __ovld __cnfn bit_reverse(char); -uchar __ovld __cnfn bit_reverse(uchar); -short __ovld __cnfn bit_reverse(short); -ushort __ovld __cnfn bit_reverse(ushort); -int __ovld __cnfn bit_reverse(int); -uint __ovld __cnfn bit_reverse(uint); -long __ovld __cnfn bit_reverse(long); -ulong __ovld __cnfn bit_reverse(ulong); -char2 __ovld __cnfn bit_reverse(char2); -uchar2 __ovld __cnfn bit_reverse(uchar2); -short2 __ovld __cnfn bit_reverse(short2); -ushort2 __ovld __cnfn bit_reverse(ushort2); -int2 __ovld __cnfn bit_reverse(int2); -uint2 __ovld __cnfn bit_reverse(uint2); -long2 __ovld __cnfn bit_reverse(long2); -ulong2 __ovld __cnfn bit_reverse(ulong2); -char3 __ovld __cnfn bit_reverse(char3); -uchar3 __ovld __cnfn bit_reverse(uchar3); -short3 __ovld __cnfn bit_reverse(short3); -ushort3 __ovld __cnfn bit_reverse(ushort3); -int3 __ovld __cnfn bit_reverse(int3); -uint3 __ovld __cnfn bit_reverse(uint3); -long3 __ovld __cnfn bit_reverse(long3); -ulong3 __ovld __cnfn bit_reverse(ulong3); -char4 __ovld __cnfn bit_reverse(char4); -uchar4 __ovld __cnfn bit_reverse(uchar4); -short4 __ovld __cnfn bit_reverse(short4); -ushort4 __ovld __cnfn bit_reverse(ushort4); -int4 __ovld __cnfn bit_reverse(int4); -uint4 __ovld __cnfn bit_reverse(uint4); -long4 __ovld __cnfn bit_reverse(long4); -ulong4 __ovld __cnfn bit_reverse(ulong4); -char8 __ovld __cnfn bit_reverse(char8); -uchar8 __ovld __cnfn bit_reverse(uchar8); -short8 __ovld __cnfn bit_reverse(short8); -ushort8 __ovld __cnfn bit_reverse(ushort8); -int8 __ovld __cnfn bit_reverse(int8); -uint8 __ovld __cnfn bit_reverse(uint8); -long8 __ovld __cnfn bit_reverse(long8); -ulong8 __ovld __cnfn bit_reverse(ulong8); -char16 __ovld __cnfn bit_reverse(char16); -uchar16 __ovld __cnfn bit_reverse(uchar16); -short16 __ovld __cnfn bit_reverse(short16); -ushort16 __ovld __cnfn bit_reverse(ushort16); -int16 __ovld __cnfn bit_reverse(int16); -uint16 __ovld __cnfn bit_reverse(uint16); -long16 __ovld __cnfn bit_reverse(long16); -ulong16 __ovld __cnfn bit_reverse(ulong16); -#endif // cl_khr_extended_bit_ops - -#if defined(__opencl_c_integer_dot_product_input_4x8bit) -uint __ovld __cnfn dot(uchar4, uchar4); -int __ovld __cnfn dot(char4, char4); -int __ovld __cnfn dot(uchar4, char4); -int __ovld __cnfn dot(char4, uchar4); - -uint __ovld __cnfn dot_acc_sat(uchar4, uchar4, uint); -int __ovld __cnfn dot_acc_sat(char4, char4, int); -int __ovld __cnfn dot_acc_sat(uchar4, char4, int); -int __ovld __cnfn dot_acc_sat(char4, uchar4, int); -#endif // __opencl_c_integer_dot_product_input_4x8bit - -#if defined(__opencl_c_integer_dot_product_input_4x8bit_packed) -uint __ovld __cnfn dot_4x8packed_uu_uint(uint, uint); -int __ovld __cnfn dot_4x8packed_ss_int(uint, uint); -int __ovld __cnfn dot_4x8packed_us_int(uint, uint); -int __ovld __cnfn dot_4x8packed_su_int(uint, uint); - -uint __ovld __cnfn dot_acc_sat_4x8packed_uu_uint(uint, uint, uint); -int __ovld __cnfn dot_acc_sat_4x8packed_ss_int(uint, uint, int); -int __ovld __cnfn dot_acc_sat_4x8packed_us_int(uint, uint, int); -int __ovld __cnfn dot_acc_sat_4x8packed_su_int(uint, uint, int); -#endif // __opencl_c_integer_dot_product_input_4x8bit_packed - -#if defined(cl_khr_subgroup_rotate) -char __ovld __conv sub_group_rotate(char, int); -uchar __ovld __conv sub_group_rotate(uchar, int); -short __ovld __conv sub_group_rotate(short, int); -ushort __ovld __conv sub_group_rotate(ushort, int); -int __ovld __conv sub_group_rotate(int, int); -uint __ovld __conv sub_group_rotate(uint, int); -long __ovld __conv sub_group_rotate(long, int); -ulong __ovld __conv sub_group_rotate(ulong, int); -float __ovld __conv sub_group_rotate(float, int); -#if defined(cl_khr_fp64) -double __ovld __conv sub_group_rotate(double, int); -#endif // cl_khr_fp64 -#if defined(cl_khr_fp16) -half __ovld __conv sub_group_rotate(half, int); -#endif // cl_khr_fp16 - -char __ovld __conv sub_group_clustered_rotate(char, int, uint); -uchar __ovld __conv sub_group_clustered_rotate(uchar, int, uint); -short __ovld __conv sub_group_clustered_rotate(short, int, uint); -ushort __ovld __conv sub_group_clustered_rotate(ushort, int, uint); -int __ovld __conv sub_group_clustered_rotate(int, int, uint); -uint __ovld __conv sub_group_clustered_rotate(uint, int, uint); -long __ovld __conv sub_group_clustered_rotate(long, int, uint); -ulong __ovld __conv sub_group_clustered_rotate(ulong, int, uint); -float __ovld __conv sub_group_clustered_rotate(float, int, uint); -#if defined(cl_khr_fp64) -double __ovld __conv sub_group_clustered_rotate(double, int, uint); -#endif // cl_khr_fp64 -#if defined(cl_khr_fp16) -half __ovld __conv sub_group_clustered_rotate(half, int, uint); -#endif // cl_khr_fp16 -#endif // cl_khr_subgroup_rotate - -#if defined(cl_intel_subgroups) -// Intel-Specific Sub Group Functions -float __ovld __conv intel_sub_group_shuffle( float , uint ); -float2 __ovld __conv intel_sub_group_shuffle( float2, uint ); -float3 __ovld __conv intel_sub_group_shuffle( float3, uint ); -float4 __ovld __conv intel_sub_group_shuffle( float4, uint ); -float8 __ovld __conv intel_sub_group_shuffle( float8, uint ); -float16 __ovld __conv intel_sub_group_shuffle( float16, uint ); - -int __ovld __conv intel_sub_group_shuffle( int , uint ); -int2 __ovld __conv intel_sub_group_shuffle( int2, uint ); -int3 __ovld __conv intel_sub_group_shuffle( int3, uint ); -int4 __ovld __conv intel_sub_group_shuffle( int4, uint ); -int8 __ovld __conv intel_sub_group_shuffle( int8, uint ); -int16 __ovld __conv intel_sub_group_shuffle( int16, uint ); - -uint __ovld __conv intel_sub_group_shuffle( uint , uint ); -uint2 __ovld __conv intel_sub_group_shuffle( uint2, uint ); -uint3 __ovld __conv intel_sub_group_shuffle( uint3, uint ); -uint4 __ovld __conv intel_sub_group_shuffle( uint4, uint ); -uint8 __ovld __conv intel_sub_group_shuffle( uint8, uint ); -uint16 __ovld __conv intel_sub_group_shuffle( uint16, uint ); - -long __ovld __conv intel_sub_group_shuffle( long, uint ); -ulong __ovld __conv intel_sub_group_shuffle( ulong, uint ); - -float __ovld __conv intel_sub_group_shuffle_down( float cur, float next, uint ); -float2 __ovld __conv intel_sub_group_shuffle_down( float2 cur, float2 next, uint ); -float3 __ovld __conv intel_sub_group_shuffle_down( float3 cur, float3 next, uint ); -float4 __ovld __conv intel_sub_group_shuffle_down( float4 cur, float4 next, uint ); -float8 __ovld __conv intel_sub_group_shuffle_down( float8 cur, float8 next, uint ); -float16 __ovld __conv intel_sub_group_shuffle_down( float16 cur, float16 next, uint ); - -int __ovld __conv intel_sub_group_shuffle_down( int cur, int next, uint ); -int2 __ovld __conv intel_sub_group_shuffle_down( int2 cur, int2 next, uint ); -int3 __ovld __conv intel_sub_group_shuffle_down( int3 cur, int3 next, uint ); -int4 __ovld __conv intel_sub_group_shuffle_down( int4 cur, int4 next, uint ); -int8 __ovld __conv intel_sub_group_shuffle_down( int8 cur, int8 next, uint ); -int16 __ovld __conv intel_sub_group_shuffle_down( int16 cur, int16 next, uint ); - -uint __ovld __conv intel_sub_group_shuffle_down( uint cur, uint next, uint ); -uint2 __ovld __conv intel_sub_group_shuffle_down( uint2 cur, uint2 next, uint ); -uint3 __ovld __conv intel_sub_group_shuffle_down( uint3 cur, uint3 next, uint ); -uint4 __ovld __conv intel_sub_group_shuffle_down( uint4 cur, uint4 next, uint ); -uint8 __ovld __conv intel_sub_group_shuffle_down( uint8 cur, uint8 next, uint ); -uint16 __ovld __conv intel_sub_group_shuffle_down( uint16 cur, uint16 next, uint ); - -long __ovld __conv intel_sub_group_shuffle_down( long prev, long cur, uint ); -ulong __ovld __conv intel_sub_group_shuffle_down( ulong prev, ulong cur, uint ); - -float __ovld __conv intel_sub_group_shuffle_up( float prev, float cur, uint ); -float2 __ovld __conv intel_sub_group_shuffle_up( float2 prev, float2 cur, uint ); -float3 __ovld __conv intel_sub_group_shuffle_up( float3 prev, float3 cur, uint ); -float4 __ovld __conv intel_sub_group_shuffle_up( float4 prev, float4 cur, uint ); -float8 __ovld __conv intel_sub_group_shuffle_up( float8 prev, float8 cur, uint ); -float16 __ovld __conv intel_sub_group_shuffle_up( float16 prev, float16 cur, uint ); - -int __ovld __conv intel_sub_group_shuffle_up( int prev, int cur, uint ); -int2 __ovld __conv intel_sub_group_shuffle_up( int2 prev, int2 cur, uint ); -int3 __ovld __conv intel_sub_group_shuffle_up( int3 prev, int3 cur, uint ); -int4 __ovld __conv intel_sub_group_shuffle_up( int4 prev, int4 cur, uint ); -int8 __ovld __conv intel_sub_group_shuffle_up( int8 prev, int8 cur, uint ); -int16 __ovld __conv intel_sub_group_shuffle_up( int16 prev, int16 cur, uint ); - -uint __ovld __conv intel_sub_group_shuffle_up( uint prev, uint cur, uint ); -uint2 __ovld __conv intel_sub_group_shuffle_up( uint2 prev, uint2 cur, uint ); -uint3 __ovld __conv intel_sub_group_shuffle_up( uint3 prev, uint3 cur, uint ); -uint4 __ovld __conv intel_sub_group_shuffle_up( uint4 prev, uint4 cur, uint ); -uint8 __ovld __conv intel_sub_group_shuffle_up( uint8 prev, uint8 cur, uint ); -uint16 __ovld __conv intel_sub_group_shuffle_up( uint16 prev, uint16 cur, uint ); - -long __ovld __conv intel_sub_group_shuffle_up( long prev, long cur, uint ); -ulong __ovld __conv intel_sub_group_shuffle_up( ulong prev, ulong cur, uint ); - -float __ovld __conv intel_sub_group_shuffle_xor( float , uint ); -float2 __ovld __conv intel_sub_group_shuffle_xor( float2, uint ); -float3 __ovld __conv intel_sub_group_shuffle_xor( float3, uint ); -float4 __ovld __conv intel_sub_group_shuffle_xor( float4, uint ); -float8 __ovld __conv intel_sub_group_shuffle_xor( float8, uint ); -float16 __ovld __conv intel_sub_group_shuffle_xor( float16, uint ); - -int __ovld __conv intel_sub_group_shuffle_xor( int , uint ); -int2 __ovld __conv intel_sub_group_shuffle_xor( int2, uint ); -int3 __ovld __conv intel_sub_group_shuffle_xor( int3, uint ); -int4 __ovld __conv intel_sub_group_shuffle_xor( int4, uint ); -int8 __ovld __conv intel_sub_group_shuffle_xor( int8, uint ); -int16 __ovld __conv intel_sub_group_shuffle_xor( int16, uint ); - -uint __ovld __conv intel_sub_group_shuffle_xor( uint , uint ); -uint2 __ovld __conv intel_sub_group_shuffle_xor( uint2, uint ); -uint3 __ovld __conv intel_sub_group_shuffle_xor( uint3, uint ); -uint4 __ovld __conv intel_sub_group_shuffle_xor( uint4, uint ); -uint8 __ovld __conv intel_sub_group_shuffle_xor( uint8, uint ); -uint16 __ovld __conv intel_sub_group_shuffle_xor( uint16, uint ); - -long __ovld __conv intel_sub_group_shuffle_xor( long, uint ); -ulong __ovld __conv intel_sub_group_shuffle_xor( ulong, uint ); - -#if defined(__opencl_c_images) -uint __ovld __conv intel_sub_group_block_read(read_only image2d_t, int2); -uint2 __ovld __conv intel_sub_group_block_read2(read_only image2d_t, int2); -uint4 __ovld __conv intel_sub_group_block_read4(read_only image2d_t, int2); -uint8 __ovld __conv intel_sub_group_block_read8(read_only image2d_t, int2); - -#if defined(__opencl_c_read_write_images) -uint __ovld __conv intel_sub_group_block_read(read_write image2d_t, int2); -uint2 __ovld __conv intel_sub_group_block_read2(read_write image2d_t, int2); -uint4 __ovld __conv intel_sub_group_block_read4(read_write image2d_t, int2); -uint8 __ovld __conv intel_sub_group_block_read8(read_write image2d_t, int2); -#endif // defined(__opencl_c_read_write_images) -#endif - -uint __ovld __conv intel_sub_group_block_read( const __global uint* p ); -uint2 __ovld __conv intel_sub_group_block_read2( const __global uint* p ); -uint4 __ovld __conv intel_sub_group_block_read4( const __global uint* p ); -uint8 __ovld __conv intel_sub_group_block_read8( const __global uint* p ); - -#if defined(__opencl_c_images) -void __ovld __conv intel_sub_group_block_write(write_only image2d_t, int2, uint); -void __ovld __conv intel_sub_group_block_write2(write_only image2d_t, int2, uint2); -void __ovld __conv intel_sub_group_block_write4(write_only image2d_t, int2, uint4); -void __ovld __conv intel_sub_group_block_write8(write_only image2d_t, int2, uint8); - -#if defined(__opencl_c_read_write_images) -void __ovld __conv intel_sub_group_block_write(read_write image2d_t, int2, uint); -void __ovld __conv intel_sub_group_block_write2(read_write image2d_t, int2, uint2); -void __ovld __conv intel_sub_group_block_write4(read_write image2d_t, int2, uint4); -void __ovld __conv intel_sub_group_block_write8(read_write image2d_t, int2, uint8); -#endif // defined(__opencl_c_read_write_images) -#endif // defined(__opencl_c_images) - -void __ovld __conv intel_sub_group_block_write( __global uint* p, uint data ); -void __ovld __conv intel_sub_group_block_write2( __global uint* p, uint2 data ); -void __ovld __conv intel_sub_group_block_write4( __global uint* p, uint4 data ); -void __ovld __conv intel_sub_group_block_write8( __global uint* p, uint8 data ); - -#ifdef cl_khr_fp16 -half __ovld __conv intel_sub_group_shuffle( half, uint ); -half __ovld __conv intel_sub_group_shuffle_down( half prev, half cur, uint ); -half __ovld __conv intel_sub_group_shuffle_up( half prev, half cur, uint ); -half __ovld __conv intel_sub_group_shuffle_xor( half, uint ); -#endif - -#if defined(cl_khr_fp64) -double __ovld __conv intel_sub_group_shuffle( double, uint ); -double __ovld __conv intel_sub_group_shuffle_down( double prev, double cur, uint ); -double __ovld __conv intel_sub_group_shuffle_up( double prev, double cur, uint ); -double __ovld __conv intel_sub_group_shuffle_xor( double, uint ); -#endif - -#endif //cl_intel_subgroups - -#if defined(cl_intel_subgroups_short) -short __ovld __conv intel_sub_group_broadcast( short , uint sub_group_local_id ); -short2 __ovld __conv intel_sub_group_broadcast( short2, uint sub_group_local_id ); -short3 __ovld __conv intel_sub_group_broadcast( short3, uint sub_group_local_id ); -short4 __ovld __conv intel_sub_group_broadcast( short4, uint sub_group_local_id ); -short8 __ovld __conv intel_sub_group_broadcast( short8, uint sub_group_local_id ); - -ushort __ovld __conv intel_sub_group_broadcast( ushort , uint sub_group_local_id ); -ushort2 __ovld __conv intel_sub_group_broadcast( ushort2, uint sub_group_local_id ); -ushort3 __ovld __conv intel_sub_group_broadcast( ushort3, uint sub_group_local_id ); -ushort4 __ovld __conv intel_sub_group_broadcast( ushort4, uint sub_group_local_id ); -ushort8 __ovld __conv intel_sub_group_broadcast( ushort8, uint sub_group_local_id ); - -short __ovld __conv intel_sub_group_shuffle( short , uint ); -short2 __ovld __conv intel_sub_group_shuffle( short2 , uint ); -short3 __ovld __conv intel_sub_group_shuffle( short3 , uint ); -short4 __ovld __conv intel_sub_group_shuffle( short4 , uint ); -short8 __ovld __conv intel_sub_group_shuffle( short8 , uint ); -short16 __ovld __conv intel_sub_group_shuffle( short16, uint); - -ushort __ovld __conv intel_sub_group_shuffle( ushort , uint ); -ushort2 __ovld __conv intel_sub_group_shuffle( ushort2 , uint ); -ushort3 __ovld __conv intel_sub_group_shuffle( ushort3 , uint ); -ushort4 __ovld __conv intel_sub_group_shuffle( ushort4 , uint ); -ushort8 __ovld __conv intel_sub_group_shuffle( ushort8 , uint ); -ushort16 __ovld __conv intel_sub_group_shuffle( ushort16, uint ); - -short __ovld __conv intel_sub_group_shuffle_down( short cur, short next, uint ); -short2 __ovld __conv intel_sub_group_shuffle_down( short2 cur, short2 next, uint ); -short3 __ovld __conv intel_sub_group_shuffle_down( short3 cur, short3 next, uint ); -short4 __ovld __conv intel_sub_group_shuffle_down( short4 cur, short4 next, uint ); -short8 __ovld __conv intel_sub_group_shuffle_down( short8 cur, short8 next, uint ); -short16 __ovld __conv intel_sub_group_shuffle_down( short16 cur, short16 next, uint ); - -ushort __ovld __conv intel_sub_group_shuffle_down( ushort cur, ushort next, uint ); -ushort2 __ovld __conv intel_sub_group_shuffle_down( ushort2 cur, ushort2 next, uint ); -ushort3 __ovld __conv intel_sub_group_shuffle_down( ushort3 cur, ushort3 next, uint ); -ushort4 __ovld __conv intel_sub_group_shuffle_down( ushort4 cur, ushort4 next, uint ); -ushort8 __ovld __conv intel_sub_group_shuffle_down( ushort8 cur, ushort8 next, uint ); -ushort16 __ovld __conv intel_sub_group_shuffle_down( ushort16 cur, ushort16 next, uint ); - -short __ovld __conv intel_sub_group_shuffle_up( short cur, short next, uint ); -short2 __ovld __conv intel_sub_group_shuffle_up( short2 cur, short2 next, uint ); -short3 __ovld __conv intel_sub_group_shuffle_up( short3 cur, short3 next, uint ); -short4 __ovld __conv intel_sub_group_shuffle_up( short4 cur, short4 next, uint ); -short8 __ovld __conv intel_sub_group_shuffle_up( short8 cur, short8 next, uint ); -short16 __ovld __conv intel_sub_group_shuffle_up( short16 cur, short16 next, uint ); - -ushort __ovld __conv intel_sub_group_shuffle_up( ushort cur, ushort next, uint ); -ushort2 __ovld __conv intel_sub_group_shuffle_up( ushort2 cur, ushort2 next, uint ); -ushort3 __ovld __conv intel_sub_group_shuffle_up( ushort3 cur, ushort3 next, uint ); -ushort4 __ovld __conv intel_sub_group_shuffle_up( ushort4 cur, ushort4 next, uint ); -ushort8 __ovld __conv intel_sub_group_shuffle_up( ushort8 cur, ushort8 next, uint ); -ushort16 __ovld __conv intel_sub_group_shuffle_up( ushort16 cur, ushort16 next, uint ); - -short __ovld __conv intel_sub_group_shuffle_xor( short , uint ); -short2 __ovld __conv intel_sub_group_shuffle_xor( short2 , uint ); -short3 __ovld __conv intel_sub_group_shuffle_xor( short3 , uint ); -short4 __ovld __conv intel_sub_group_shuffle_xor( short4 , uint ); -short8 __ovld __conv intel_sub_group_shuffle_xor( short8 , uint ); -short16 __ovld __conv intel_sub_group_shuffle_xor( short16, uint ); - -ushort __ovld __conv intel_sub_group_shuffle_xor( ushort , uint ); -ushort2 __ovld __conv intel_sub_group_shuffle_xor( ushort2 , uint ); -ushort3 __ovld __conv intel_sub_group_shuffle_xor( ushort3 , uint ); -ushort4 __ovld __conv intel_sub_group_shuffle_xor( ushort4 , uint ); -ushort8 __ovld __conv intel_sub_group_shuffle_xor( ushort8 , uint ); -ushort16 __ovld __conv intel_sub_group_shuffle_xor( ushort16, uint ); - -short __ovld __conv intel_sub_group_reduce_add( short x ); -ushort __ovld __conv intel_sub_group_reduce_add( ushort x ); -short __ovld __conv intel_sub_group_reduce_min( short x ); -ushort __ovld __conv intel_sub_group_reduce_min( ushort x ); -short __ovld __conv intel_sub_group_reduce_max( short x ); -ushort __ovld __conv intel_sub_group_reduce_max( ushort x ); - -short __ovld __conv intel_sub_group_scan_exclusive_add( short x ); -ushort __ovld __conv intel_sub_group_scan_exclusive_add( ushort x ); -short __ovld __conv intel_sub_group_scan_exclusive_min( short x ); -ushort __ovld __conv intel_sub_group_scan_exclusive_min( ushort x ); -short __ovld __conv intel_sub_group_scan_exclusive_max( short x ); -ushort __ovld __conv intel_sub_group_scan_exclusive_max( ushort x ); - -short __ovld __conv intel_sub_group_scan_inclusive_add( short x ); -ushort __ovld __conv intel_sub_group_scan_inclusive_add( ushort x ); -short __ovld __conv intel_sub_group_scan_inclusive_min( short x ); -ushort __ovld __conv intel_sub_group_scan_inclusive_min( ushort x ); -short __ovld __conv intel_sub_group_scan_inclusive_max( short x ); -ushort __ovld __conv intel_sub_group_scan_inclusive_max( ushort x ); - -#if defined(__opencl_c_images) -uint __ovld __conv intel_sub_group_block_read_ui(read_only image2d_t, int2); -uint2 __ovld __conv intel_sub_group_block_read_ui2(read_only image2d_t, int2); -uint4 __ovld __conv intel_sub_group_block_read_ui4(read_only image2d_t, int2); -uint8 __ovld __conv intel_sub_group_block_read_ui8(read_only image2d_t, int2); - -#if defined(__opencl_c_read_write_images) -uint __ovld __conv intel_sub_group_block_read_ui(read_write image2d_t, int2); -uint2 __ovld __conv intel_sub_group_block_read_ui2(read_write image2d_t, int2); -uint4 __ovld __conv intel_sub_group_block_read_ui4(read_write image2d_t, int2); -uint8 __ovld __conv intel_sub_group_block_read_ui8(read_write image2d_t, int2); -#endif // defined(__opencl_c_read_write_images) -#endif // defined(__opencl_c_images) - -uint __ovld __conv intel_sub_group_block_read_ui( const __global uint* p ); -uint2 __ovld __conv intel_sub_group_block_read_ui2( const __global uint* p ); -uint4 __ovld __conv intel_sub_group_block_read_ui4( const __global uint* p ); -uint8 __ovld __conv intel_sub_group_block_read_ui8( const __global uint* p ); - -#if defined(__opencl_c_images) -void __ovld __conv intel_sub_group_block_write_ui(read_only image2d_t, int2, uint); -void __ovld __conv intel_sub_group_block_write_ui2(read_only image2d_t, int2, uint2); -void __ovld __conv intel_sub_group_block_write_ui4(read_only image2d_t, int2, uint4); -void __ovld __conv intel_sub_group_block_write_ui8(read_only image2d_t, int2, uint8); - -#if defined(__opencl_c_read_write_images) -void __ovld __conv intel_sub_group_block_write_ui(read_write image2d_t, int2, uint); -void __ovld __conv intel_sub_group_block_write_ui2(read_write image2d_t, int2, uint2); -void __ovld __conv intel_sub_group_block_write_ui4(read_write image2d_t, int2, uint4); -void __ovld __conv intel_sub_group_block_write_ui8(read_write image2d_t, int2, uint8); -#endif // defined(__opencl_c_read_write_images) -#endif //defined(__opencl_c_images) - -void __ovld __conv intel_sub_group_block_write_ui( __global uint* p, uint data ); -void __ovld __conv intel_sub_group_block_write_ui2( __global uint* p, uint2 data ); -void __ovld __conv intel_sub_group_block_write_ui4( __global uint* p, uint4 data ); -void __ovld __conv intel_sub_group_block_write_ui8( __global uint* p, uint8 data ); - -#if defined(__opencl_c_images) -ushort __ovld __conv intel_sub_group_block_read_us(read_only image2d_t, int2); -ushort2 __ovld __conv intel_sub_group_block_read_us2(read_only image2d_t, int2); -ushort4 __ovld __conv intel_sub_group_block_read_us4(read_only image2d_t, int2); -ushort8 __ovld __conv intel_sub_group_block_read_us8(read_only image2d_t, int2); - -#if defined(__opencl_c_read_write_images) -ushort __ovld __conv intel_sub_group_block_read_us(read_write image2d_t, int2); -ushort2 __ovld __conv intel_sub_group_block_read_us2(read_write image2d_t, int2); -ushort4 __ovld __conv intel_sub_group_block_read_us4(read_write image2d_t, int2); -ushort8 __ovld __conv intel_sub_group_block_read_us8(read_write image2d_t, int2); -#endif // defined(__opencl_c_read_write_images) -#endif // defined(__opencl_c_images) - -ushort __ovld __conv intel_sub_group_block_read_us( const __global ushort* p ); -ushort2 __ovld __conv intel_sub_group_block_read_us2( const __global ushort* p ); -ushort4 __ovld __conv intel_sub_group_block_read_us4( const __global ushort* p ); -ushort8 __ovld __conv intel_sub_group_block_read_us8( const __global ushort* p ); - -#if defined(__opencl_c_images) -void __ovld __conv intel_sub_group_block_write_us(write_only image2d_t, int2, ushort); -void __ovld __conv intel_sub_group_block_write_us2(write_only image2d_t, int2, ushort2); -void __ovld __conv intel_sub_group_block_write_us4(write_only image2d_t, int2, ushort4); -void __ovld __conv intel_sub_group_block_write_us8(write_only image2d_t, int2, ushort8); - -#if defined(__opencl_c_read_write_images) -void __ovld __conv intel_sub_group_block_write_us(read_write image2d_t, int2, ushort); -void __ovld __conv intel_sub_group_block_write_us2(read_write image2d_t, int2, ushort2); -void __ovld __conv intel_sub_group_block_write_us4(read_write image2d_t, int2, ushort4); -void __ovld __conv intel_sub_group_block_write_us8(read_write image2d_t, int2, ushort8); -#endif // defined(__opencl_c_read_write_images) -#endif // defined(__opencl_c_images) - -void __ovld __conv intel_sub_group_block_write_us( __global ushort* p, ushort data ); -void __ovld __conv intel_sub_group_block_write_us2( __global ushort* p, ushort2 data ); -void __ovld __conv intel_sub_group_block_write_us4( __global ushort* p, ushort4 data ); -void __ovld __conv intel_sub_group_block_write_us8( __global ushort* p, ushort8 data ); -#endif // cl_intel_subgroups_short - -#ifdef cl_intel_device_side_avc_motion_estimation -#pragma OPENCL EXTENSION cl_intel_device_side_avc_motion_estimation : begin - -// MCE built-in functions -uchar __ovld -intel_sub_group_avc_mce_get_default_inter_base_multi_reference_penalty( - uchar slice_type, uchar qp); -ulong __ovld intel_sub_group_avc_mce_get_default_inter_shape_penalty( - uchar slice_type, uchar qp); -uchar __ovld intel_sub_group_avc_mce_get_default_inter_direction_penalty( - uchar slice_type, uchar qp); -uint __ovld intel_sub_group_avc_mce_get_default_intra_luma_shape_penalty( - uchar slice_type, uchar qp); -uint2 __ovld -intel_sub_group_avc_mce_get_default_inter_motion_vector_cost_table( - uchar slice_type, uchar qp); -uchar __ovld intel_sub_group_avc_mce_get_default_intra_luma_mode_penalty( - uchar slice_type, uchar qp); - -uint2 __ovld intel_sub_group_avc_mce_get_default_high_penalty_cost_table(); -uint2 __ovld intel_sub_group_avc_mce_get_default_medium_penalty_cost_table(); -uint2 __ovld intel_sub_group_avc_mce_get_default_low_penalty_cost_table(); -uint __ovld intel_sub_group_avc_mce_get_default_non_dc_luma_intra_penalty(); -uchar __ovld -intel_sub_group_avc_mce_get_default_intra_chroma_mode_base_penalty(); - -intel_sub_group_avc_mce_payload_t __ovld -intel_sub_group_avc_mce_set_inter_base_multi_reference_penalty( - uchar reference_base_penalty, intel_sub_group_avc_mce_payload_t payload); -intel_sub_group_avc_mce_payload_t __ovld -intel_sub_group_avc_mce_set_inter_shape_penalty( - ulong packed_shape_penalty, intel_sub_group_avc_mce_payload_t payload); -intel_sub_group_avc_mce_payload_t __ovld -intel_sub_group_avc_mce_set_inter_direction_penalty( - uchar direction_cost, intel_sub_group_avc_mce_payload_t payload); -intel_sub_group_avc_mce_payload_t __ovld -intel_sub_group_avc_mce_set_motion_vector_cost_function( - ulong packed_cost_center_delta, uint2 packed_cost_table, - uchar cost_precision, intel_sub_group_avc_mce_payload_t payload); -intel_sub_group_avc_mce_payload_t __ovld -intel_sub_group_avc_mce_set_ac_only_haar( - intel_sub_group_avc_mce_payload_t payload); -intel_sub_group_avc_mce_payload_t __ovld -intel_sub_group_avc_mce_set_source_interlaced_field_polarity( - uchar src_field_polarity, intel_sub_group_avc_mce_payload_t payload); -intel_sub_group_avc_mce_payload_t __ovld -intel_sub_group_avc_mce_set_single_reference_interlaced_field_polarity( - uchar ref_field_polarity, intel_sub_group_avc_mce_payload_t payload); -intel_sub_group_avc_mce_payload_t __ovld -intel_sub_group_avc_mce_set_dual_reference_interlaced_field_polarities( - uchar fwd_ref_field_polarity, uchar bwd_ref_field_polarity, - intel_sub_group_avc_mce_payload_t payload); - -ulong __ovld intel_sub_group_avc_mce_get_motion_vectors( - intel_sub_group_avc_mce_result_t result); -ushort __ovld intel_sub_group_avc_mce_get_inter_distortions( - intel_sub_group_avc_mce_result_t result); -ushort __ovld intel_sub_group_avc_mce_get_best_inter_distortion( - intel_sub_group_avc_mce_result_t result); -uchar __ovld intel_sub_group_avc_mce_get_inter_major_shape( - intel_sub_group_avc_mce_result_t result); -uchar __ovld intel_sub_group_avc_mce_get_inter_minor_shapes( - intel_sub_group_avc_mce_result_t result); -uchar __ovld intel_sub_group_avc_mce_get_inter_directions( - intel_sub_group_avc_mce_result_t result); -uchar __ovld intel_sub_group_avc_mce_get_inter_motion_vector_count( - intel_sub_group_avc_mce_result_t result); -uint __ovld intel_sub_group_avc_mce_get_inter_reference_ids( - intel_sub_group_avc_mce_result_t result); -uchar __ovld -intel_sub_group_avc_mce_get_inter_reference_interlaced_field_polarities( - uint packed_reference_ids, uint packed_reference_parameter_field_polarities, - intel_sub_group_avc_mce_result_t result); - -// IME built-in functions -intel_sub_group_avc_ime_payload_t __ovld -intel_sub_group_avc_ime_initialize( - ushort2 src_coord, uchar partition_mask, uchar sad_adjustment); -intel_sub_group_avc_ime_payload_t __ovld -intel_sub_group_avc_ime_set_single_reference( - short2 ref_offset, uchar search_window_config, - intel_sub_group_avc_ime_payload_t payload); -intel_sub_group_avc_ime_payload_t __ovld -intel_sub_group_avc_ime_set_dual_reference( - short2 fwd_ref_offset, short2 bwd_ref_offset, uchar search_window_config, - intel_sub_group_avc_ime_payload_t payload); -intel_sub_group_avc_ime_payload_t __ovld -intel_sub_group_avc_ime_set_max_motion_vector_count( - uchar max_motion_vector_count, intel_sub_group_avc_ime_payload_t payload); -intel_sub_group_avc_ime_payload_t __ovld -intel_sub_group_avc_ime_set_unidirectional_mix_disable( - intel_sub_group_avc_ime_payload_t payload); -intel_sub_group_avc_ime_payload_t __ovld -intel_sub_group_avc_ime_set_early_search_termination_threshold( - uchar threshold, intel_sub_group_avc_ime_payload_t payload); -intel_sub_group_avc_ime_payload_t __ovld -intel_sub_group_avc_ime_set_weighted_sad( - uint packed_sad_weights, intel_sub_group_avc_ime_payload_t payload); - -__attribute__((deprecated("If you use the latest Intel driver, please use " - "intel_sub_group_avc_ime_ref_window_size instead", - "intel_sub_group_avc_ime_ref_window_size"))) -ushort2 __ovld -intel_sub_group_ime_ref_window_size(uchar search_window_config, char dual_ref); -ushort2 __ovld intel_sub_group_avc_ime_ref_window_size( - uchar search_window_config, char dual_ref); -short2 __ovld intel_sub_group_avc_ime_adjust_ref_offset( - short2 ref_offset, ushort2 src_coord, ushort2 ref_window_size, - ushort2 image_size); - -#if defined(__opencl_c_images) -intel_sub_group_avc_ime_result_t __ovld -intel_sub_group_avc_ime_evaluate_with_single_reference( - read_only image2d_t src_image, read_only image2d_t ref_image, - sampler_t vme_media_sampler, intel_sub_group_avc_ime_payload_t payload); -intel_sub_group_avc_ime_result_t __ovld -intel_sub_group_avc_ime_evaluate_with_dual_reference( - read_only image2d_t src_image, read_only image2d_t fwd_ref_image, - read_only image2d_t bwd_ref_image, sampler_t vme_media_sampler, - intel_sub_group_avc_ime_payload_t payload); -intel_sub_group_avc_ime_result_single_reference_streamout_t __ovld -intel_sub_group_avc_ime_evaluate_with_single_reference_streamout( - read_only image2d_t src_image, read_only image2d_t ref_image, - sampler_t vme_media_sampler, intel_sub_group_avc_ime_payload_t payload); -intel_sub_group_avc_ime_result_dual_reference_streamout_t __ovld -intel_sub_group_avc_ime_evaluate_with_dual_reference_streamout( - read_only image2d_t src_image, read_only image2d_t fwd_ref_image, - read_only image2d_t bwd_ref_image, sampler_t vme_media_sampler, - intel_sub_group_avc_ime_payload_t payload); -intel_sub_group_avc_ime_result_t __ovld -intel_sub_group_avc_ime_evaluate_with_single_reference_streamin( - read_only image2d_t src_image, read_only image2d_t ref_image, - sampler_t vme_media_sampler, intel_sub_group_avc_ime_payload_t payload, - intel_sub_group_avc_ime_single_reference_streamin_t streamin_components); -intel_sub_group_avc_ime_result_t __ovld -intel_sub_group_avc_ime_evaluate_with_dual_reference_streamin( - read_only image2d_t src_image, read_only image2d_t fwd_ref_image, - read_only image2d_t bwd_ref_image, sampler_t vme_media_sampler, - intel_sub_group_avc_ime_payload_t payload, - intel_sub_group_avc_ime_dual_reference_streamin_t streamin_components); -intel_sub_group_avc_ime_result_single_reference_streamout_t __ovld -intel_sub_group_avc_ime_evaluate_with_single_reference_streaminout( - read_only image2d_t src_image, read_only image2d_t ref_image, - sampler_t vme_media_sampler, intel_sub_group_avc_ime_payload_t payload, - intel_sub_group_avc_ime_single_reference_streamin_t streamin_components); -intel_sub_group_avc_ime_result_dual_reference_streamout_t __ovld -intel_sub_group_avc_ime_evaluate_with_dual_reference_streaminout( - read_only image2d_t src_image, read_only image2d_t fwd_ref_image, - read_only image2d_t bwd_ref_image, sampler_t vme_media_sampler, - intel_sub_group_avc_ime_payload_t payload, - intel_sub_group_avc_ime_dual_reference_streamin_t streamin_components); -#endif - -intel_sub_group_avc_ime_single_reference_streamin_t __ovld -intel_sub_group_avc_ime_get_single_reference_streamin( - intel_sub_group_avc_ime_result_single_reference_streamout_t result); -intel_sub_group_avc_ime_dual_reference_streamin_t __ovld -intel_sub_group_avc_ime_get_dual_reference_streamin( - intel_sub_group_avc_ime_result_dual_reference_streamout_t result); -intel_sub_group_avc_ime_result_t __ovld -intel_sub_group_avc_ime_strip_single_reference_streamout( - intel_sub_group_avc_ime_result_single_reference_streamout_t result); -intel_sub_group_avc_ime_result_t __ovld -intel_sub_group_avc_ime_strip_dual_reference_streamout( - intel_sub_group_avc_ime_result_dual_reference_streamout_t result); - -uint __ovld intel_sub_group_avc_ime_get_streamout_major_shape_motion_vectors( - intel_sub_group_avc_ime_result_single_reference_streamout_t result, - uchar major_shape); -ushort __ovld intel_sub_group_avc_ime_get_streamout_major_shape_distortions( - intel_sub_group_avc_ime_result_single_reference_streamout_t result, - uchar major_shape); -uchar __ovld intel_sub_group_avc_ime_get_streamout_major_shape_reference_ids( - intel_sub_group_avc_ime_result_single_reference_streamout_t result, - uchar major_shape); -uint __ovld intel_sub_group_avc_ime_get_streamout_major_shape_motion_vectors( - intel_sub_group_avc_ime_result_dual_reference_streamout_t result, - uchar major_shape, uchar direction); -ushort __ovld intel_sub_group_avc_ime_get_streamout_major_shape_distortions( - intel_sub_group_avc_ime_result_dual_reference_streamout_t result, - uchar major_shape, uchar direction); -uchar __ovld intel_sub_group_avc_ime_get_streamout_major_shape_reference_ids( - intel_sub_group_avc_ime_result_dual_reference_streamout_t result, - uchar major_shape, uchar direction); - -uchar __ovld intel_sub_group_avc_ime_get_border_reached( - uchar image_select, intel_sub_group_avc_ime_result_t result); -uchar __ovld intel_sub_group_avc_ime_get_truncated_search_indication( - intel_sub_group_avc_ime_result_t result); -uchar __ovld -intel_sub_group_avc_ime_get_unidirectional_early_search_termination( - intel_sub_group_avc_ime_result_t result); -uint __ovld intel_sub_group_avc_ime_get_weighting_pattern_minimum_motion_vector( - intel_sub_group_avc_ime_result_t result); -ushort __ovld intel_sub_group_avc_ime_get_weighting_pattern_minimum_distortion( - intel_sub_group_avc_ime_result_t result); - -// REF built-in functions -intel_sub_group_avc_ref_payload_t __ovld -intel_sub_group_avc_fme_initialize( - ushort2 src_coord, ulong motion_vectors, uchar major_shapes, - uchar minor_shapes, uchar directions, uchar pixel_resolution, - uchar sad_adjustment); -intel_sub_group_avc_ref_payload_t __ovld -intel_sub_group_avc_bme_initialize( - ushort2 src_coord, ulong motion_vectors, uchar major_shapes, - uchar minor_shapes, uchar directions, uchar pixel_resolution, - uchar bidirectional_weight, uchar sad_adjustment); - -intel_sub_group_avc_ref_payload_t __ovld -intel_sub_group_avc_ref_set_bidirectional_mix_disable( - intel_sub_group_avc_ref_payload_t payload); -intel_sub_group_avc_ref_payload_t __ovld -intel_sub_group_avc_ref_set_bilinear_filter_enable( - intel_sub_group_avc_ref_payload_t payload); - -#if defined(__opencl_c_images) -intel_sub_group_avc_ref_result_t __ovld -intel_sub_group_avc_ref_evaluate_with_single_reference( - read_only image2d_t src_image, read_only image2d_t ref_image, - sampler_t vme_media_sampler, intel_sub_group_avc_ref_payload_t payload); -intel_sub_group_avc_ref_result_t __ovld -intel_sub_group_avc_ref_evaluate_with_dual_reference( - read_only image2d_t src_image, read_only image2d_t fwd_ref_image, - read_only image2d_t bwd_ref_image, sampler_t vme_media_sampler, - intel_sub_group_avc_ref_payload_t payload); -intel_sub_group_avc_ref_result_t __ovld -intel_sub_group_avc_ref_evaluate_with_multi_reference( - read_only image2d_t src_image, uint packed_reference_ids, - sampler_t vme_media_sampler, intel_sub_group_avc_ref_payload_t payload); -intel_sub_group_avc_ref_result_t __ovld -intel_sub_group_avc_ref_evaluate_with_multi_reference( - read_only image2d_t src_image, uint packed_reference_ids, - uchar packed_reference_field_polarities, sampler_t vme_media_sampler, - intel_sub_group_avc_ref_payload_t payload); -#endif //defined(__opencl_c_images) - -// SIC built-in functions -intel_sub_group_avc_sic_payload_t __ovld -intel_sub_group_avc_sic_initialize( - ushort2 src_coord); -intel_sub_group_avc_sic_payload_t __ovld -intel_sub_group_avc_sic_configure_skc( - uint skip_block_partition_type, uint skip_motion_vector_mask, - ulong motion_vectors, uchar bidirectional_weight, uchar skip_sad_adjustment, - intel_sub_group_avc_sic_payload_t payload); -intel_sub_group_avc_sic_payload_t __ovld intel_sub_group_avc_sic_configure_ipe( - uchar luma_intra_partition_mask, uchar intra_neighbour_availability, - uchar left_edge_luma_pixels, uchar upper_left_corner_luma_pixel, - uchar upper_edge_luma_pixels, uchar upper_right_edge_luma_pixels, - uchar intra_sad_adjustment, intel_sub_group_avc_sic_payload_t payload); -intel_sub_group_avc_sic_payload_t __ovld intel_sub_group_avc_sic_configure_ipe( - uchar luma_intra_partition_mask, uchar intra_neighbour_availability, - uchar left_edge_luma_pixels, uchar upper_left_corner_luma_pixel, - uchar upper_edge_luma_pixels, uchar upper_right_edge_luma_pixels, - ushort left_edge_chroma_pixels, ushort upper_left_corner_chroma_pixel, - ushort upper_edge_chroma_pixels, uchar intra_sad_adjustment, - intel_sub_group_avc_sic_payload_t payload); -uint __ovld -intel_sub_group_avc_sic_get_motion_vector_mask( - uint skip_block_partition_type, uchar direction); - -intel_sub_group_avc_sic_payload_t __ovld -intel_sub_group_avc_sic_set_intra_luma_shape_penalty( - uint packed_shape_cost, intel_sub_group_avc_sic_payload_t payload); -intel_sub_group_avc_sic_payload_t __ovld -intel_sub_group_avc_sic_set_intra_luma_mode_cost_function( - uchar luma_mode_penalty, uint luma_packed_neighbor_modes, - uint luma_packed_non_dc_penalty, intel_sub_group_avc_sic_payload_t payload); -intel_sub_group_avc_sic_payload_t __ovld -intel_sub_group_avc_sic_set_intra_chroma_mode_cost_function( - uchar chroma_mode_penalty, intel_sub_group_avc_sic_payload_t payload); - -intel_sub_group_avc_sic_payload_t __ovld -intel_sub_group_avc_sic_set_skc_bilinear_filter_enable( - intel_sub_group_avc_sic_payload_t payload); -intel_sub_group_avc_sic_payload_t __ovld -intel_sub_group_avc_sic_set_skc_forward_transform_enable( - ulong packed_sad_coefficients, intel_sub_group_avc_sic_payload_t payload); -intel_sub_group_avc_sic_payload_t __ovld -intel_sub_group_avc_sic_set_block_based_raw_skip_sad( - uchar block_based_skip_type, - intel_sub_group_avc_sic_payload_t payload); - -#if defined(__opencl_c_images) -intel_sub_group_avc_sic_result_t __ovld -intel_sub_group_avc_sic_evaluate_ipe( - read_only image2d_t src_image, sampler_t vme_media_sampler, - intel_sub_group_avc_sic_payload_t payload); -intel_sub_group_avc_sic_result_t __ovld -intel_sub_group_avc_sic_evaluate_with_single_reference( - read_only image2d_t src_image, read_only image2d_t ref_image, - sampler_t vme_media_sampler, intel_sub_group_avc_sic_payload_t payload); -intel_sub_group_avc_sic_result_t __ovld -intel_sub_group_avc_sic_evaluate_with_dual_reference( - read_only image2d_t src_image, read_only image2d_t fwd_ref_image, - read_only image2d_t bwd_ref_image, sampler_t vme_media_sampler, - intel_sub_group_avc_sic_payload_t payload); -intel_sub_group_avc_sic_result_t __ovld -intel_sub_group_avc_sic_evaluate_with_multi_reference( - read_only image2d_t src_image, uint packed_reference_ids, - sampler_t vme_media_sampler, intel_sub_group_avc_sic_payload_t payload); -intel_sub_group_avc_sic_result_t __ovld -intel_sub_group_avc_sic_evaluate_with_multi_reference( - read_only image2d_t src_image, uint packed_reference_ids, - uchar packed_reference_field_polarities, sampler_t vme_media_sampler, - intel_sub_group_avc_sic_payload_t payload); -#endif //defined(__opencl_c_images) - -uchar __ovld intel_sub_group_avc_sic_get_ipe_luma_shape( - intel_sub_group_avc_sic_result_t result); -ushort __ovld intel_sub_group_avc_sic_get_best_ipe_luma_distortion( - intel_sub_group_avc_sic_result_t result); -ushort __ovld intel_sub_group_avc_sic_get_best_ipe_chroma_distortion( - intel_sub_group_avc_sic_result_t result); -ulong __ovld intel_sub_group_avc_sic_get_packed_ipe_luma_modes( - intel_sub_group_avc_sic_result_t result); -uchar __ovld intel_sub_group_avc_sic_get_ipe_chroma_mode( - intel_sub_group_avc_sic_result_t result); -uint __ovld intel_sub_group_avc_sic_get_packed_skc_luma_count_threshold( - intel_sub_group_avc_sic_result_t result); -ulong __ovld intel_sub_group_avc_sic_get_packed_skc_luma_sum_threshold( - intel_sub_group_avc_sic_result_t result); -ushort __ovld intel_sub_group_avc_sic_get_inter_raw_sads( - intel_sub_group_avc_sic_result_t result); - -// Wrappers -intel_sub_group_avc_ime_payload_t __ovld -intel_sub_group_avc_ime_set_inter_base_multi_reference_penalty( - uchar reference_base_penalty, intel_sub_group_avc_ime_payload_t payload); -intel_sub_group_avc_ref_payload_t __ovld -intel_sub_group_avc_ref_set_inter_base_multi_reference_penalty( - uchar reference_base_penalty, intel_sub_group_avc_ref_payload_t payload); -intel_sub_group_avc_sic_payload_t __ovld -intel_sub_group_avc_sic_set_inter_base_multi_reference_penalty( - uchar reference_base_penalty, intel_sub_group_avc_sic_payload_t payload); - -intel_sub_group_avc_ime_payload_t __ovld -intel_sub_group_avc_ime_set_inter_shape_penalty( - ulong packed_shape_cost, intel_sub_group_avc_ime_payload_t payload); -intel_sub_group_avc_ref_payload_t __ovld -intel_sub_group_avc_ref_set_inter_shape_penalty( - ulong packed_shape_cost, intel_sub_group_avc_ref_payload_t payload); -intel_sub_group_avc_sic_payload_t __ovld -intel_sub_group_avc_sic_set_inter_shape_penalty( - ulong packed_shape_cost, intel_sub_group_avc_sic_payload_t payload); - -intel_sub_group_avc_ime_payload_t __ovld -intel_sub_group_avc_ime_set_inter_direction_penalty( - uchar direction_cost, intel_sub_group_avc_ime_payload_t payload); -intel_sub_group_avc_ref_payload_t __ovld -intel_sub_group_avc_ref_set_inter_direction_penalty( - uchar direction_cost, intel_sub_group_avc_ref_payload_t payload); -intel_sub_group_avc_sic_payload_t __ovld -intel_sub_group_avc_sic_set_inter_direction_penalty( - uchar direction_cost, intel_sub_group_avc_sic_payload_t payload); - -intel_sub_group_avc_ime_payload_t __ovld -intel_sub_group_avc_ime_set_motion_vector_cost_function( - ulong packed_cost_center_delta, uint2 packed_cost_table, - uchar cost_precision, intel_sub_group_avc_ime_payload_t payload); -intel_sub_group_avc_ref_payload_t __ovld -intel_sub_group_avc_ref_set_motion_vector_cost_function( - ulong packed_cost_center_delta, uint2 packed_cost_table, - uchar cost_precision, intel_sub_group_avc_ref_payload_t payload); -intel_sub_group_avc_sic_payload_t __ovld -intel_sub_group_avc_sic_set_motion_vector_cost_function( - ulong packed_cost_center_delta, uint2 packed_cost_table, - uchar cost_precision, intel_sub_group_avc_sic_payload_t payload); - -intel_sub_group_avc_ime_payload_t __ovld -intel_sub_group_avc_ime_set_source_interlaced_field_polarity( - uchar src_field_polarity, intel_sub_group_avc_ime_payload_t payload); -intel_sub_group_avc_ref_payload_t __ovld -intel_sub_group_avc_ref_set_source_interlaced_field_polarity( - uchar src_field_polarity, intel_sub_group_avc_ref_payload_t payload); -intel_sub_group_avc_sic_payload_t __ovld -intel_sub_group_avc_sic_set_source_interlaced_field_polarity( - uchar src_field_polarity, intel_sub_group_avc_sic_payload_t payload); - -intel_sub_group_avc_ime_payload_t __ovld -intel_sub_group_avc_ime_set_single_reference_interlaced_field_polarity( - uchar ref_field_polarity, intel_sub_group_avc_ime_payload_t payload); -intel_sub_group_avc_ref_payload_t __ovld -intel_sub_group_avc_ref_set_single_reference_interlaced_field_polarity( - uchar ref_field_polarity, intel_sub_group_avc_ref_payload_t payload); -intel_sub_group_avc_sic_payload_t __ovld -intel_sub_group_avc_sic_set_single_reference_interlaced_field_polarity( - uchar ref_field_polarity, intel_sub_group_avc_sic_payload_t payload); -intel_sub_group_avc_ime_payload_t __ovld -intel_sub_group_avc_ime_set_dual_reference_interlaced_field_polarities( - uchar fwd_ref_field_polarity, uchar bwd_ref_field_polarity, - intel_sub_group_avc_ime_payload_t payload); -intel_sub_group_avc_ref_payload_t __ovld -intel_sub_group_avc_ref_set_dual_reference_interlaced_field_polarities( - uchar fwd_ref_field_polarity, uchar bwd_ref_field_polarity, - intel_sub_group_avc_ref_payload_t payload); -intel_sub_group_avc_sic_payload_t __ovld -intel_sub_group_avc_sic_set_dual_reference_interlaced_field_polarities( - uchar fwd_ref_field_polarity, uchar bwd_ref_field_polarity, - intel_sub_group_avc_sic_payload_t payload); - -intel_sub_group_avc_ime_payload_t __ovld -intel_sub_group_avc_ime_set_ac_only_haar( - intel_sub_group_avc_ime_payload_t payload); -intel_sub_group_avc_ref_payload_t __ovld -intel_sub_group_avc_ref_set_ac_only_haar( - intel_sub_group_avc_ref_payload_t payload); -intel_sub_group_avc_sic_payload_t __ovld -intel_sub_group_avc_sic_set_ac_only_haar( - intel_sub_group_avc_sic_payload_t payload); - -ulong __ovld intel_sub_group_avc_ime_get_motion_vectors( - intel_sub_group_avc_ime_result_t result); -ulong __ovld intel_sub_group_avc_ref_get_motion_vectors( - intel_sub_group_avc_ref_result_t result); - -ushort __ovld intel_sub_group_avc_ime_get_inter_distortions( - intel_sub_group_avc_ime_result_t result); -ushort __ovld intel_sub_group_avc_ref_get_inter_distortions( - intel_sub_group_avc_ref_result_t result); -ushort __ovld intel_sub_group_avc_sic_get_inter_distortions( - intel_sub_group_avc_sic_result_t result); - -ushort __ovld intel_sub_group_avc_ime_get_best_inter_distortion( - intel_sub_group_avc_ime_result_t result); -ushort __ovld intel_sub_group_avc_ref_get_best_inter_distortion( - intel_sub_group_avc_ref_result_t result); - -uchar __ovld intel_sub_group_avc_ime_get_inter_major_shape( - intel_sub_group_avc_ime_result_t result); -uchar __ovld intel_sub_group_avc_ref_get_inter_major_shape( - intel_sub_group_avc_ref_result_t result); -uchar __ovld intel_sub_group_avc_ime_get_inter_minor_shapes( - intel_sub_group_avc_ime_result_t result); -uchar __ovld intel_sub_group_avc_ref_get_inter_minor_shapes( - intel_sub_group_avc_ref_result_t result); - -uchar __ovld intel_sub_group_avc_ime_get_inter_directions( - intel_sub_group_avc_ime_result_t result); -uchar __ovld intel_sub_group_avc_ref_get_inter_directions( - intel_sub_group_avc_ref_result_t result); - -uchar __ovld intel_sub_group_avc_ime_get_inter_motion_vector_count( - intel_sub_group_avc_ime_result_t result); -uchar __ovld intel_sub_group_avc_ref_get_inter_motion_vector_count( - intel_sub_group_avc_ref_result_t result); - -uint __ovld intel_sub_group_avc_ime_get_inter_reference_ids( - intel_sub_group_avc_ime_result_t result); -uint __ovld intel_sub_group_avc_ref_get_inter_reference_ids( - intel_sub_group_avc_ref_result_t result); - -uchar __ovld -intel_sub_group_avc_ime_get_inter_reference_interlaced_field_polarities( - uint packed_reference_ids, uint packed_reference_parameter_field_polarities, - intel_sub_group_avc_ime_result_t result); -uchar __ovld -intel_sub_group_avc_ref_get_inter_reference_interlaced_field_polarities( - uint packed_reference_ids, uint packed_reference_parameter_field_polarities, - intel_sub_group_avc_ref_result_t result); - -// Type conversion functions -intel_sub_group_avc_mce_payload_t __ovld -intel_sub_group_avc_ime_convert_to_mce_payload( - intel_sub_group_avc_ime_payload_t payload); -intel_sub_group_avc_ime_payload_t __ovld -intel_sub_group_avc_mce_convert_to_ime_payload( - intel_sub_group_avc_mce_payload_t payload); -intel_sub_group_avc_mce_payload_t __ovld -intel_sub_group_avc_ref_convert_to_mce_payload( - intel_sub_group_avc_ref_payload_t payload); -intel_sub_group_avc_ref_payload_t __ovld -intel_sub_group_avc_mce_convert_to_ref_payload( - intel_sub_group_avc_mce_payload_t payload); -intel_sub_group_avc_mce_payload_t __ovld -intel_sub_group_avc_sic_convert_to_mce_payload( - intel_sub_group_avc_sic_payload_t payload); -intel_sub_group_avc_sic_payload_t __ovld -intel_sub_group_avc_mce_convert_to_sic_payload( - intel_sub_group_avc_mce_payload_t payload); - -intel_sub_group_avc_mce_result_t __ovld -intel_sub_group_avc_ime_convert_to_mce_result( - intel_sub_group_avc_ime_result_t result); -intel_sub_group_avc_ime_result_t __ovld -intel_sub_group_avc_mce_convert_to_ime_result( - intel_sub_group_avc_mce_result_t result); -intel_sub_group_avc_mce_result_t __ovld -intel_sub_group_avc_ref_convert_to_mce_result( - intel_sub_group_avc_ref_result_t result); -intel_sub_group_avc_ref_result_t __ovld -intel_sub_group_avc_mce_convert_to_ref_result( - intel_sub_group_avc_mce_result_t result); -intel_sub_group_avc_mce_result_t __ovld -intel_sub_group_avc_sic_convert_to_mce_result( - intel_sub_group_avc_sic_result_t result); -intel_sub_group_avc_sic_result_t __ovld -intel_sub_group_avc_mce_convert_to_sic_result( - intel_sub_group_avc_mce_result_t result); -#pragma OPENCL EXTENSION cl_intel_device_side_avc_motion_estimation : end -#endif // cl_intel_device_side_avc_motion_estimation - -#ifdef cl_amd_media_ops -uint __ovld amd_bitalign(uint, uint, uint); -uint2 __ovld amd_bitalign(uint2, uint2, uint2); -uint3 __ovld amd_bitalign(uint3, uint3, uint3); -uint4 __ovld amd_bitalign(uint4, uint4, uint4); -uint8 __ovld amd_bitalign(uint8, uint8, uint8); -uint16 __ovld amd_bitalign(uint16, uint16, uint16); - -uint __ovld amd_bytealign(uint, uint, uint); -uint2 __ovld amd_bytealign(uint2, uint2, uint2); -uint3 __ovld amd_bytealign(uint3, uint3, uint3); -uint4 __ovld amd_bytealign(uint4, uint4, uint4); -uint8 __ovld amd_bytealign(uint8, uint8, uint8); -uint16 __ovld amd_bytealign(uint16, uint16, uint16); - -uint __ovld amd_lerp(uint, uint, uint); -uint2 __ovld amd_lerp(uint2, uint2, uint2); -uint3 __ovld amd_lerp(uint3, uint3, uint3); -uint4 __ovld amd_lerp(uint4, uint4, uint4); -uint8 __ovld amd_lerp(uint8, uint8, uint8); -uint16 __ovld amd_lerp(uint16, uint16, uint16); - -uint __ovld amd_pack(float4 v); - -uint __ovld amd_sad4(uint4, uint4, uint); - -uint __ovld amd_sadhi(uint, uint, uint); -uint2 __ovld amd_sadhi(uint2, uint2, uint2); -uint3 __ovld amd_sadhi(uint3, uint3, uint3); -uint4 __ovld amd_sadhi(uint4, uint4, uint4); -uint8 __ovld amd_sadhi(uint8, uint8, uint8); -uint16 __ovld amd_sadhi(uint16, uint16, uint16); - -uint __ovld amd_sad(uint, uint, uint); -uint2 __ovld amd_sad(uint2, uint2, uint2); -uint3 __ovld amd_sad(uint3, uint3, uint3); -uint4 __ovld amd_sad(uint4, uint4, uint4); -uint8 __ovld amd_sad(uint8, uint8, uint8); -uint16 __ovld amd_sad(uint16, uint16, uint16); - -float __ovld amd_unpack0(uint); -float2 __ovld amd_unpack0(uint2); -float3 __ovld amd_unpack0(uint3); -float4 __ovld amd_unpack0(uint4); -float8 __ovld amd_unpack0(uint8); -float16 __ovld amd_unpack0(uint16); - -float __ovld amd_unpack1(uint); -float2 __ovld amd_unpack1(uint2); -float3 __ovld amd_unpack1(uint3); -float4 __ovld amd_unpack1(uint4); -float8 __ovld amd_unpack1(uint8); -float16 __ovld amd_unpack1(uint16); - -float __ovld amd_unpack2(uint); -float2 __ovld amd_unpack2(uint2); -float3 __ovld amd_unpack2(uint3); -float4 __ovld amd_unpack2(uint4); -float8 __ovld amd_unpack2(uint8); -float16 __ovld amd_unpack2(uint16); - -float __ovld amd_unpack3(uint); -float2 __ovld amd_unpack3(uint2); -float3 __ovld amd_unpack3(uint3); -float4 __ovld amd_unpack3(uint4); -float8 __ovld amd_unpack3(uint8); -float16 __ovld amd_unpack3(uint16); -#endif // cl_amd_media_ops - -#ifdef cl_amd_media_ops2 -int __ovld amd_bfe(int src0, uint src1, uint src2); -int2 __ovld amd_bfe(int2 src0, uint2 src1, uint2 src2); -int3 __ovld amd_bfe(int3 src0, uint3 src1, uint3 src2); -int4 __ovld amd_bfe(int4 src0, uint4 src1, uint4 src2); -int8 __ovld amd_bfe(int8 src0, uint8 src1, uint8 src2); -int16 __ovld amd_bfe(int16 src0, uint16 src1, uint16 src2); - -uint __ovld amd_bfe(uint src0, uint src1, uint src2); -uint2 __ovld amd_bfe(uint2 src0, uint2 src1, uint2 src2); -uint3 __ovld amd_bfe(uint3 src0, uint3 src1, uint3 src2); -uint4 __ovld amd_bfe(uint4 src0, uint4 src1, uint4 src2); -uint8 __ovld amd_bfe(uint8 src0, uint8 src1, uint8 src2); -uint16 __ovld amd_bfe(uint16 src0, uint16 src1, uint16 src2); - -uint __ovld amd_bfm(uint src0, uint src1); -uint2 __ovld amd_bfm(uint2 src0, uint2 src1); -uint3 __ovld amd_bfm(uint3 src0, uint3 src1); -uint4 __ovld amd_bfm(uint4 src0, uint4 src1); -uint8 __ovld amd_bfm(uint8 src0, uint8 src1); -uint16 __ovld amd_bfm(uint16 src0, uint16 src1); - -float __ovld amd_max3(float src0, float src1, float src2); -float2 __ovld amd_max3(float2 src0, float2 src1, float2 src2); -float3 __ovld amd_max3(float3 src0, float3 src1, float3 src2); -float4 __ovld amd_max3(float4 src0, float4 src1, float4 src2); -float8 __ovld amd_max3(float8 src0, float8 src1, float8 src2); -float16 __ovld amd_max3(float16 src0, float16 src1, float16 src2); - -int __ovld amd_max3(int src0, int src1, int src2); -int2 __ovld amd_max3(int2 src0, int2 src1, int2 src2); -int3 __ovld amd_max3(int3 src0, int3 src1, int3 src2); -int4 __ovld amd_max3(int4 src0, int4 src1, int4 src2); -int8 __ovld amd_max3(int8 src0, int8 src1, int8 src2); -int16 __ovld amd_max3(int16 src0, int16 src1, int16 src2); - -uint __ovld amd_max3(uint src0, uint src1, uint src2); -uint2 __ovld amd_max3(uint2 src0, uint2 src1, uint2 src2); -uint3 __ovld amd_max3(uint3 src0, uint3 src1, uint3 src2); -uint4 __ovld amd_max3(uint4 src0, uint4 src1, uint4 src2); -uint8 __ovld amd_max3(uint8 src0, uint8 src1, uint8 src2); -uint16 __ovld amd_max3(uint16 src0, uint16 src1, uint16 src2); - -float __ovld amd_median3(float src0, float src1, float src2); -float2 __ovld amd_median3(float2 src0, float2 src1, float2 src2); -float3 __ovld amd_median3(float3 src0, float3 src1, float3 src2); -float4 __ovld amd_median3(float4 src0, float4 src1, float4 src2); -float8 __ovld amd_median3(float8 src0, float8 src1, float8 src2); -float16 __ovld amd_median3(float16 src0, float16 src1, float16 src2); - -int __ovld amd_median3(int src0, int src1, int src2); -int2 __ovld amd_median3(int2 src0, int2 src1, int2 src2); -int3 __ovld amd_median3(int3 src0, int3 src1, int3 src2); -int4 __ovld amd_median3(int4 src0, int4 src1, int4 src2); -int8 __ovld amd_median3(int8 src0, int8 src1, int8 src2); -int16 __ovld amd_median3(int16 src0, int16 src1, int16 src2); - -uint __ovld amd_median3(uint src0, uint src1, uint src2); -uint2 __ovld amd_median3(uint2 src0, uint2 src1, uint2 src2); -uint3 __ovld amd_median3(uint3 src0, uint3 src1, uint3 src2); -uint4 __ovld amd_median3(uint4 src0, uint4 src1, uint4 src2); -uint8 __ovld amd_median3(uint8 src0, uint8 src1, uint8 src2); -uint16 __ovld amd_median3(uint16 src0, uint16 src1, uint16 src2); - -float __ovld amd_min3(float src0, float src1, float src); -float2 __ovld amd_min3(float2 src0, float2 src1, float2 src); -float3 __ovld amd_min3(float3 src0, float3 src1, float3 src); -float4 __ovld amd_min3(float4 src0, float4 src1, float4 src); -float8 __ovld amd_min3(float8 src0, float8 src1, float8 src); -float16 __ovld amd_min3(float16 src0, float16 src1, float16 src); - -int __ovld amd_min3(int src0, int src1, int src2); -int2 __ovld amd_min3(int2 src0, int2 src1, int2 src2); -int3 __ovld amd_min3(int3 src0, int3 src1, int3 src2); -int4 __ovld amd_min3(int4 src0, int4 src1, int4 src2); -int8 __ovld amd_min3(int8 src0, int8 src1, int8 src2); -int16 __ovld amd_min3(int16 src0, int16 src1, int16 src2); - -uint __ovld amd_min3(uint src0, uint src1, uint src2); -uint2 __ovld amd_min3(uint2 src0, uint2 src1, uint2 src2); -uint3 __ovld amd_min3(uint3 src0, uint3 src1, uint3 src2); -uint4 __ovld amd_min3(uint4 src0, uint4 src1, uint4 src2); -uint8 __ovld amd_min3(uint8 src0, uint8 src1, uint8 src2); -uint16 __ovld amd_min3(uint16 src0, uint16 src1, uint16 src2); - -ulong __ovld amd_mqsad(ulong src0, uint src1, ulong src2); -ulong2 __ovld amd_mqsad(ulong2 src0, uint2 src1, ulong2 src2); -ulong3 __ovld amd_mqsad(ulong3 src0, uint3 src1, ulong3 src2); -ulong4 __ovld amd_mqsad(ulong4 src0, uint4 src1, ulong4 src2); -ulong8 __ovld amd_mqsad(ulong8 src0, uint8 src1, ulong8 src2); -ulong16 __ovld amd_mqsad(ulong16 src0, uint16 src1, ulong16 src2); - -ulong __ovld amd_qsad(ulong src0, uint src1, ulong src2); -ulong2 __ovld amd_qsad(ulong2 src0, uint2 src1, ulong2 src2); -ulong3 __ovld amd_qsad(ulong3 src0, uint3 src1, ulong3 src2); -ulong4 __ovld amd_qsad(ulong4 src0, uint4 src1, ulong4 src2); -ulong8 __ovld amd_qsad(ulong8 src0, uint8 src1, ulong8 src2); -ulong16 __ovld amd_qsad(ulong16 src0, uint16 src1, ulong16 src2); - -uint __ovld amd_msad(uint src0, uint src1, uint src2); -uint2 __ovld amd_msad(uint2 src0, uint2 src1, uint2 src2); -uint3 __ovld amd_msad(uint3 src0, uint3 src1, uint3 src2); -uint4 __ovld amd_msad(uint4 src0, uint4 src1, uint4 src2); -uint8 __ovld amd_msad(uint8 src0, uint8 src1, uint8 src2); -uint16 __ovld amd_msad(uint16 src0, uint16 src1, uint16 src2); - -uint __ovld amd_sadd(uint src0, uint src1, uint src2); -uint2 __ovld amd_sadd(uint2 src0, uint2 src1, uint2 src2); -uint3 __ovld amd_sadd(uint3 src0, uint3 src1, uint3 src2); -uint4 __ovld amd_sadd(uint4 src0, uint4 src1, uint4 src2); -uint8 __ovld amd_sadd(uint8 src0, uint8 src1, uint8 src2); -uint16 __ovld amd_sadd(uint16 src0, uint16 src1, uint16 src2); - -uint __ovld amd_sadw(uint src0, uint src1, uint src2); -uint2 __ovld amd_sadw(uint2 src0, uint2 src1, uint2 src2); -uint3 __ovld amd_sadw(uint3 src0, uint3 src1, uint3 src2); -uint4 __ovld amd_sadw(uint4 src0, uint4 src1, uint4 src2); -uint8 __ovld amd_sadw(uint8 src0, uint8 src1, uint8 src2); -uint16 __ovld amd_sadw(uint16 src0, uint16 src1, uint16 src2); -#endif // cl_amd_media_ops2 - -#if defined(cl_arm_integer_dot_product_int8) -uint __ovld arm_dot(uchar4, uchar4); -int __ovld arm_dot(char4, char4); -#endif // defined(cl_arm_integer_dot_product_int8) - -#if defined(cl_arm_integer_dot_product_accumulate_int8) -uint __ovld arm_dot_acc(uchar4, uchar4, uint); -int __ovld arm_dot_acc(char4, char4, int); -#endif // defined(cl_arm_integer_dot_product_accumulate_int8) - -#if defined(cl_arm_integer_dot_product_accumulate_int16) -uint __ovld arm_dot_acc(ushort2, ushort2, uint); -int __ovld arm_dot_acc(short2, short2, int); -#endif // defined(cl_arm_integer_dot_product_accumulate_int16) - -#if defined(cl_arm_integer_dot_product_accumulate_saturate_int8) -uint __ovld arm_dot_acc_sat(uchar4, uchar4, uint); -int __ovld arm_dot_acc_sat(char4, char4, int); -#endif // defined(cl_arm_integer_dot_product_accumulate_saturate_int8) - -// Disable any extensions we may have enabled previously. -#pragma OPENCL EXTENSION all : disable - -#undef __opencl_c_named_address_space_builtins - -#undef __cnfn -#undef __ovld -#endif //_OPENCL_H_ diff --git a/drivers/pocl-gen7/share/pocl/include/pocl.h b/drivers/pocl-gen7/share/pocl/include/pocl.h deleted file mode 100644 index 3269f93..0000000 --- a/drivers/pocl-gen7/share/pocl/include/pocl.h +++ /dev/null @@ -1,617 +0,0 @@ -/* pocl.h - global pocl declarations for the host side runtime. - - Copyright (c) 2011 Universidad Rey Juan Carlos - 2011-2019 Pekka Jääskeläinen - 2024 Pekka Jääskeläinen / Intel Finland Oy - - Permission is hereby granted, free of charge, to any person obtaining a copy - of this software and associated documentation files (the "Software"), to - deal in the Software without restriction, including without limitation the - rights to use, copy, modify, merge, publish, distribute, sublicense, and/or - sell copies of the Software, and to permit persons to whom the Software is - furnished to do so, subject to the following conditions: - - The above copyright notice and this permission notice shall be included in - all copies or substantial portions of the Software. - - THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR - IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, - FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE - AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER - LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING - FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS - IN THE SOFTWARE. -*/ - -/** - * @file pocl.h - * - * The declarations in this file are such that are used both in the - * libpocl implementation CL and the kernel compiler. Others should be - * moved to pocl_cl.h of lib/CL or under the kernel compiler dir. - * @todo Check if there are extra declarations here that could be moved. - */ -#ifndef POCL_H -#define POCL_H - -#include - -/* The running number used for identifying PoCL runtime allocated objects. - 0 marks an invalid/undefined object. */ -typedef uint64_t pocl_obj_id_t; - -#if defined(EXPORT_POCL_LIB) && defined(_MSC_VER) -/* To successfully export OpenCL API, the dllexport must be placed on - * both the declaration and the definition as MSVC requires that both - * of them have the same attributes. - * - * NOTE: Trouble is expected if CL/opencl.h is not included for the - * first time here. - */ -#undef CL_API_ENTRY -#define CL_API_ENTRY __declspec(dllexport) -#endif - -#ifndef CL_TARGET_OPENCL_VERSION -#define CL_TARGET_OPENCL_VERSION 300 -#endif -#include - -#include "config.h" - -#include "pocl_export.h" - -#include "pocl_context.h" - -#include "vccompat.hpp" - -/* The maximum file, directory and path name lengths. - NOTE: GDB seems to fail to load symbols from .so files which have - longer pathnames than 511, thus the quite small dir/filename length - limiter. */ -#define POCL_MAX_DIRNAME_LENGTH 64 -#define POCL_MAX_FILENAME_LENGTH (POCL_MAX_DIRNAME_LENGTH) -/* -5: Leave space for .so and for additional .o if temp file debugging - is enabled. */ -#define POCL_HASH_FILENAME_LENGTH (POCL_MAX_DIRNAME_LENGTH - 5) -#define POCL_MAX_PATHNAME_LENGTH 4096 - -/* official Khronos ID */ -#ifndef CL_KHRONOS_VENDOR_ID_POCL -#define CL_KHRONOS_VENDOR_ID_POCL 0x10006 -#endif - -#if __cplusplus >= 201103L -# define POCL_ALIGNAS(x) alignas(x) -#elif __STDC_VERSION__ >= 201112L /* C11 */ -# define POCL_ALIGNAS(x) _Alignas(x) -#elif defined(_MSC_VER) -# define POCL_ALIGNAS(x) __declspec(align(x)) -#elif defined(__clang__) || defined(__GNUC__) -# define POCL_ALIGNAS(x) __attribute__ ((aligned (x))) -#else -/* Emit an error for potential correctness issues if alignas() is ignored. */ -# error "Don't know alignas() counterpart for this compiler!" -#endif - -#ifndef _WIN32 -#define POCL_PATH_SEPARATOR "/" -#else -#define POCL_PATH_SEPARATOR "\\" -#endif - -/* Always align buffer allocations, context data, and kernel arguments to - sizeof(double16) to enforce easier vectorization for targets with naturally - aligned loads/stores. */ -#define MAX_EXTENDED_ALIGNMENT 128 - -/* represents a single buffer to host memory mapping */ -typedef struct mem_mapping -{ - void *host_ptr; /* the location of the mapped buffer chunk in the host memory - */ - size_t offset; /* offset to the beginning of the buffer */ - size_t size; - struct mem_mapping *prev, *next; - - /* This is required, because two clEnqueueMap() with the same - buffer+size+offset, will create two identical mappings in the - buffer->mappings LL. Without this flag, both corresponding clEnqUnmap()s - will find the same mapping (the first one in mappings LL), which will lead - to memory double-free corruption later. */ - int unmap_requested; - - cl_map_flags map_flags; - /* image mapping data */ - size_t origin[3]; - size_t region[3]; - size_t row_pitch; - size_t slice_pitch; -} mem_mapping_t; - -/* A single buffer can and will be allocated in - multiple different devices which might or might not share the global memory. - This struct captures a single buffer to global memory allocation's - properties. -*/ -typedef struct pocl_mem_identifier -{ - /* Global-memory-specific pointer to hardware resource that represents - memory. This may be anything, but must be non-NULL while the memory is - actually allocated, and NULL when it's not */ - void *mem_ptr; - - /* If mem_ptr represents an address in the device global memory which - is pinned for the lifetime of the buffer. */ - int is_pinned; - - /* The device-side memory address (if known). If is_pinned is true, this - must be a valid value (note: 0 means invalid address). */ - void *device_addr; - - /* Content version tracking. Every write use (clEnqWriteBuffer, - * clMapBuffer(CL_MAP_WRITE), write_only image, read/write buffers as kernel - * args etc) increases the version; read uses do not. This version is used in - * implicit migrations to find the latest copy of the data. - * - * In theory, a simple bool of "valid/invalid" could be used; - * the only difference is that a version numbering scheme saves history, - * which could be useful for LRU global memory garbage collection among other - * things in the future. - */ - uint64_t version; - - /* Extra pointer for drivers to use for anything. - * - * Currently CUDA uses it to track ALLOC_HOST_PTR allocations. - * Vulkan uses it to store host-mapped staging memory. - */ - void *extra_ptr; - - /* Extra integer for drivers to use for anything. - * - * Currently Vulkan uses it to track vulkan memory requirements. - */ - uint64_t extra; - -} pocl_mem_identifier; - -typedef char pixel_t[16]; - -typedef struct _mem_destructor_callback mem_destructor_callback_t; -/* represents a memory object destructor callback */ -struct _mem_destructor_callback -{ - void (CL_CALLBACK * pfn_notify) (cl_mem, void*); /* callback function */ - void *user_data; /* user supplied data passed to callback function */ - mem_destructor_callback_t *next; -}; - -typedef struct _build_program_callback build_program_callback_t; -struct _build_program_callback -{ - void (CL_CALLBACK * callback_function) (cl_program, void*); /* callback function */ - void *user_data; /* user supplied data passed to callback function */ -}; - -// same as SHA1_DIGEST_SIZE -#define POCL_KERNEL_DIGEST_SIZE 20 -typedef uint8_t pocl_kernel_hash_t[POCL_KERNEL_DIGEST_SIZE]; - -/* For clEnqueueNDRangeKernel(). */ -typedef struct -{ - void *hash; - void *wg; /* The work group function ptr. Device specific. */ - cl_kernel kernel; - /* The launch data that can be passed to the kernel execution environment. */ - struct pocl_context pc; - struct pocl_argument *arguments; - /* Can be used to store/cache arbitrary device-specific data. */ - void *device_data; - /* If set to 1, disallow any work-group function specialization. */ - int force_generic_wg_func; - /* If set to 1, disallow "small grid" WG function specialization. */ - int force_large_grid_wg_func; -} _cl_command_run; - -/* For clEnqueueCommandBufferKHR(). */ -typedef struct -{ - cl_command_buffer_khr buffer; -} _cl_command_replay; - -/* For clEnqueueNativeKernel(). */ -typedef struct -{ - void *args; - size_t cb_args; - /* The argument buffers are stored in _cl_command's migr_info list. */ - void **arg_locs; - void(CL_CALLBACK *user_func) (void *); -} _cl_command_native; - -/* For clEnqueueReadBuffer(). */ -typedef struct -{ - void *__restrict__ dst_host_ptr; - pocl_mem_identifier *src_content_size_mem_id; - size_t offset; - size_t size; - size_t *content_size; - cl_mem src; -} _cl_command_read; - -/* For clEnqueueWriteBuffer(). */ -typedef struct -{ - const void *__restrict__ src_host_ptr; - size_t offset; - size_t size; - cl_mem dst; -} _cl_command_write; - -/* For clEnqueueCopyBuffer(). */ -typedef struct -{ - pocl_mem_identifier *src_content_size_mem_id; - cl_mem src; - cl_mem src_content_size; - cl_mem dst; - size_t src_offset; - size_t dst_offset; - size_t size; -} _cl_command_copy; - -/* For clEnqueueReadBufferRect(). */ -typedef struct -{ - void *__restrict__ dst_host_ptr; - size_t buffer_origin[3]; - size_t host_origin[3]; - size_t region[3]; - size_t buffer_row_pitch; - size_t buffer_slice_pitch; - size_t host_row_pitch; - size_t host_slice_pitch; - cl_mem src; -} _cl_command_read_rect; - -/* For clEnqueueWriteBufferRect(). */ -typedef struct -{ - const void *__restrict__ src_host_ptr; - size_t buffer_origin[3]; - size_t host_origin[3]; - size_t region[3]; - size_t buffer_row_pitch; - size_t buffer_slice_pitch; - size_t host_row_pitch; - size_t host_slice_pitch; - cl_mem dst; -} _cl_command_write_rect; - -/* For clEnqueueCopyBufferRect(). */ -typedef struct -{ - cl_mem src; - cl_mem dst; - size_t dst_origin[3]; - size_t src_origin[3]; - size_t region[3]; - size_t src_row_pitch; - size_t src_slice_pitch; - size_t dst_row_pitch; - size_t dst_slice_pitch; -} _cl_command_copy_rect; - -/* For clEnqueueMapBuffer(). */ -typedef struct -{ - mem_mapping_t *mapping; - cl_mem buffer; -} _cl_command_map; - -/* For clEnqueueUnMapMemObject(). */ -typedef struct -{ - mem_mapping_t *mapping; - cl_mem buffer; -} _cl_command_unmap; - -/* For clEnqueueFillBuffer(). */ -typedef struct -{ - size_t size; - size_t offset; - void *__restrict__ pattern; - size_t pattern_size; - cl_mem dst; -} _cl_command_fill_mem; - -/* For clEnqueue(Write/Read)Image(). */ -typedef struct -{ - void *__restrict__ dst_host_ptr; - cl_mem src; - cl_mem dst; - size_t dst_offset; - size_t origin[3]; - size_t region[3]; - size_t dst_row_pitch; - size_t dst_slice_pitch; -} _cl_command_read_image; - -typedef struct -{ - const void *__restrict__ src_host_ptr; - cl_mem src; - cl_mem dst; - size_t src_offset; - size_t origin[3]; - size_t region[3]; - size_t src_row_pitch; - size_t src_slice_pitch; -} _cl_command_write_image; - -typedef struct -{ - cl_mem src; - cl_mem dst; - size_t dst_origin[3]; - size_t src_origin[3]; - size_t region[3]; -} _cl_command_copy_image; - -/* For clEnqueueFillImage(). */ -typedef struct -{ - pixel_t fill_pixel; - cl_uint4 orig_pixel; - size_t pixel_size; - size_t origin[3]; - size_t region[3]; - cl_mem dst; -} _cl_command_fill_image; - -/* For clEnqueueMarkerWithWaitlist(). */ -typedef struct -{ - void *data; - int has_wait_list; -} _cl_command_marker; - -/* For clEnqueueBarrierWithWaitlist(). */ -typedef _cl_command_marker _cl_command_barrier; - -typedef enum pocl_migration_type_e { - ENQUEUE_MIGRATE_TYPE_NOP, - ENQUEUE_MIGRATE_TYPE_D2H, - ENQUEUE_MIGRATE_TYPE_H2D, - ENQUEUE_MIGRATE_TYPE_D2D -} pocl_migration_type_t; - -/* For clEnqueueMigrateMemObjects(). */ -typedef struct -{ - pocl_migration_type_t type; - cl_device_id src_device; - /** For migrating a buffer that has a size buffer as per - * cl_pocl_content_size */ - uint64_t migration_size; - pocl_mem_identifier *src_content_size_mem_id; - /* Number of buffers to migrate. The actual buffers are in migr_info in - the _cl_command_node. */ - size_t num_buffers; - /* Set to 1 if this is a migration command generated by the runtime to - ensure coherence for the input buffers of commands. */ - char implicit; -} _cl_command_migrate; - -typedef struct -{ - void* data; - cl_command_queue queue; - unsigned num_svm_pointers; - void **svm_pointers; - void (CL_CALLBACK *pfn_free_func) ( cl_command_queue queue, - unsigned num_svm_pointers, - void *svm_pointers[], - void *user_data); -} _cl_command_svm_free; - -typedef struct -{ - unsigned num_svm_pointers; - size_t *sizes; - void **svm_pointers; -} _cl_command_svm_migrate; - -typedef struct -{ - void* svm_ptr; - size_t size; - cl_map_flags flags; -} _cl_command_svm_map; - -typedef struct -{ - void* svm_ptr; - size_t size; -} _cl_command_svm_unmap; - -typedef struct -{ - const void *__restrict__ src; - void *__restrict__ dst; - size_t size; -} _cl_command_svm_cpy; - -typedef struct -{ - const void *__restrict__ src; - void *__restrict__ dst; - size_t region[3]; - size_t src_origin[3]; - size_t dst_origin[3]; - size_t src_row_pitch; - size_t src_slice_pitch; - size_t dst_row_pitch; - size_t dst_slice_pitch; -} _cl_command_svm_cpy_rect; - -typedef struct -{ - void *__restrict__ svm_ptr; - size_t size; - void *__restrict__ pattern; - size_t pattern_size; -} _cl_command_svm_fill; - -typedef struct -{ - void *__restrict__ svm_ptr; - void *__restrict__ pattern; - size_t region[3]; - size_t origin[3]; - size_t row_pitch; - size_t slice_pitch; - size_t pattern_size; -} _cl_command_svm_fill_rect; - -typedef struct -{ - const void *ptr; - size_t size; - cl_mem_advice_intel advice; -} _cl_command_svm_memadvise; - -typedef union -{ - _cl_command_run run; - _cl_command_native native; - _cl_command_replay replay; - - _cl_command_read read; - _cl_command_write write; - _cl_command_copy copy; - _cl_command_read_rect read_rect; - _cl_command_write_rect write_rect; - _cl_command_copy_rect copy_rect; - _cl_command_fill_mem memfill; - - _cl_command_read_image read_image; - _cl_command_write_image write_image; - _cl_command_copy_image copy_image; - _cl_command_fill_image fill_image; - - _cl_command_map map; - _cl_command_unmap unmap; - - _cl_command_marker marker; - _cl_command_barrier barrier; - _cl_command_migrate migrate; - - _cl_command_svm_free svm_free; - _cl_command_svm_map svm_map; - _cl_command_svm_unmap svm_unmap; - _cl_command_svm_cpy svm_memcpy; - _cl_command_svm_cpy_rect svm_memcpy_rect; - _cl_command_svm_fill svm_fill; - _cl_command_svm_fill_rect svm_fill_rect; - _cl_command_svm_migrate svm_migrate; - - _cl_command_svm_memadvise mem_advise; -} _cl_command_t; - -typedef struct _pocl_buffer_migration_info - pocl_buffer_migration_info; - -/** - * Enum that represents different possible states of a command node. - */ -typedef enum -{ - POCL_COMMAND_FAILED = -1, - /* Default unless set to ready. */ - POCL_COMMAND_NOT_READY = 0, - POCL_COMMAND_READY = 1, -} pocl_command_state; - -/* One item in a command queue or a command buffer. */ -typedef struct _cl_command_node _cl_command_node; -struct _cl_command_node -{ - _cl_command_t command; - cl_command_type type; - _cl_command_node *next; // for linked-list storage - _cl_command_node *prev; - - /*** - * Command buffers use sync points as a template for synchronizing commands - * within the buffer. Commands outside the buffer can't depend on sync points - * and individual commands in the buffer can't depend on events. Because this - * struct is used both for recorded and immediately enqueued commands, the - * two synchronization mechanisms are made mutually exclusive here. - * */ - union - { - struct - { - cl_event event; - } event; - struct - { - cl_sync_point_khr sync_point; - cl_uint num_sync_points_in_wait_list; - cl_sync_point_khr *sync_point_wait_list; - } syncpoint; - } sync; - cl_device_id device; - /* The index of the targeted device in the **program** device list. */ - unsigned program_device_i; - - /* Used to indicate if a node is ready to be executed or failed. */ - pocl_command_state state; - - /* true if the node belongs to a cl_command_buffer_khr */ - cl_int buffered; - - /* Which of the command queues in the command buffer's queue list - * this command was recorded for. */ - cl_uint queue_idx; - /* List of buffers this command accesses, used for inserting migrations */ - pocl_buffer_migration_info *migr_infos; - - /* back pointer to the command buffer, when this command is recorded - * in a cl_khr_command_buffer. NULL for other (non-buffered) commands */ - cl_command_buffer_khr cmd_buffer; -}; - -/** - * Enumeration for different modes of converting automatic locals - */ -typedef enum -{ - POCL_AUTOLOCALS_TO_ARGS_NEVER = 0, - POCL_AUTOLOCALS_TO_ARGS_ALWAYS = 1, - /* convert autolocals to args only if there are dynamic local memory - * function arguments in the kernel. */ - POCL_AUTOLOCALS_TO_ARGS_ONLY_IF_DYNAMIC_LOCALS_PRESENT = 2, -} pocl_autolocals_to_args_strategy; - -typedef struct pocl_version_t -{ - unsigned major; - unsigned minor; - -#ifdef __cplusplus - pocl_version_t () : major{0}, minor{0} {} - pocl_version_t (unsigned the_major, unsigned the_minor) - : major{the_major}, minor{the_minor} - { - } -#endif -} pocl_version_t; - -#endif /* POCL_H */ diff --git a/drivers/pocl-gen7/share/pocl/include/pocl_device.h b/drivers/pocl-gen7/share/pocl/include/pocl_device.h deleted file mode 100644 index 2418fac..0000000 --- a/drivers/pocl-gen7/share/pocl/include/pocl_device.h +++ /dev/null @@ -1,78 +0,0 @@ -/* pocl_device.h - global pocl declarations to be used in the device binaries in - case applicable by the target - - Copyright (c) 2012-2018 Pekka Jääskeläinen / Tampere University of Technology - - Permission is hereby granted, free of charge, to any person obtaining a copy - of this software and associated documentation files (the "Software"), to deal - in the Software without restriction, including without limitation the rights - to use, copy, modify, merge, publish, distribute, sublicense, and/or sell - copies of the Software, and to permit persons to whom the Software is - furnished to do so, subject to the following conditions: - - The above copyright notice and this permission notice shall be included in - all copies or substantial portions of the Software. - - THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR - IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, - FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE - AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER - LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, - OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN - THE SOFTWARE. -*/ - -#ifndef POCL_DEVICE_H -#define POCL_DEVICE_H - -#include "pocl_types.h" - -#define MAX_KERNEL_ARGS 64 -#define MAX_KERNEL_NAME_LENGTH 64 - -/* Metadata of a single kernel stored in the device.*/ -typedef struct { - const uchar name[MAX_KERNEL_NAME_LENGTH]; - ushort num_args; - ushort num_locals; - void *work_group_func; -} __kernel_metadata; - -#ifdef _MSC_VER - #define ALIGN4(x) __declspec(align(4)) x - #define ALIGN8(x) __declspec(align(4)) x -#else - #define ALIGN4(x) x __attribute__ ((aligned (4))) - #define ALIGN8(x) x __attribute__ ((aligned (8))) -#endif - -/* A kernel invocation command. */ -typedef struct { - /* The kernel to execute. Points to the metadata in the device global - memory. It will be casted to a __kernel_metadata* */ - ALIGN8 (uint kernel_meta); - /* Pointer to the kernel arguments in the local memory. Will be - casted to 32 bit void* */ - ALIGN8 (uint args); - ALIGN8 (uint args_size); - /* pocl context */ - ALIGN8 (uint ctx); - ALIGN8 (uint ctx_size); - /* The execution status of this queue slot. */ - ALIGN8 (uint status); -} __kernel_exec_cmd; - -/* Kernel execution statuses. */ - -/* The invocation entry is free to use. */ -#define POCL_KST_FREE 1 -/* The kernel structure has been populated and is waiting to be - executed. */ -#define POCL_KST_READY 2 -/* The kernel is currently running in the device. */ -#define POCL_KST_RUNNING 3 -/* The kernel has finished execution. The results can be collected and the - execution entry be freed (by writing POCL_KST_FREE to the status). */ -#define POCL_KST_FINISHED 4 - -#endif diff --git a/drivers/pocl-gen7/share/pocl/include/pocl_image_types.h b/drivers/pocl-gen7/share/pocl/include/pocl_image_types.h deleted file mode 100644 index a8db3c7..0000000 --- a/drivers/pocl-gen7/share/pocl/include/pocl_image_types.h +++ /dev/null @@ -1,52 +0,0 @@ -/* pocl_image_types.h - image data structure used by device implementations - - Copyright (c) 2013 Ville Korhonen - Copyright (c) 2017 Michal Babej / Tampere University of Technology - - Permission is hereby granted, free of charge, to any person obtaining a copy - of this software and associated documentation files (the "Software"), to deal - in the Software without restriction, including without limitation the rights - to use, copy, modify, merge, publish, distribute, sublicense, and/or sell - copies of the Software, and to permit persons to whom the Software is - furnished to do so, subject to the following conditions: - - The above copyright notice and this permission notice shall be included in - all copies or substantial portions of the Software. - - THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR - IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, - FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE - AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER - LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, - OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN - THE SOFTWARE. -*/ - -#ifndef __X86_IMAGE_H__ -#define __X86_IMAGE_H__ - -#ifdef __CBUILD__ -#define INTTYPE cl_int -#else -#define INTTYPE int -#endif - -typedef uintptr_t dev_sampler_t; - -typedef struct dev_image_t { - void *_data; - INTTYPE _width; - INTTYPE _height; - INTTYPE _depth; - INTTYPE _image_array_size; - INTTYPE _row_pitch; - INTTYPE _slice_pitch; - INTTYPE _num_mip_levels; /* maybe not needed */ - INTTYPE _num_samples; /* maybe not needed */ - INTTYPE _order; - INTTYPE _data_type; - INTTYPE _num_channels; - INTTYPE _elem_size; -} dev_image_t; - -#endif diff --git a/drivers/pocl-gen7/share/pocl/include/pocl_spir.h b/drivers/pocl-gen7/share/pocl/include/pocl_spir.h deleted file mode 100644 index 0dd1f92..0000000 --- a/drivers/pocl-gen7/share/pocl/include/pocl_spir.h +++ /dev/null @@ -1,33 +0,0 @@ -/* pocl-spir.h - global pocl declarations for the SPIR(-V) support. - - Copyright (c) 2018-2022 Pekka Jääskeläinen - - Permission is hereby granted, free of charge, to any person obtaining a copy - of this software and associated documentation files (the "Software"), to - deal in the Software without restriction, including without limitation the - rights to use, copy, modify, merge, publish, distribute, sublicense, and/or - sell copies of the Software, and to permit persons to whom the Software is - furnished to do so, subject to the following conditions: - - The above copyright notice and this permission notice shall be included in - all copies or substantial portions of the Software. - - THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR - IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, - FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE - AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER - LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING - FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS - IN THE SOFTWARE. -*/ - -#ifndef POCL_SPIR_H -#define POCL_SPIR_H - -#define SPIR_ADDRESS_SPACE_PRIVATE 0 -#define SPIR_ADDRESS_SPACE_GLOBAL 1 -#define SPIR_ADDRESS_SPACE_CONSTANT 2 -#define SPIR_ADDRESS_SPACE_LOCAL 3 -#define SPIR_ADDRESS_SPACE_GENERIC 4 - -#endif diff --git a/drivers/pocl-gen7/share/pocl/include/pocl_types.h b/drivers/pocl-gen7/share/pocl/include/pocl_types.h deleted file mode 100644 index 7bc5c3f..0000000 --- a/drivers/pocl-gen7/share/pocl/include/pocl_types.h +++ /dev/null @@ -1,179 +0,0 @@ -/* pocl_types.h - The basic OpenCL C device side scalar data types. - - Copyright (c) 2018 Pekka Jääskeläinen / Tampere University of Technology - - Permission is hereby granted, free of charge, to any person obtaining a copy - of this software and associated documentation files (the "Software"), to deal - in the Software without restriction, including without limitation the rights - to use, copy, modify, merge, publish, distribute, sublicense, and/or sell - copies of the Software, and to permit persons to whom the Software is - furnished to do so, subject to the following conditions: - - The above copyright notice and this permission notice shall be included in - all copies or substantial portions of the Software. - - THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR - IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, - FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE - AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER - LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, - OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN - THE SOFTWARE. -*/ - -/* This header is designed to be included both from the device and the host. - In case compiling OpenCL C sources, __OPENCL_VERSION__ should be set. - In case compiling in the host, all but the device-specific types are - defined (size_t and others). Devices should avoid including the C - stdint.h instead of this one as OpenCL C size_t et al. is allowed to - be of different width than when targeting C. - - TODO: replace this header (partially) with Clang's opencl-c.h -*/ - -#ifndef POCL_DEVICE_TYPES_H -#define POCL_DEVICE_TYPES_H - -#ifdef __OPENCL_VERSION__ - -/* required for LLVM 13+ */ -typedef unsigned reserve_id_t; - -#ifdef __USE_CLANG_OPENCL_C_H - -/* Minimal definitions, only the target specific macro overrides, - just in case Clang export the C ones which might differ for - OpenCL C. */ - -#ifdef __INTPTR_TYPE__ -#undef __INTPTR_TYPE__ -#endif - -#ifdef __UINTPTR_TYPE__ -#undef __UINTPTR_TYPE__ -#endif - -#ifdef __SIZE_TYPE__ -#undef __SIZE_TYPE__ -#endif - -#ifdef __SIZE_MAX__ -#undef __SIZE_MAX__ -#endif - -#if defined(POCL_DEVICE_ADDRESS_BITS) && POCL_DEVICE_ADDRESS_BITS == 32 -#define __SIZE_TYPE__ uint -#define __SIZE_MAX__ UINT_MAX -#define __INTPTR_TYPE__ int -#define __UINTPTR_TYPE__ uint -#else -#define __SIZE_TYPE__ ulong -#define __SIZE_MAX__ ULONG_MAX -#define __INTPTR_TYPE__ long -#define __UINTPTR_TYPE__ ulong -#endif - - - -#else - -/* Compiling Device-specific OpenCL C or builtin library C. */ - -#if defined cl_khr_fp64 && !defined cl_khr_int64 -#error "cl_khr_fp64 requires cl_khr_int64" -#endif - -/* TODO FIXME We should not use these in OpenCL library's C code at all. - * The problem is that 1) these are predefined by glibc, 2) while we can - * re-define "ulong", we cannot control the size of "long" at all. - * which can lead to "ulong" being 64bit and "long" 32bit, resulting in - * mysterious errors and bugs. Therefore OpenCL library's C code should - * use the fixed size C types where integer size matters. */ - -#ifdef __CBUILD__ - -/* Builtin library C code definitions. */ - -#define size_t csize_t -#define uintptr_t cuintptr_t -#define intptr_t cintptr_t - -#include - -#undef size_t -#undef uintptr_t -#undef intptr_t - -typedef uint8_t uchar; -typedef uint16_t ushort; -typedef uint32_t uint; - -#ifdef cl_khr_int64 -#if __APPLE__ -typedef unsigned long ulong; -#else -typedef uint64_t ulong; -#endif -#else -typedef uint32_t ulong; -#endif - -#endif - -/* The definitions below intentionally lead to errors if these types - are used when they are not available in the language. This prevents - accidentally using them if the compiler does not disable these - types, but only e.g. defines them with an incorrect size.*/ - -#ifndef cl_khr_fp64 -typedef struct error_undefined_type_double error_undefined_type_double; -#define double error_undefined_type_double -#endif - -#ifdef __SIZE_TYPE__ -#undef __SIZE_TYPE__ -#endif - -#ifdef __SIZE_MAX__ -#undef __SIZE_MAX__ -#endif - -#if defined(POCL_DEVICE_ADDRESS_BITS) && POCL_DEVICE_ADDRESS_BITS == 32 -#define __SIZE_TYPE__ uint -#define __SIZE_MAX__ UINT_MAX -#else -#define __SIZE_TYPE__ ulong -#define __SIZE_MAX__ ULONG_MAX -#endif - -typedef __SIZE_TYPE__ size_t; -typedef __PTRDIFF_TYPE__ ptrdiff_t; -typedef ptrdiff_t intptr_t; -typedef size_t uintptr_t; - -#endif /* #ifdef __USE_CLANG_OPENCL_C_H */ - -#else /* #ifdef __OPENCL_VERSION__ */ - -/* Including from a host source (runtime API implementation). Introduce - the fixed width datatypes, but do not override C's size_t and other - target specific datatypes. */ - -typedef unsigned char uchar; - -/* FIXME see the above TODO about these types. */ - -#if !(defined(_SYS_TYPES_H) && defined(__USE_MISC)) -/* glibc, when including sys/types.h, typedefs these. */ - -typedef unsigned long int ulong; -typedef unsigned short int ushort; -typedef unsigned int uint; - -#endif - -#include - -#endif - -#endif diff --git a/drivers/pocl-gen7/share/pocl/kernel-x86_64-unknown-linux-gnu-ivybridge.bc b/drivers/pocl-gen7/share/pocl/kernel-x86_64-unknown-linux-gnu-ivybridge.bc deleted file mode 100644 index 76f8942..0000000 Binary files a/drivers/pocl-gen7/share/pocl/kernel-x86_64-unknown-linux-gnu-ivybridge.bc and /dev/null differ