[libclc] b231647 - [libclc] Move relational functions to the CLC library (#115171)
via cfe-commits
cfe-commits at lists.llvm.org
Wed Nov 6 11:28:49 PST 2024
Author: Fraser Cormack
Date: 2024-11-06T19:28:44Z
New Revision: b231647475b7fa78ad9382a5505889f1167e9cea
URL: https://github.com/llvm/llvm-project/commit/b231647475b7fa78ad9382a5505889f1167e9cea
DIFF: https://github.com/llvm/llvm-project/commit/b231647475b7fa78ad9382a5505889f1167e9cea.diff
LOG: [libclc] Move relational functions to the CLC library (#115171)
The OpenCL relational functions now call their CLC counterparts, and the
CLC relational functions are defined identically to how the OpenCL
functions were defined.
As usual, clspv and spir-v targets bypass these.
No observable changes to any libclc target (measured with llvm-diff).
Added:
libclc/clc/include/clc/clc_as_type.h
libclc/clc/include/clc/relational/binary_decl.inc
libclc/clc/include/clc/relational/clc_all.h
libclc/clc/include/clc/relational/clc_any.h
libclc/clc/include/clc/relational/clc_bitselect.h
libclc/clc/include/clc/relational/clc_bitselect.inc
libclc/clc/include/clc/relational/clc_isequal.h
libclc/clc/include/clc/relational/clc_isfinite.h
libclc/clc/include/clc/relational/clc_isgreater.h
libclc/clc/include/clc/relational/clc_isgreaterequal.h
libclc/clc/include/clc/relational/clc_isinf.h
libclc/clc/include/clc/relational/clc_isless.h
libclc/clc/include/clc/relational/clc_islessequal.h
libclc/clc/include/clc/relational/clc_islessgreater.h
libclc/clc/include/clc/relational/clc_isnan.h
libclc/clc/include/clc/relational/clc_isnormal.h
libclc/clc/include/clc/relational/clc_isnotequal.h
libclc/clc/include/clc/relational/clc_isordered.h
libclc/clc/include/clc/relational/clc_isunordered.h
libclc/clc/include/clc/relational/clc_select.h
libclc/clc/include/clc/relational/clc_select.inc
libclc/clc/include/clc/relational/clc_signbit.h
libclc/clc/include/clc/relational/floatn.inc
libclc/clc/include/clc/relational/relational.h
libclc/clc/include/clc/relational/unary_decl.inc
libclc/clc/lib/generic/relational/clc_all.cl
libclc/clc/lib/generic/relational/clc_any.cl
libclc/clc/lib/generic/relational/clc_bitselect.cl
libclc/clc/lib/generic/relational/clc_bitselect.inc
libclc/clc/lib/generic/relational/clc_isequal.cl
libclc/clc/lib/generic/relational/clc_isfinite.cl
libclc/clc/lib/generic/relational/clc_isgreater.cl
libclc/clc/lib/generic/relational/clc_isgreaterequal.cl
libclc/clc/lib/generic/relational/clc_isinf.cl
libclc/clc/lib/generic/relational/clc_isless.cl
libclc/clc/lib/generic/relational/clc_islessequal.cl
libclc/clc/lib/generic/relational/clc_islessgreater.cl
libclc/clc/lib/generic/relational/clc_isnan.cl
libclc/clc/lib/generic/relational/clc_isnormal.cl
libclc/clc/lib/generic/relational/clc_isnotequal.cl
libclc/clc/lib/generic/relational/clc_isordered.cl
libclc/clc/lib/generic/relational/clc_isunordered.cl
libclc/clc/lib/generic/relational/clc_select.cl
libclc/clc/lib/generic/relational/clc_select.inc
libclc/clc/lib/generic/relational/clc_signbit.cl
libclc/generic/lib/relational/binary_def.inc
libclc/generic/lib/relational/unary_def.inc
Modified:
libclc/clc/include/clc/internal/clc.h
libclc/clc/lib/generic/SOURCES
libclc/generic/include/clc/relational/any.h
libclc/generic/lib/math/clc_exp10.cl
libclc/generic/lib/math/clc_fma.cl
libclc/generic/lib/math/clc_hypot.cl
libclc/generic/lib/math/clc_ldexp.cl
libclc/generic/lib/math/clc_nextafter.cl
libclc/generic/lib/math/clc_tan.cl
libclc/generic/lib/relational/all.cl
libclc/generic/lib/relational/any.cl
libclc/generic/lib/relational/bitselect.cl
libclc/generic/lib/relational/isequal.cl
libclc/generic/lib/relational/isfinite.cl
libclc/generic/lib/relational/isgreater.cl
libclc/generic/lib/relational/isgreaterequal.cl
libclc/generic/lib/relational/isinf.cl
libclc/generic/lib/relational/isless.cl
libclc/generic/lib/relational/islessequal.cl
libclc/generic/lib/relational/islessgreater.cl
libclc/generic/lib/relational/isnan.cl
libclc/generic/lib/relational/isnormal.cl
libclc/generic/lib/relational/isnotequal.cl
libclc/generic/lib/relational/isordered.cl
libclc/generic/lib/relational/isunordered.cl
libclc/generic/lib/relational/signbit.cl
Removed:
libclc/generic/include/clc/relational/binary_decl.inc
libclc/generic/include/clc/relational/floatn.inc
libclc/generic/include/clc/relational/unary_decl.inc
libclc/generic/lib/relational/relational.h
################################################################################
diff --git a/libclc/clc/include/clc/clc_as_type.h b/libclc/clc/include/clc/clc_as_type.h
new file mode 100644
index 00000000000000..966139523e80b2
--- /dev/null
+++ b/libclc/clc/include/clc/clc_as_type.h
@@ -0,0 +1,82 @@
+#ifndef __CLC_CLC_AS_TYPE_H__
+#define __CLC_CLC_AS_TYPE_H__
+
+#define __clc_as_char(x) __builtin_astype(x, char)
+#define __clc_as_uchar(x) __builtin_astype(x, uchar)
+#define __clc_as_short(x) __builtin_astype(x, short)
+#define __clc_as_ushort(x) __builtin_astype(x, ushort)
+#define __clc_as_int(x) __builtin_astype(x, int)
+#define __clc_as_uint(x) __builtin_astype(x, uint)
+#define __clc_as_long(x) __builtin_astype(x, long)
+#define __clc_as_ulong(x) __builtin_astype(x, ulong)
+#define __clc_as_float(x) __builtin_astype(x, float)
+
+#define __clc_as_char2(x) __builtin_astype(x, char2)
+#define __clc_as_uchar2(x) __builtin_astype(x, uchar2)
+#define __clc_as_short2(x) __builtin_astype(x, short2)
+#define __clc_as_ushort2(x) __builtin_astype(x, ushort2)
+#define __clc_as_int2(x) __builtin_astype(x, int2)
+#define __clc_as_uint2(x) __builtin_astype(x, uint2)
+#define __clc_as_long2(x) __builtin_astype(x, long2)
+#define __clc_as_ulong2(x) __builtin_astype(x, ulong2)
+#define __clc_as_float2(x) __builtin_astype(x, float2)
+
+#define __clc_as_char3(x) __builtin_astype(x, char3)
+#define __clc_as_uchar3(x) __builtin_astype(x, uchar3)
+#define __clc_as_short3(x) __builtin_astype(x, short3)
+#define __clc_as_ushort3(x) __builtin_astype(x, ushort3)
+#define __clc_as_int3(x) __builtin_astype(x, int3)
+#define __clc_as_uint3(x) __builtin_astype(x, uint3)
+#define __clc_as_long3(x) __builtin_astype(x, long3)
+#define __clc_as_ulong3(x) __builtin_astype(x, ulong3)
+#define __clc_as_float3(x) __builtin_astype(x, float3)
+
+#define __clc_as_char4(x) __builtin_astype(x, char4)
+#define __clc_as_uchar4(x) __builtin_astype(x, uchar4)
+#define __clc_as_short4(x) __builtin_astype(x, short4)
+#define __clc_as_ushort4(x) __builtin_astype(x, ushort4)
+#define __clc_as_int4(x) __builtin_astype(x, int4)
+#define __clc_as_uint4(x) __builtin_astype(x, uint4)
+#define __clc_as_long4(x) __builtin_astype(x, long4)
+#define __clc_as_ulong4(x) __builtin_astype(x, ulong4)
+#define __clc_as_float4(x) __builtin_astype(x, float4)
+
+#define __clc_as_char8(x) __builtin_astype(x, char8)
+#define __clc_as_uchar8(x) __builtin_astype(x, uchar8)
+#define __clc_as_short8(x) __builtin_astype(x, short8)
+#define __clc_as_ushort8(x) __builtin_astype(x, ushort8)
+#define __clc_as_int8(x) __builtin_astype(x, int8)
+#define __clc_as_uint8(x) __builtin_astype(x, uint8)
+#define __clc_as_long8(x) __builtin_astype(x, long8)
+#define __clc_as_ulong8(x) __builtin_astype(x, ulong8)
+#define __clc_as_float8(x) __builtin_astype(x, float8)
+
+#define __clc_as_char16(x) __builtin_astype(x, char16)
+#define __clc_as_uchar16(x) __builtin_astype(x, uchar16)
+#define __clc_as_short16(x) __builtin_astype(x, short16)
+#define __clc_as_ushort16(x) __builtin_astype(x, ushort16)
+#define __clc_as_int16(x) __builtin_astype(x, int16)
+#define __clc_as_uint16(x) __builtin_astype(x, uint16)
+#define __clc_as_long16(x) __builtin_astype(x, long16)
+#define __clc_as_ulong16(x) __builtin_astype(x, ulong16)
+#define __clc_as_float16(x) __builtin_astype(x, float16)
+
+#ifdef cl_khr_fp64
+#define __clc_as_double(x) __builtin_astype(x, double)
+#define __clc_as_double2(x) __builtin_astype(x, double2)
+#define __clc_as_double3(x) __builtin_astype(x, double3)
+#define __clc_as_double4(x) __builtin_astype(x, double4)
+#define __clc_as_double8(x) __builtin_astype(x, double8)
+#define __clc_as_double16(x) __builtin_astype(x, double16)
+#endif
+
+#ifdef cl_khr_fp16
+#define __clc_as_half(x) __builtin_astype(x, half)
+#define __clc_as_half2(x) __builtin_astype(x, half2)
+#define __clc_as_half3(x) __builtin_astype(x, half3)
+#define __clc_as_half4(x) __builtin_astype(x, half4)
+#define __clc_as_half8(x) __builtin_astype(x, half8)
+#define __clc_as_half16(x) __builtin_astype(x, half16)
+#endif
+
+#endif // __CLC_CLC_AS_TYPE_H__
diff --git a/libclc/clc/include/clc/internal/clc.h b/libclc/clc/include/clc/internal/clc.h
index c3bdfd754105f7..f448c6c50ba526 100644
--- a/libclc/clc/include/clc/internal/clc.h
+++ b/libclc/clc/include/clc/internal/clc.h
@@ -21,6 +21,9 @@
/* 6.1 Supported Data Types */
#include <clc/clctypes.h>
+/* 6.2.4.2 Reinterpreting Types Using __clc_as_type() and __clc_as_typen() */
+#include <clc/clc_as_type.h>
+
#pragma OPENCL EXTENSION all : disable
#endif // __CLC_INTERNAL_CLC_H_
diff --git a/libclc/clc/include/clc/relational/binary_decl.inc b/libclc/clc/include/clc/relational/binary_decl.inc
new file mode 100644
index 00000000000000..2e4b4fde1efe8f
--- /dev/null
+++ b/libclc/clc/include/clc/relational/binary_decl.inc
@@ -0,0 +1,2 @@
+_CLC_OVERLOAD _CLC_DECL __CLC_INTN __CLC_FUNCTION(__CLC_FLOATN a,
+ __CLC_FLOATN b);
diff --git a/libclc/clc/include/clc/relational/clc_all.h b/libclc/clc/include/clc/relational/clc_all.h
new file mode 100644
index 00000000000000..bf068105aa1be1
--- /dev/null
+++ b/libclc/clc/include/clc/relational/clc_all.h
@@ -0,0 +1,31 @@
+#ifndef __CLC_RELATIONAL_CLC_ALL_H__
+#define __CLC_RELATIONAL_CLC_ALL_H__
+
+#if defined(CLC_CLSPV) || defined(CLC_SPIRV)
+// clspv and spir-v targets provide their own OpenCL-compatible all
+#define __clc_all all
+#else
+
+#include <clc/clcfunc.h>
+
+#define _CLC_ALL_DECL(TYPE) _CLC_OVERLOAD _CLC_DECL int __clc_all(TYPE v);
+
+#define _CLC_VECTOR_ALL_DECL(TYPE) \
+ _CLC_ALL_DECL(TYPE) \
+ _CLC_ALL_DECL(TYPE##2) \
+ _CLC_ALL_DECL(TYPE##3) \
+ _CLC_ALL_DECL(TYPE##4) \
+ _CLC_ALL_DECL(TYPE##8) \
+ _CLC_ALL_DECL(TYPE##16)
+
+_CLC_VECTOR_ALL_DECL(char)
+_CLC_VECTOR_ALL_DECL(short)
+_CLC_VECTOR_ALL_DECL(int)
+_CLC_VECTOR_ALL_DECL(long)
+
+#undef _CLC_ALL_DECL
+#undef _CLC_VECTOR_ALL_DECL
+
+#endif
+
+#endif // __CLC_RELATIONAL_CLC_ALL_H__
diff --git a/libclc/clc/include/clc/relational/clc_any.h b/libclc/clc/include/clc/relational/clc_any.h
new file mode 100644
index 00000000000000..f947b77e08341f
--- /dev/null
+++ b/libclc/clc/include/clc/relational/clc_any.h
@@ -0,0 +1,31 @@
+#ifndef __CLC_RELATIONAL_CLC_ANY_H__
+#define __CLC_RELATIONAL_CLC_ANY_H__
+
+#if defined(CLC_CLSPV) || defined(CLC_SPIRV)
+// clspv and spir-v targets provide their own OpenCL-compatible any
+#define __clc_any any
+#else
+
+#include <clc/clcfunc.h>
+
+#define _CLC_ANY_DECL(TYPE) _CLC_OVERLOAD _CLC_DECL int __clc_any(TYPE v);
+
+#define _CLC_VECTOR_ANY_DECL(TYPE) \
+ _CLC_ANY_DECL(TYPE) \
+ _CLC_ANY_DECL(TYPE##2) \
+ _CLC_ANY_DECL(TYPE##3) \
+ _CLC_ANY_DECL(TYPE##4) \
+ _CLC_ANY_DECL(TYPE##8) \
+ _CLC_ANY_DECL(TYPE##16)
+
+_CLC_VECTOR_ANY_DECL(char)
+_CLC_VECTOR_ANY_DECL(short)
+_CLC_VECTOR_ANY_DECL(int)
+_CLC_VECTOR_ANY_DECL(long)
+
+#undef _CLC_ANY_DECL
+#undef _CLC_VECTOR_ANY_DECL
+
+#endif
+
+#endif // __CLC_RELATIONAL_CLC_ANY_H__
diff --git a/libclc/clc/include/clc/relational/clc_bitselect.h b/libclc/clc/include/clc/relational/clc_bitselect.h
new file mode 100644
index 00000000000000..53fae6a7a2dcba
--- /dev/null
+++ b/libclc/clc/include/clc/relational/clc_bitselect.h
@@ -0,0 +1,33 @@
+/*
+ * Copyright (c) 2015 Advanced Micro Devices, Inc.
+ *
+ * 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 __CLC_RELATIONAL_CLC_BITSELECT_H__
+#define __CLC_RELATIONAL_CLC_BITSELECT_H__
+
+#define __CLC_BODY <clc/relational/clc_bitselect.inc>
+#include <clc/math/gentype.inc>
+#define __CLC_BODY <clc/relational/clc_bitselect.inc>
+#include <clc/integer/gentype.inc>
+
+#undef __CLC_BODY
+
+#endif // __CLC_RELATIONAL_CLC_BITSELECT_H__
diff --git a/libclc/clc/include/clc/relational/clc_bitselect.inc b/libclc/clc/include/clc/relational/clc_bitselect.inc
new file mode 100644
index 00000000000000..14d5bea6dbe7d9
--- /dev/null
+++ b/libclc/clc/include/clc/relational/clc_bitselect.inc
@@ -0,0 +1,25 @@
+/*
+ * Copyright (c) 2015 Advanced Micro Devices, Inc.
+ *
+ * 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.
+ */
+
+_CLC_OVERLOAD _CLC_DECL __CLC_GENTYPE __clc_bitselect(__CLC_GENTYPE x,
+ __CLC_GENTYPE y,
+ __CLC_GENTYPE z);
diff --git a/libclc/clc/include/clc/relational/clc_isequal.h b/libclc/clc/include/clc/relational/clc_isequal.h
new file mode 100644
index 00000000000000..3a36ea24fd2994
--- /dev/null
+++ b/libclc/clc/include/clc/relational/clc_isequal.h
@@ -0,0 +1,41 @@
+#ifndef __CLC_RELATIONAL_CLC_ISEQUAL_H__
+#define __CLC_RELATIONAL_CLC_ISEQUAL_H__
+
+#if defined(CLC_CLSPV) || defined(CLC_SPIRV)
+// clspv and spir-v targets provide their own OpenCL-compatible isequal
+#define __clc_isequal isequal
+#else
+
+#include <clc/clcfunc.h>
+
+#define _CLC_ISEQUAL_DECL(TYPE, RETTYPE) \
+ _CLC_OVERLOAD _CLC_DECL RETTYPE __clc_isequal(TYPE x, TYPE y);
+
+#define _CLC_VECTOR_ISEQUAL_DECL(TYPE, RETTYPE) \
+ _CLC_ISEQUAL_DECL(TYPE##2, RETTYPE##2) \
+ _CLC_ISEQUAL_DECL(TYPE##3, RETTYPE##3) \
+ _CLC_ISEQUAL_DECL(TYPE##4, RETTYPE##4) \
+ _CLC_ISEQUAL_DECL(TYPE##8, RETTYPE##8) \
+ _CLC_ISEQUAL_DECL(TYPE##16, RETTYPE##16)
+
+_CLC_ISEQUAL_DECL(float, int)
+_CLC_VECTOR_ISEQUAL_DECL(float, int)
+
+#ifdef cl_khr_fp64
+#pragma OPENCL EXTENSION cl_khr_fp64 : enable
+_CLC_ISEQUAL_DECL(double, int)
+_CLC_VECTOR_ISEQUAL_DECL(double, long)
+#endif
+
+#ifdef cl_khr_fp16
+#pragma OPENCL EXTENSION cl_khr_fp16 : enable
+_CLC_ISEQUAL_DECL(half, int)
+_CLC_VECTOR_ISEQUAL_DECL(half, short)
+#endif
+
+#undef _CLC_ISEQUAL_DECL
+#undef _CLC_VECTOR_ISEQUAL_DECL
+
+#endif
+
+#endif // __CLC_RELATIONAL_CLC_ISEQUAL_H__
diff --git a/libclc/clc/include/clc/relational/clc_isfinite.h b/libclc/clc/include/clc/relational/clc_isfinite.h
new file mode 100644
index 00000000000000..3ed276e07a2f10
--- /dev/null
+++ b/libclc/clc/include/clc/relational/clc_isfinite.h
@@ -0,0 +1,19 @@
+#ifndef __CLC_RELATIONAL_CLC_ISFINITE_H__
+#define __CLC_RELATIONAL_CLC_ISFINITE_H__
+
+#if defined(CLC_CLSPV) || defined(CLC_SPIRV)
+// clspv and spir-v targets provide their own OpenCL-compatible isfinite
+#define __clc_isfinite isfinite
+#else
+
+#define __CLC_FUNCTION __clc_isfinite
+#define __CLC_BODY <clc/relational/unary_decl.inc>
+
+#include <clc/relational/floatn.inc>
+
+#undef __CLC_BODY
+#undef __CLC_FUNCTION
+
+#endif
+
+#endif // __CLC_RELATIONAL_CLC_ISFINITE_H__
diff --git a/libclc/clc/include/clc/relational/clc_isgreater.h b/libclc/clc/include/clc/relational/clc_isgreater.h
new file mode 100644
index 00000000000000..b51d59aeb54998
--- /dev/null
+++ b/libclc/clc/include/clc/relational/clc_isgreater.h
@@ -0,0 +1,19 @@
+#ifndef __CLC_RELATIONAL_CLC_ISGREATER_H__
+#define __CLC_RELATIONAL_CLC_ISGREATER_H__
+
+#if defined(CLC_CLSPV) || defined(CLC_SPIRV)
+// clspv and spir-v targets provide their own OpenCL-compatible isgreater
+#define __clc_isgreater isgreater
+#else
+
+#define __CLC_FUNCTION __clc_isgreater
+#define __CLC_BODY <clc/relational/binary_decl.inc>
+
+#include <clc/relational/floatn.inc>
+
+#undef __CLC_BODY
+#undef __CLC_FUNCTION
+
+#endif
+
+#endif // __CLC_RELATIONAL_CLC_ISGREATER_H__
diff --git a/libclc/clc/include/clc/relational/clc_isgreaterequal.h b/libclc/clc/include/clc/relational/clc_isgreaterequal.h
new file mode 100644
index 00000000000000..b7ffce151847fd
--- /dev/null
+++ b/libclc/clc/include/clc/relational/clc_isgreaterequal.h
@@ -0,0 +1,19 @@
+#ifndef __CLC_RELATIONAL_CLC_ISGREATEREQUAL_H__
+#define __CLC_RELATIONAL_CLC_ISGREATEREQUAL_H__
+
+#if defined(CLC_CLSPV) || defined(CLC_SPIRV)
+// clspv and spir-v targets provide their own OpenCL-compatible isgreaterequal
+#define __clc_isgreaterequal isgreaterequal
+#else
+
+#define __CLC_FUNCTION __clc_isgreaterequal
+#define __CLC_BODY <clc/relational/binary_decl.inc>
+
+#include <clc/relational/floatn.inc>
+
+#undef __CLC_BODY
+#undef __CLC_FUNCTION
+
+#endif
+
+#endif // __CLC_RELATIONAL_CLC_ISGREATEREQUAL_H__
diff --git a/libclc/clc/include/clc/relational/clc_isinf.h b/libclc/clc/include/clc/relational/clc_isinf.h
new file mode 100644
index 00000000000000..c33ef9bb9527d3
--- /dev/null
+++ b/libclc/clc/include/clc/relational/clc_isinf.h
@@ -0,0 +1,41 @@
+#ifndef __CLC_RELATIONAL_CLC_ISINF_H__
+#define __CLC_RELATIONAL_CLC_ISINF_H__
+
+#if defined(CLC_CLSPV) || defined(CLC_SPIRV)
+// clspv and spir-v targets provide their own OpenCL-compatible isinf
+#define __clc_isinf isinf
+#else
+
+#include <clc/clcfunc.h>
+
+#define _CLC_ISINF_DECL(RET_TYPE, ARG_TYPE) \
+ _CLC_OVERLOAD _CLC_DECL RET_TYPE __clc_isinf(ARG_TYPE);
+
+#define _CLC_VECTOR_ISINF_DECL(RET_TYPE, ARG_TYPE) \
+ _CLC_ISINF_DECL(RET_TYPE##2, ARG_TYPE##2) \
+ _CLC_ISINF_DECL(RET_TYPE##3, ARG_TYPE##3) \
+ _CLC_ISINF_DECL(RET_TYPE##4, ARG_TYPE##4) \
+ _CLC_ISINF_DECL(RET_TYPE##8, ARG_TYPE##8) \
+ _CLC_ISINF_DECL(RET_TYPE##16, ARG_TYPE##16)
+
+_CLC_ISINF_DECL(int, float)
+_CLC_VECTOR_ISINF_DECL(int, float)
+
+#ifdef cl_khr_fp64
+#pragma OPENCL EXTENSION cl_khr_fp64 : enable
+_CLC_ISINF_DECL(int, double)
+_CLC_VECTOR_ISINF_DECL(long, double)
+#endif
+
+#ifdef cl_khr_fp16
+#pragma OPENCL EXTENSION cl_khr_fp16 : enable
+_CLC_ISINF_DECL(int, half)
+_CLC_VECTOR_ISINF_DECL(short, half)
+#endif
+
+#undef _CLC_ISINF_DECL
+#undef _CLC_VECTOR_ISINF_DECL
+
+#endif
+
+#endif // __CLC_RELATIONAL_CLC_ISINF_H__
diff --git a/libclc/clc/include/clc/relational/clc_isless.h b/libclc/clc/include/clc/relational/clc_isless.h
new file mode 100644
index 00000000000000..c6950aa61ad908
--- /dev/null
+++ b/libclc/clc/include/clc/relational/clc_isless.h
@@ -0,0 +1,19 @@
+#ifndef __CLC_RELATIONAL_CLC_ISLESS_H__
+#define __CLC_RELATIONAL_CLC_ISLESS_H__
+
+#if defined(CLC_CLSPV) || defined(CLC_SPIRV)
+// clspv and spir-v targets provide their own OpenCL-compatible isless
+#define __clc_isless isless
+#else
+
+#define __CLC_FUNCTION __clc_isless
+#define __CLC_BODY <clc/relational/binary_decl.inc>
+
+#include <clc/relational/floatn.inc>
+
+#undef __CLC_BODY
+#undef __CLC_FUNCTION
+
+#endif
+
+#endif // __CLC_RELATIONAL_CLC_ISLESS_H__
diff --git a/libclc/clc/include/clc/relational/clc_islessequal.h b/libclc/clc/include/clc/relational/clc_islessequal.h
new file mode 100644
index 00000000000000..7efac163e106a2
--- /dev/null
+++ b/libclc/clc/include/clc/relational/clc_islessequal.h
@@ -0,0 +1,19 @@
+#ifndef __CLC_RELATIONAL_CLC_ISLESSEQUAL_H__
+#define __CLC_RELATIONAL_CLC_ISLESSEQUAL_H__
+
+#if defined(CLC_CLSPV) || defined(CLC_SPIRV)
+// clspv and spir-v targets provide their own OpenCL-compatible islessequal
+#define __clc_islessequal islessequal
+#else
+
+#define __CLC_FUNCTION __clc_islessequal
+#define __CLC_BODY <clc/relational/binary_decl.inc>
+
+#include <clc/relational/floatn.inc>
+
+#undef __CLC_BODY
+#undef __CLC_FUNCTION
+
+#endif
+
+#endif // __CLC_RELATIONAL_CLC_ISLESSEQUAL_H__
diff --git a/libclc/clc/include/clc/relational/clc_islessgreater.h b/libclc/clc/include/clc/relational/clc_islessgreater.h
new file mode 100644
index 00000000000000..df3c5e513c86ce
--- /dev/null
+++ b/libclc/clc/include/clc/relational/clc_islessgreater.h
@@ -0,0 +1,19 @@
+#ifndef __CLC_RELATIONAL_CLC_ISLESSGREATER_H__
+#define __CLC_RELATIONAL_CLC_ISLESSGREATER_H__
+
+#if defined(CLC_CLSPV) || defined(CLC_SPIRV)
+// clspv and spir-v targets provide their own OpenCL-compatible islessgreater
+#define __clc_islessgreater islessgreater
+#else
+
+#define __CLC_FUNCTION __clc_islessgreater
+#define __CLC_BODY <clc/relational/binary_decl.inc>
+
+#include <clc/relational/floatn.inc>
+
+#undef __CLC_BODY
+#undef __CLC_FUNCTION
+
+#endif
+
+#endif // __CLC_RELATIONAL_CLC_ISLESSGREATER_H__
diff --git a/libclc/clc/include/clc/relational/clc_isnan.h b/libclc/clc/include/clc/relational/clc_isnan.h
new file mode 100644
index 00000000000000..08351eb5515f9c
--- /dev/null
+++ b/libclc/clc/include/clc/relational/clc_isnan.h
@@ -0,0 +1,41 @@
+#ifndef __CLC_RELATIONAL_CLC_ISNAN_H__
+#define __CLC_RELATIONAL_CLC_ISNAN_H__
+
+#if defined(CLC_CLSPV) || defined(CLC_SPIRV)
+// clspv and spir-v targets provide their own OpenCL-compatible isnan
+#define __clc_isnan isnan
+#else
+
+#include <clc/clcfunc.h>
+
+#define _CLC_ISNAN_DECL(RET_TYPE, ARG_TYPE) \
+ _CLC_OVERLOAD _CLC_DECL RET_TYPE __clc_isnan(ARG_TYPE);
+
+#define _CLC_VECTOR_ISNAN_DECL(RET_TYPE, ARG_TYPE) \
+ _CLC_ISNAN_DECL(RET_TYPE##2, ARG_TYPE##2) \
+ _CLC_ISNAN_DECL(RET_TYPE##3, ARG_TYPE##3) \
+ _CLC_ISNAN_DECL(RET_TYPE##4, ARG_TYPE##4) \
+ _CLC_ISNAN_DECL(RET_TYPE##8, ARG_TYPE##8) \
+ _CLC_ISNAN_DECL(RET_TYPE##16, ARG_TYPE##16)
+
+_CLC_ISNAN_DECL(int, float)
+_CLC_VECTOR_ISNAN_DECL(int, float)
+
+#ifdef cl_khr_fp64
+#pragma OPENCL EXTENSION cl_khr_fp64 : enable
+_CLC_ISNAN_DECL(int, double)
+_CLC_VECTOR_ISNAN_DECL(long, double)
+#endif
+
+#ifdef cl_khr_fp16
+#pragma OPENCL EXTENSION cl_khr_fp16 : enable
+_CLC_ISNAN_DECL(int, half)
+_CLC_VECTOR_ISNAN_DECL(short, half)
+#endif
+
+#undef _CLC_ISNAN_DECL
+#undef _CLC_VECTOR_ISNAN_DECL
+
+#endif
+
+#endif // __CLC_RELATIONAL_CLC_ISNAN_H__
diff --git a/libclc/clc/include/clc/relational/clc_isnormal.h b/libclc/clc/include/clc/relational/clc_isnormal.h
new file mode 100644
index 00000000000000..48ee6b83a5711b
--- /dev/null
+++ b/libclc/clc/include/clc/relational/clc_isnormal.h
@@ -0,0 +1,19 @@
+#ifndef __CLC_RELATIONAL_CLC_ISNORMAL_H__
+#define __CLC_RELATIONAL_CLC_ISNORMAL_H__
+
+#if defined(CLC_CLSPV) || defined(CLC_SPIRV)
+// clspv and spir-v targets provide their own OpenCL-compatible isnormal
+#define __clc_isnormal isnormal
+#else
+
+#define __CLC_FUNCTION __clc_isnormal
+#define __CLC_BODY <clc/relational/unary_decl.inc>
+
+#include <clc/relational/floatn.inc>
+
+#undef __CLC_BODY
+#undef __CLC_FUNCTION
+
+#endif
+
+#endif // __CLC_RELATIONAL_CLC_ISNORMAL_H__
diff --git a/libclc/clc/include/clc/relational/clc_isnotequal.h b/libclc/clc/include/clc/relational/clc_isnotequal.h
new file mode 100644
index 00000000000000..55c1bd91b2dd5d
--- /dev/null
+++ b/libclc/clc/include/clc/relational/clc_isnotequal.h
@@ -0,0 +1,19 @@
+#ifndef __CLC_RELATIONAL_CLC_ISNOTEQUAL_H__
+#define __CLC_RELATIONAL_CLC_ISNOTEQUAL_H__
+
+#if defined(CLC_CLSPV) || defined(CLC_SPIRV)
+// clspv and spir-v targets provide their own OpenCL-compatible isnotequal
+#define __clc_isnotequal isnotequal
+#else
+
+#define __CLC_FUNCTION __clc_isnotequal
+#define __CLC_BODY <clc/relational/binary_decl.inc>
+
+#include <clc/relational/floatn.inc>
+
+#undef __CLC_BODY
+#undef __CLC_FUNCTION
+
+#endif
+
+#endif // __CLC_RELATIONAL_CLC_ISNOTEQUAL_H__
diff --git a/libclc/clc/include/clc/relational/clc_isordered.h b/libclc/clc/include/clc/relational/clc_isordered.h
new file mode 100644
index 00000000000000..5ce2bfe334027f
--- /dev/null
+++ b/libclc/clc/include/clc/relational/clc_isordered.h
@@ -0,0 +1,19 @@
+#ifndef __CLC_RELATIONAL_CLC_ISORDERED_H__
+#define __CLC_RELATIONAL_CLC_ISORDERED_H__
+
+#if defined(CLC_CLSPV) || defined(CLC_SPIRV)
+// clspv and spir-v targets provide their own OpenCL-compatible isordered
+#define __clc_isordered isordered
+#else
+
+#define __CLC_FUNCTION __clc_isordered
+#define __CLC_BODY <clc/relational/binary_decl.inc>
+
+#include <clc/relational/floatn.inc>
+
+#undef __CLC_BODY
+#undef __CLC_FUNCTION
+
+#endif
+
+#endif // __CLC_RELATIONAL_CLC_ISORDERED_H__
diff --git a/libclc/clc/include/clc/relational/clc_isunordered.h b/libclc/clc/include/clc/relational/clc_isunordered.h
new file mode 100644
index 00000000000000..305d2b4e9131ff
--- /dev/null
+++ b/libclc/clc/include/clc/relational/clc_isunordered.h
@@ -0,0 +1,19 @@
+#ifndef __CLC_RELATIONAL_CLC_ISUNORDERED_H__
+#define __CLC_RELATIONAL_CLC_ISUNORDERED_H__
+
+#if defined(CLC_CLSPV) || defined(CLC_SPIRV)
+// clspv and spir-v targets provide their own OpenCL-compatible isunordered
+#define __clc_isunordered isunordered
+#else
+
+#define __CLC_FUNCTION __clc_isunordered
+#define __CLC_BODY <clc/relational/binary_decl.inc>
+
+#include <clc/relational/floatn.inc>
+
+#undef __CLC_BODY
+#undef __CLC_FUNCTION
+
+#endif
+
+#endif // __CLC_RELATIONAL_CLC_ISUNORDERED_H__
diff --git a/libclc/clc/include/clc/relational/clc_select.h b/libclc/clc/include/clc/relational/clc_select.h
new file mode 100644
index 00000000000000..ddea7c528ec74a
--- /dev/null
+++ b/libclc/clc/include/clc/relational/clc_select.h
@@ -0,0 +1,23 @@
+#ifndef __CLC_RELATIONAL_CLC_SELECT_H__
+#define __CLC_RELATIONAL_CLC_SELECT_H__
+
+#if defined(CLC_CLSPV) || defined(CLC_SPIRV)
+// clspv and spir-v targets provide their own OpenCL-compatible select
+#define __clc_select select
+#else
+
+/* Duplciate these so we don't have to distribute utils.h */
+#define __CLC_CONCAT(x, y) x##y
+#define __CLC_XCONCAT(x, y) __CLC_CONCAT(x, y)
+
+#define __CLC_BODY <clc/relational/clc_select.inc>
+#include <clc/math/gentype.inc>
+#define __CLC_BODY <clc/relational/clc_select.inc>
+#include <clc/integer/gentype.inc>
+
+#undef __CLC_CONCAT
+#undef __CLC_XCONCAT
+
+#endif
+
+#endif // __CLC_RELATIONAL_CLC_SELECT_H__
diff --git a/libclc/clc/include/clc/relational/clc_select.inc b/libclc/clc/include/clc/relational/clc_select.inc
new file mode 100644
index 00000000000000..abf0e0fa436003
--- /dev/null
+++ b/libclc/clc/include/clc/relational/clc_select.inc
@@ -0,0 +1,29 @@
+#ifdef __CLC_SCALAR
+#define __CLC_VECSIZE
+#endif
+
+#if __CLC_FPSIZE == 64
+#define __CLC_S_GENTYPE __CLC_XCONCAT(long, __CLC_VECSIZE)
+#define __CLC_U_GENTYPE __CLC_XCONCAT(ulong, __CLC_VECSIZE)
+#elif __CLC_FPSIZE == 32
+#define __CLC_S_GENTYPE __CLC_XCONCAT(int, __CLC_VECSIZE)
+#define __CLC_U_GENTYPE __CLC_XCONCAT(uint, __CLC_VECSIZE)
+#elif __CLC_FPSIZE == 16
+#define __CLC_S_GENTYPE __CLC_XCONCAT(short, __CLC_VECSIZE)
+#define __CLC_U_GENTYPE __CLC_XCONCAT(ushort, __CLC_VECSIZE)
+#endif
+
+_CLC_OVERLOAD _CLC_DECL __CLC_GENTYPE __clc_select(__CLC_GENTYPE x,
+ __CLC_GENTYPE y,
+ __CLC_S_GENTYPE z);
+_CLC_OVERLOAD _CLC_DECL __CLC_GENTYPE __clc_select(__CLC_GENTYPE x,
+ __CLC_GENTYPE y,
+ __CLC_U_GENTYPE z);
+
+#ifdef __CLC_FPSIZE
+#undef __CLC_S_GENTYPE
+#undef __CLC_U_GENTYPE
+#endif
+#ifdef __CLC_SCALAR
+#undef __CLC_VECSIZE
+#endif
diff --git a/libclc/clc/include/clc/relational/clc_signbit.h b/libclc/clc/include/clc/relational/clc_signbit.h
new file mode 100644
index 00000000000000..45a7112c9eb969
--- /dev/null
+++ b/libclc/clc/include/clc/relational/clc_signbit.h
@@ -0,0 +1,19 @@
+#ifndef __CLC_RELATIONAL_CLC_SIGNBIT_H__
+#define __CLC_RELATIONAL_CLC_SIGNBIT_H__
+
+#if defined(CLC_CLSPV) || defined(CLC_SPIRV)
+// clspv and spir-v targets provide their own OpenCL-compatible signbit
+#define __clc_signbit signbit
+#else
+
+#define __CLC_FUNCTION __clc_signbit
+#define __CLC_BODY <clc/relational/unary_decl.inc>
+
+#include <clc/relational/floatn.inc>
+
+#undef __CLC_BODY
+#undef __CLC_FUNCTION
+
+#endif
+
+#endif // __CLC_RELATIONAL_CLC_SIGNBIT_H__
diff --git a/libclc/generic/include/clc/relational/floatn.inc b/libclc/clc/include/clc/relational/floatn.inc
similarity index 100%
rename from libclc/generic/include/clc/relational/floatn.inc
rename to libclc/clc/include/clc/relational/floatn.inc
diff --git a/libclc/clc/include/clc/relational/relational.h b/libclc/clc/include/clc/relational/relational.h
new file mode 100644
index 00000000000000..54241b6493c8e7
--- /dev/null
+++ b/libclc/clc/include/clc/relational/relational.h
@@ -0,0 +1,145 @@
+#ifndef __CLC_RELATIONAL_RELATIONAL_H__
+#define __CLC_RELATIONAL_RELATIONAL_H__
+
+/*
+ * Contains relational macros that have to return 1 for scalar and -1 for vector
+ * when the result is true.
+ */
+
+#define _CLC_DEFINE_RELATIONAL_UNARY_SCALAR(RET_TYPE, FUNCTION, BUILTIN_NAME, \
+ ARG_TYPE) \
+ _CLC_DEF _CLC_OVERLOAD RET_TYPE FUNCTION(ARG_TYPE x) { \
+ return BUILTIN_NAME(x); \
+ }
+
+#define _CLC_DEFINE_RELATIONAL_UNARY_VEC2(RET_TYPE, FUNCTION, ARG_TYPE) \
+ _CLC_DEF _CLC_OVERLOAD RET_TYPE FUNCTION(ARG_TYPE x) { \
+ return (RET_TYPE)((RET_TYPE){FUNCTION(x.lo), FUNCTION(x.hi)} != \
+ (RET_TYPE)0); \
+ }
+
+#define _CLC_DEFINE_RELATIONAL_UNARY_VEC3(RET_TYPE, FUNCTION, ARG_TYPE) \
+ _CLC_DEF _CLC_OVERLOAD RET_TYPE FUNCTION(ARG_TYPE x) { \
+ return (RET_TYPE)((RET_TYPE){FUNCTION(x.s0), FUNCTION(x.s1), \
+ FUNCTION(x.s2)} != (RET_TYPE)0); \
+ }
+
+#define _CLC_DEFINE_RELATIONAL_UNARY_VEC4(RET_TYPE, FUNCTION, ARG_TYPE) \
+ _CLC_DEF _CLC_OVERLOAD RET_TYPE FUNCTION(ARG_TYPE x) { \
+ return (RET_TYPE)((RET_TYPE){FUNCTION(x.s0), FUNCTION(x.s1), \
+ FUNCTION(x.s2), \
+ FUNCTION(x.s3)} != (RET_TYPE)0); \
+ }
+
+#define _CLC_DEFINE_RELATIONAL_UNARY_VEC8(RET_TYPE, FUNCTION, ARG_TYPE) \
+ _CLC_DEF _CLC_OVERLOAD RET_TYPE FUNCTION(ARG_TYPE x) { \
+ return ( \
+ RET_TYPE)((RET_TYPE){FUNCTION(x.s0), FUNCTION(x.s1), FUNCTION(x.s2), \
+ FUNCTION(x.s3), FUNCTION(x.s4), FUNCTION(x.s5), \
+ FUNCTION(x.s6), FUNCTION(x.s7)} != (RET_TYPE)0); \
+ }
+
+#define _CLC_DEFINE_RELATIONAL_UNARY_VEC16(RET_TYPE, FUNCTION, ARG_TYPE) \
+ _CLC_DEF _CLC_OVERLOAD RET_TYPE FUNCTION(ARG_TYPE x) { \
+ return ( \
+ RET_TYPE)((RET_TYPE){FUNCTION(x.s0), FUNCTION(x.s1), FUNCTION(x.s2), \
+ FUNCTION(x.s3), FUNCTION(x.s4), FUNCTION(x.s5), \
+ FUNCTION(x.s6), FUNCTION(x.s7), FUNCTION(x.s8), \
+ FUNCTION(x.s9), FUNCTION(x.sa), FUNCTION(x.sb), \
+ FUNCTION(x.sc), FUNCTION(x.sd), FUNCTION(x.se), \
+ FUNCTION(x.sf)} != (RET_TYPE)0); \
+ }
+
+#define _CLC_DEFINE_RELATIONAL_UNARY_VEC_ALL(RET_TYPE, FUNCTION, ARG_TYPE) \
+ _CLC_DEFINE_RELATIONAL_UNARY_VEC2(RET_TYPE##2, FUNCTION, ARG_TYPE##2) \
+ _CLC_DEFINE_RELATIONAL_UNARY_VEC3(RET_TYPE##3, FUNCTION, ARG_TYPE##3) \
+ _CLC_DEFINE_RELATIONAL_UNARY_VEC4(RET_TYPE##4, FUNCTION, ARG_TYPE##4) \
+ _CLC_DEFINE_RELATIONAL_UNARY_VEC8(RET_TYPE##8, FUNCTION, ARG_TYPE##8) \
+ _CLC_DEFINE_RELATIONAL_UNARY_VEC16(RET_TYPE##16, FUNCTION, ARG_TYPE##16)
+
+#define _CLC_DEFINE_RELATIONAL_UNARY(RET_TYPE, FUNCTION, BUILTIN_FUNCTION, \
+ ARG_TYPE) \
+ _CLC_DEFINE_RELATIONAL_UNARY_SCALAR(RET_TYPE, FUNCTION, BUILTIN_FUNCTION, \
+ ARG_TYPE) \
+ _CLC_DEFINE_RELATIONAL_UNARY_VEC_ALL(RET_TYPE, FUNCTION, ARG_TYPE)
+
+#define _CLC_DEFINE_RELATIONAL_BINARY_SCALAR(RET_TYPE, FUNCTION, BUILTIN_NAME, \
+ ARG0_TYPE, ARG1_TYPE) \
+ _CLC_DEF _CLC_OVERLOAD RET_TYPE FUNCTION(ARG0_TYPE x, ARG1_TYPE y) { \
+ return BUILTIN_NAME(x, y); \
+ }
+
+#define _CLC_DEFINE_RELATIONAL_BINARY_VEC(RET_TYPE, FUNCTION, ARG0_TYPE, \
+ ARG1_TYPE) \
+ _CLC_DEF _CLC_OVERLOAD RET_TYPE FUNCTION(ARG0_TYPE x, ARG1_TYPE y) { \
+ return (RET_TYPE)((RET_TYPE){FUNCTION(x.lo, y.lo), \
+ FUNCTION(x.hi, y.hi)} != (RET_TYPE)0); \
+ }
+
+#define _CLC_DEFINE_RELATIONAL_BINARY_VEC2(RET_TYPE, FUNCTION, ARG0_TYPE, \
+ ARG1_TYPE) \
+ _CLC_DEF _CLC_OVERLOAD RET_TYPE FUNCTION(ARG0_TYPE x, ARG1_TYPE y) { \
+ return (RET_TYPE)((RET_TYPE){FUNCTION(x.lo, y.lo), \
+ FUNCTION(x.hi, y.hi)} != (RET_TYPE)0); \
+ }
+
+#define _CLC_DEFINE_RELATIONAL_BINARY_VEC3(RET_TYPE, FUNCTION, ARG0_TYPE, \
+ ARG1_TYPE) \
+ _CLC_DEF _CLC_OVERLOAD RET_TYPE FUNCTION(ARG0_TYPE x, ARG1_TYPE y) { \
+ return (RET_TYPE)((RET_TYPE){FUNCTION(x.s0, y.s0), FUNCTION(x.s1, y.s1), \
+ FUNCTION(x.s2, y.s2)} != (RET_TYPE)0); \
+ }
+
+#define _CLC_DEFINE_RELATIONAL_BINARY_VEC4(RET_TYPE, FUNCTION, ARG0_TYPE, \
+ ARG1_TYPE) \
+ _CLC_DEF _CLC_OVERLOAD RET_TYPE FUNCTION(ARG0_TYPE x, ARG1_TYPE y) { \
+ return (RET_TYPE)((RET_TYPE){FUNCTION(x.s0, y.s0), FUNCTION(x.s1, y.s1), \
+ FUNCTION(x.s2, y.s2), \
+ FUNCTION(x.s3, y.s3)} != (RET_TYPE)0); \
+ }
+
+#define _CLC_DEFINE_RELATIONAL_BINARY_VEC8(RET_TYPE, FUNCTION, ARG0_TYPE, \
+ ARG1_TYPE) \
+ _CLC_DEF _CLC_OVERLOAD RET_TYPE FUNCTION(ARG0_TYPE x, ARG1_TYPE y) { \
+ return (RET_TYPE)((RET_TYPE){FUNCTION(x.s0, y.s0), FUNCTION(x.s1, y.s1), \
+ FUNCTION(x.s2, y.s2), FUNCTION(x.s3, y.s3), \
+ FUNCTION(x.s4, y.s4), FUNCTION(x.s5, y.s5), \
+ FUNCTION(x.s6, y.s6), \
+ FUNCTION(x.s7, y.s7)} != (RET_TYPE)0); \
+ }
+
+#define _CLC_DEFINE_RELATIONAL_BINARY_VEC16(RET_TYPE, FUNCTION, ARG0_TYPE, \
+ ARG1_TYPE) \
+ _CLC_DEF _CLC_OVERLOAD RET_TYPE FUNCTION(ARG0_TYPE x, ARG1_TYPE y) { \
+ return (RET_TYPE)((RET_TYPE){FUNCTION(x.s0, y.s0), FUNCTION(x.s1, y.s1), \
+ FUNCTION(x.s2, y.s2), FUNCTION(x.s3, y.s3), \
+ FUNCTION(x.s4, y.s4), FUNCTION(x.s5, y.s5), \
+ FUNCTION(x.s6, y.s6), FUNCTION(x.s7, y.s7), \
+ FUNCTION(x.s8, y.s8), FUNCTION(x.s9, y.s9), \
+ FUNCTION(x.sa, y.sa), FUNCTION(x.sb, y.sb), \
+ FUNCTION(x.sc, y.sc), FUNCTION(x.sd, y.sd), \
+ FUNCTION(x.se, y.se), \
+ FUNCTION(x.sf, y.sf)} != (RET_TYPE)0); \
+ }
+
+#define _CLC_DEFINE_RELATIONAL_BINARY_VEC_ALL(RET_TYPE, FUNCTION, ARG0_TYPE, \
+ ARG1_TYPE) \
+ _CLC_DEFINE_RELATIONAL_BINARY_VEC2(RET_TYPE##2, FUNCTION, ARG0_TYPE##2, \
+ ARG1_TYPE##2) \
+ _CLC_DEFINE_RELATIONAL_BINARY_VEC3(RET_TYPE##3, FUNCTION, ARG0_TYPE##3, \
+ ARG1_TYPE##3) \
+ _CLC_DEFINE_RELATIONAL_BINARY_VEC4(RET_TYPE##4, FUNCTION, ARG0_TYPE##4, \
+ ARG1_TYPE##4) \
+ _CLC_DEFINE_RELATIONAL_BINARY_VEC8(RET_TYPE##8, FUNCTION, ARG0_TYPE##8, \
+ ARG1_TYPE##8) \
+ _CLC_DEFINE_RELATIONAL_BINARY_VEC16(RET_TYPE##16, FUNCTION, ARG0_TYPE##16, \
+ ARG1_TYPE##16)
+
+#define _CLC_DEFINE_RELATIONAL_BINARY(RET_TYPE, FUNCTION, BUILTIN_FUNCTION, \
+ ARG0_TYPE, ARG1_TYPE) \
+ _CLC_DEFINE_RELATIONAL_BINARY_SCALAR(RET_TYPE, FUNCTION, BUILTIN_FUNCTION, \
+ ARG0_TYPE, ARG1_TYPE) \
+ _CLC_DEFINE_RELATIONAL_BINARY_VEC_ALL(RET_TYPE, FUNCTION, ARG0_TYPE, \
+ ARG1_TYPE)
+
+#endif // __CLC_RELATIONAL_RELATIONAL_H__
diff --git a/libclc/generic/include/clc/relational/unary_decl.inc b/libclc/clc/include/clc/relational/unary_decl.inc
similarity index 100%
rename from libclc/generic/include/clc/relational/unary_decl.inc
rename to libclc/clc/include/clc/relational/unary_decl.inc
diff --git a/libclc/clc/lib/generic/SOURCES b/libclc/clc/lib/generic/SOURCES
index bcf715ff376078..d7ffaaf6dc3f42 100644
--- a/libclc/clc/lib/generic/SOURCES
+++ b/libclc/clc/lib/generic/SOURCES
@@ -1,6 +1,24 @@
geometric/clc_dot.cl
integer/clc_abs.cl
integer/clc_abs_
diff .cl
+relational/clc_all.cl
+relational/clc_any.cl
+relational/clc_bitselect.cl
+relational/clc_isequal.cl
+relational/clc_isfinite.cl
+relational/clc_isgreater.cl
+relational/clc_isgreaterequal.cl
+relational/clc_isinf.cl
+relational/clc_isless.cl
+relational/clc_islessequal.cl
+relational/clc_islessgreater.cl
+relational/clc_isnan.cl
+relational/clc_isnormal.cl
+relational/clc_isnotequal.cl
+relational/clc_isordered.cl
+relational/clc_isunordered.cl
+relational/clc_select.cl
+relational/clc_signbit.cl
shared/clc_clamp.cl
shared/clc_max.cl
shared/clc_min.cl
diff --git a/libclc/clc/lib/generic/relational/clc_all.cl b/libclc/clc/lib/generic/relational/clc_all.cl
new file mode 100644
index 00000000000000..e371126d144f06
--- /dev/null
+++ b/libclc/clc/lib/generic/relational/clc_all.cl
@@ -0,0 +1,28 @@
+#include <clc/internal/clc.h>
+
+#define _CLC_ALL(v) (((v) >> ((sizeof(v) * 8) - 1)) & 0x1)
+#define _CLC_ALL2(v) (_CLC_ALL((v).s0) & _CLC_ALL((v).s1))
+#define _CLC_ALL3(v) (_CLC_ALL2((v)) & _CLC_ALL((v).s2))
+#define _CLC_ALL4(v) (_CLC_ALL3((v)) & _CLC_ALL((v).s3))
+#define _CLC_ALL8(v) \
+ (_CLC_ALL4((v)) & _CLC_ALL((v).s4) & _CLC_ALL((v).s5) & _CLC_ALL((v).s6) & \
+ _CLC_ALL((v).s7))
+#define _CLC_ALL16(v) \
+ (_CLC_ALL8((v)) & _CLC_ALL((v).s8) & _CLC_ALL((v).s9) & _CLC_ALL((v).sA) & \
+ _CLC_ALL((v).sB) & _CLC_ALL((v).sC) & _CLC_ALL((v).sD) & _CLC_ALL((v).sE) & \
+ _CLC_ALL((v).sf))
+
+#define ALL_ID(TYPE) _CLC_OVERLOAD _CLC_DEF int __clc_all(TYPE v)
+
+#define ALL_VECTORIZE(TYPE) \
+ ALL_ID(TYPE) { return _CLC_ALL(v); } \
+ ALL_ID(TYPE##2) { return _CLC_ALL2(v); } \
+ ALL_ID(TYPE##3) { return _CLC_ALL3(v); } \
+ ALL_ID(TYPE##4) { return _CLC_ALL4(v); } \
+ ALL_ID(TYPE##8) { return _CLC_ALL8(v); } \
+ ALL_ID(TYPE##16) { return _CLC_ALL16(v); }
+
+ALL_VECTORIZE(char)
+ALL_VECTORIZE(short)
+ALL_VECTORIZE(int)
+ALL_VECTORIZE(long)
diff --git a/libclc/clc/lib/generic/relational/clc_any.cl b/libclc/clc/lib/generic/relational/clc_any.cl
new file mode 100644
index 00000000000000..e69f2113c94f55
--- /dev/null
+++ b/libclc/clc/lib/generic/relational/clc_any.cl
@@ -0,0 +1,28 @@
+#include <clc/internal/clc.h>
+
+#define _CLC_ANY(v) (((v) >> ((sizeof(v) * 8) - 1)) & 0x1)
+#define _CLC_ANY2(v) (_CLC_ANY((v).s0) | _CLC_ANY((v).s1))
+#define _CLC_ANY3(v) (_CLC_ANY2((v)) | _CLC_ANY((v).s2))
+#define _CLC_ANY4(v) (_CLC_ANY3((v)) | _CLC_ANY((v).s3))
+#define _CLC_ANY8(v) \
+ (_CLC_ANY4((v)) | _CLC_ANY((v).s4) | _CLC_ANY((v).s5) | _CLC_ANY((v).s6) | \
+ _CLC_ANY((v).s7))
+#define _CLC_ANY16(v) \
+ (_CLC_ANY8((v)) | _CLC_ANY((v).s8) | _CLC_ANY((v).s9) | _CLC_ANY((v).sA) | \
+ _CLC_ANY((v).sB) | _CLC_ANY((v).sC) | _CLC_ANY((v).sD) | _CLC_ANY((v).sE) | \
+ _CLC_ANY((v).sf))
+
+#define ANY_ID(TYPE) _CLC_OVERLOAD _CLC_DEF int __clc_any(TYPE v)
+
+#define ANY_VECTORIZE(TYPE) \
+ ANY_ID(TYPE) { return _CLC_ANY(v); } \
+ ANY_ID(TYPE##2) { return _CLC_ANY2(v); } \
+ ANY_ID(TYPE##3) { return _CLC_ANY3(v); } \
+ ANY_ID(TYPE##4) { return _CLC_ANY4(v); } \
+ ANY_ID(TYPE##8) { return _CLC_ANY8(v); } \
+ ANY_ID(TYPE##16) { return _CLC_ANY16(v); }
+
+ANY_VECTORIZE(char)
+ANY_VECTORIZE(short)
+ANY_VECTORIZE(int)
+ANY_VECTORIZE(long)
diff --git a/libclc/clc/lib/generic/relational/clc_bitselect.cl b/libclc/clc/lib/generic/relational/clc_bitselect.cl
new file mode 100644
index 00000000000000..66b28af71b38d3
--- /dev/null
+++ b/libclc/clc/lib/generic/relational/clc_bitselect.cl
@@ -0,0 +1,55 @@
+/*
+ * Copyright (c) 2014,2015 Advanced Micro Devices, Inc.
+ *
+ * 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.
+ */
+
+#include <clc/clcmacro.h>
+#include <clc/internal/clc.h>
+
+#define __CLC_BODY <clc_bitselect.inc>
+#include <clc/integer/gentype.inc>
+#undef __CLC_BODY
+
+#define FLOAT_BITSELECT(f_type, i_type, width) \
+ _CLC_OVERLOAD _CLC_DEF f_type##width __clc_bitselect( \
+ f_type##width x, f_type##width y, f_type##width z) { \
+ return __clc_as_##f_type##width(__clc_bitselect( \
+ __clc_as_##i_type##width(x), __clc_as_##i_type##width(y), \
+ __clc_as_##i_type##width(z))); \
+ }
+
+FLOAT_BITSELECT(float, uint, )
+FLOAT_BITSELECT(float, uint, 2)
+FLOAT_BITSELECT(float, uint, 3)
+FLOAT_BITSELECT(float, uint, 4)
+FLOAT_BITSELECT(float, uint, 8)
+FLOAT_BITSELECT(float, uint, 16)
+
+#ifdef cl_khr_fp64
+#pragma OPENCL EXTENSION cl_khr_fp64 : enable
+
+FLOAT_BITSELECT(double, ulong, )
+FLOAT_BITSELECT(double, ulong, 2)
+FLOAT_BITSELECT(double, ulong, 3)
+FLOAT_BITSELECT(double, ulong, 4)
+FLOAT_BITSELECT(double, ulong, 8)
+FLOAT_BITSELECT(double, ulong, 16)
+
+#endif
diff --git a/libclc/clc/lib/generic/relational/clc_bitselect.inc b/libclc/clc/lib/generic/relational/clc_bitselect.inc
new file mode 100644
index 00000000000000..dc906ef6bee0bd
--- /dev/null
+++ b/libclc/clc/lib/generic/relational/clc_bitselect.inc
@@ -0,0 +1,27 @@
+/*
+ * Copyright (c) 2014,2015 Advanced Micro Devices, Inc.
+ *
+ * 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.
+ */
+
+_CLC_OVERLOAD _CLC_DEF __CLC_GENTYPE __clc_bitselect(__CLC_GENTYPE x,
+ __CLC_GENTYPE y,
+ __CLC_GENTYPE z) {
+ return ((x) ^ ((z) & ((y) ^ (x))));
+}
diff --git a/libclc/clc/lib/generic/relational/clc_isequal.cl b/libclc/clc/lib/generic/relational/clc_isequal.cl
new file mode 100644
index 00000000000000..7664df7767cb3f
--- /dev/null
+++ b/libclc/clc/lib/generic/relational/clc_isequal.cl
@@ -0,0 +1,44 @@
+#include <clc/internal/clc.h>
+
+#define _CLC_DEFINE_ISEQUAL(RET_TYPE, FUNCTION, ARG1_TYPE, ARG2_TYPE) \
+ _CLC_DEF _CLC_OVERLOAD RET_TYPE FUNCTION(ARG1_TYPE x, ARG2_TYPE y) { \
+ return (x == y); \
+ }
+
+_CLC_DEFINE_ISEQUAL(int, __clc_isequal, float, float)
+_CLC_DEFINE_ISEQUAL(int2, __clc_isequal, float2, float2)
+_CLC_DEFINE_ISEQUAL(int3, __clc_isequal, float3, float3)
+_CLC_DEFINE_ISEQUAL(int4, __clc_isequal, float4, float4)
+_CLC_DEFINE_ISEQUAL(int8, __clc_isequal, float8, float8)
+_CLC_DEFINE_ISEQUAL(int16, __clc_isequal, float16, float16)
+
+#ifdef cl_khr_fp64
+
+#pragma OPENCL EXTENSION cl_khr_fp64 : enable
+
+// The scalar version of __clc_isequal(double) returns an int, but the vector
+// versions return long.
+_CLC_DEFINE_ISEQUAL(int, __clc_isequal, double, double)
+_CLC_DEFINE_ISEQUAL(long2, __clc_isequal, double2, double2)
+_CLC_DEFINE_ISEQUAL(long3, __clc_isequal, double3, double3)
+_CLC_DEFINE_ISEQUAL(long4, __clc_isequal, double4, double4)
+_CLC_DEFINE_ISEQUAL(long8, __clc_isequal, double8, double8)
+_CLC_DEFINE_ISEQUAL(long16, __clc_isequal, double16, double16)
+
+#endif
+#ifdef cl_khr_fp16
+
+#pragma OPENCL EXTENSION cl_khr_fp16 : enable
+
+// The scalar version of __clc_isequal(half) returns an int, but the vector
+// versions return short.
+_CLC_DEFINE_ISEQUAL(int, __clc_isequal, half, half)
+_CLC_DEFINE_ISEQUAL(short2, __clc_isequal, half2, half2)
+_CLC_DEFINE_ISEQUAL(short3, __clc_isequal, half3, half3)
+_CLC_DEFINE_ISEQUAL(short4, __clc_isequal, half4, half4)
+_CLC_DEFINE_ISEQUAL(short8, __clc_isequal, half8, half8)
+_CLC_DEFINE_ISEQUAL(short16, __clc_isequal, half16, half16)
+
+#endif
+
+#undef _CLC_DEFINE_ISEQUAL
diff --git a/libclc/clc/lib/generic/relational/clc_isfinite.cl b/libclc/clc/lib/generic/relational/clc_isfinite.cl
new file mode 100644
index 00000000000000..c3def5dc5f0d51
--- /dev/null
+++ b/libclc/clc/lib/generic/relational/clc_isfinite.cl
@@ -0,0 +1,31 @@
+#include <clc/internal/clc.h>
+#include <clc/relational/relational.h>
+
+_CLC_DEFINE_RELATIONAL_UNARY(int, __clc_isfinite, __builtin_isfinite, float)
+
+#ifdef cl_khr_fp64
+
+#pragma OPENCL EXTENSION cl_khr_fp64 : enable
+
+// The scalar version of __clc_isfinite(double) returns an int, but the vector
+// versions return long.
+_CLC_DEF _CLC_OVERLOAD int __clc_isfinite(double x) {
+ return __builtin_isfinite(x);
+}
+
+_CLC_DEFINE_RELATIONAL_UNARY_VEC_ALL(long, __clc_isfinite, double)
+
+#endif
+#ifdef cl_khr_fp16
+
+#pragma OPENCL EXTENSION cl_khr_fp16 : enable
+
+// The scalar version of __clc_isfinite(half) returns an int, but the vector
+// versions return short.
+_CLC_DEF _CLC_OVERLOAD int __clc_isfinite(half x) {
+ return __builtin_isfinite(x);
+}
+
+_CLC_DEFINE_RELATIONAL_UNARY_VEC_ALL(short, __clc_isfinite, half)
+
+#endif
diff --git a/libclc/clc/lib/generic/relational/clc_isgreater.cl b/libclc/clc/lib/generic/relational/clc_isgreater.cl
new file mode 100644
index 00000000000000..39fb6b07fb1859
--- /dev/null
+++ b/libclc/clc/lib/generic/relational/clc_isgreater.cl
@@ -0,0 +1,39 @@
+#include <clc/internal/clc.h>
+#include <clc/relational/relational.h>
+
+// Note: It would be nice to use __builtin_isgreater with vector inputs, but it
+// seems to only take scalar values as input, which will produce incorrect
+// output for vector input types.
+
+_CLC_DEFINE_RELATIONAL_BINARY(int, __clc_isgreater, __builtin_isgreater, float,
+ float)
+
+#ifdef cl_khr_fp64
+
+#pragma OPENCL EXTENSION cl_khr_fp64 : enable
+
+// The scalar version of __clc_isgreater(double, double) returns an int, but the
+// vector versions return long.
+
+_CLC_DEF _CLC_OVERLOAD int __clc_isgreater(double x, double y) {
+ return __builtin_isgreater(x, y);
+}
+
+_CLC_DEFINE_RELATIONAL_BINARY_VEC_ALL(long, __clc_isgreater, double, double)
+
+#endif
+
+#ifdef cl_khr_fp16
+
+#pragma OPENCL EXTENSION cl_khr_fp16 : enable
+
+// The scalar version of __clc_isgreater(half, half) returns an int, but the
+// vector versions return short.
+
+_CLC_DEF _CLC_OVERLOAD int __clc_isgreater(half x, half y) {
+ return __builtin_isgreater(x, y);
+}
+
+_CLC_DEFINE_RELATIONAL_BINARY_VEC_ALL(short, __clc_isgreater, half, half)
+
+#endif
diff --git a/libclc/clc/lib/generic/relational/clc_isgreaterequal.cl b/libclc/clc/lib/generic/relational/clc_isgreaterequal.cl
new file mode 100644
index 00000000000000..ccf7c881a5549b
--- /dev/null
+++ b/libclc/clc/lib/generic/relational/clc_isgreaterequal.cl
@@ -0,0 +1,39 @@
+#include <clc/internal/clc.h>
+#include <clc/relational/relational.h>
+
+// Note: It would be nice to use __builtin_isgreaterequal with vector inputs,
+// but it seems to only take scalar values as input, which will produce
+// incorrect output for vector input types.
+
+_CLC_DEFINE_RELATIONAL_BINARY(int, __clc_isgreaterequal,
+ __builtin_isgreaterequal, float, float)
+
+#ifdef cl_khr_fp64
+
+#pragma OPENCL EXTENSION cl_khr_fp64 : enable
+
+// The scalar version of __clc_isgreaterequal(double, double) returns an int,
+// but the vector versions return long.
+
+_CLC_DEF _CLC_OVERLOAD int __clc_isgreaterequal(double x, double y) {
+ return __builtin_isgreaterequal(x, y);
+}
+
+_CLC_DEFINE_RELATIONAL_BINARY_VEC_ALL(long, __clc_isgreaterequal, double,
+ double)
+
+#endif
+#ifdef cl_khr_fp16
+
+#pragma OPENCL EXTENSION cl_khr_fp16 : enable
+
+// The scalar version of __clc_isgreaterequal(half, half) returns an int, but
+// the vector versions return short.
+
+_CLC_DEF _CLC_OVERLOAD int __clc_isgreaterequal(half x, half y) {
+ return __builtin_isgreaterequal(x, y);
+}
+
+_CLC_DEFINE_RELATIONAL_BINARY_VEC_ALL(short, __clc_isgreaterequal, half, half)
+
+#endif
diff --git a/libclc/clc/lib/generic/relational/clc_isinf.cl b/libclc/clc/lib/generic/relational/clc_isinf.cl
new file mode 100644
index 00000000000000..afe29122f36a3e
--- /dev/null
+++ b/libclc/clc/lib/generic/relational/clc_isinf.cl
@@ -0,0 +1,26 @@
+#include <clc/internal/clc.h>
+#include <clc/relational/relational.h>
+
+_CLC_DEFINE_RELATIONAL_UNARY(int, __clc_isinf, __builtin_isinf, float)
+
+#ifdef cl_khr_fp64
+
+#pragma OPENCL EXTENSION cl_khr_fp64 : enable
+
+// The scalar version of __clc_isinf(double) returns an int, but the vector
+// versions return long.
+_CLC_DEF _CLC_OVERLOAD int __clc_isinf(double x) { return __builtin_isinf(x); }
+
+_CLC_DEFINE_RELATIONAL_UNARY_VEC_ALL(long, __clc_isinf, double)
+#endif
+
+#ifdef cl_khr_fp16
+
+#pragma OPENCL EXTENSION cl_khr_fp16 : enable
+
+// The scalar version of __clc_isinf(half) returns an int, but the vector
+// versions return short.
+_CLC_DEF _CLC_OVERLOAD int __clc_isinf(half x) { return __builtin_isinf(x); }
+
+_CLC_DEFINE_RELATIONAL_UNARY_VEC_ALL(short, __clc_isinf, half)
+#endif
diff --git a/libclc/clc/lib/generic/relational/clc_isless.cl b/libclc/clc/lib/generic/relational/clc_isless.cl
new file mode 100644
index 00000000000000..1204a5057d8640
--- /dev/null
+++ b/libclc/clc/lib/generic/relational/clc_isless.cl
@@ -0,0 +1,37 @@
+#include <clc/internal/clc.h>
+#include <clc/relational/relational.h>
+
+// Note: It would be nice to use __builtin_isless with vector inputs, but it
+// seems to only take scalar values as input, which will produce incorrect
+// output for vector input types.
+
+_CLC_DEFINE_RELATIONAL_BINARY(int, __clc_isless, __builtin_isless, float, float)
+
+#ifdef cl_khr_fp64
+
+#pragma OPENCL EXTENSION cl_khr_fp64 : enable
+
+// The scalar version of __clc_isless(double, double) returns an int, but the
+// vector versions return long.
+
+_CLC_DEF _CLC_OVERLOAD int __clc_isless(double x, double y) {
+ return __builtin_isless(x, y);
+}
+
+_CLC_DEFINE_RELATIONAL_BINARY_VEC_ALL(long, __clc_isless, double, double)
+
+#endif
+#ifdef cl_khr_fp16
+
+#pragma OPENCL EXTENSION cl_khr_fp16 : enable
+
+// The scalar version of __clc_isless(half, half) returns an int, but the vector
+// versions return short.
+
+_CLC_DEF _CLC_OVERLOAD int __clc_isless(half x, half y) {
+ return __builtin_isless(x, y);
+}
+
+_CLC_DEFINE_RELATIONAL_BINARY_VEC_ALL(short, __clc_isless, half, half)
+
+#endif
diff --git a/libclc/clc/lib/generic/relational/clc_islessequal.cl b/libclc/clc/lib/generic/relational/clc_islessequal.cl
new file mode 100644
index 00000000000000..6fde763263e2b0
--- /dev/null
+++ b/libclc/clc/lib/generic/relational/clc_islessequal.cl
@@ -0,0 +1,39 @@
+#include <clc/internal/clc.h>
+#include <clc/relational/relational.h>
+
+// Note: It would be nice to use __builtin_islessequal with vector inputs, but
+// it seems to only take scalar values as input, which will produce incorrect
+// output for vector input types.
+
+_CLC_DEFINE_RELATIONAL_BINARY(int, __clc_islessequal, __builtin_islessequal,
+ float, float)
+
+#ifdef cl_khr_fp64
+
+#pragma OPENCL EXTENSION cl_khr_fp64 : enable
+
+// The scalar version of __clc_islessequal(double, double) returns an int, but
+// the vector versions return long.
+
+_CLC_DEF _CLC_OVERLOAD int __clc_islessequal(double x, double y) {
+ return __builtin_islessequal(x, y);
+}
+
+_CLC_DEFINE_RELATIONAL_BINARY_VEC_ALL(long, __clc_islessequal, double, double)
+
+#endif
+
+#ifdef cl_khr_fp16
+
+#pragma OPENCL EXTENSION cl_khr_fp16 : enable
+
+// The scalar version of __clc_islessequal(half, half) returns an int, but the
+// vector versions return short.
+
+_CLC_DEF _CLC_OVERLOAD int __clc_islessequal(half x, half y) {
+ return __builtin_islessequal(x, y);
+}
+
+_CLC_DEFINE_RELATIONAL_BINARY_VEC_ALL(short, __clc_islessequal, half, half)
+
+#endif
diff --git a/libclc/clc/lib/generic/relational/clc_islessgreater.cl b/libclc/clc/lib/generic/relational/clc_islessgreater.cl
new file mode 100644
index 00000000000000..5106c9f460e2ca
--- /dev/null
+++ b/libclc/clc/lib/generic/relational/clc_islessgreater.cl
@@ -0,0 +1,38 @@
+#include <clc/internal/clc.h>
+#include <clc/relational/relational.h>
+
+// Note: It would be nice to use __builtin_islessgreater with vector inputs, but
+// it seems to only take scalar values as input, which will produce incorrect
+// output for vector input types.
+
+_CLC_DEFINE_RELATIONAL_BINARY(int, __clc_islessgreater, __builtin_islessgreater,
+ float, float)
+
+#ifdef cl_khr_fp64
+
+#pragma OPENCL EXTENSION cl_khr_fp64 : enable
+
+// The scalar version of __clc_islessgreater(double, double) returns an int, but
+// the vector versions return long.
+
+_CLC_DEF _CLC_OVERLOAD int __clc_islessgreater(double x, double y) {
+ return __builtin_islessgreater(x, y);
+}
+
+_CLC_DEFINE_RELATIONAL_BINARY_VEC_ALL(long, __clc_islessgreater, double, double)
+
+#endif
+#ifdef cl_khr_fp16
+
+#pragma OPENCL EXTENSION cl_khr_fp16 : enable
+
+// The scalar version of __clc_islessgreater(half, half) returns an int, but the
+// vector versions return short.
+
+_CLC_DEF _CLC_OVERLOAD int __clc_islessgreater(half x, half y) {
+ return __builtin_islessgreater(x, y);
+}
+
+_CLC_DEFINE_RELATIONAL_BINARY_VEC_ALL(short, __clc_islessgreater, half, half)
+
+#endif
diff --git a/libclc/clc/lib/generic/relational/clc_isnan.cl b/libclc/clc/lib/generic/relational/clc_isnan.cl
new file mode 100644
index 00000000000000..fb30cd5419214b
--- /dev/null
+++ b/libclc/clc/lib/generic/relational/clc_isnan.cl
@@ -0,0 +1,28 @@
+#include <clc/internal/clc.h>
+#include <clc/relational/relational.h>
+
+_CLC_DEFINE_RELATIONAL_UNARY(int, __clc_isnan, __builtin_isnan, float)
+
+#ifdef cl_khr_fp64
+
+#pragma OPENCL EXTENSION cl_khr_fp64 : enable
+
+// The scalar version of __clc_isnan(double) returns an int, but the vector
+// versions return long.
+_CLC_DEF _CLC_OVERLOAD int __clc_isnan(double x) { return __builtin_isnan(x); }
+
+_CLC_DEFINE_RELATIONAL_UNARY_VEC_ALL(long, __clc_isnan, double)
+
+#endif
+
+#ifdef cl_khr_fp16
+
+#pragma OPENCL EXTENSION cl_khr_fp16 : enable
+
+// The scalar version of __clc_isnan(half) returns an int, but the vector
+// versions return short.
+_CLC_DEF _CLC_OVERLOAD int __clc_isnan(half x) { return __builtin_isnan(x); }
+
+_CLC_DEFINE_RELATIONAL_UNARY_VEC_ALL(short, __clc_isnan, half)
+
+#endif
diff --git a/libclc/clc/lib/generic/relational/clc_isnormal.cl b/libclc/clc/lib/generic/relational/clc_isnormal.cl
new file mode 100644
index 00000000000000..e0da8cc0756f42
--- /dev/null
+++ b/libclc/clc/lib/generic/relational/clc_isnormal.cl
@@ -0,0 +1,31 @@
+#include <clc/internal/clc.h>
+#include <clc/relational/relational.h>
+
+_CLC_DEFINE_RELATIONAL_UNARY(int, __clc_isnormal, __builtin_isnormal, float)
+
+#ifdef cl_khr_fp64
+
+#pragma OPENCL EXTENSION cl_khr_fp64 : enable
+
+// The scalar version of __clc_isnormal(double) returns an int, but the vector
+// versions return long.
+_CLC_DEF _CLC_OVERLOAD int __clc_isnormal(double x) {
+ return __builtin_isnormal(x);
+}
+
+_CLC_DEFINE_RELATIONAL_UNARY_VEC_ALL(long, __clc_isnormal, double)
+
+#endif
+#ifdef cl_khr_fp16
+
+#pragma OPENCL EXTENSION cl_khr_fp16 : enable
+
+// The scalar version of __clc_isnormal(half) returns an int, but the vector
+// versions return short.
+_CLC_DEF _CLC_OVERLOAD int __clc_isnormal(half x) {
+ return __builtin_isnormal(x);
+}
+
+_CLC_DEFINE_RELATIONAL_UNARY_VEC_ALL(short, __clc_isnormal, half)
+
+#endif
diff --git a/libclc/clc/lib/generic/relational/clc_isnotequal.cl b/libclc/clc/lib/generic/relational/clc_isnotequal.cl
new file mode 100644
index 00000000000000..9f90713b2da508
--- /dev/null
+++ b/libclc/clc/lib/generic/relational/clc_isnotequal.cl
@@ -0,0 +1,33 @@
+#include <clc/internal/clc.h>
+#include <clc/relational/relational.h>
+
+#define _CLC_DEFINE_ISNOTEQUAL(RET_TYPE, FUNCTION, ARG1_TYPE, ARG2_TYPE) \
+ _CLC_DEF _CLC_OVERLOAD RET_TYPE FUNCTION(ARG1_TYPE x, ARG2_TYPE y) { \
+ return (x != y); \
+ }
+
+_CLC_DEFINE_ISNOTEQUAL(int, __clc_isnotequal, float, float)
+_CLC_DEFINE_RELATIONAL_BINARY_VEC_ALL(int, __clc_isnotequal, float, float)
+
+#ifdef cl_khr_fp64
+#pragma OPENCL EXTENSION cl_khr_fp64 : enable
+
+// The scalar version of __clc_isnotequal(double, double) returns an int, but
+// the vector versions return long.
+
+_CLC_DEFINE_ISNOTEQUAL(int, __clc_isnotequal, double, double)
+_CLC_DEFINE_RELATIONAL_BINARY_VEC_ALL(long, __clc_isnotequal, double, double)
+
+#endif
+#ifdef cl_khr_fp16
+#pragma OPENCL EXTENSION cl_khr_fp16 : enable
+
+// The scalar version of __clc_isnotequal(half, half) returns an int, but the
+// vector versions return short.
+
+_CLC_DEFINE_ISNOTEQUAL(int, __clc_isnotequal, half, half)
+_CLC_DEFINE_RELATIONAL_BINARY_VEC_ALL(short, __clc_isnotequal, half, half)
+
+#endif
+
+#undef _CLC_DEFINE_ISNOTEQUAL
diff --git a/libclc/clc/lib/generic/relational/clc_isordered.cl b/libclc/clc/lib/generic/relational/clc_isordered.cl
new file mode 100644
index 00000000000000..6183d1ddf918f5
--- /dev/null
+++ b/libclc/clc/lib/generic/relational/clc_isordered.cl
@@ -0,0 +1,34 @@
+#include <clc/internal/clc.h>
+#include <clc/relational/clc_isequal.h>
+#include <clc/relational/relational.h>
+
+#define _CLC_DEFINE_ISORDERED(RET_TYPE, FUNCTION, ARG1_TYPE, ARG2_TYPE) \
+ _CLC_DEF _CLC_OVERLOAD RET_TYPE FUNCTION(ARG1_TYPE x, ARG2_TYPE y) { \
+ return __clc_isequal(x, x) && __clc_isequal(y, y); \
+ }
+
+_CLC_DEFINE_ISORDERED(int, __clc_isordered, float, float)
+_CLC_DEFINE_RELATIONAL_BINARY_VEC_ALL(int, __clc_isordered, float, float)
+
+#ifdef cl_khr_fp64
+#pragma OPENCL EXTENSION cl_khr_fp64 : enable
+
+// The scalar version of __clc_isordered(double, double) returns an int, but the
+// vector versions return long.
+
+_CLC_DEFINE_ISORDERED(int, __clc_isordered, double, double)
+_CLC_DEFINE_RELATIONAL_BINARY_VEC_ALL(long, __clc_isordered, double, double)
+
+#endif
+#ifdef cl_khr_fp16
+#pragma OPENCL EXTENSION cl_khr_fp16 : enable
+
+// The scalar version of __clc_isordered(half, half) returns an int, but the
+// vector versions return short.
+
+_CLC_DEFINE_ISORDERED(int, __clc_isordered, half, half)
+_CLC_DEFINE_RELATIONAL_BINARY_VEC_ALL(short, __clc_isordered, half, half)
+
+#endif
+
+#undef _CLC_DEFINE_ISORDERED
diff --git a/libclc/clc/lib/generic/relational/clc_isunordered.cl b/libclc/clc/lib/generic/relational/clc_isunordered.cl
new file mode 100644
index 00000000000000..dbbec031a65e58
--- /dev/null
+++ b/libclc/clc/lib/generic/relational/clc_isunordered.cl
@@ -0,0 +1,38 @@
+#include <clc/internal/clc.h>
+#include <clc/relational/relational.h>
+
+// Note: It would be nice to use __builtin_isunordered with vector inputs, but
+// it seems to only take scalar values as input, which will produce incorrect
+// output for vector input types.
+
+_CLC_DEFINE_RELATIONAL_BINARY(int, __clc_isunordered, __builtin_isunordered,
+ float, float)
+
+#ifdef cl_khr_fp64
+
+#pragma OPENCL EXTENSION cl_khr_fp64 : enable
+
+// The scalar version of __clc_isunordered(double, double) returns an int, but
+// the vector versions return long.
+
+_CLC_DEF _CLC_OVERLOAD int __clc_isunordered(double x, double y) {
+ return __builtin_isunordered(x, y);
+}
+
+_CLC_DEFINE_RELATIONAL_BINARY_VEC_ALL(long, __clc_isunordered, double, double)
+
+#endif
+#ifdef cl_khr_fp16
+
+#pragma OPENCL EXTENSION cl_khr_fp16 : enable
+
+// The scalar version of __clc_isunordered(half, half) returns an int, but the
+// vector versions return short.
+
+_CLC_DEF _CLC_OVERLOAD int __clc_isunordered(half x, half y) {
+ return __builtin_isunordered(x, y);
+}
+
+_CLC_DEFINE_RELATIONAL_BINARY_VEC_ALL(short, __clc_isunordered, half, half)
+
+#endif
diff --git a/libclc/clc/lib/generic/relational/clc_select.cl b/libclc/clc/lib/generic/relational/clc_select.cl
new file mode 100644
index 00000000000000..bb016ed2993e7e
--- /dev/null
+++ b/libclc/clc/lib/generic/relational/clc_select.cl
@@ -0,0 +1,7 @@
+#include <clc/internal/clc.h>
+#include <clc/utils.h>
+
+#define __CLC_BODY <clc_select.inc>
+#include <clc/math/gentype.inc>
+#define __CLC_BODY <clc_select.inc>
+#include <clc/integer/gentype.inc>
diff --git a/libclc/clc/lib/generic/relational/clc_select.inc b/libclc/clc/lib/generic/relational/clc_select.inc
new file mode 100644
index 00000000000000..47db80672a02c2
--- /dev/null
+++ b/libclc/clc/lib/generic/relational/clc_select.inc
@@ -0,0 +1,35 @@
+#ifdef __CLC_SCALAR
+#define __CLC_VECSIZE
+#endif
+
+#if __CLC_FPSIZE == 64
+#define __CLC_S_GENTYPE __CLC_XCONCAT(long, __CLC_VECSIZE)
+#define __CLC_U_GENTYPE __CLC_XCONCAT(ulong, __CLC_VECSIZE)
+#elif __CLC_FPSIZE == 32
+#define __CLC_S_GENTYPE __CLC_XCONCAT(int, __CLC_VECSIZE)
+#define __CLC_U_GENTYPE __CLC_XCONCAT(uint, __CLC_VECSIZE)
+#elif __CLC_FPSIZE == 16
+#define __CLC_S_GENTYPE __CLC_XCONCAT(short, __CLC_VECSIZE)
+#define __CLC_U_GENTYPE __CLC_XCONCAT(ushort, __CLC_VECSIZE)
+#endif
+
+_CLC_OVERLOAD _CLC_DEF __CLC_GENTYPE __clc_select(__CLC_GENTYPE x,
+ __CLC_GENTYPE y,
+ __CLC_S_GENTYPE z) {
+ return z ? y : x;
+}
+
+_CLC_OVERLOAD _CLC_DEF __CLC_GENTYPE __clc_select(__CLC_GENTYPE x,
+ __CLC_GENTYPE y,
+ __CLC_U_GENTYPE z) {
+ return z ? y : x;
+}
+
+#ifdef __CLC_FPSIZE
+#undef __CLC_S_GENTYPE
+#undef __CLC_U_GENTYPE
+#endif
+
+#ifdef __CLC_SCALAR
+#undef __CLC_VECSIZE
+#endif
diff --git a/libclc/clc/lib/generic/relational/clc_signbit.cl b/libclc/clc/lib/generic/relational/clc_signbit.cl
new file mode 100644
index 00000000000000..b1b294379e5a82
--- /dev/null
+++ b/libclc/clc/lib/generic/relational/clc_signbit.cl
@@ -0,0 +1,33 @@
+#include <clc/internal/clc.h>
+#include <clc/relational/relational.h>
+
+_CLC_DEFINE_RELATIONAL_UNARY(int, __clc_signbit, __builtin_signbitf, float)
+
+#ifdef cl_khr_fp64
+
+#pragma OPENCL EXTENSION cl_khr_fp64 : enable
+
+// The scalar version of __clc_signbit(double) returns an int, but the vector
+// versions return long.
+
+_CLC_DEF _CLC_OVERLOAD int __clc_signbit(double x) {
+ return __builtin_signbit(x);
+}
+
+_CLC_DEFINE_RELATIONAL_UNARY_VEC_ALL(long, __clc_signbit, double)
+
+#endif
+#ifdef cl_khr_fp16
+
+#pragma OPENCL EXTENSION cl_khr_fp16 : enable
+
+// The scalar version of __clc_signbit(half) returns an int, but the vector
+// versions return short.
+
+_CLC_DEF _CLC_OVERLOAD int __clc_signbit(half x) {
+ return __builtin_signbit(x);
+}
+
+_CLC_DEFINE_RELATIONAL_UNARY_VEC_ALL(short, __clc_signbit, half)
+
+#endif
diff --git a/libclc/generic/include/clc/relational/any.h b/libclc/generic/include/clc/relational/any.h
index 4687ed263793e5..3989796262dd36 100644
--- a/libclc/generic/include/clc/relational/any.h
+++ b/libclc/generic/include/clc/relational/any.h
@@ -14,3 +14,6 @@ _CLC_VECTOR_ANY_DECL(char)
_CLC_VECTOR_ANY_DECL(short)
_CLC_VECTOR_ANY_DECL(int)
_CLC_VECTOR_ANY_DECL(long)
+
+#undef _CLC_ANY_DECL
+#undef _CLC_VECTOR_ANY_DECL
diff --git a/libclc/generic/include/clc/relational/binary_decl.inc b/libclc/generic/include/clc/relational/binary_decl.inc
deleted file mode 100644
index c9e4aee839a17c..00000000000000
--- a/libclc/generic/include/clc/relational/binary_decl.inc
+++ /dev/null
@@ -1 +0,0 @@
-_CLC_OVERLOAD _CLC_DECL __CLC_INTN __CLC_FUNCTION(__CLC_FLOATN a, __CLC_FLOATN b);
diff --git a/libclc/generic/lib/math/clc_exp10.cl b/libclc/generic/lib/math/clc_exp10.cl
index 01e6fd652004a9..6ea8743e39c5f7 100644
--- a/libclc/generic/lib/math/clc_exp10.cl
+++ b/libclc/generic/lib/math/clc_exp10.cl
@@ -22,6 +22,7 @@
#include <clc/clc.h>
#include <clc/clcmacro.h>
+#include <clc/relational/clc_isnan.h>
#include "config.h"
#include "math.h"
@@ -62,7 +63,7 @@ _CLC_DEF _CLC_OVERLOAD float __clc_exp10(float x)
const float R_LOG10_2_BY_64_TL = 0x1.04d426p-18f; // log2/(64 * log10) tail : 0.00000388665057
const float R_LN10 = 0x1.26bb1cp+1f;
- int return_nan = isnan(x);
+ int return_nan = __clc_isnan(x);
int return_inf = x > X_MAX;
int return_zero = x < X_MIN;
@@ -138,7 +139,7 @@ _CLC_DEF _CLC_OVERLOAD double __clc_exp10(double x)
z2 = ldexp(z2, m);
z2 = small_value ? z3: z2;
- z2 = isnan(x) ? x : z2;
+ z2 = __clc_isnan(x) ? x : z2;
z2 = x > X_MAX ? as_double(PINFBITPATT_DP64) : z2;
z2 = x < X_MIN ? 0.0 : z2;
diff --git a/libclc/generic/lib/math/clc_fma.cl b/libclc/generic/lib/math/clc_fma.cl
index 4013360bcd0612..15de4c8032a932 100644
--- a/libclc/generic/lib/math/clc_fma.cl
+++ b/libclc/generic/lib/math/clc_fma.cl
@@ -23,6 +23,8 @@
#include <clc/clc.h>
#include <clc/clcmacro.h>
#include <clc/integer/clc_abs.h>
+#include <clc/relational/clc_isinf.h>
+#include <clc/relational/clc_isnan.h>
#include <clc/shared/clc_max.h>
#include "config.h"
@@ -36,11 +38,12 @@ struct fp {
_CLC_DEF _CLC_OVERLOAD float __clc_sw_fma(float a, float b, float c) {
/* special cases */
- if (isnan(a) || isnan(b) || isnan(c) || isinf(a) || isinf(b))
+ if (__clc_isnan(a) || __clc_isnan(b) || __clc_isnan(c) || __clc_isinf(a) ||
+ __clc_isinf(b))
return mad(a, b, c);
/* If only c is inf, and both a,b are regular numbers, the result is c*/
- if (isinf(c))
+ if (__clc_isinf(c))
return c;
a = __clc_flush_denormal_if_not_supported(a);
diff --git a/libclc/generic/lib/math/clc_hypot.cl b/libclc/generic/lib/math/clc_hypot.cl
index abc000770ae3f3..a17e661603fa67 100644
--- a/libclc/generic/lib/math/clc_hypot.cl
+++ b/libclc/generic/lib/math/clc_hypot.cl
@@ -23,6 +23,7 @@
#include <clc/clc.h>
#include <clc/clcmacro.h>
#include <clc/integer/clc_abs.h>
+#include <clc/relational/clc_isnan.h>
#include <clc/shared/clc_clamp.h>
#include <math/clc_hypot.h>
@@ -88,7 +89,7 @@ _CLC_DEF _CLC_OVERLOAD double __clc_hypot(double x, double y) {
// Check for NaN
// c = x != x | y != y;
- c = isnan(x) | isnan(y);
+ c = __clc_isnan(x) | __clc_isnan(y);
r = c ? as_double(QNANBITPATT_DP64) : r;
// If either is Inf, we must return Inf
diff --git a/libclc/generic/lib/math/clc_ldexp.cl b/libclc/generic/lib/math/clc_ldexp.cl
index ccb37631706b80..6d3721588df813 100644
--- a/libclc/generic/lib/math/clc_ldexp.cl
+++ b/libclc/generic/lib/math/clc_ldexp.cl
@@ -24,6 +24,8 @@
#include "math.h"
#include <clc/clc.h>
#include <clc/clcmacro.h>
+#include <clc/relational/clc_isinf.h>
+#include <clc/relational/clc_isnan.h>
#include <clc/shared/clc_clamp.h>
_CLC_DEF _CLC_OVERLOAD float __clc_ldexp(float x, int n) {
@@ -90,7 +92,7 @@ _CLC_DEF _CLC_OVERLOAD float __clc_ldexp(float x, int n) {
val_ui = dexp == 0 ? dval_ui : val_ui;
val_f = as_float(val_ui);
- val_f = isnan(x) | isinf(x) | val_x == 0 ? x : val_f;
+ val_f = __clc_isnan(x) | __clc_isinf(x) | val_x == 0 ? x : val_f;
return val_f;
}
@@ -123,7 +125,7 @@ _CLC_DEF _CLC_OVERLOAD double __clc_ldexp(double x, int n) {
mr = v == 0x7ff ? as_double(s | PINFBITPATT_DP64) : mr;
mr = v < -53 ? as_double(s) : mr;
- mr = ((n == 0) | isinf(x) | (x == 0)) ? x : mr;
+ mr = ((n == 0) | __clc_isinf(x) | (x == 0)) ? x : mr;
return mr;
}
diff --git a/libclc/generic/lib/math/clc_nextafter.cl b/libclc/generic/lib/math/clc_nextafter.cl
index ccb7624d20c56f..623eb11c18c3b1 100644
--- a/libclc/generic/lib/math/clc_nextafter.cl
+++ b/libclc/generic/lib/math/clc_nextafter.cl
@@ -1,41 +1,44 @@
#include <clc/clc.h>
#include <clc/clcmacro.h>
+#include <clc/relational/clc_isnan.h>
// This file provides OpenCL C implementations of nextafter for
// targets that don't support the clang builtin.
#define AS_TYPE(x) as_##x
-#define NEXTAFTER(FLOAT_TYPE, UINT_TYPE, INT_TYPE) \
-_CLC_OVERLOAD _CLC_DEF FLOAT_TYPE __clc_nextafter(FLOAT_TYPE x, FLOAT_TYPE y) { \
- const UINT_TYPE sign_bit \
- = (UINT_TYPE)1 << (sizeof(INT_TYPE) * 8 - 1); \
- const UINT_TYPE sign_bit_mask = sign_bit - 1; \
- INT_TYPE ix = AS_TYPE(INT_TYPE)(x); \
- INT_TYPE ax = ix & sign_bit_mask; \
- INT_TYPE mx = sign_bit - ix; \
- mx = ix < 0 ? mx : ix; \
- INT_TYPE iy = AS_TYPE(INT_TYPE)(y); \
- INT_TYPE ay = iy & sign_bit_mask; \
- INT_TYPE my = sign_bit - iy; \
- my = iy < 0 ? my : iy; \
- INT_TYPE t = mx + (mx < my ? 1 : -1); \
- INT_TYPE r = sign_bit - t; \
- r = t < 0 ? r : t; \
- r = isnan(x) ? ix : r; \
- r = isnan(y) ? iy : r; \
- r = ((ax | ay) == 0 | ix == iy) ? iy : r; \
- return AS_TYPE(FLOAT_TYPE)(r); \
-}
+#define NEXTAFTER(FLOAT_TYPE, UINT_TYPE, INT_TYPE) \
+ _CLC_OVERLOAD _CLC_DEF FLOAT_TYPE __clc_nextafter(FLOAT_TYPE x, \
+ FLOAT_TYPE y) { \
+ const UINT_TYPE sign_bit = (UINT_TYPE)1 << (sizeof(INT_TYPE) * 8 - 1); \
+ const UINT_TYPE sign_bit_mask = sign_bit - 1; \
+ INT_TYPE ix = AS_TYPE(INT_TYPE)(x); \
+ INT_TYPE ax = ix & sign_bit_mask; \
+ INT_TYPE mx = sign_bit - ix; \
+ mx = ix < 0 ? mx : ix; \
+ INT_TYPE iy = AS_TYPE(INT_TYPE)(y); \
+ INT_TYPE ay = iy & sign_bit_mask; \
+ INT_TYPE my = sign_bit - iy; \
+ my = iy < 0 ? my : iy; \
+ INT_TYPE t = mx + (mx < my ? 1 : -1); \
+ INT_TYPE r = sign_bit - t; \
+ r = t < 0 ? r : t; \
+ r = __clc_isnan(x) ? ix : r; \
+ r = __clc_isnan(y) ? iy : r; \
+ r = ((ax | ay) == 0 | ix == iy) ? iy : r; \
+ return AS_TYPE(FLOAT_TYPE)(r); \
+ }
NEXTAFTER(float, uint, int)
-_CLC_BINARY_VECTORIZE(_CLC_OVERLOAD _CLC_DEF, float, __clc_nextafter, float, float)
+_CLC_BINARY_VECTORIZE(_CLC_OVERLOAD _CLC_DEF, float, __clc_nextafter, float,
+ float)
#ifdef cl_khr_fp64
#pragma OPENCL EXTENSION cl_khr_fp64 : enable
NEXTAFTER(double, ulong, long)
-_CLC_BINARY_VECTORIZE(_CLC_OVERLOAD _CLC_DEF, double, __clc_nextafter, double, double)
+_CLC_BINARY_VECTORIZE(_CLC_OVERLOAD _CLC_DEF, double, __clc_nextafter, double,
+ double)
#endif
#ifdef cl_khr_fp16
diff --git a/libclc/generic/lib/math/clc_tan.cl b/libclc/generic/lib/math/clc_tan.cl
index d14ab71740501a..4daaee59b10d2d 100644
--- a/libclc/generic/lib/math/clc_tan.cl
+++ b/libclc/generic/lib/math/clc_tan.cl
@@ -22,6 +22,8 @@
#include <clc/clc.h>
#include <clc/clcmacro.h>
#include <clc/math/clc_fabs.h>
+#include <clc/relational/clc_isinf.h>
+#include <clc/relational/clc_isnan.h>
#include "math.h"
#include "sincos_helpers.h"
@@ -64,7 +66,8 @@ _CLC_DEF _CLC_OVERLOAD double __clc_tan(double x) {
int2 t = as_int2(regn & 1 ? tt.y : tt.x);
t.hi ^= (x < 0.0) << 31;
- return isnan(x) || isinf(x) ? as_double(QNANBITPATT_DP64) : as_double(t);
+ return __clc_isnan(x) || __clc_isinf(x) ? as_double(QNANBITPATT_DP64)
+ : as_double(t);
}
_CLC_UNARY_VECTORIZE(_CLC_DEF _CLC_OVERLOAD, double, __clc_tan, double);
diff --git a/libclc/generic/lib/relational/all.cl b/libclc/generic/lib/relational/all.cl
index 607d7a9c68c488..e4af0fc514f691 100644
--- a/libclc/generic/lib/relational/all.cl
+++ b/libclc/generic/lib/relational/all.cl
@@ -1,27 +1,15 @@
#include <clc/clc.h>
+#include <clc/relational/clc_all.h>
-#define _CLC_ALL(v) (((v) >> ((sizeof(v) * 8) - 1)) & 0x1)
-#define _CLC_ALL2(v) (_CLC_ALL((v).s0) & _CLC_ALL((v).s1))
-#define _CLC_ALL3(v) (_CLC_ALL2((v)) & _CLC_ALL((v).s2))
-#define _CLC_ALL4(v) (_CLC_ALL3((v)) & _CLC_ALL((v).s3))
-#define _CLC_ALL8(v) (_CLC_ALL4((v)) & _CLC_ALL((v).s4) & _CLC_ALL((v).s5) \
- & _CLC_ALL((v).s6) & _CLC_ALL((v).s7))
-#define _CLC_ALL16(v) (_CLC_ALL8((v)) & _CLC_ALL((v).s8) & _CLC_ALL((v).s9) \
- & _CLC_ALL((v).sA) & _CLC_ALL((v).sB) \
- & _CLC_ALL((v).sC) & _CLC_ALL((v).sD) \
- & _CLC_ALL((v).sE) & _CLC_ALL((v).sf))
+#define ALL_ID(TYPE) _CLC_OVERLOAD _CLC_DEF int all(TYPE v)
-
-#define ALL_ID(TYPE) \
- _CLC_OVERLOAD _CLC_DEF int all(TYPE v)
-
-#define ALL_VECTORIZE(TYPE) \
- ALL_ID(TYPE) { return _CLC_ALL(v); } \
- ALL_ID(TYPE##2) { return _CLC_ALL2(v); } \
- ALL_ID(TYPE##3) { return _CLC_ALL3(v); } \
- ALL_ID(TYPE##4) { return _CLC_ALL4(v); } \
- ALL_ID(TYPE##8) { return _CLC_ALL8(v); } \
- ALL_ID(TYPE##16) { return _CLC_ALL16(v); }
+#define ALL_VECTORIZE(TYPE) \
+ ALL_ID(TYPE) { return __clc_all(v); } \
+ ALL_ID(TYPE##2) { return __clc_all(v); } \
+ ALL_ID(TYPE##3) { return __clc_all(v); } \
+ ALL_ID(TYPE##4) { return __clc_all(v); } \
+ ALL_ID(TYPE##8) { return __clc_all(v); } \
+ ALL_ID(TYPE##16) { return __clc_all(v); }
ALL_VECTORIZE(char)
ALL_VECTORIZE(short)
diff --git a/libclc/generic/lib/relational/any.cl b/libclc/generic/lib/relational/any.cl
index 4d372102021b96..3d975bd6d9df9b 100644
--- a/libclc/generic/lib/relational/any.cl
+++ b/libclc/generic/lib/relational/any.cl
@@ -1,30 +1,17 @@
#include <clc/clc.h>
+#include <clc/relational/clc_any.h>
-#define _CLC_ANY(v) (((v) >> ((sizeof(v) * 8) - 1)) & 0x1)
-#define _CLC_ANY2(v) (_CLC_ANY((v).s0) | _CLC_ANY((v).s1))
-#define _CLC_ANY3(v) (_CLC_ANY2((v)) | _CLC_ANY((v).s2))
-#define _CLC_ANY4(v) (_CLC_ANY3((v)) | _CLC_ANY((v).s3))
-#define _CLC_ANY8(v) (_CLC_ANY4((v)) | _CLC_ANY((v).s4) | _CLC_ANY((v).s5) \
- | _CLC_ANY((v).s6) | _CLC_ANY((v).s7))
-#define _CLC_ANY16(v) (_CLC_ANY8((v)) | _CLC_ANY((v).s8) | _CLC_ANY((v).s9) \
- | _CLC_ANY((v).sA) | _CLC_ANY((v).sB) \
- | _CLC_ANY((v).sC) | _CLC_ANY((v).sD) \
- | _CLC_ANY((v).sE) | _CLC_ANY((v).sf))
+#define ANY_ID(TYPE) _CLC_OVERLOAD _CLC_DEF int any(TYPE v)
-
-#define ANY_ID(TYPE) \
- _CLC_OVERLOAD _CLC_DEF int any(TYPE v)
-
-#define ANY_VECTORIZE(TYPE) \
- ANY_ID(TYPE) { return _CLC_ANY(v); } \
- ANY_ID(TYPE##2) { return _CLC_ANY2(v); } \
- ANY_ID(TYPE##3) { return _CLC_ANY3(v); } \
- ANY_ID(TYPE##4) { return _CLC_ANY4(v); } \
- ANY_ID(TYPE##8) { return _CLC_ANY8(v); } \
- ANY_ID(TYPE##16) { return _CLC_ANY16(v); }
+#define ANY_VECTORIZE(TYPE) \
+ ANY_ID(TYPE) { return __clc_any(v); } \
+ ANY_ID(TYPE##2) { return __clc_any(v); } \
+ ANY_ID(TYPE##3) { return __clc_any(v); } \
+ ANY_ID(TYPE##4) { return __clc_any(v); } \
+ ANY_ID(TYPE##8) { return __clc_any(v); } \
+ ANY_ID(TYPE##16) { return __clc_any(v); }
ANY_VECTORIZE(char)
ANY_VECTORIZE(short)
ANY_VECTORIZE(int)
ANY_VECTORIZE(long)
-
diff --git a/libclc/generic/lib/relational/binary_def.inc b/libclc/generic/lib/relational/binary_def.inc
new file mode 100644
index 00000000000000..3ed68be142d005
--- /dev/null
+++ b/libclc/generic/lib/relational/binary_def.inc
@@ -0,0 +1,7 @@
+#include <clc/utils.h>
+
+#define __CLC_FUNCTION(x) __CLC_CONCAT(__clc_, x)
+
+_CLC_OVERLOAD _CLC_DECL __CLC_INTN FUNCTION(__CLC_FLOATN a, __CLC_FLOATN b) {
+ return __CLC_FUNCTION(FUNCTION)(a, b);
+}
diff --git a/libclc/generic/lib/relational/bitselect.cl b/libclc/generic/lib/relational/bitselect.cl
index d2a7a920606782..a470447f1fb91a 100644
--- a/libclc/generic/lib/relational/bitselect.cl
+++ b/libclc/generic/lib/relational/bitselect.cl
@@ -22,15 +22,17 @@
#include <clc/clc.h>
#include <clc/clcmacro.h>
+#include <clc/relational/clc_bitselect.h>
#define __CLC_BODY <bitselect.inc>
#include <clc/integer/gentype.inc>
#undef __CLC_BODY
-#define FLOAT_BITSELECT(f_type, i_type, width) \
- _CLC_OVERLOAD _CLC_DEF f_type##width bitselect(f_type##width x, f_type##width y, f_type##width z) { \
- return as_##f_type##width(bitselect(as_##i_type##width(x), as_##i_type##width(y), as_##i_type##width(z))); \
-}
+#define FLOAT_BITSELECT(f_type, i_type, width) \
+ _CLC_OVERLOAD _CLC_DEF f_type##width bitselect( \
+ f_type##width x, f_type##width y, f_type##width z) { \
+ return __clc_bitselect(x, y, z); \
+ }
FLOAT_BITSELECT(float, uint, )
FLOAT_BITSELECT(float, uint, 2)
diff --git a/libclc/generic/lib/relational/isequal.cl b/libclc/generic/lib/relational/isequal.cl
index 3f14f945bfd337..4ed545f4563eb3 100644
--- a/libclc/generic/lib/relational/isequal.cl
+++ b/libclc/generic/lib/relational/isequal.cl
@@ -1,44 +1,7 @@
#include <clc/clc.h>
+#include <clc/relational/clc_isequal.h>
-#define _CLC_DEFINE_ISEQUAL(RET_TYPE, FUNCTION, ARG1_TYPE, ARG2_TYPE) \
-_CLC_DEF _CLC_OVERLOAD RET_TYPE FUNCTION(ARG1_TYPE x, ARG2_TYPE y) { \
- return (x == y); \
-} \
+#define FUNCTION isequal
+#define __CLC_BODY "binary_def.inc"
-_CLC_DEFINE_ISEQUAL(int, isequal, float, float)
-_CLC_DEFINE_ISEQUAL(int2, isequal, float2, float2)
-_CLC_DEFINE_ISEQUAL(int3, isequal, float3, float3)
-_CLC_DEFINE_ISEQUAL(int4, isequal, float4, float4)
-_CLC_DEFINE_ISEQUAL(int8, isequal, float8, float8)
-_CLC_DEFINE_ISEQUAL(int16, isequal, float16, float16)
-
-#ifdef cl_khr_fp64
-
-#pragma OPENCL EXTENSION cl_khr_fp64 : enable
-
-// The scalar version of isequal(double) returns an int, but the vector versions
-// return long.
-_CLC_DEFINE_ISEQUAL(int, isequal, double, double)
-_CLC_DEFINE_ISEQUAL(long2, isequal, double2, double2)
-_CLC_DEFINE_ISEQUAL(long3, isequal, double3, double3)
-_CLC_DEFINE_ISEQUAL(long4, isequal, double4, double4)
-_CLC_DEFINE_ISEQUAL(long8, isequal, double8, double8)
-_CLC_DEFINE_ISEQUAL(long16, isequal, double16, double16)
-
-#endif
-#ifdef cl_khr_fp16
-
-#pragma OPENCL EXTENSION cl_khr_fp16 : enable
-
-// The scalar version of isequal(half) returns an int, but the vector versions
-// return short.
-_CLC_DEFINE_ISEQUAL(int, isequal, half, half)
-_CLC_DEFINE_ISEQUAL(short2, isequal, half2, half2)
-_CLC_DEFINE_ISEQUAL(short3, isequal, half3, half3)
-_CLC_DEFINE_ISEQUAL(short4, isequal, half4, half4)
-_CLC_DEFINE_ISEQUAL(short8, isequal, half8, half8)
-_CLC_DEFINE_ISEQUAL(short16, isequal, half16, half16)
-
-#endif
-
-#undef _CLC_DEFINE_ISEQUAL
+#include <clc/relational/floatn.inc>
diff --git a/libclc/generic/lib/relational/isfinite.cl b/libclc/generic/lib/relational/isfinite.cl
index 15b92fa41296e6..d73bf6e5309947 100644
--- a/libclc/generic/lib/relational/isfinite.cl
+++ b/libclc/generic/lib/relational/isfinite.cl
@@ -1,31 +1,7 @@
#include <clc/clc.h>
-#include "relational.h"
+#include <clc/relational/clc_isfinite.h>
-_CLC_DEFINE_RELATIONAL_UNARY(int, isfinite, __builtin_isfinite, float)
+#define FUNCTION isfinite
+#define __CLC_BODY "unary_def.inc"
-#ifdef cl_khr_fp64
-
-#pragma OPENCL EXTENSION cl_khr_fp64 : enable
-
-// The scalar version of isfinite(double) returns an int, but the vector versions
-// return long.
-_CLC_DEF _CLC_OVERLOAD int isfinite(double x) {
- return __builtin_isfinite(x);
-}
-
-_CLC_DEFINE_RELATIONAL_UNARY_VEC_ALL(long, isfinite, double)
-
-#endif
-#ifdef cl_khr_fp16
-
-#pragma OPENCL EXTENSION cl_khr_fp16 : enable
-
-// The scalar version of isfinite(half) returns an int, but the vector versions
-// return short.
-_CLC_DEF _CLC_OVERLOAD int isfinite(half x) {
- return __builtin_isfinite(x);
-}
-
-_CLC_DEFINE_RELATIONAL_UNARY_VEC_ALL(short, isfinite, half)
-
-#endif
+#include <clc/relational/floatn.inc>
diff --git a/libclc/generic/lib/relational/isgreater.cl b/libclc/generic/lib/relational/isgreater.cl
index 167d6f213552ba..c4f7b43588d151 100644
--- a/libclc/generic/lib/relational/isgreater.cl
+++ b/libclc/generic/lib/relational/isgreater.cl
@@ -1,37 +1,7 @@
#include <clc/clc.h>
-#include "relational.h"
+#include <clc/relational/clc_isgreater.h>
-//Note: It would be nice to use __builtin_isgreater with vector inputs, but it seems to only take scalar values as
-// input, which will produce incorrect output for vector input types.
+#define FUNCTION isgreater
+#define __CLC_BODY "binary_def.inc"
-_CLC_DEFINE_RELATIONAL_BINARY(int, isgreater, __builtin_isgreater, float, float)
-
-#ifdef cl_khr_fp64
-
-#pragma OPENCL EXTENSION cl_khr_fp64 : enable
-
-// The scalar version of isgreater(double, double) returns an int, but the vector versions
-// return long.
-
-_CLC_DEF _CLC_OVERLOAD int isgreater(double x, double y){
- return __builtin_isgreater(x, y);
-}
-
-_CLC_DEFINE_RELATIONAL_BINARY_VEC_ALL(long, isgreater, double, double)
-
-#endif
-
-#ifdef cl_khr_fp16
-
-#pragma OPENCL EXTENSION cl_khr_fp16 : enable
-
-// The scalar version of isgreater(half, half) returns an int, but the vector versions
-// return short.
-
-_CLC_DEF _CLC_OVERLOAD int isgreater(half x, half y){
- return __builtin_isgreater(x, y);
-}
-
-_CLC_DEFINE_RELATIONAL_BINARY_VEC_ALL(short, isgreater, half, half)
-
-#endif
+#include <clc/relational/floatn.inc>
diff --git a/libclc/generic/lib/relational/isgreaterequal.cl b/libclc/generic/lib/relational/isgreaterequal.cl
index 128a1d0de4eccf..28473393a761f9 100644
--- a/libclc/generic/lib/relational/isgreaterequal.cl
+++ b/libclc/generic/lib/relational/isgreaterequal.cl
@@ -1,36 +1,7 @@
#include <clc/clc.h>
-#include "relational.h"
+#include <clc/relational/clc_isgreaterequal.h>
-//Note: It would be nice to use __builtin_isgreaterequal with vector inputs, but it seems to only take scalar values as
-// input, which will produce incorrect output for vector input types.
+#define FUNCTION isgreaterequal
+#define __CLC_BODY "binary_def.inc"
-_CLC_DEFINE_RELATIONAL_BINARY(int, isgreaterequal, __builtin_isgreaterequal, float, float)
-
-#ifdef cl_khr_fp64
-
-#pragma OPENCL EXTENSION cl_khr_fp64 : enable
-
-// The scalar version of isgreaterequal(double, double) returns an int, but the vector versions
-// return long.
-
-_CLC_DEF _CLC_OVERLOAD int isgreaterequal(double x, double y){
- return __builtin_isgreaterequal(x, y);
-}
-
-_CLC_DEFINE_RELATIONAL_BINARY_VEC_ALL(long, isgreaterequal, double, double)
-
-#endif
-#ifdef cl_khr_fp16
-
-#pragma OPENCL EXTENSION cl_khr_fp16 : enable
-
-// The scalar version of isgreaterequal(half, half) returns an int, but the vector versions
-// return short.
-
-_CLC_DEF _CLC_OVERLOAD int isgreaterequal(half x, half y){
- return __builtin_isgreaterequal(x, y);
-}
-
-_CLC_DEFINE_RELATIONAL_BINARY_VEC_ALL(short, isgreaterequal, half, half)
-
-#endif
+#include <clc/relational/floatn.inc>
diff --git a/libclc/generic/lib/relational/isinf.cl b/libclc/generic/lib/relational/isinf.cl
index 96aae4aa700e41..f6816659c6e84c 100644
--- a/libclc/generic/lib/relational/isinf.cl
+++ b/libclc/generic/lib/relational/isinf.cl
@@ -1,30 +1,7 @@
#include <clc/clc.h>
-#include "relational.h"
+#include <clc/relational/clc_isinf.h>
-_CLC_DEFINE_RELATIONAL_UNARY(int, isinf, __builtin_isinf, float)
+#define FUNCTION isinf
+#define __CLC_BODY "unary_def.inc"
-#ifdef cl_khr_fp64
-
-#pragma OPENCL EXTENSION cl_khr_fp64 : enable
-
-// The scalar version of isinf(double) returns an int, but the vector versions
-// return long.
-_CLC_DEF _CLC_OVERLOAD int isinf(double x) {
- return __builtin_isinf(x);
-}
-
-_CLC_DEFINE_RELATIONAL_UNARY_VEC_ALL(long, isinf, double)
-#endif
-
-#ifdef cl_khr_fp16
-
-#pragma OPENCL EXTENSION cl_khr_fp16 : enable
-
-// The scalar version of isinf(half) returns an int, but the vector versions
-// return short.
-_CLC_DEF _CLC_OVERLOAD int isinf(half x) {
- return __builtin_isinf(x);
-}
-
-_CLC_DEFINE_RELATIONAL_UNARY_VEC_ALL(short, isinf, half)
-#endif
+#include <clc/relational/floatn.inc>
diff --git a/libclc/generic/lib/relational/isless.cl b/libclc/generic/lib/relational/isless.cl
index 1dbf7676060b37..ea79ce4f3fe19c 100644
--- a/libclc/generic/lib/relational/isless.cl
+++ b/libclc/generic/lib/relational/isless.cl
@@ -1,36 +1,7 @@
#include <clc/clc.h>
-#include "relational.h"
+#include <clc/relational/clc_isless.h>
-//Note: It would be nice to use __builtin_isless with vector inputs, but it seems to only take scalar values as
-// input, which will produce incorrect output for vector input types.
+#define FUNCTION isless
+#define __CLC_BODY "binary_def.inc"
-_CLC_DEFINE_RELATIONAL_BINARY(int, isless, __builtin_isless, float, float)
-
-#ifdef cl_khr_fp64
-
-#pragma OPENCL EXTENSION cl_khr_fp64 : enable
-
-// The scalar version of isless(double, double) returns an int, but the vector versions
-// return long.
-
-_CLC_DEF _CLC_OVERLOAD int isless(double x, double y){
- return __builtin_isless(x, y);
-}
-
-_CLC_DEFINE_RELATIONAL_BINARY_VEC_ALL(long, isless, double, double)
-
-#endif
-#ifdef cl_khr_fp16
-
-#pragma OPENCL EXTENSION cl_khr_fp16 : enable
-
-// The scalar version of isless(half, half) returns an int, but the vector versions
-// return short.
-
-_CLC_DEF _CLC_OVERLOAD int isless(half x, half y){
- return __builtin_isless(x, y);
-}
-
-_CLC_DEFINE_RELATIONAL_BINARY_VEC_ALL(short, isless, half, half)
-
-#endif
+#include <clc/relational/floatn.inc>
diff --git a/libclc/generic/lib/relational/islessequal.cl b/libclc/generic/lib/relational/islessequal.cl
index db64bea5dcd354..9b09577074aa0c 100644
--- a/libclc/generic/lib/relational/islessequal.cl
+++ b/libclc/generic/lib/relational/islessequal.cl
@@ -1,36 +1,7 @@
#include <clc/clc.h>
-#include "relational.h"
+#include <clc/relational/clc_islessequal.h>
-//Note: It would be nice to use __builtin_islessequal with vector inputs, but it seems to only take scalar values as
-// input, which will produce incorrect output for vector input types.
+#define FUNCTION islessequal
+#define __CLC_BODY "binary_def.inc"
-_CLC_DEFINE_RELATIONAL_BINARY(int, islessequal, __builtin_islessequal, float, float)
-
-#ifdef cl_khr_fp64
-
-#pragma OPENCL EXTENSION cl_khr_fp64 : enable
-
-// The scalar version of islessequal(double, double) returns an int, but the vector versions
-// return long.
-
-_CLC_DEF _CLC_OVERLOAD int islessequal(double x, double y){
- return __builtin_islessequal(x, y);
-}
-
-_CLC_DEFINE_RELATIONAL_BINARY_VEC_ALL(long, islessequal, double, double)
-
-#endif
-#ifdef cl_khr_fp16
-
-#pragma OPENCL EXTENSION cl_khr_fp16 : enable
-
-// The scalar version of islessequal(half, half) returns an int, but the vector versions
-// return short.
-
-_CLC_DEF _CLC_OVERLOAD int islessequal(half x, half y){
- return __builtin_islessequal(x, y);
-}
-
-_CLC_DEFINE_RELATIONAL_BINARY_VEC_ALL(short, islessequal, half, half)
-
-#endif
+#include <clc/relational/floatn.inc>
diff --git a/libclc/generic/lib/relational/islessgreater.cl b/libclc/generic/lib/relational/islessgreater.cl
index 9e9b11ec9b6b1e..08f7c955182974 100644
--- a/libclc/generic/lib/relational/islessgreater.cl
+++ b/libclc/generic/lib/relational/islessgreater.cl
@@ -1,36 +1,7 @@
#include <clc/clc.h>
-#include "relational.h"
+#include <clc/relational/clc_islessgreater.h>
-//Note: It would be nice to use __builtin_islessgreater with vector inputs, but it seems to only take scalar values as
-// input, which will produce incorrect output for vector input types.
+#define FUNCTION islessgreater
+#define __CLC_BODY "binary_def.inc"
-_CLC_DEFINE_RELATIONAL_BINARY(int, islessgreater, __builtin_islessgreater, float, float)
-
-#ifdef cl_khr_fp64
-
-#pragma OPENCL EXTENSION cl_khr_fp64 : enable
-
-// The scalar version of islessgreater(double, double) returns an int, but the vector versions
-// return long.
-
-_CLC_DEF _CLC_OVERLOAD int islessgreater(double x, double y){
- return __builtin_islessgreater(x, y);
-}
-
-_CLC_DEFINE_RELATIONAL_BINARY_VEC_ALL(long, islessgreater, double, double)
-
-#endif
-#ifdef cl_khr_fp16
-
-#pragma OPENCL EXTENSION cl_khr_fp16 : enable
-
-// The scalar version of islessgreater(half, half) returns an int, but the vector versions
-// return short.
-
-_CLC_DEF _CLC_OVERLOAD int islessgreater(half x, half y){
- return __builtin_islessgreater(x, y);
-}
-
-_CLC_DEFINE_RELATIONAL_BINARY_VEC_ALL(short, islessgreater, half, half)
-
-#endif
+#include <clc/relational/floatn.inc>
diff --git a/libclc/generic/lib/relational/isnan.cl b/libclc/generic/lib/relational/isnan.cl
index 3d3104783b7e54..c61343722f9c86 100644
--- a/libclc/generic/lib/relational/isnan.cl
+++ b/libclc/generic/lib/relational/isnan.cl
@@ -1,32 +1,7 @@
#include <clc/clc.h>
-#include "relational.h"
+#include <clc/relational/clc_isnan.h>
-_CLC_DEFINE_RELATIONAL_UNARY(int, isnan, __builtin_isnan, float)
+#define FUNCTION isnan
+#define __CLC_BODY "unary_def.inc"
-#ifdef cl_khr_fp64
-
-#pragma OPENCL EXTENSION cl_khr_fp64 : enable
-
-// The scalar version of isnan(double) returns an int, but the vector versions
-// return long.
-_CLC_DEF _CLC_OVERLOAD int isnan(double x) {
- return __builtin_isnan(x);
-}
-
-_CLC_DEFINE_RELATIONAL_UNARY_VEC_ALL(long, isnan, double)
-
-#endif
-
-#ifdef cl_khr_fp16
-
-#pragma OPENCL EXTENSION cl_khr_fp16 : enable
-
-// The scalar version of isnan(half) returns an int, but the vector versions
-// return short.
-_CLC_DEF _CLC_OVERLOAD int isnan(half x) {
- return __builtin_isnan(x);
-}
-
-_CLC_DEFINE_RELATIONAL_UNARY_VEC_ALL(short, isnan, half)
-
-#endif
+#include <clc/relational/floatn.inc>
diff --git a/libclc/generic/lib/relational/isnormal.cl b/libclc/generic/lib/relational/isnormal.cl
index a3dbf661c61835..de2bd6ad20e925 100644
--- a/libclc/generic/lib/relational/isnormal.cl
+++ b/libclc/generic/lib/relational/isnormal.cl
@@ -1,31 +1,7 @@
#include <clc/clc.h>
-#include "relational.h"
+#include <clc/relational/clc_isnormal.h>
-_CLC_DEFINE_RELATIONAL_UNARY(int, isnormal, __builtin_isnormal, float)
+#define FUNCTION isnormal
+#define __CLC_BODY "unary_def.inc"
-#ifdef cl_khr_fp64
-
-#pragma OPENCL EXTENSION cl_khr_fp64 : enable
-
-// The scalar version of isnormal(double) returns an int, but the vector versions
-// return long.
-_CLC_DEF _CLC_OVERLOAD int isnormal(double x) {
- return __builtin_isnormal(x);
-}
-
-_CLC_DEFINE_RELATIONAL_UNARY_VEC_ALL(long, isnormal, double)
-
-#endif
-#ifdef cl_khr_fp16
-
-#pragma OPENCL EXTENSION cl_khr_fp16 : enable
-
-// The scalar version of isnormal(half) returns an int, but the vector versions
-// return short.
-_CLC_DEF _CLC_OVERLOAD int isnormal(half x) {
- return __builtin_isnormal(x);
-}
-
-_CLC_DEFINE_RELATIONAL_UNARY_VEC_ALL(short, isnormal, half)
-
-#endif
+#include <clc/relational/floatn.inc>
diff --git a/libclc/generic/lib/relational/isnotequal.cl b/libclc/generic/lib/relational/isnotequal.cl
index afd293dda01dbe..c04752b0d15b4d 100644
--- a/libclc/generic/lib/relational/isnotequal.cl
+++ b/libclc/generic/lib/relational/isnotequal.cl
@@ -1,33 +1,7 @@
#include <clc/clc.h>
-#include "relational.h"
+#include <clc/relational/clc_isnotequal.h>
-#define _CLC_DEFINE_ISNOTEQUAL(RET_TYPE, FUNCTION, ARG1_TYPE, ARG2_TYPE) \
-_CLC_DEF _CLC_OVERLOAD RET_TYPE FUNCTION(ARG1_TYPE x, ARG2_TYPE y) { \
- return (x != y); \
-} \
+#define FUNCTION isnotequal
+#define __CLC_BODY "binary_def.inc"
-_CLC_DEFINE_ISNOTEQUAL(int, isnotequal, float, float)
-_CLC_DEFINE_RELATIONAL_BINARY_VEC_ALL(int, isnotequal, float, float)
-
-#ifdef cl_khr_fp64
-#pragma OPENCL EXTENSION cl_khr_fp64 : enable
-
-// The scalar version of isnotequal(double, double) returns an int, but the vector versions
-// return long.
-
-_CLC_DEFINE_ISNOTEQUAL(int, isnotequal, double, double)
-_CLC_DEFINE_RELATIONAL_BINARY_VEC_ALL(long, isnotequal, double, double)
-
-#endif
-#ifdef cl_khr_fp16
-#pragma OPENCL EXTENSION cl_khr_fp16 : enable
-
-// The scalar version of isnotequal(half, half) returns an int, but the vector versions
-// return short.
-
-_CLC_DEFINE_ISNOTEQUAL(int, isnotequal, half, half)
-_CLC_DEFINE_RELATIONAL_BINARY_VEC_ALL(short, isnotequal, half, half)
-
-#endif
-
-#undef _CLC_DEFINE_ISNOTEQUAL
+#include <clc/relational/floatn.inc>
diff --git a/libclc/generic/lib/relational/isordered.cl b/libclc/generic/lib/relational/isordered.cl
index cedd05f6e0492d..347fc2df8a3b60 100644
--- a/libclc/generic/lib/relational/isordered.cl
+++ b/libclc/generic/lib/relational/isordered.cl
@@ -1,33 +1,7 @@
#include <clc/clc.h>
-#include "relational.h"
+#include <clc/relational/clc_isordered.h>
-#define _CLC_DEFINE_ISORDERED(RET_TYPE, FUNCTION, ARG1_TYPE, ARG2_TYPE) \
-_CLC_DEF _CLC_OVERLOAD RET_TYPE FUNCTION(ARG1_TYPE x, ARG2_TYPE y) { \
- return isequal(x, x) && isequal(y, y); \
-} \
+#define FUNCTION isordered
+#define __CLC_BODY "binary_def.inc"
-_CLC_DEFINE_ISORDERED(int, isordered, float, float)
-_CLC_DEFINE_RELATIONAL_BINARY_VEC_ALL(int, isordered, float, float)
-
-#ifdef cl_khr_fp64
-#pragma OPENCL EXTENSION cl_khr_fp64 : enable
-
-// The scalar version of isordered(double, double) returns an int, but the vector versions
-// return long.
-
-_CLC_DEFINE_ISORDERED(int, isordered, double, double)
-_CLC_DEFINE_RELATIONAL_BINARY_VEC_ALL(long, isordered, double, double)
-
-#endif
-#ifdef cl_khr_fp16
-#pragma OPENCL EXTENSION cl_khr_fp16 : enable
-
-// The scalar version of isordered(half, half) returns an int, but the vector versions
-// return short.
-
-_CLC_DEFINE_ISORDERED(int, isordered, half, half)
-_CLC_DEFINE_RELATIONAL_BINARY_VEC_ALL(short, isordered, half, half)
-
-#endif
-
-#undef _CLC_DEFINE_ISORDERED
+#include <clc/relational/floatn.inc>
diff --git a/libclc/generic/lib/relational/isunordered.cl b/libclc/generic/lib/relational/isunordered.cl
index 90939807ffd3bb..46db60332c422e 100644
--- a/libclc/generic/lib/relational/isunordered.cl
+++ b/libclc/generic/lib/relational/isunordered.cl
@@ -1,36 +1,7 @@
#include <clc/clc.h>
-#include "relational.h"
+#include <clc/relational/clc_isunordered.h>
-//Note: It would be nice to use __builtin_isunordered with vector inputs, but it seems to only take scalar values as
-// input, which will produce incorrect output for vector input types.
+#define FUNCTION isunordered
+#define __CLC_BODY "binary_def.inc"
-_CLC_DEFINE_RELATIONAL_BINARY(int, isunordered, __builtin_isunordered, float, float)
-
-#ifdef cl_khr_fp64
-
-#pragma OPENCL EXTENSION cl_khr_fp64 : enable
-
-// The scalar version of isunordered(double, double) returns an int, but the vector versions
-// return long.
-
-_CLC_DEF _CLC_OVERLOAD int isunordered(double x, double y){
- return __builtin_isunordered(x, y);
-}
-
-_CLC_DEFINE_RELATIONAL_BINARY_VEC_ALL(long, isunordered, double, double)
-
-#endif
-#ifdef cl_khr_fp16
-
-#pragma OPENCL EXTENSION cl_khr_fp16 : enable
-
-// The scalar version of isunordered(half, half) returns an int, but the vector versions
-// return short.
-
-_CLC_DEF _CLC_OVERLOAD int isunordered(half x, half y){
- return __builtin_isunordered(x, y);
-}
-
-_CLC_DEFINE_RELATIONAL_BINARY_VEC_ALL(short, isunordered, half, half)
-
-#endif
+#include <clc/relational/floatn.inc>
diff --git a/libclc/generic/lib/relational/relational.h b/libclc/generic/lib/relational/relational.h
deleted file mode 100644
index e492750dacb329..00000000000000
--- a/libclc/generic/lib/relational/relational.h
+++ /dev/null
@@ -1,117 +0,0 @@
-/*
- * Contains relational macros that have to return 1 for scalar and -1 for vector
- * when the result is true.
- */
-
-#define _CLC_DEFINE_RELATIONAL_UNARY_SCALAR(RET_TYPE, FUNCTION, BUILTIN_NAME, ARG_TYPE) \
-_CLC_DEF _CLC_OVERLOAD RET_TYPE FUNCTION(ARG_TYPE x){ \
- return BUILTIN_NAME(x); \
-}
-
-#define _CLC_DEFINE_RELATIONAL_UNARY_VEC2(RET_TYPE, FUNCTION, ARG_TYPE) \
-_CLC_DEF _CLC_OVERLOAD RET_TYPE FUNCTION(ARG_TYPE x) { \
- return (RET_TYPE)( (RET_TYPE){FUNCTION(x.lo), FUNCTION(x.hi)} != (RET_TYPE)0); \
-}
-
-#define _CLC_DEFINE_RELATIONAL_UNARY_VEC3(RET_TYPE, FUNCTION, ARG_TYPE) \
-_CLC_DEF _CLC_OVERLOAD RET_TYPE FUNCTION(ARG_TYPE x) { \
- return (RET_TYPE)( (RET_TYPE){FUNCTION(x.s0), FUNCTION(x.s1), FUNCTION(x.s2)} != (RET_TYPE)0); \
-}
-
-#define _CLC_DEFINE_RELATIONAL_UNARY_VEC4(RET_TYPE, FUNCTION, ARG_TYPE) \
-_CLC_DEF _CLC_OVERLOAD RET_TYPE FUNCTION(ARG_TYPE x) { \
- return (RET_TYPE)( \
- (RET_TYPE){ \
- FUNCTION(x.s0), FUNCTION(x.s1), FUNCTION(x.s2), FUNCTION(x.s3) \
- } != (RET_TYPE)0); \
-}
-
-#define _CLC_DEFINE_RELATIONAL_UNARY_VEC8(RET_TYPE, FUNCTION, ARG_TYPE) \
-_CLC_DEF _CLC_OVERLOAD RET_TYPE FUNCTION(ARG_TYPE x) { \
- return (RET_TYPE)( \
- (RET_TYPE){ \
- FUNCTION(x.s0), FUNCTION(x.s1), FUNCTION(x.s2), FUNCTION(x.s3), \
- FUNCTION(x.s4), FUNCTION(x.s5), FUNCTION(x.s6), FUNCTION(x.s7) \
- } != (RET_TYPE)0); \
-}
-
-#define _CLC_DEFINE_RELATIONAL_UNARY_VEC16(RET_TYPE, FUNCTION, ARG_TYPE) \
-_CLC_DEF _CLC_OVERLOAD RET_TYPE FUNCTION(ARG_TYPE x) { \
- return (RET_TYPE)( \
- (RET_TYPE){ \
- FUNCTION(x.s0), FUNCTION(x.s1), FUNCTION(x.s2), FUNCTION(x.s3), \
- FUNCTION(x.s4), FUNCTION(x.s5), FUNCTION(x.s6), FUNCTION(x.s7), \
- FUNCTION(x.s8), FUNCTION(x.s9), FUNCTION(x.sa), FUNCTION(x.sb), \
- FUNCTION(x.sc), FUNCTION(x.sd), FUNCTION(x.se), FUNCTION(x.sf) \
- } != (RET_TYPE)0); \
-}
-
-#define _CLC_DEFINE_RELATIONAL_UNARY_VEC_ALL(RET_TYPE, FUNCTION, ARG_TYPE) \
-_CLC_DEFINE_RELATIONAL_UNARY_VEC2(RET_TYPE##2, FUNCTION, ARG_TYPE##2) \
-_CLC_DEFINE_RELATIONAL_UNARY_VEC3(RET_TYPE##3, FUNCTION, ARG_TYPE##3) \
-_CLC_DEFINE_RELATIONAL_UNARY_VEC4(RET_TYPE##4, FUNCTION, ARG_TYPE##4) \
-_CLC_DEFINE_RELATIONAL_UNARY_VEC8(RET_TYPE##8, FUNCTION, ARG_TYPE##8) \
-_CLC_DEFINE_RELATIONAL_UNARY_VEC16(RET_TYPE##16, FUNCTION, ARG_TYPE##16)
-
-#define _CLC_DEFINE_RELATIONAL_UNARY(RET_TYPE, FUNCTION, BUILTIN_FUNCTION, ARG_TYPE) \
-_CLC_DEFINE_RELATIONAL_UNARY_SCALAR(RET_TYPE, FUNCTION, BUILTIN_FUNCTION, ARG_TYPE) \
-_CLC_DEFINE_RELATIONAL_UNARY_VEC_ALL(RET_TYPE, FUNCTION, ARG_TYPE) \
-
-#define _CLC_DEFINE_RELATIONAL_BINARY_SCALAR(RET_TYPE, FUNCTION, BUILTIN_NAME, ARG0_TYPE, ARG1_TYPE) \
-_CLC_DEF _CLC_OVERLOAD RET_TYPE FUNCTION(ARG0_TYPE x, ARG1_TYPE y){ \
- return BUILTIN_NAME(x, y); \
-}
-
-#define _CLC_DEFINE_RELATIONAL_BINARY_VEC(RET_TYPE, FUNCTION, ARG0_TYPE, ARG1_TYPE) \
-_CLC_DEF _CLC_OVERLOAD RET_TYPE FUNCTION(ARG0_TYPE x, ARG1_TYPE y) { \
- return (RET_TYPE)( (RET_TYPE){FUNCTION(x.lo, y.lo), FUNCTION(x.hi, y.hi)} != (RET_TYPE)0); \
-}
-
-#define _CLC_DEFINE_RELATIONAL_BINARY_VEC2(RET_TYPE, FUNCTION, ARG0_TYPE, ARG1_TYPE) \
-_CLC_DEF _CLC_OVERLOAD RET_TYPE FUNCTION(ARG0_TYPE x, ARG1_TYPE y) { \
- return (RET_TYPE)( (RET_TYPE){FUNCTION(x.lo, y.lo), FUNCTION(x.hi, y.hi)} != (RET_TYPE)0); \
-}
-
-#define _CLC_DEFINE_RELATIONAL_BINARY_VEC3(RET_TYPE, FUNCTION, ARG0_TYPE, ARG1_TYPE) \
-_CLC_DEF _CLC_OVERLOAD RET_TYPE FUNCTION(ARG0_TYPE x, ARG1_TYPE y) { \
- return (RET_TYPE)( (RET_TYPE){FUNCTION(x.s0, y.s0), FUNCTION(x.s1, y.s1), FUNCTION(x.s2, y.s2)} != (RET_TYPE)0); \
-}
-
-#define _CLC_DEFINE_RELATIONAL_BINARY_VEC4(RET_TYPE, FUNCTION, ARG0_TYPE, ARG1_TYPE) \
-_CLC_DEF _CLC_OVERLOAD RET_TYPE FUNCTION(ARG0_TYPE x, ARG1_TYPE y) { \
- return (RET_TYPE)( \
- (RET_TYPE){ \
- FUNCTION(x.s0, y.s0), FUNCTION(x.s1, y.s1), FUNCTION(x.s2, y.s2), FUNCTION(x.s3, y.s3) \
- } != (RET_TYPE)0); \
-}
-
-#define _CLC_DEFINE_RELATIONAL_BINARY_VEC8(RET_TYPE, FUNCTION, ARG0_TYPE, ARG1_TYPE) \
-_CLC_DEF _CLC_OVERLOAD RET_TYPE FUNCTION(ARG0_TYPE x, ARG1_TYPE y) { \
- return (RET_TYPE)( \
- (RET_TYPE){ \
- FUNCTION(x.s0, y.s0), FUNCTION(x.s1, y.s1), FUNCTION(x.s2, y.s2), FUNCTION(x.s3, y.s3), \
- FUNCTION(x.s4, y.s4), FUNCTION(x.s5, y.s5), FUNCTION(x.s6, y.s6), FUNCTION(x.s7, y.s7) \
- } != (RET_TYPE)0); \
-}
-
-#define _CLC_DEFINE_RELATIONAL_BINARY_VEC16(RET_TYPE, FUNCTION, ARG0_TYPE, ARG1_TYPE) \
-_CLC_DEF _CLC_OVERLOAD RET_TYPE FUNCTION(ARG0_TYPE x, ARG1_TYPE y) { \
- return (RET_TYPE)( \
- (RET_TYPE){ \
- FUNCTION(x.s0, y.s0), FUNCTION(x.s1, y.s1), FUNCTION(x.s2, y.s2), FUNCTION(x.s3, y.s3), \
- FUNCTION(x.s4, y.s4), FUNCTION(x.s5, y.s5), FUNCTION(x.s6, y.s6), FUNCTION(x.s7, y.s7), \
- FUNCTION(x.s8, y.s8), FUNCTION(x.s9, y.s9), FUNCTION(x.sa, y.sa), FUNCTION(x.sb, y.sb), \
- FUNCTION(x.sc, y.sc), FUNCTION(x.sd, y.sd), FUNCTION(x.se, y.se), FUNCTION(x.sf, y.sf) \
- } != (RET_TYPE)0); \
-}
-
-#define _CLC_DEFINE_RELATIONAL_BINARY_VEC_ALL(RET_TYPE, FUNCTION, ARG0_TYPE, ARG1_TYPE) \
-_CLC_DEFINE_RELATIONAL_BINARY_VEC2(RET_TYPE##2, FUNCTION, ARG0_TYPE##2, ARG1_TYPE##2) \
-_CLC_DEFINE_RELATIONAL_BINARY_VEC3(RET_TYPE##3, FUNCTION, ARG0_TYPE##3, ARG1_TYPE##3) \
-_CLC_DEFINE_RELATIONAL_BINARY_VEC4(RET_TYPE##4, FUNCTION, ARG0_TYPE##4, ARG1_TYPE##4) \
-_CLC_DEFINE_RELATIONAL_BINARY_VEC8(RET_TYPE##8, FUNCTION, ARG0_TYPE##8, ARG1_TYPE##8) \
-_CLC_DEFINE_RELATIONAL_BINARY_VEC16(RET_TYPE##16, FUNCTION, ARG0_TYPE##16, ARG1_TYPE##16)
-
-#define _CLC_DEFINE_RELATIONAL_BINARY(RET_TYPE, FUNCTION, BUILTIN_FUNCTION, ARG0_TYPE, ARG1_TYPE) \
-_CLC_DEFINE_RELATIONAL_BINARY_SCALAR(RET_TYPE, FUNCTION, BUILTIN_FUNCTION, ARG0_TYPE, ARG1_TYPE) \
-_CLC_DEFINE_RELATIONAL_BINARY_VEC_ALL(RET_TYPE, FUNCTION, ARG0_TYPE, ARG1_TYPE)
diff --git a/libclc/generic/lib/relational/signbit.cl b/libclc/generic/lib/relational/signbit.cl
index a7378d7d6053e2..1cf993e22cb599 100644
--- a/libclc/generic/lib/relational/signbit.cl
+++ b/libclc/generic/lib/relational/signbit.cl
@@ -1,33 +1,7 @@
#include <clc/clc.h>
-#include "relational.h"
+#include <clc/relational/clc_signbit.h>
-_CLC_DEFINE_RELATIONAL_UNARY(int, signbit, __builtin_signbitf, float)
+#define FUNCTION signbit
+#define __CLC_BODY "unary_def.inc"
-#ifdef cl_khr_fp64
-
-#pragma OPENCL EXTENSION cl_khr_fp64 : enable
-
-// The scalar version of signbit(double) returns an int, but the vector versions
-// return long.
-
-_CLC_DEF _CLC_OVERLOAD int signbit(double x){
- return __builtin_signbit(x);
-}
-
-_CLC_DEFINE_RELATIONAL_UNARY_VEC_ALL(long, signbit, double)
-
-#endif
-#ifdef cl_khr_fp16
-
-#pragma OPENCL EXTENSION cl_khr_fp16 : enable
-
-// The scalar version of signbit(half) returns an int, but the vector versions
-// return short.
-
-_CLC_DEF _CLC_OVERLOAD int signbit(half x){
- return __builtin_signbit(x);
-}
-
-_CLC_DEFINE_RELATIONAL_UNARY_VEC_ALL(short, signbit, half)
-
-#endif
+#include <clc/relational/floatn.inc>
diff --git a/libclc/generic/lib/relational/unary_def.inc b/libclc/generic/lib/relational/unary_def.inc
new file mode 100644
index 00000000000000..dd9fe48731f969
--- /dev/null
+++ b/libclc/generic/lib/relational/unary_def.inc
@@ -0,0 +1,7 @@
+#include <clc/utils.h>
+
+#define __CLC_FUNCTION(x) __CLC_CONCAT(__clc_, x)
+
+_CLC_OVERLOAD _CLC_DECL __CLC_INTN FUNCTION(__CLC_FLOATN a) {
+ return __CLC_FUNCTION(FUNCTION)(a);
+}
More information about the cfe-commits
mailing list