https://github.com/wenju-he created https://github.com/llvm/llvm-project/pull/172634
Remove the Python dependency for generating convert builtins, aligning with how other builtins are defined. In addition, our downstream target relies on this PR to override convert implementations. llvm-diff shows no changes to all bitcodes: amdgcn--amdhsa.bc, barts-r600--.bc, cayman-r600--.bc, cedar-r600--.bc, clspv64--.bc, clspv--.bc, cypress-r600--.bc, nvptx64--.bc, nvptx64--nvidiacl.bc, nvptx--.bc, nvptx--nvidiacl.bc, tahiti-amdgcn--.bc and tahiti-amdgcn-mesa-mesa3d.bc. >From c4f056c0949d6806d3da671bfd57445c198d04db Mon Sep 17 00:00:00 2001 From: Wenju He <[email protected]> Date: Wed, 17 Dec 2025 12:23:47 +0100 Subject: [PATCH] [libclc][NFC] Move convert builtins from Python generator to .cl sources Remove the Python dependency for generating convert builtins, aligning with how other builtins are defined. In addition, our downstream target relies on this PR to override convert implementations. llvm-diff shows no changes to all bitcodes: amdgcn--amdhsa.bc, barts-r600--.bc, cayman-r600--.bc, cedar-r600--.bc, clspv64--.bc, clspv--.bc, cypress-r600--.bc, nvptx64--.bc, nvptx64--nvidiacl.bc, nvptx--.bc, nvptx--nvidiacl.bc, tahiti-amdgcn--.bc and tahiti-amdgcn-mesa-mesa3d.bc. --- libclc/CMakeLists.txt | 42 +---- libclc/clc/lib/generic/SOURCES | 2 + .../generic/conversion/clc_convert_float.inc | 161 ++++++++++++++++++ .../conversion/clc_convert_float2float.cl | 52 ++++++ .../conversion/clc_convert_float2int.cl | 65 +++++++ .../conversion/clc_convert_float2int.inc | 146 ++++++++++++++++ .../conversion/clc_convert_int2float.cl | 103 +++++++++++ .../generic/conversion/clc_convert_integer.cl | 64 +++++++ .../conversion/clc_convert_integer.inc | 146 ++++++++++++++++ libclc/cmake/modules/AddLibclc.cmake | 45 ++--- libclc/opencl/lib/clspv/SOURCES | 4 + .../lib/clspv/conversion/convert_float.inc | 67 ++++++++ .../clspv/conversion/convert_float2float.cl | 37 ++++ .../lib/clspv/conversion/convert_float2int.cl | 50 ++++++ .../lib/clspv/conversion/convert_int2float.cl | 43 +++++ .../lib/clspv/conversion/convert_integer.cl | 43 +++++ .../lib/clspv/conversion/convert_integer.inc | 49 ++++++ libclc/opencl/lib/generic/SOURCES | 4 + .../lib/generic/conversion/convert_float.inc | 57 +++++++ .../generic/conversion/convert_float2float.cl | 37 ++++ .../generic/conversion/convert_float2int.cl | 49 ++++++ .../generic/conversion/convert_int2float.cl | 43 +++++ .../lib/generic/conversion/convert_integer.cl | 43 +++++ .../generic/conversion/convert_integer.inc | 30 ++++ 24 files changed, 1311 insertions(+), 71 deletions(-) create mode 100644 libclc/clc/lib/generic/conversion/clc_convert_float.inc create mode 100644 libclc/clc/lib/generic/conversion/clc_convert_float2float.cl create mode 100644 libclc/clc/lib/generic/conversion/clc_convert_float2int.cl create mode 100644 libclc/clc/lib/generic/conversion/clc_convert_float2int.inc create mode 100644 libclc/clc/lib/generic/conversion/clc_convert_int2float.cl create mode 100644 libclc/clc/lib/generic/conversion/clc_convert_integer.cl create mode 100644 libclc/clc/lib/generic/conversion/clc_convert_integer.inc create mode 100644 libclc/opencl/lib/clspv/conversion/convert_float.inc create mode 100644 libclc/opencl/lib/clspv/conversion/convert_float2float.cl create mode 100644 libclc/opencl/lib/clspv/conversion/convert_float2int.cl create mode 100644 libclc/opencl/lib/clspv/conversion/convert_int2float.cl create mode 100644 libclc/opencl/lib/clspv/conversion/convert_integer.cl create mode 100644 libclc/opencl/lib/clspv/conversion/convert_integer.inc create mode 100644 libclc/opencl/lib/generic/conversion/convert_float.inc create mode 100644 libclc/opencl/lib/generic/conversion/convert_float2float.cl create mode 100644 libclc/opencl/lib/generic/conversion/convert_float2int.cl create mode 100644 libclc/opencl/lib/generic/conversion/convert_int2float.cl create mode 100644 libclc/opencl/lib/generic/conversion/convert_integer.cl create mode 100644 libclc/opencl/lib/generic/conversion/convert_integer.inc diff --git a/libclc/CMakeLists.txt b/libclc/CMakeLists.txt index 1d29adb0f3995..f9ee80645b70f 100644 --- a/libclc/CMakeLists.txt +++ b/libclc/CMakeLists.txt @@ -248,31 +248,6 @@ if( ENABLE_RUNTIME_SUBNORMAL ) endforeach() endif() -find_package( Python3 REQUIRED COMPONENTS Interpreter ) -file( TO_CMAKE_PATH ${CMAKE_CURRENT_SOURCE_DIR}/utils/gen_convert.py script_loc ) -add_custom_command( - OUTPUT convert.cl - COMMAND ${Python3_EXECUTABLE} ${script_loc} > convert.cl - DEPENDS ${script_loc} ) -add_custom_target( generate-convert.cl DEPENDS convert.cl ) -set_target_properties( generate-convert.cl PROPERTIES FOLDER "libclc/Sourcegenning" ) - -add_custom_command( - OUTPUT clc-convert.cl - COMMAND ${Python3_EXECUTABLE} ${script_loc} --clc > clc-convert.cl - DEPENDS ${script_loc} ) -add_custom_target( generate-clc-convert.cl DEPENDS clc-convert.cl ) -set_target_properties( generate-clc-convert.cl PROPERTIES FOLDER "libclc/Sourcegenning" ) - -if ( clspv-- IN_LIST LIBCLC_TARGETS_TO_BUILD OR clspv64-- IN_LIST LIBCLC_TARGETS_TO_BUILD ) - add_custom_command( - OUTPUT clspv-convert.cl - COMMAND ${Python3_EXECUTABLE} ${script_loc} --clspv > clspv-convert.cl - DEPENDS ${script_loc} ) - add_custom_target( generate-clspv-convert.cl DEPENDS clspv-convert.cl ) - set_target_properties( generate-clspv-convert.cl PROPERTIES FOLDER "libclc/Sourcegenning" ) -endif() - set_source_files_properties( # CLC builtins ${CMAKE_CURRENT_SOURCE_DIR}/clc/lib/generic/math/clc_native_cos.cl @@ -359,7 +334,6 @@ foreach( t ${LIBCLC_TARGETS_TO_BUILD} ) endif() set( clc_lib_files ) - set( clc_gen_files clc-convert.cl ) libclc_configure_lib_source( clc_lib_files @@ -368,17 +342,11 @@ foreach( t ${LIBCLC_TARGETS_TO_BUILD} ) ) set( opencl_lib_files ) - set( opencl_gen_files ) - if( NOT ARCH STREQUAL spirv AND NOT ARCH STREQUAL spirv64 ) - if( ARCH STREQUAL clspv OR ARCH STREQUAL clspv64 ) - list( APPEND opencl_gen_files clspv-convert.cl ) - else() - list( APPEND opencl_gen_files convert.cl ) - if ( NOT ENABLE_RUNTIME_SUBNORMAL ) - list( APPEND opencl_lib_files opencl/lib/generic/subnormal_use_default.ll ) - endif() - endif() + if( NOT ARCH STREQUAL spirv AND NOT ARCH STREQUAL spirv64 AND + NOT ARCH STREQUAL clspv AND NOT ARCH STREQUAL clspv64 AND + NOT ENABLE_RUNTIME_SUBNORMAL ) + list( APPEND opencl_lib_files opencl/lib/generic/subnormal_use_default.ll ) endif() libclc_configure_lib_source( @@ -473,7 +441,6 @@ foreach( t ${LIBCLC_TARGETS_TO_BUILD} ) COMPILE_FLAGS ${build_flags} OPT_FLAGS ${opt_flags} LIB_FILES ${clc_lib_files} - GEN_FILES ${clc_gen_files} ) list( APPEND build_flags @@ -488,7 +455,6 @@ foreach( t ${LIBCLC_TARGETS_TO_BUILD} ) COMPILE_FLAGS ${build_flags} OPT_FLAGS ${opt_flags} LIB_FILES ${opencl_lib_files} - GEN_FILES ${opencl_gen_files} ALIASES ${${d}_aliases} PARENT_TARGET libclc-opencl-builtins # Link in the CLC builtins and internalize their symbols diff --git a/libclc/clc/lib/generic/SOURCES b/libclc/clc/lib/generic/SOURCES index 64fc6b4827a1a..62fcaddfa4b12 100644 --- a/libclc/clc/lib/generic/SOURCES +++ b/libclc/clc/lib/generic/SOURCES @@ -19,6 +19,8 @@ common/clc_radians.cl common/clc_sign.cl common/clc_smoothstep.cl common/clc_step.cl +conversion/clc_convert_float2float.cl +conversion/clc_convert_integer.cl geometric/clc_cross.cl geometric/clc_distance.cl geometric/clc_dot.cl diff --git a/libclc/clc/lib/generic/conversion/clc_convert_float.inc b/libclc/clc/lib/generic/conversion/clc_convert_float.inc new file mode 100644 index 0000000000000..75558dbd34ae2 --- /dev/null +++ b/libclc/clc/lib/generic/conversion/clc_convert_float.inc @@ -0,0 +1,161 @@ +//===----------------------------------------------------------------------===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +#ifdef __CLC_I2F +#ifdef __CLC_GEN_S + +#if __CLC_GENSIZE_SRC == 8 +#define __CLC_SRC_MAX SCHAR_MAX +#elif __CLC_GENSIZE_SRC == 16 +#define __CLC_SRC_MAX SHRT_MAX +#elif __CLC_GENSIZE_SRC == 32 +#define __CLC_SRC_MAX INT_MAX +#elif __CLC_GENSIZE_SRC == 64 +#define __CLC_SRC_MAX LONG_MAX +#endif + +#else // __CLC_GEN_S + +#if __CLC_GENSIZE_SRC == 8 +#define __CLC_SRC_MAX UCHAR_MAX +#elif __CLC_GENSIZE_SRC == 16 +#define __CLC_SRC_MAX USHRT_MAX +#elif __CLC_GENSIZE_SRC == 32 +#define __CLC_SRC_MAX UINT_MAX +#elif __CLC_GENSIZE_SRC == 64 +#define __CLC_SRC_MAX ULONG_MAX +#endif + +#endif // __CLC_GEN_S +#endif // __CLC_I2F + +// Default conversion + +// All conversions are in accordance with the OpenCL specification, +// which cites the C99 conversion rules. +// +// Conversions from integer to floating-point, and floating-point to +// floating-point through casting is done with the default rounding +// mode. While C99 allows dynamically changing the rounding mode +// during runtime, it is not a supported feature in OpenCL according +// to Section 7.1 - Rounding Modes in the OpenCL 1.2 specification. +// +// Therefore, we can assume for optimization purposes that the +// rounding mode is fixed to round-to-nearest-even. Platform target +// authors should ensure that the rounding-control registers remain +// in this state, and that this invariant holds. +// +// Also note, even though the OpenCL specification isn't entirely +// clear on this matter, we implement all rounding mode combinations +// even for integer-to-integer conversions. When such a conversion +// is used, the rounding mode is ignored. + +#ifdef __CLC_SCALAR + +_CLC_OVERLOAD _CLC_DEF __CLC_GENTYPE __CLC_FUNCTION(__CLC_GENTYPE_SRC x) { + return (__CLC_GENTYPE)x; +} + +#else // __CLC_SCALAR + +_CLC_OVERLOAD _CLC_DEF __CLC_GENTYPE __CLC_FUNCTION(__CLC_GENTYPE_SRC x) { + return __builtin_convertvector(x, __CLC_GENTYPE); +} + +#endif // __CLC_SCALAR + +// Rounding mode conversion + +_CLC_OVERLOAD _CLC_DEF __CLC_GENTYPE __CLC_XCONCAT(__CLC_FUNCTION, + _rte)(__CLC_GENTYPE_SRC x) { + return __CLC_FUNCTION(x); +} + +_CLC_OVERLOAD _CLC_DEF __CLC_GENTYPE __CLC_XCONCAT(__CLC_FUNCTION, + _rtz)(__CLC_GENTYPE_SRC x) { + __CLC_GENTYPE r = __CLC_FUNCTION(x); +#ifdef __CLC_I2F + __CLC_GENTYPE_SRC y = + __CLC_XCONCAT(__CLC_XCONCAT(__clc_convert_, __CLC_GENTYPE_SRC), _sat)(r); + __CLC_GENTYPE_SRC_U abs_x = __clc_abs(x); + __CLC_GENTYPE_SRC_U abs_y = __clc_abs(y); +#else + __CLC_GENTYPE_SRC y = __CLC_XCONCAT(__clc_convert_, __CLC_GENTYPE_SRC)(r); + __CLC_GENTYPE_SRC abs_x = __clc_fabs(x); + __CLC_GENTYPE_SRC abs_y = __clc_fabs(y); +#endif + __CLC_S_GENTYPE c = __CLC_CONVERT_S_GENTYPE(abs_y > abs_x); +#if defined(__CLC_I2F) && (__CLC_GENSIZE_SRC >= __CLC_FPSIZE) + c = c || __CLC_CONVERT_S_GENTYPE((__CLC_GENTYPE_SRC)__CLC_SRC_MAX == x); +#endif + __CLC_GENTYPE sel = __clc_select( + r, __clc_nextafter(r, __clc_sign(r) * (__CLC_GENTYPE)-INFINITY), c); +#if defined(__CLC_I2F) && (__CLC_FPSIZE == 16) && (__CLC_GENSIZE_SRC >= 16) +#if defined(__CLC_GEN_S) && (__CLC_GENSIZE_SRC == 16) + // short is 16 bits signed, so the maximum value rounded to zero is + // 0x1.ffcp+14 (0x1p+15 == 32768 > 0x7fff == 32767) + half dst_max = 0x1.ffcp+14h; +#else + half dst_max = 0x1.ffcp+15h; +#endif // defined(__CLC_GEN_S) && (__CLC_GENSIZE_SRC == 16) + half dst_min = -0x1.ffcp+15h; + sel = __clc_clamp(sel, (__CLC_GENTYPE)dst_min, (__CLC_GENTYPE)dst_max); +#endif // defined(__CLC_I2F) && (__CLC_FPSIZE == 16) && (__CLC_GENSIZE_SRC >= + // 16) + return sel; +} + +_CLC_OVERLOAD _CLC_DEF __CLC_GENTYPE __CLC_XCONCAT(__CLC_FUNCTION, + _rtp)(__CLC_GENTYPE_SRC x) { + __CLC_GENTYPE r = __CLC_FUNCTION(x); +#ifdef __CLC_I2F + __CLC_GENTYPE_SRC y = + __CLC_XCONCAT(__CLC_XCONCAT(__clc_convert_, __CLC_GENTYPE_SRC), _sat)(r); +#else + __CLC_GENTYPE_SRC y = __CLC_XCONCAT(__clc_convert_, __CLC_GENTYPE_SRC)(r); +#endif + __CLC_GENTYPE sel = + __clc_select(r, __clc_nextafter(r, (__CLC_GENTYPE)INFINITY), + __CLC_CONVERT_S_GENTYPE(y < x)); +#if defined(__CLC_I2F) && (__CLC_FPSIZE == 16) && (__CLC_GENSIZE_SRC >= 16) + half dst_min = -0x1.ffcp+15h; + sel = __clc_max(sel, (__CLC_GENTYPE)dst_min); +#endif + return sel; +} + +_CLC_OVERLOAD _CLC_DEF __CLC_GENTYPE __CLC_XCONCAT(__CLC_FUNCTION, + _rtn)(__CLC_GENTYPE_SRC x) { + __CLC_GENTYPE r = __CLC_FUNCTION(x); +#ifdef __CLC_I2F + __CLC_GENTYPE_SRC y = + __CLC_XCONCAT(__CLC_XCONCAT(__clc_convert_, __CLC_GENTYPE_SRC), _sat)(r); +#else + __CLC_GENTYPE_SRC y = __CLC_XCONCAT(__clc_convert_, __CLC_GENTYPE_SRC)(r); +#endif + __CLC_S_GENTYPE c = __CLC_CONVERT_S_GENTYPE(y > x); +#if defined(__CLC_I2F) && (__CLC_GENSIZE_SRC >= __CLC_FPSIZE) + c = c || __CLC_CONVERT_S_GENTYPE((__CLC_GENTYPE_SRC)__CLC_SRC_MAX == x); +#endif + __CLC_GENTYPE sel = + __clc_select(r, __clc_nextafter(r, (__CLC_GENTYPE)-INFINITY), c); +#if defined(__CLC_I2F) && (__CLC_FPSIZE == 16) && (__CLC_GENSIZE_SRC >= 16) +#if defined(__CLC_GEN_S) && (__CLC_GENSIZE_SRC == 16) + // short is 16 bits signed, so the maximum value rounded to negative infinity + // is 0x1.ffcp+14 (0x1p+15 == 32768 > 0x7fff == 32767) + half dst_max = 0x1.ffcp+14h; +#else + half dst_max = 0x1.ffcp+15h; +#endif // defined(__CLC_GEN_S) && (__CLC_GENSIZE_SRC == 16) + sel = __clc_min(sel, (__CLC_GENTYPE)dst_max); +#endif // defined(__CLC_I2F) && (__CLC_FPSIZE == 16) && + // (__CLC_GENSIZE_SRC >= 16) + return sel; +} + +#undef __CLC_SRC_MAX diff --git a/libclc/clc/lib/generic/conversion/clc_convert_float2float.cl b/libclc/clc/lib/generic/conversion/clc_convert_float2float.cl new file mode 100644 index 0000000000000..41dc43f67aa66 --- /dev/null +++ b/libclc/clc/lib/generic/conversion/clc_convert_float2float.cl @@ -0,0 +1,52 @@ +//===----------------------------------------------------------------------===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +#include <clc/clc_convert.h> +#include <clc/common/clc_sign.h> +#include <clc/float/definitions.h> +#include <clc/math/clc_fabs.h> +#include <clc/math/clc_nextafter.h> +#include <clc/relational/clc_select.h> +#include <clc/shared/clc_clamp.h> + +#define __CLC_GENTYPE_SRC __CLC_XCONCAT(__CLC_SCALAR_TYPE_SRC, __CLC_VECSIZE) + +#define __CLC_GENTYPE_SRC_S \ + __CLC_XCONCAT(__CLC_SCALAR_TYPE_SRC_S, __CLC_VECSIZE) + +#define __CLC_FUNCTION __CLC_XCONCAT(__clc_convert_, __CLC_GENTYPE) + +#ifdef cl_khr_fp16 +#pragma OPENCL EXTENSION cl_khr_fp16 : enable +#define __CLC_SCALAR_TYPE_SRC half +#define __CLC_SCALAR_TYPE_SRC_S short +#define __CLC_BODY <clc_convert_float.inc> +#include <clc/math/gentype.inc> +#undef __CLC_SCALAR_TYPE_SRC +#undef __CLC_SCALAR_TYPE_SRC_S +#endif // cl_khr_fp16 + +#define __CLC_SCALAR_TYPE_SRC float +#define __CLC_SCALAR_TYPE_SRC_S int +#define __CLC_BODY <clc_convert_float.inc> +#include <clc/math/gentype.inc> +#undef __CLC_SCALAR_TYPE_SRC +#undef __CLC_SCALAR_TYPE_SRC_S + +#ifdef cl_khr_fp64 +#define __CLC_SCALAR_TYPE_SRC double +#define __CLC_SCALAR_TYPE_SRC_S long +#define __CLC_BODY <clc_convert_float.inc> +#include <clc/math/gentype.inc> +#undef __CLC_SCALAR_TYPE_SRC +#undef __CLC_SCALAR_TYPE_SRC_S +#endif // cl_khr_fp64 + +#undef __CLC_GENTYPE_SRC +#undef __CLC_GENTYPE_SRC_S +#undef __CLC_FUNCTION diff --git a/libclc/clc/lib/generic/conversion/clc_convert_float2int.cl b/libclc/clc/lib/generic/conversion/clc_convert_float2int.cl new file mode 100644 index 0000000000000..cc7016fcbefbd --- /dev/null +++ b/libclc/clc/lib/generic/conversion/clc_convert_float2int.cl @@ -0,0 +1,65 @@ +//===----------------------------------------------------------------------===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +#include <clc/clc_convert.h> +#include <clc/integer/definitions.h> +#include <clc/math/clc_ceil.h> +#include <clc/math/clc_floor.h> +#include <clc/math/clc_rint.h> +#include <clc/relational/clc_select.h> + +#define __CLC_S_SCALAR_TYPE_DST __CLC_SCALAR_TYPE_DST +#define __CLC_U_SCALAR_TYPE_DST __CLC_XCONCAT(u, __CLC_SCALAR_TYPE_DST) + +#define __CLC_S_GENTYPE_DST \ + __CLC_XCONCAT(__CLC_S_SCALAR_TYPE_DST, __CLC_VECSIZE) +#define __CLC_U_GENTYPE_DST \ + __CLC_XCONCAT(__CLC_U_SCALAR_TYPE_DST, __CLC_VECSIZE) + +#define __CLC_FUNCTION_S __CLC_XCONCAT(__clc_convert_, __CLC_S_GENTYPE_DST) +#define __CLC_FUNCTION_U __CLC_XCONCAT(__clc_convert_, __CLC_U_GENTYPE_DST) +#define __CLC_FUNCTION_S_SAT __CLC_XCONCAT(__CLC_FUNCTION_S, _sat) +#define __CLC_FUNCTION_U_SAT __CLC_XCONCAT(__CLC_FUNCTION_U, _sat) + +#define __CLC_SCALAR_TYPE_DST char +#define __CLC_GENSIZE_DST 8 +#define __CLC_BODY <clc_convert_float2int.inc> +#include <clc/math/gentype.inc> +#undef __CLC_SCALAR_TYPE_DST +#undef __CLC_GENSIZE_DST + +#define __CLC_SCALAR_TYPE_DST short +#define __CLC_GENSIZE_DST 16 +#define __CLC_BODY <clc_convert_float2int.inc> +#include <clc/math/gentype.inc> +#undef __CLC_SCALAR_TYPE_DST +#undef __CLC_GENSIZE_DST + +#define __CLC_SCALAR_TYPE_DST int +#define __CLC_GENSIZE_DST 32 +#define __CLC_BODY <clc_convert_float2int.inc> +#include <clc/math/gentype.inc> +#undef __CLC_SCALAR_TYPE_DST +#undef __CLC_GENSIZE_DST + +#define __CLC_SCALAR_TYPE_DST long +#define __CLC_GENSIZE_DST 64 +#define __CLC_BODY <clc_convert_float2int.inc> +#include <clc/math/gentype.inc> +#undef __CLC_SCALAR_TYPE_DST +#undef __CLC_GENSIZE_DST + +#undef __CLC_S_SCALAR_TYPE_DST +#undef __CLC_U_SCALAR_TYPE_DST +#undef __CLC_S_GENTYPE_DST +#undef __CLC_U_GENTYPE_DST + +#undef __CLC_FUNCTION_S +#undef __CLC_FUNCTION_U +#undef __CLC_FUNCTION_S_SAT +#undef __CLC_FUNCTION_U_SAT diff --git a/libclc/clc/lib/generic/conversion/clc_convert_float2int.inc b/libclc/clc/lib/generic/conversion/clc_convert_float2int.inc new file mode 100644 index 0000000000000..48345d017c5dd --- /dev/null +++ b/libclc/clc/lib/generic/conversion/clc_convert_float2int.inc @@ -0,0 +1,146 @@ +//===----------------------------------------------------------------------===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +// Default conversion + +// All conversions are in accordance with the OpenCL specification, +// which cites the C99 conversion rules. +// +// Casting from floating point to integer results in conversions +// with truncation, so it should be suitable for the default convert +// functions. +// +// While C99 allows dynamically changing the rounding mode +// during runtime, it is not a supported feature in OpenCL according +// to Section 7.1 - Rounding Modes in the OpenCL 1.2 specification. +// +// Therefore, we can assume for optimization purposes that the +// rounding mode is fixed to round-to-nearest-even. Platform target +// authors should ensure that the rounding-control registers remain +// in this state, and that this invariant holds. +// +// Also note, even though the OpenCL specification isn't entirely +// clear on this matter, we implement all rounding mode combinations +// even for integer-to-integer conversions. When such a conversion +// is used, the rounding mode is ignored. + +#ifdef __CLC_SCALAR + +_CLC_OVERLOAD _CLC_DEF __CLC_S_GENTYPE_DST __CLC_FUNCTION_S(__CLC_GENTYPE x) { + return (__CLC_S_GENTYPE_DST)x; +} +_CLC_OVERLOAD _CLC_DEF __CLC_U_GENTYPE_DST __CLC_FUNCTION_U(__CLC_GENTYPE x) { + return (__CLC_U_GENTYPE_DST)x; +} + +#else // __CLC_SCALAR + +_CLC_OVERLOAD _CLC_DEF __CLC_S_GENTYPE_DST __CLC_FUNCTION_S(__CLC_GENTYPE x) { + return __builtin_convertvector(x, __CLC_S_GENTYPE_DST); +} +_CLC_OVERLOAD _CLC_DEF __CLC_U_GENTYPE_DST __CLC_FUNCTION_U(__CLC_GENTYPE x) { + return __builtin_convertvector(x, __CLC_U_GENTYPE_DST); +} + +#endif // __CLC_SCALAR + +// Saturated conversion + +#if __CLC_GENSIZE_DST == 8 +#define __CLC_DST_MAX_S SCHAR_MAX +#define __CLC_DST_MIN_S SCHAR_MIN +#define __CLC_DST_MAX_U UCHAR_MAX +#define __CLC_DST_MIN_U UCHAR_MIN +#elif __CLC_GENSIZE_DST == 16 +#define __CLC_DST_MAX_S SHRT_MAX +#define __CLC_DST_MIN_S SHRT_MIN +#define __CLC_DST_MAX_U USHRT_MAX +#define __CLC_DST_MIN_U USHRT_MIN +#elif __CLC_GENSIZE_DST == 32 +#define __CLC_DST_MAX_S INT_MAX +#define __CLC_DST_MIN_S INT_MIN +#define __CLC_DST_MAX_U UINT_MAX +#define __CLC_DST_MIN_U UINT_MIN +#elif __CLC_GENSIZE_DST == 64 +#define __CLC_DST_MAX_S LONG_MAX +#define __CLC_DST_MIN_S LONG_MIN +#define __CLC_DST_MAX_U ULONG_MAX +#define __CLC_DST_MIN_U ULONG_MIN +#endif + +_CLC_OVERLOAD +_CLC_DEF __CLC_S_GENTYPE_DST __CLC_FUNCTION_S_SAT(__CLC_GENTYPE x) { + __CLC_S_GENTYPE_DST y = __CLC_FUNCTION_S(x); + y = __clc_select(y, (__CLC_S_GENTYPE_DST)__CLC_DST_MIN_S, + __CLC_FUNCTION_S(x <= (__CLC_GENTYPE)__CLC_DST_MIN_S)); + y = __clc_select(y, (__CLC_S_GENTYPE_DST)__CLC_DST_MAX_S, + __CLC_FUNCTION_S(x >= (__CLC_GENTYPE)__CLC_DST_MAX_S)); + return y; +} +_CLC_OVERLOAD _CLC_DEF __CLC_U_GENTYPE_DST +__CLC_FUNCTION_U_SAT(__CLC_GENTYPE x) { + __CLC_U_GENTYPE_DST y = __CLC_FUNCTION_U(x); + // FIXME: This is a work around for lack of select function with signed + // third argument when the first two arguments are unsigned types. We cast + // to the signed type for sign-extension, then do a bitcast to the unsigned + // type. + y = __clc_select(y, (__CLC_U_GENTYPE_DST)__CLC_DST_MIN_U, + __CLC_XCONCAT(__clc_as_, __CLC_U_GENTYPE_DST)( + __CLC_FUNCTION_S(x <= (__CLC_GENTYPE)__CLC_DST_MIN_U))); + y = __clc_select(y, (__CLC_U_GENTYPE_DST)__CLC_DST_MAX_U, + __CLC_XCONCAT(__clc_as_, __CLC_U_GENTYPE_DST)( + __CLC_FUNCTION_S(x >= (__CLC_GENTYPE)__CLC_DST_MAX_U))); + return y; +} + +#undef __CLC_DST_MAX_S +#undef __CLC_DST_MIN_S +#undef __CLC_DST_MAX_U +#undef __CLC_DST_MIN_U + +// Saturated conversion with rounding mode + +#define __CLC_DEFINE_FUNCTION_SAT_ROUNDING_MODE(MODE, ROUND_FUNC) \ + _CLC_OVERLOAD _CLC_DEF __CLC_S_GENTYPE_DST __CLC_XCONCAT( \ + __CLC_FUNCTION_S_SAT, MODE)(__CLC_GENTYPE x) { \ + x = ROUND_FUNC(x); \ + return __CLC_FUNCTION_S_SAT(x); \ + } \ + _CLC_OVERLOAD _CLC_DEF __CLC_U_GENTYPE_DST __CLC_XCONCAT( \ + __CLC_FUNCTION_U_SAT, MODE)(__CLC_GENTYPE x) { \ + x = ROUND_FUNC(x); \ + return __CLC_FUNCTION_U_SAT(x); \ + } + +__CLC_DEFINE_FUNCTION_SAT_ROUNDING_MODE(_rte, __clc_rint) +__CLC_DEFINE_FUNCTION_SAT_ROUNDING_MODE(_rtz, ) +__CLC_DEFINE_FUNCTION_SAT_ROUNDING_MODE(_rtp, __clc_ceil) +__CLC_DEFINE_FUNCTION_SAT_ROUNDING_MODE(_rtn, __clc_floor) + +#undef __CLC_DEFINE_FUNCTION_SAT_ROUNDING_MODE + +// Rounding mode conversion + +#define __CLC_DEFINE_FUNCTION_ROUNDING_MODE(MODE, ROUND_FUNC) \ + _CLC_OVERLOAD _CLC_DEF __CLC_S_GENTYPE_DST __CLC_XCONCAT( \ + __CLC_FUNCTION_S, MODE)(__CLC_GENTYPE x) { \ + x = ROUND_FUNC(x); \ + return __CLC_FUNCTION_S(x); \ + } \ + _CLC_OVERLOAD _CLC_DEF __CLC_U_GENTYPE_DST __CLC_XCONCAT( \ + __CLC_FUNCTION_U, MODE)(__CLC_GENTYPE x) { \ + x = ROUND_FUNC(x); \ + return __CLC_FUNCTION_U(x); \ + } + +__CLC_DEFINE_FUNCTION_ROUNDING_MODE(_rte, __clc_rint) +__CLC_DEFINE_FUNCTION_ROUNDING_MODE(_rtz, ) +__CLC_DEFINE_FUNCTION_ROUNDING_MODE(_rtp, __clc_ceil) +__CLC_DEFINE_FUNCTION_ROUNDING_MODE(_rtn, __clc_floor) + +#undef __CLC_DEFINE_FUNCTION_ROUNDING_MODE diff --git a/libclc/clc/lib/generic/conversion/clc_convert_int2float.cl b/libclc/clc/lib/generic/conversion/clc_convert_int2float.cl new file mode 100644 index 0000000000000..70bb027d9e436 --- /dev/null +++ b/libclc/clc/lib/generic/conversion/clc_convert_int2float.cl @@ -0,0 +1,103 @@ +//===----------------------------------------------------------------------===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +#include <clc/clc_convert.h> +#include <clc/common/clc_sign.h> +#include <clc/float/definitions.h> +#include <clc/integer/clc_abs.h> +#include <clc/integer/definitions.h> +#include <clc/math/clc_nextafter.h> +#include <clc/relational/clc_select.h> +#include <clc/shared/clc_clamp.h> +#include <clc/shared/clc_max.h> +#include <clc/shared/clc_min.h> + +#define __CLC_GENTYPE_SRC __CLC_XCONCAT(__CLC_SCALAR_TYPE_SRC, __CLC_VECSIZE) + +#define __CLC_GENTYPE_SRC_S \ + __CLC_XCONCAT(__CLC_SCALAR_TYPE_SRC_S, __CLC_VECSIZE) +#define __CLC_GENTYPE_SRC_U \ + __CLC_XCONCAT(__CLC_XCONCAT(u, __CLC_SCALAR_TYPE_SRC_S), __CLC_VECSIZE) + +#define __CLC_FUNCTION __CLC_XCONCAT(__clc_convert_, __CLC_GENTYPE) + +#define __CLC_I2F + +#define __CLC_SCALAR_TYPE_SRC_S char +#define __CLC_GENSIZE_SRC 8 + +#define __CLC_GEN_S +#define __CLC_SCALAR_TYPE_SRC char +#define __CLC_BODY <clc_convert_float.inc> +#include <clc/math/gentype.inc> +#undef __CLC_SCALAR_TYPE_SRC +#undef __CLC_GEN_S + +#define __CLC_SCALAR_TYPE_SRC uchar +#define __CLC_BODY <clc_convert_float.inc> +#include <clc/math/gentype.inc> +#undef __CLC_SCALAR_TYPE_SRC + +#undef __CLC_SCALAR_TYPE_SRC_S +#undef __CLC_GENSIZE_SRC +#define __CLC_SCALAR_TYPE_SRC_S short +#define __CLC_GENSIZE_SRC 16 + +#define __CLC_GEN_S +#define __CLC_SCALAR_TYPE_SRC short +#define __CLC_BODY <clc_convert_float.inc> +#include <clc/math/gentype.inc> +#undef __CLC_SCALAR_TYPE_SRC +#undef __CLC_GEN_S + +#define __CLC_SCALAR_TYPE_SRC ushort +#define __CLC_BODY <clc_convert_float.inc> +#include <clc/math/gentype.inc> +#undef __CLC_SCALAR_TYPE_SRC + +#undef __CLC_SCALAR_TYPE_SRC_S +#undef __CLC_GENSIZE_SRC +#define __CLC_SCALAR_TYPE_SRC_S int +#define __CLC_GENSIZE_SRC 32 + +#define __CLC_GEN_S +#define __CLC_SCALAR_TYPE_SRC int +#define __CLC_BODY <clc_convert_float.inc> +#include <clc/math/gentype.inc> +#undef __CLC_SCALAR_TYPE_SRC +#undef __CLC_GEN_S + +#define __CLC_SCALAR_TYPE_SRC uint +#define __CLC_BODY <clc_convert_float.inc> +#include <clc/math/gentype.inc> +#undef __CLC_SCALAR_TYPE_SRC + +#undef __CLC_SCALAR_TYPE_SRC_S +#undef __CLC_GENSIZE_SRC +#define __CLC_SCALAR_TYPE_SRC_S long +#define __CLC_GENSIZE_SRC 64 + +#define __CLC_GEN_S +#define __CLC_SCALAR_TYPE_SRC long +#define __CLC_BODY <clc_convert_float.inc> +#include <clc/math/gentype.inc> +#undef __CLC_SCALAR_TYPE_SRC +#undef __CLC_GEN_S + +#define __CLC_SCALAR_TYPE_SRC ulong +#define __CLC_BODY <clc_convert_float.inc> +#include <clc/math/gentype.inc> +#undef __CLC_SCALAR_TYPE_SRC + +#undef __CLC_GENTYPE_SRC +#undef __CLC_GENTYPE_SRC_S +#undef __CLC_GENTYPE_SRC_U +#undef __CLC_FUNCTION +#undef __CLC_I2F +#undef __CLC_SCALAR_TYPE_SRC_S +#undef __CLC_GENSIZE_SRC diff --git a/libclc/clc/lib/generic/conversion/clc_convert_integer.cl b/libclc/clc/lib/generic/conversion/clc_convert_integer.cl new file mode 100644 index 0000000000000..66c61e3db8d9b --- /dev/null +++ b/libclc/clc/lib/generic/conversion/clc_convert_integer.cl @@ -0,0 +1,64 @@ +//===----------------------------------------------------------------------===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +#include <clc/clc_convert.h> +#include <clc/integer/definitions.h> +#include <clc/shared/clc_clamp.h> +#include <clc/shared/clc_max.h> +#include <clc/shared/clc_min.h> + +#define __CLC_S_SCALAR_TYPE_SRC __CLC_SCALAR_TYPE_SRC +#define __CLC_U_SCALAR_TYPE_SRC __CLC_XCONCAT(u, __CLC_SCALAR_TYPE_SRC) + +#define __CLC_S_GENTYPE_SRC \ + __CLC_XCONCAT(__CLC_S_SCALAR_TYPE_SRC, __CLC_VECSIZE) +#define __CLC_U_GENTYPE_SRC \ + __CLC_XCONCAT(__CLC_U_SCALAR_TYPE_SRC, __CLC_VECSIZE) + +#define __CLC_FUNCTION __CLC_XCONCAT(__clc_convert_, __CLC_GENTYPE) +#define __CLC_FUNCTION_SAT __CLC_XCONCAT(__CLC_FUNCTION, _sat) + +#define __CLC_SCALAR_TYPE_SRC char +#define __CLC_GENSIZE_SRC 8 +#define __CLC_BODY <clc_convert_integer.inc> +#include <clc/integer/gentype.inc> +#undef __CLC_SCALAR_TYPE_SRC +#undef __CLC_GENSIZE_SRC + +#define __CLC_SCALAR_TYPE_SRC short +#define __CLC_GENSIZE_SRC 16 +#define __CLC_BODY <clc_convert_integer.inc> +#include <clc/integer/gentype.inc> +#undef __CLC_SCALAR_TYPE_SRC +#undef __CLC_GENSIZE_SRC + +#define __CLC_SCALAR_TYPE_SRC int +#define __CLC_GENSIZE_SRC 32 +#define __CLC_BODY <clc_convert_integer.inc> +#include <clc/integer/gentype.inc> +#undef __CLC_SCALAR_TYPE_SRC +#undef __CLC_GENSIZE_SRC + +#if defined cles_khr_int64 || !defined(__EMBEDDED_PROFILE__) +#define __CLC_SCALAR_TYPE_SRC long +#define __CLC_GENSIZE_SRC 64 +#define __CLC_BODY <clc_convert_integer.inc> +#include <clc/integer/gentype.inc> +#undef __CLC_SCALAR_TYPE_SRC +#undef __CLC_GENSIZE_SRC +#endif // defined cles_khr_int64 || !defined(__EMBEDDED_PROFILE__) + +#undef __CLC_S_SCALAR_TYPE_SRC +#undef __CLC_U_SCALAR_TYPE_SRC +#undef __CLC_S_GENTYPE_SRC +#undef __CLC_U_GENTYPE_SRC +#undef __CLC_FUNCTION +#undef __CLC_FUNCTION_SAT + +#include <clc_convert_float2int.cl> +#include <clc_convert_int2float.cl> diff --git a/libclc/clc/lib/generic/conversion/clc_convert_integer.inc b/libclc/clc/lib/generic/conversion/clc_convert_integer.inc new file mode 100644 index 0000000000000..c0a517a927433 --- /dev/null +++ b/libclc/clc/lib/generic/conversion/clc_convert_integer.inc @@ -0,0 +1,146 @@ +//===----------------------------------------------------------------------===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +// Default conversion + +// All conversions are in accordance with the OpenCL specification, +// which cites the C99 conversion rules. +// +// While C99 allows dynamically changing the rounding mode +// during runtime, it is not a supported feature in OpenCL according +// to Section 7.1 - Rounding Modes in the OpenCL 1.2 specification. +// +// Therefore, we can assume for optimization purposes that the +// rounding mode is fixed to round-to-nearest-even. Platform target +// authors should ensure that the rounding-control registers remain +// in this state, and that this invariant holds. +// +// Also note, even though the OpenCL specification isn't entirely +// clear on this matter, we implement all rounding mode combinations +// even for integer-to-integer conversions. When such a conversion +// is used, the rounding mode is ignored. + +#define __CLC_GENSIZE_DST __CLC_GENSIZE + +_CLC_OVERLOAD _CLC_DEF __CLC_GENTYPE __CLC_FUNCTION(__CLC_S_GENTYPE_SRC x) { +#ifdef __CLC_SCALAR + return x; +#else + return __builtin_convertvector(x, __CLC_GENTYPE); +#endif +} +_CLC_OVERLOAD _CLC_DEF __CLC_GENTYPE __CLC_FUNCTION(__CLC_U_GENTYPE_SRC x) { +#ifdef __CLC_SCALAR + return x; +#else + return __builtin_convertvector(x, __CLC_GENTYPE); +#endif +} + +#ifdef __CLC_GEN_S + +#if __CLC_GENSIZE == 8 +#define __CLC_DST_MAX SCHAR_MAX +#define __CLC_DST_MIN SCHAR_MIN +#elif __CLC_GENSIZE == 16 +#define __CLC_DST_MAX SHRT_MAX +#define __CLC_DST_MIN SHRT_MIN +#elif __CLC_GENSIZE == 32 +#define __CLC_DST_MAX INT_MAX +#define __CLC_DST_MIN INT_MIN +#elif __CLC_GENSIZE == 64 +#define __CLC_DST_MAX LONG_MAX +#define __CLC_DST_MIN LONG_MIN +#endif + +#else // __CLC_GEN_S + +#if __CLC_GENSIZE == 8 +#define __CLC_DST_MAX UCHAR_MAX +#define __CLC_DST_MIN UCHAR_MIN +#elif __CLC_GENSIZE == 16 +#define __CLC_DST_MAX USHRT_MAX +#define __CLC_DST_MIN USHRT_MIN +#elif __CLC_GENSIZE == 32 +#define __CLC_DST_MAX UINT_MAX +#define __CLC_DST_MIN UINT_MIN +#elif __CLC_GENSIZE == 64 +#define __CLC_DST_MAX ULONG_MAX +#define __CLC_DST_MIN ULONG_MIN +#endif + +#endif // __CLC_GEN_S + +_CLC_OVERLOAD _CLC_DEF __CLC_GENTYPE __CLC_FUNCTION_SAT(__CLC_S_GENTYPE_SRC x) { +#if defined(__CLC_GEN_S) && (__CLC_GENSIZE_SRC == __CLC_GENSIZE_DST) + // Conversion between same types + return x; +#else +#if __CLC_GENSIZE_SRC == __CLC_GENSIZE_DST + x = __clc_max(x, (__CLC_S_SCALAR_TYPE_SRC)0); +#elif __CLC_GENSIZE_SRC > __CLC_GENSIZE_DST + x = __clc_clamp(x, (__CLC_S_SCALAR_TYPE_SRC)__CLC_DST_MIN, + (__CLC_S_SCALAR_TYPE_SRC)__CLC_DST_MAX); +#elif defined(__CLC_GEN_U) + // sizeof(src) < sizeof(dst) + x = __clc_max(x, (__CLC_S_SCALAR_TYPE_SRC)0); +#endif + return __CLC_FUNCTION(x); +#endif +} + +_CLC_OVERLOAD _CLC_DEF __CLC_GENTYPE __CLC_FUNCTION_SAT(__CLC_U_GENTYPE_SRC x) { +#if defined(__CLC_GEN_U) && (__CLC_GENSIZE_SRC == __CLC_GENSIZE_DST) + // Conversion between same types + return x; +#else +#if __CLC_GENSIZE_SRC >= __CLC_GENSIZE_DST + x = __clc_min(x, (__CLC_U_SCALAR_TYPE_SRC)__CLC_DST_MAX); +#endif + return __CLC_FUNCTION(x); +#endif +} + +#ifdef __CLC_SCALAR +#define __CLC_DEFINE_FUNCTION_ROUNDING_MODE_NONSAT_IMPL(TYPE_SRC, MODE) \ + _CLC_OVERLOAD _CLC_DEF __CLC_GENTYPE __CLC_XCONCAT(__CLC_FUNCTION, \ + MODE)(TYPE_SRC x) { \ + return x; \ + } +#else +#define __CLC_DEFINE_FUNCTION_ROUNDING_MODE_NONSAT_IMPL(TYPE_SRC, MODE) \ + _CLC_OVERLOAD _CLC_DEF __CLC_GENTYPE __CLC_XCONCAT(__CLC_FUNCTION, \ + MODE)(TYPE_SRC x) { \ + return __builtin_convertvector(x, __CLC_GENTYPE); \ + } +#endif + +#define __CLC_DEFINE_FUNCTION_ROUNDING_MODE_IMPL(TYPE_SRC, MODE) \ + __CLC_DEFINE_FUNCTION_ROUNDING_MODE_NONSAT_IMPL(TYPE_SRC, MODE) \ + _CLC_OVERLOAD _CLC_DEF __CLC_GENTYPE __CLC_XCONCAT(__CLC_FUNCTION_SAT, \ + MODE)(TYPE_SRC x) { \ + return __CLC_FUNCTION_SAT(x); \ + } + +#define __CLC_DEFINE_FUNCTION_ROUNDING_MODE(MODE) \ + __CLC_DEFINE_FUNCTION_ROUNDING_MODE_IMPL(__CLC_S_GENTYPE_SRC, MODE) \ + __CLC_DEFINE_FUNCTION_ROUNDING_MODE_IMPL(__CLC_U_GENTYPE_SRC, MODE) + +__CLC_DEFINE_FUNCTION_ROUNDING_MODE(_rte) +__CLC_DEFINE_FUNCTION_ROUNDING_MODE(_rtz) +__CLC_DEFINE_FUNCTION_ROUNDING_MODE(_rtp) +__CLC_DEFINE_FUNCTION_ROUNDING_MODE(_rtn) + +#undef __CLC_DEFINE_FUNCTION_ROUNDING_MODE_NONSAT_IMPL +#undef __CLC_DEFINE_FUNCTION_ROUNDING_MODE_IMPL +#undef __CLC_DEFINE_FUNCTION_ROUNDING_MODE + +#undef __CLC_DST_MAX +#undef __CLC_DST_MIN + +#undef __CLC_GENSIZE_DST diff --git a/libclc/cmake/modules/AddLibclc.cmake b/libclc/cmake/modules/AddLibclc.cmake index b83ee7cf184eb..53b8fa91bf3fe 100644 --- a/libclc/cmake/modules/AddLibclc.cmake +++ b/libclc/cmake/modules/AddLibclc.cmake @@ -269,9 +269,8 @@ function(libclc_install) ) endfunction() -# Compiles a list of library source files (provided by LIB_FILES/GEN_FILES) and -# compiles them to LLVM bytecode (or SPIR-V), links them together and optimizes -# them. +# Compiles a list of library source files (provided by LIB_FILES) and compiles +# them to LLVM bytecode (or SPIR-V), links them together and optimizes them. # # For bytecode libraries, a list of ALIASES may optionally be provided to # produce additional symlinks. @@ -292,8 +291,6 @@ endfunction() # optimized and do not have aliases created. # * LIB_FILES <string> ... # List of files that should be built for this library -# * GEN_FILES <string> ... -# List of generated files (in build dir) that should be built for this library # * COMPILE_FLAGS <string> ... # Compilation options (for clang) # * OPT_FLAGS <string> ... @@ -308,7 +305,7 @@ function(add_libclc_builtin_set) cmake_parse_arguments(ARG "CLC_INTERNAL" "ARCH;TRIPLE;ARCH_SUFFIX;PARENT_TARGET" - "LIB_FILES;GEN_FILES;COMPILE_FLAGS;OPT_FLAGS;ALIASES;INTERNAL_LINK_DEPENDENCIES" + "LIB_FILES;COMPILE_FLAGS;OPT_FLAGS;ALIASES;INTERNAL_LINK_DEPENDENCIES" ${ARGN} ) @@ -318,32 +315,15 @@ function(add_libclc_builtin_set) set( bytecode_files ) set( bytecode_ir_files ) - foreach( file IN LISTS ARG_GEN_FILES ARG_LIB_FILES ) - # We need to take each file and produce an absolute input file, as well - # as a unique architecture-specific output file. We deal with a mix of - # different input files, which makes this trickier. - set( input_file_dep ) - if( ${file} IN_LIST ARG_GEN_FILES ) - # Generated files are given just as file names, which we must make - # absolute to the binary directory. - set( input_file ${CMAKE_CURRENT_BINARY_DIR}/${file} ) - set( output_file "${LIBCLC_ARCH_OBJFILE_DIR}/${file}.bc" ) - # If a target exists that generates this file, add that as a dependency - # of the custom command. - if( TARGET generate-${file} ) - set( input_file_dep generate-${file} ) - endif() - else() - # Other files are originally relative to each SOURCE file, which are - # then make relative to the libclc root directory. We must normalize - # the path (e.g., ironing out any ".."), then make it relative to the - # root directory again, and use that relative path component for the - # binary path. - get_filename_component( abs_path ${file} ABSOLUTE BASE_DIR ${CMAKE_CURRENT_SOURCE_DIR} ) - file( RELATIVE_PATH root_rel_path ${CMAKE_CURRENT_SOURCE_DIR} ${abs_path} ) - set( input_file ${CMAKE_CURRENT_SOURCE_DIR}/${file} ) - set( output_file "${LIBCLC_ARCH_OBJFILE_DIR}/${root_rel_path}.bc" ) - endif() + foreach( file IN LISTS ARG_LIB_FILES ) + # Files are originally relative to each SOURCE file, which are then make + # relative to the libclc root directory. We must normalize the path + # (e.g., ironing out any ".."), then make it relative to the root directory + # again, and use that relative path component for the binary path. + get_filename_component( abs_path ${file} ABSOLUTE BASE_DIR ${CMAKE_CURRENT_SOURCE_DIR} ) + file( RELATIVE_PATH root_rel_path ${CMAKE_CURRENT_SOURCE_DIR} ${abs_path} ) + set( input_file ${CMAKE_CURRENT_SOURCE_DIR}/${file} ) + set( output_file "${LIBCLC_ARCH_OBJFILE_DIR}/${root_rel_path}.bc" ) get_filename_component( file_dir ${file} DIRECTORY ) @@ -360,7 +340,6 @@ function(add_libclc_builtin_set) EXTRA_OPTS -nostdlib "${ARG_COMPILE_FLAGS}" "${file_specific_compile_options}" -I${CMAKE_CURRENT_SOURCE_DIR}/${file_dir} - DEPENDENCIES ${input_file_dep} ) # Collect all files originating in LLVM IR separately diff --git a/libclc/opencl/lib/clspv/SOURCES b/libclc/opencl/lib/clspv/SOURCES index 0a142ed3e6043..8537d7c2d6b42 100644 --- a/libclc/opencl/lib/clspv/SOURCES +++ b/libclc/opencl/lib/clspv/SOURCES @@ -1,3 +1,7 @@ +conversion/convert_float2float.cl +conversion/convert_float2int.cl +conversion/convert_int2float.cl +conversion/convert_integer.cl math/fma.cl shared/vstore_half.cl subnormal_config.cl diff --git a/libclc/opencl/lib/clspv/conversion/convert_float.inc b/libclc/opencl/lib/clspv/conversion/convert_float.inc new file mode 100644 index 0000000000000..4febe2cee2d8f --- /dev/null +++ b/libclc/opencl/lib/clspv/conversion/convert_float.inc @@ -0,0 +1,67 @@ +//===----------------------------------------------------------------------===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +#ifdef __CLC_F2F + +#define __CLC_DEFINE_FUNCTION_ROUNDING_MODE(MODE) \ + _CLC_OVERLOAD _CLC_DEF __CLC_GENTYPE __CLC_XCONCAT(__CLC_FUNCTION, MODE)( \ + __CLC_GENTYPE_SRC x) { \ + return __CLC_XCONCAT(__CLC_IMPL_FUNCTION, MODE)(x); \ + } + +#elif defined(__CLC_I2F) + +#define __CLC_DEFINE_FUNCTION_ROUNDING_MODE(MODE) \ + _CLC_OVERLOAD _CLC_DEF __CLC_GENTYPE __CLC_XCONCAT(__CLC_FUNCTION, MODE)( \ + __CLC_S_GENTYPE_SRC x) { \ + return __CLC_XCONCAT(__CLC_IMPL_FUNCTION, MODE)(x); \ + } \ + _CLC_OVERLOAD _CLC_DEF __CLC_GENTYPE __CLC_XCONCAT(__CLC_FUNCTION, MODE)( \ + __CLC_U_GENTYPE_SRC x) { \ + return __CLC_XCONCAT(__CLC_IMPL_FUNCTION, MODE)(x); \ + } + +#elif defined(__CLC_F2I) + +_CLC_OVERLOAD _CLC_DEF __CLC_S_GENTYPE_DST +__CLC_FUNCTION_S_SAT(__CLC_GENTYPE x) { + return __CLC_IMPL_FUNCTION_S_SAT(x); +} +_CLC_OVERLOAD _CLC_DEF __CLC_U_GENTYPE_DST +__CLC_FUNCTION_U_SAT(__CLC_GENTYPE x) { + return __CLC_IMPL_FUNCTION_U_SAT(x); +} + +#define __CLC_DEFINE_FUNCTION_ROUNDING_MODE(MODE) \ + _CLC_OVERLOAD _CLC_DEF __CLC_S_GENTYPE_DST __CLC_XCONCAT( \ + __CLC_FUNCTION_S, MODE)(__CLC_GENTYPE x) { \ + return __CLC_XCONCAT(__CLC_IMPL_FUNCTION_S, MODE)(x); \ + } \ + _CLC_OVERLOAD _CLC_DEF __CLC_S_GENTYPE_DST __CLC_XCONCAT( \ + __CLC_FUNCTION_S_SAT, MODE)(__CLC_GENTYPE x) { \ + return __CLC_XCONCAT(__CLC_IMPL_FUNCTION_S_SAT, MODE)(x); \ + } \ + _CLC_OVERLOAD _CLC_DEF __CLC_U_GENTYPE_DST __CLC_XCONCAT( \ + __CLC_FUNCTION_U, MODE)(__CLC_GENTYPE x) { \ + return __CLC_XCONCAT(__CLC_IMPL_FUNCTION_U, MODE)(x); \ + } \ + _CLC_OVERLOAD _CLC_DEF __CLC_U_GENTYPE_DST __CLC_XCONCAT( \ + __CLC_FUNCTION_U_SAT, MODE)(__CLC_GENTYPE x) { \ + return __CLC_XCONCAT(__CLC_IMPL_FUNCTION_U_SAT, MODE)(x); \ + } + +#endif + +#ifdef __CLC_HAVE_RTE +__CLC_DEFINE_FUNCTION_ROUNDING_MODE(_rte) +#endif +__CLC_DEFINE_FUNCTION_ROUNDING_MODE(_rtz) +__CLC_DEFINE_FUNCTION_ROUNDING_MODE(_rtp) +__CLC_DEFINE_FUNCTION_ROUNDING_MODE(_rtn) + +#undef __CLC_DEFINE_FUNCTION_ROUNDING_MODE diff --git a/libclc/opencl/lib/clspv/conversion/convert_float2float.cl b/libclc/opencl/lib/clspv/conversion/convert_float2float.cl new file mode 100644 index 0000000000000..be74b71f66b71 --- /dev/null +++ b/libclc/opencl/lib/clspv/conversion/convert_float2float.cl @@ -0,0 +1,37 @@ +//===----------------------------------------------------------------------===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +#include <clc/clc_convert.h> +#include <clc/opencl/convert.h> + +#define __CLC_GENTYPE_SRC __CLC_XCONCAT(__CLC_SCALAR_TYPE_SRC, __CLC_VECSIZE) + +#define __CLC_FUNCTION __CLC_XCONCAT(convert_, __CLC_GENTYPE) +#define __CLC_IMPL_FUNCTION __CLC_XCONCAT(__clc_convert_, __CLC_GENTYPE) + +#define __CLC_F2F + +#ifdef cl_khr_fp16 +#pragma OPENCL EXTENSION cl_khr_fp16 : enable +#define __CLC_SCALAR_TYPE_SRC half +#define __CLC_BODY <convert_float.inc> +#include <clc/math/gentype.inc> +#undef __CLC_SCALAR_TYPE_SRC +#endif // cl_khr_fp16 + +#define __CLC_SCALAR_TYPE_SRC float +#define __CLC_BODY <convert_float.inc> +#include <clc/math/gentype.inc> +#undef __CLC_SCALAR_TYPE_SRC + +#ifdef cl_khr_fp64 +#define __CLC_SCALAR_TYPE_SRC double +#define __CLC_BODY <convert_float.inc> +#include <clc/math/gentype.inc> +#undef __CLC_SCALAR_TYPE_SRC +#endif // cl_khr_fp64 diff --git a/libclc/opencl/lib/clspv/conversion/convert_float2int.cl b/libclc/opencl/lib/clspv/conversion/convert_float2int.cl new file mode 100644 index 0000000000000..eca64bd3d1818 --- /dev/null +++ b/libclc/opencl/lib/clspv/conversion/convert_float2int.cl @@ -0,0 +1,50 @@ +//===----------------------------------------------------------------------===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +#include <clc/clc_convert.h> +#include <clc/opencl/convert.h> + +#define __CLC_S_SCALAR_TYPE_DST __CLC_SCALAR_TYPE_DST +#define __CLC_U_SCALAR_TYPE_DST __CLC_XCONCAT(u, __CLC_SCALAR_TYPE_DST) + +#define __CLC_S_GENTYPE_DST \ + __CLC_XCONCAT(__CLC_S_SCALAR_TYPE_DST, __CLC_VECSIZE) +#define __CLC_U_GENTYPE_DST \ + __CLC_XCONCAT(__CLC_U_SCALAR_TYPE_DST, __CLC_VECSIZE) + +#define __CLC_FUNCTION_S __CLC_XCONCAT(convert_, __CLC_S_GENTYPE_DST) +#define __CLC_FUNCTION_U __CLC_XCONCAT(convert_, __CLC_U_GENTYPE_DST) +#define __CLC_FUNCTION_S_SAT __CLC_XCONCAT(__CLC_FUNCTION_S, _sat) +#define __CLC_FUNCTION_U_SAT __CLC_XCONCAT(__CLC_FUNCTION_U, _sat) +#define __CLC_IMPL_FUNCTION_S __CLC_XCONCAT(__clc_convert_, __CLC_S_GENTYPE_DST) +#define __CLC_IMPL_FUNCTION_U __CLC_XCONCAT(__clc_convert_, __CLC_U_GENTYPE_DST) +#define __CLC_IMPL_FUNCTION_S_SAT __CLC_XCONCAT(__CLC_IMPL_FUNCTION_S, _sat) +#define __CLC_IMPL_FUNCTION_U_SAT __CLC_XCONCAT(__CLC_IMPL_FUNCTION_U, _sat) + +#define __CLC_F2I +#define __CLC_HAVE_RTE + +#define __CLC_SCALAR_TYPE_DST char +#define __CLC_BODY <convert_float.inc> +#include <clc/math/gentype.inc> +#undef __CLC_SCALAR_TYPE_DST + +#define __CLC_SCALAR_TYPE_DST short +#define __CLC_BODY <convert_float.inc> +#include <clc/math/gentype.inc> +#undef __CLC_SCALAR_TYPE_DST + +#define __CLC_SCALAR_TYPE_DST int +#define __CLC_BODY <convert_float.inc> +#include <clc/math/gentype.inc> +#undef __CLC_SCALAR_TYPE_DST + +#define __CLC_SCALAR_TYPE_DST long +#define __CLC_BODY <convert_float.inc> +#include <clc/math/gentype.inc> +#undef __CLC_SCALAR_TYPE_DST diff --git a/libclc/opencl/lib/clspv/conversion/convert_int2float.cl b/libclc/opencl/lib/clspv/conversion/convert_int2float.cl new file mode 100644 index 0000000000000..e514d5a48b476 --- /dev/null +++ b/libclc/opencl/lib/clspv/conversion/convert_int2float.cl @@ -0,0 +1,43 @@ +//===----------------------------------------------------------------------===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +#include <clc/clc_convert.h> +#include <clc/opencl/convert.h> + +#define __CLC_S_SCALAR_TYPE_SRC __CLC_SCALAR_TYPE_SRC +#define __CLC_U_SCALAR_TYPE_SRC __CLC_XCONCAT(u, __CLC_SCALAR_TYPE_SRC) + +#define __CLC_S_GENTYPE_SRC \ + __CLC_XCONCAT(__CLC_S_SCALAR_TYPE_SRC, __CLC_VECSIZE) +#define __CLC_U_GENTYPE_SRC \ + __CLC_XCONCAT(__CLC_U_SCALAR_TYPE_SRC, __CLC_VECSIZE) + +#define __CLC_FUNCTION __CLC_XCONCAT(convert_, __CLC_GENTYPE) +#define __CLC_IMPL_FUNCTION __CLC_XCONCAT(__clc_convert_, __CLC_GENTYPE) + +#define __CLC_I2F + +#define __CLC_SCALAR_TYPE_SRC char +#define __CLC_BODY <convert_float.inc> +#include <clc/math/gentype.inc> +#undef __CLC_SCALAR_TYPE_SRC + +#define __CLC_SCALAR_TYPE_SRC short +#define __CLC_BODY <convert_float.inc> +#include <clc/math/gentype.inc> +#undef __CLC_SCALAR_TYPE_SRC + +#define __CLC_SCALAR_TYPE_SRC int +#define __CLC_BODY <convert_float.inc> +#include <clc/math/gentype.inc> +#undef __CLC_SCALAR_TYPE_SRC + +#define __CLC_SCALAR_TYPE_SRC long +#define __CLC_BODY <convert_float.inc> +#include <clc/math/gentype.inc> +#undef __CLC_SCALAR_TYPE_SRC diff --git a/libclc/opencl/lib/clspv/conversion/convert_integer.cl b/libclc/opencl/lib/clspv/conversion/convert_integer.cl new file mode 100644 index 0000000000000..a2e217e924f77 --- /dev/null +++ b/libclc/opencl/lib/clspv/conversion/convert_integer.cl @@ -0,0 +1,43 @@ +//===----------------------------------------------------------------------===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +#include <clc/clc_convert.h> +#include <clc/opencl/convert.h> + +#define __CLC_S_SCALAR_TYPE_SRC __CLC_SCALAR_TYPE_SRC +#define __CLC_U_SCALAR_TYPE_SRC __CLC_XCONCAT(u, __CLC_SCALAR_TYPE_SRC) + +#define __CLC_S_GENTYPE_SRC \ + __CLC_XCONCAT(__CLC_S_SCALAR_TYPE_SRC, __CLC_VECSIZE) +#define __CLC_U_GENTYPE_SRC \ + __CLC_XCONCAT(__CLC_U_SCALAR_TYPE_SRC, __CLC_VECSIZE) + +#define __CLC_FUNCTION __CLC_XCONCAT(convert_, __CLC_GENTYPE) +#define __CLC_FUNCTION_SAT __CLC_XCONCAT(__CLC_FUNCTION, _sat) +#define __CLC_IMPL_FUNCTION __CLC_XCONCAT(__clc_convert_, __CLC_GENTYPE) +#define __CLC_IMPL_FUNCTION_SAT __CLC_XCONCAT(__CLC_IMPL_FUNCTION, _sat) + +#define __CLC_SCALAR_TYPE_SRC char +#define __CLC_BODY <convert_integer.inc> +#include <clc/integer/gentype.inc> +#undef __CLC_SCALAR_TYPE_SRC + +#define __CLC_SCALAR_TYPE_SRC short +#define __CLC_BODY <convert_integer.inc> +#include <clc/integer/gentype.inc> +#undef __CLC_SCALAR_TYPE_SRC + +#define __CLC_SCALAR_TYPE_SRC int +#define __CLC_BODY <convert_integer.inc> +#include <clc/integer/gentype.inc> +#undef __CLC_SCALAR_TYPE_SRC + +#define __CLC_SCALAR_TYPE_SRC long +#define __CLC_BODY <convert_integer.inc> +#include <clc/integer/gentype.inc> +#undef __CLC_SCALAR_TYPE_SRC diff --git a/libclc/opencl/lib/clspv/conversion/convert_integer.inc b/libclc/opencl/lib/clspv/conversion/convert_integer.inc new file mode 100644 index 0000000000000..dc0dad71ca445 --- /dev/null +++ b/libclc/opencl/lib/clspv/conversion/convert_integer.inc @@ -0,0 +1,49 @@ +//===----------------------------------------------------------------------===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +// Do not generate user-facing default conversions for clspv as they are handled +// natively. Do not generate user-facing "_rte" conversions for clspv as they +// are handled natively. + +#define __CLC_DEFINE_FUNCTION_ROUNDING_MODE_SATURATION_IMPL(TYPE_SRC, MODE) \ + _CLC_OVERLOAD _CLC_DEF __CLC_GENTYPE __CLC_XCONCAT(__CLC_FUNCTION_SAT, \ + MODE)(TYPE_SRC x) { \ + return __CLC_XCONCAT(__CLC_IMPL_FUNCTION_SAT, MODE)(x); \ + } + +#define __CLC_DEFINE_FUNCTION_ROUNDING_MODE_SATURATION(MODE) \ + __CLC_DEFINE_FUNCTION_ROUNDING_MODE_SATURATION_IMPL(__CLC_S_GENTYPE_SRC, \ + MODE) \ + __CLC_DEFINE_FUNCTION_ROUNDING_MODE_SATURATION_IMPL(__CLC_U_GENTYPE_SRC, MODE) + +__CLC_DEFINE_FUNCTION_ROUNDING_MODE_SATURATION() +__CLC_DEFINE_FUNCTION_ROUNDING_MODE_SATURATION(_rte) + +#undef __CLC_DEFINE_FUNCTION_ROUNDING_MODE_SATURATION_IMPL +#undef __CLC_DEFINE_FUNCTION_ROUNDING_MODE_SATURATION + +#define __CLC_DEFINE_FUNCTION_ROUNDING_MODE_IMPL(TYPE_SRC, MODE) \ + _CLC_OVERLOAD _CLC_DEF __CLC_GENTYPE __CLC_XCONCAT(__CLC_FUNCTION, \ + MODE)(TYPE_SRC x) { \ + return __CLC_XCONCAT(__CLC_IMPL_FUNCTION, MODE)(x); \ + } \ + _CLC_OVERLOAD _CLC_DEF __CLC_GENTYPE __CLC_XCONCAT(__CLC_FUNCTION_SAT, \ + MODE)(TYPE_SRC x) { \ + return __CLC_XCONCAT(__CLC_IMPL_FUNCTION_SAT, MODE)(x); \ + } + +#define __CLC_DEFINE_FUNCTION_ROUNDING_MODE(MODE) \ + __CLC_DEFINE_FUNCTION_ROUNDING_MODE_IMPL(__CLC_S_GENTYPE_SRC, MODE) \ + __CLC_DEFINE_FUNCTION_ROUNDING_MODE_IMPL(__CLC_U_GENTYPE_SRC, MODE) + +__CLC_DEFINE_FUNCTION_ROUNDING_MODE(_rtz) +__CLC_DEFINE_FUNCTION_ROUNDING_MODE(_rtp) +__CLC_DEFINE_FUNCTION_ROUNDING_MODE(_rtn) + +#undef __CLC_DEFINE_FUNCTION_ROUNDING_MODE_IMPL +#undef __CLC_DEFINE_FUNCTION_ROUNDING_MODE diff --git a/libclc/opencl/lib/generic/SOURCES b/libclc/opencl/lib/generic/SOURCES index 94a333e765b18..a2c6af8b9252c 100644 --- a/libclc/opencl/lib/generic/SOURCES +++ b/libclc/opencl/lib/generic/SOURCES @@ -47,6 +47,10 @@ common/radians.cl common/sign.cl common/smoothstep.cl common/step.cl +conversion/convert_float2float.cl +conversion/convert_float2int.cl +conversion/convert_int2float.cl +conversion/convert_integer.cl geometric/cross.cl geometric/distance.cl geometric/dot.cl diff --git a/libclc/opencl/lib/generic/conversion/convert_float.inc b/libclc/opencl/lib/generic/conversion/convert_float.inc new file mode 100644 index 0000000000000..35c9c959780b3 --- /dev/null +++ b/libclc/opencl/lib/generic/conversion/convert_float.inc @@ -0,0 +1,57 @@ +//===----------------------------------------------------------------------===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +#ifdef __CLC_F2F + +#define __CLC_DEFINE_FUNCTION_ROUNDING_MODE(MODE) \ + _CLC_OVERLOAD _CLC_DEF __CLC_GENTYPE __CLC_XCONCAT(__CLC_FUNCTION, MODE)( \ + __CLC_GENTYPE_SRC x) { \ + return __CLC_XCONCAT(__CLC_IMPL_FUNCTION, MODE)(x); \ + } + +#elif defined(__CLC_I2F) + +#define __CLC_DEFINE_FUNCTION_ROUNDING_MODE(MODE) \ + _CLC_OVERLOAD _CLC_DEF __CLC_GENTYPE __CLC_XCONCAT(__CLC_FUNCTION, MODE)( \ + __CLC_S_GENTYPE_SRC x) { \ + return __CLC_XCONCAT(__CLC_IMPL_FUNCTION, MODE)(x); \ + } \ + _CLC_OVERLOAD _CLC_DEF __CLC_GENTYPE __CLC_XCONCAT(__CLC_FUNCTION, MODE)( \ + __CLC_U_GENTYPE_SRC x) { \ + return __CLC_XCONCAT(__CLC_IMPL_FUNCTION, MODE)(x); \ + } + +#elif defined(__CLC_F2I) + +#define __CLC_DEFINE_FUNCTION_ROUNDING_MODE(MODE) \ + _CLC_OVERLOAD _CLC_DEF __CLC_S_GENTYPE_DST __CLC_XCONCAT( \ + __CLC_FUNCTION_S, MODE)(__CLC_GENTYPE x) { \ + return __CLC_XCONCAT(__CLC_IMPL_FUNCTION_S, MODE)(x); \ + } \ + _CLC_OVERLOAD _CLC_DEF __CLC_S_GENTYPE_DST __CLC_XCONCAT( \ + __CLC_FUNCTION_S_SAT, MODE)(__CLC_GENTYPE x) { \ + return __CLC_XCONCAT(__CLC_IMPL_FUNCTION_S_SAT, MODE)(x); \ + } \ + _CLC_OVERLOAD _CLC_DEF __CLC_U_GENTYPE_DST __CLC_XCONCAT( \ + __CLC_FUNCTION_U, MODE)(__CLC_GENTYPE x) { \ + return __CLC_XCONCAT(__CLC_IMPL_FUNCTION_U, MODE)(x); \ + } \ + _CLC_OVERLOAD _CLC_DEF __CLC_U_GENTYPE_DST __CLC_XCONCAT( \ + __CLC_FUNCTION_U_SAT, MODE)(__CLC_GENTYPE x) { \ + return __CLC_XCONCAT(__CLC_IMPL_FUNCTION_U_SAT, MODE)(x); \ + } + +#endif + +__CLC_DEFINE_FUNCTION_ROUNDING_MODE() +__CLC_DEFINE_FUNCTION_ROUNDING_MODE(_rte) +__CLC_DEFINE_FUNCTION_ROUNDING_MODE(_rtz) +__CLC_DEFINE_FUNCTION_ROUNDING_MODE(_rtp) +__CLC_DEFINE_FUNCTION_ROUNDING_MODE(_rtn) + +#undef __CLC_DEFINE_FUNCTION_ROUNDING_MODE diff --git a/libclc/opencl/lib/generic/conversion/convert_float2float.cl b/libclc/opencl/lib/generic/conversion/convert_float2float.cl new file mode 100644 index 0000000000000..be74b71f66b71 --- /dev/null +++ b/libclc/opencl/lib/generic/conversion/convert_float2float.cl @@ -0,0 +1,37 @@ +//===----------------------------------------------------------------------===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +#include <clc/clc_convert.h> +#include <clc/opencl/convert.h> + +#define __CLC_GENTYPE_SRC __CLC_XCONCAT(__CLC_SCALAR_TYPE_SRC, __CLC_VECSIZE) + +#define __CLC_FUNCTION __CLC_XCONCAT(convert_, __CLC_GENTYPE) +#define __CLC_IMPL_FUNCTION __CLC_XCONCAT(__clc_convert_, __CLC_GENTYPE) + +#define __CLC_F2F + +#ifdef cl_khr_fp16 +#pragma OPENCL EXTENSION cl_khr_fp16 : enable +#define __CLC_SCALAR_TYPE_SRC half +#define __CLC_BODY <convert_float.inc> +#include <clc/math/gentype.inc> +#undef __CLC_SCALAR_TYPE_SRC +#endif // cl_khr_fp16 + +#define __CLC_SCALAR_TYPE_SRC float +#define __CLC_BODY <convert_float.inc> +#include <clc/math/gentype.inc> +#undef __CLC_SCALAR_TYPE_SRC + +#ifdef cl_khr_fp64 +#define __CLC_SCALAR_TYPE_SRC double +#define __CLC_BODY <convert_float.inc> +#include <clc/math/gentype.inc> +#undef __CLC_SCALAR_TYPE_SRC +#endif // cl_khr_fp64 diff --git a/libclc/opencl/lib/generic/conversion/convert_float2int.cl b/libclc/opencl/lib/generic/conversion/convert_float2int.cl new file mode 100644 index 0000000000000..7fe518f3105ce --- /dev/null +++ b/libclc/opencl/lib/generic/conversion/convert_float2int.cl @@ -0,0 +1,49 @@ +//===----------------------------------------------------------------------===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +#include <clc/clc_convert.h> +#include <clc/opencl/convert.h> + +#define __CLC_S_SCALAR_TYPE_DST __CLC_SCALAR_TYPE_DST +#define __CLC_U_SCALAR_TYPE_DST __CLC_XCONCAT(u, __CLC_SCALAR_TYPE_DST) + +#define __CLC_S_GENTYPE_DST \ + __CLC_XCONCAT(__CLC_S_SCALAR_TYPE_DST, __CLC_VECSIZE) +#define __CLC_U_GENTYPE_DST \ + __CLC_XCONCAT(__CLC_U_SCALAR_TYPE_DST, __CLC_VECSIZE) + +#define __CLC_FUNCTION_S __CLC_XCONCAT(convert_, __CLC_S_GENTYPE_DST) +#define __CLC_FUNCTION_U __CLC_XCONCAT(convert_, __CLC_U_GENTYPE_DST) +#define __CLC_FUNCTION_S_SAT __CLC_XCONCAT(__CLC_FUNCTION_S, _sat) +#define __CLC_FUNCTION_U_SAT __CLC_XCONCAT(__CLC_FUNCTION_U, _sat) +#define __CLC_IMPL_FUNCTION_S __CLC_XCONCAT(__clc_convert_, __CLC_S_GENTYPE_DST) +#define __CLC_IMPL_FUNCTION_U __CLC_XCONCAT(__clc_convert_, __CLC_U_GENTYPE_DST) +#define __CLC_IMPL_FUNCTION_S_SAT __CLC_XCONCAT(__CLC_IMPL_FUNCTION_S, _sat) +#define __CLC_IMPL_FUNCTION_U_SAT __CLC_XCONCAT(__CLC_IMPL_FUNCTION_U, _sat) + +#define __CLC_F2I + +#define __CLC_SCALAR_TYPE_DST char +#define __CLC_BODY <convert_float.inc> +#include <clc/math/gentype.inc> +#undef __CLC_SCALAR_TYPE_DST + +#define __CLC_SCALAR_TYPE_DST short +#define __CLC_BODY <convert_float.inc> +#include <clc/math/gentype.inc> +#undef __CLC_SCALAR_TYPE_DST + +#define __CLC_SCALAR_TYPE_DST int +#define __CLC_BODY <convert_float.inc> +#include <clc/math/gentype.inc> +#undef __CLC_SCALAR_TYPE_DST + +#define __CLC_SCALAR_TYPE_DST long +#define __CLC_BODY <convert_float.inc> +#include <clc/math/gentype.inc> +#undef __CLC_SCALAR_TYPE_DST diff --git a/libclc/opencl/lib/generic/conversion/convert_int2float.cl b/libclc/opencl/lib/generic/conversion/convert_int2float.cl new file mode 100644 index 0000000000000..e514d5a48b476 --- /dev/null +++ b/libclc/opencl/lib/generic/conversion/convert_int2float.cl @@ -0,0 +1,43 @@ +//===----------------------------------------------------------------------===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +#include <clc/clc_convert.h> +#include <clc/opencl/convert.h> + +#define __CLC_S_SCALAR_TYPE_SRC __CLC_SCALAR_TYPE_SRC +#define __CLC_U_SCALAR_TYPE_SRC __CLC_XCONCAT(u, __CLC_SCALAR_TYPE_SRC) + +#define __CLC_S_GENTYPE_SRC \ + __CLC_XCONCAT(__CLC_S_SCALAR_TYPE_SRC, __CLC_VECSIZE) +#define __CLC_U_GENTYPE_SRC \ + __CLC_XCONCAT(__CLC_U_SCALAR_TYPE_SRC, __CLC_VECSIZE) + +#define __CLC_FUNCTION __CLC_XCONCAT(convert_, __CLC_GENTYPE) +#define __CLC_IMPL_FUNCTION __CLC_XCONCAT(__clc_convert_, __CLC_GENTYPE) + +#define __CLC_I2F + +#define __CLC_SCALAR_TYPE_SRC char +#define __CLC_BODY <convert_float.inc> +#include <clc/math/gentype.inc> +#undef __CLC_SCALAR_TYPE_SRC + +#define __CLC_SCALAR_TYPE_SRC short +#define __CLC_BODY <convert_float.inc> +#include <clc/math/gentype.inc> +#undef __CLC_SCALAR_TYPE_SRC + +#define __CLC_SCALAR_TYPE_SRC int +#define __CLC_BODY <convert_float.inc> +#include <clc/math/gentype.inc> +#undef __CLC_SCALAR_TYPE_SRC + +#define __CLC_SCALAR_TYPE_SRC long +#define __CLC_BODY <convert_float.inc> +#include <clc/math/gentype.inc> +#undef __CLC_SCALAR_TYPE_SRC diff --git a/libclc/opencl/lib/generic/conversion/convert_integer.cl b/libclc/opencl/lib/generic/conversion/convert_integer.cl new file mode 100644 index 0000000000000..a2e217e924f77 --- /dev/null +++ b/libclc/opencl/lib/generic/conversion/convert_integer.cl @@ -0,0 +1,43 @@ +//===----------------------------------------------------------------------===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +#include <clc/clc_convert.h> +#include <clc/opencl/convert.h> + +#define __CLC_S_SCALAR_TYPE_SRC __CLC_SCALAR_TYPE_SRC +#define __CLC_U_SCALAR_TYPE_SRC __CLC_XCONCAT(u, __CLC_SCALAR_TYPE_SRC) + +#define __CLC_S_GENTYPE_SRC \ + __CLC_XCONCAT(__CLC_S_SCALAR_TYPE_SRC, __CLC_VECSIZE) +#define __CLC_U_GENTYPE_SRC \ + __CLC_XCONCAT(__CLC_U_SCALAR_TYPE_SRC, __CLC_VECSIZE) + +#define __CLC_FUNCTION __CLC_XCONCAT(convert_, __CLC_GENTYPE) +#define __CLC_FUNCTION_SAT __CLC_XCONCAT(__CLC_FUNCTION, _sat) +#define __CLC_IMPL_FUNCTION __CLC_XCONCAT(__clc_convert_, __CLC_GENTYPE) +#define __CLC_IMPL_FUNCTION_SAT __CLC_XCONCAT(__CLC_IMPL_FUNCTION, _sat) + +#define __CLC_SCALAR_TYPE_SRC char +#define __CLC_BODY <convert_integer.inc> +#include <clc/integer/gentype.inc> +#undef __CLC_SCALAR_TYPE_SRC + +#define __CLC_SCALAR_TYPE_SRC short +#define __CLC_BODY <convert_integer.inc> +#include <clc/integer/gentype.inc> +#undef __CLC_SCALAR_TYPE_SRC + +#define __CLC_SCALAR_TYPE_SRC int +#define __CLC_BODY <convert_integer.inc> +#include <clc/integer/gentype.inc> +#undef __CLC_SCALAR_TYPE_SRC + +#define __CLC_SCALAR_TYPE_SRC long +#define __CLC_BODY <convert_integer.inc> +#include <clc/integer/gentype.inc> +#undef __CLC_SCALAR_TYPE_SRC diff --git a/libclc/opencl/lib/generic/conversion/convert_integer.inc b/libclc/opencl/lib/generic/conversion/convert_integer.inc new file mode 100644 index 0000000000000..30dd67c8a18fc --- /dev/null +++ b/libclc/opencl/lib/generic/conversion/convert_integer.inc @@ -0,0 +1,30 @@ +//===----------------------------------------------------------------------===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +#define __CLC_DEFINE_FUNCTION_ROUNDING_MODE_IMPL(TYPE_SRC, MODE) \ + _CLC_OVERLOAD _CLC_DEF __CLC_GENTYPE __CLC_XCONCAT(__CLC_FUNCTION, \ + MODE)(TYPE_SRC x) { \ + return __CLC_XCONCAT(__CLC_IMPL_FUNCTION, MODE)(x); \ + } \ + _CLC_OVERLOAD _CLC_DEF __CLC_GENTYPE __CLC_XCONCAT(__CLC_FUNCTION_SAT, \ + MODE)(TYPE_SRC x) { \ + return __CLC_XCONCAT(__CLC_IMPL_FUNCTION_SAT, MODE)(x); \ + } + +#define __CLC_DEFINE_FUNCTION_ROUNDING_MODE(MODE) \ + __CLC_DEFINE_FUNCTION_ROUNDING_MODE_IMPL(__CLC_S_GENTYPE_SRC, MODE) \ + __CLC_DEFINE_FUNCTION_ROUNDING_MODE_IMPL(__CLC_U_GENTYPE_SRC, MODE) + +__CLC_DEFINE_FUNCTION_ROUNDING_MODE() +__CLC_DEFINE_FUNCTION_ROUNDING_MODE(_rte) +__CLC_DEFINE_FUNCTION_ROUNDING_MODE(_rtz) +__CLC_DEFINE_FUNCTION_ROUNDING_MODE(_rtp) +__CLC_DEFINE_FUNCTION_ROUNDING_MODE(_rtn) + +#undef __CLC_DEFINE_FUNCTION_ROUNDING_MODE_IMPL +#undef __CLC_DEFINE_FUNCTION_ROUNDING_MODE _______________________________________________ cfe-commits mailing list [email protected] https://lists.llvm.org/cgi-bin/mailman/listinfo/cfe-commits
