diff --git a/buildbot/configure.py b/buildbot/configure.py index 60f6c97160e29..fdc570895273f 100644 --- a/buildbot/configure.py +++ b/buildbot/configure.py @@ -11,10 +11,11 @@ def do_configure(args): sycl_dir = os.path.join(args.src_dir, "sycl") spirv_dir = os.path.join(args.src_dir, "llvm-spirv") xpti_dir = os.path.join(args.src_dir, "xpti") + libdevice_dir = os.path.join(args.src_dir, "libdevice") ocl_header_dir = os.path.join(args.obj_dir, "OpenCL-Headers") icd_loader_lib = os.path.join(args.obj_dir, "OpenCL-ICD-Loader", "build") llvm_targets_to_build = 'X86' - llvm_enable_projects = 'clang;llvm-spirv;sycl;opencl-aot;xpti' + llvm_enable_projects = 'clang;llvm-spirv;sycl;opencl-aot;xpti;libdevice' libclc_targets_to_build = '' sycl_build_pi_cuda = 'OFF' llvm_enable_assertions = 'ON' @@ -49,10 +50,11 @@ def do_configure(args): "-DCMAKE_BUILD_TYPE={}".format(args.build_type), "-DLLVM_ENABLE_ASSERTIONS={}".format(llvm_enable_assertions), "-DLLVM_TARGETS_TO_BUILD={}".format(llvm_targets_to_build), - "-DLLVM_EXTERNAL_PROJECTS=sycl;llvm-spirv;opencl-aot;xpti", + "-DLLVM_EXTERNAL_PROJECTS=sycl;llvm-spirv;opencl-aot;xpti;libdevice", "-DLLVM_EXTERNAL_SYCL_SOURCE_DIR={}".format(sycl_dir), "-DLLVM_EXTERNAL_LLVM_SPIRV_SOURCE_DIR={}".format(spirv_dir), "-DLLVM_EXTERNAL_XPTI_SOURCE_DIR={}".format(xpti_dir), + "-DLLVM_EXTERNAL_LIBDEVICE_SOURCE_DIR={}".format(libdevice_dir), "-DLLVM_ENABLE_PROJECTS={}".format(llvm_enable_projects), "-DLIBCLC_TARGETS_TO_BUILD={}".format(libclc_targets_to_build), "-DSYCL_BUILD_PI_CUDA={}".format(sycl_build_pi_cuda), diff --git a/libdevice/CMakeLists.txt b/libdevice/CMakeLists.txt new file mode 100644 index 0000000000000..d07ed3e5eaa88 --- /dev/null +++ b/libdevice/CMakeLists.txt @@ -0,0 +1,10 @@ +# Utility project providing various functionalities for SPIR-V devices +# without native support of these functionalities. + +set(CMAKE_MODULE_PATH + ${CMAKE_MODULE_PATH} + "${CMAKE_CURRENT_SOURCE_DIR}/cmake/modules" + ) + +# Build libdevice for SYCL. +include(SYCLLibdevice) diff --git a/sycl/source/detail/devicelib/CMakeLists.txt b/libdevice/cmake/modules/SYCLLibdevice.cmake similarity index 63% rename from sycl/source/detail/devicelib/CMakeLists.txt rename to libdevice/cmake/modules/SYCLLibdevice.cmake index 84bc9f6225bef..847cac46f4a42 100644 --- a/sycl/source/detail/devicelib/CMakeLists.txt +++ b/libdevice/cmake/modules/SYCLLibdevice.cmake @@ -1,42 +1,45 @@ -# Place device libraries near the libsycl.so library in a build -# directory if (WIN32) - set(binary_dir "${CMAKE_RUNTIME_OUTPUT_DIRECTORY}") + set(binary_dir "${CMAKE_RUNTIME_OUTPUT_DIRECTORY}") else() - set(binary_dir "${CMAKE_LIBRARY_OUTPUT_DIRECTORY}") + set(binary_dir "${CMAKE_LIBRARY_OUTPUT_DIRECTORY}") endif() set(clang $) set(compile_opts - # suppress an error about SYCL_EXTERNAL - -Wno-sycl-strict - # for CL/__spirv/spirv_vars.hpp - -I${sycl_inc_dir}) + # suppress an error about SYCL_EXTERNAL being used for + # a function with a raw pointer parameter. + -Wno-sycl-strict + # Disable warnings for the host compilation, where + # we declare all functions as 'static'. + -Wno-undefined-internal + # Force definition of CL_SYCL_LANGUAGE_VERSION, as long as + # SYCL specific code is guarded by it. + -sycl-std=2017 + ) if (WIN32) - set(devicelib-obj-file ${binary_dir}/libsycl-msvc.o) - add_custom_command(OUTPUT ${devicelib-obj-file} - COMMAND ${clang} -fsycl -c - ${compile_opts} - ${CMAKE_CURRENT_SOURCE_DIR}/msvc_wrapper.cpp - -o ${devicelib-obj-file} - MAIN_DEPENDENCY msvc_wrapper.cpp - DEPENDS wrapper.h clang - VERBATIM) + set(devicelib-obj-file ${binary_dir}/libsycl-msvc.o) + add_custom_command(OUTPUT ${devicelib-obj-file} + COMMAND ${clang} -fsycl -c + ${compile_opts} + ${CMAKE_CURRENT_SOURCE_DIR}/msvc_wrapper.cpp + -o ${devicelib-obj-file} + MAIN_DEPENDENCY msvc_wrapper.cpp + DEPENDS wrapper.h device.h clang + VERBATIM) else() - set(devicelib-obj-file ${binary_dir}/libsycl-glibc.o) - add_custom_command(OUTPUT ${devicelib-obj-file} - COMMAND ${clang} -fsycl -c - ${compile_opts} - ${CMAKE_CURRENT_SOURCE_DIR}/glibc_wrapper.cpp - -o ${devicelib-obj-file} - MAIN_DEPENDENCY glibc_wrapper.cpp - DEPENDS wrapper.h clang - VERBATIM) + set(devicelib-obj-file ${binary_dir}/libsycl-glibc.o) + add_custom_command(OUTPUT ${devicelib-obj-file} + COMMAND ${clang} -fsycl -c + ${compile_opts} + ${CMAKE_CURRENT_SOURCE_DIR}/glibc_wrapper.cpp + -o ${devicelib-obj-file} + MAIN_DEPENDENCY glibc_wrapper.cpp + DEPENDS wrapper.h device.h clang + VERBATIM) endif() - set(devicelib-obj-complex ${binary_dir}/libsycl-complex.o) add_custom_command(OUTPUT ${devicelib-obj-complex} COMMAND ${clang} -fsycl -c @@ -44,7 +47,7 @@ add_custom_command(OUTPUT ${devicelib-obj-complex} ${CMAKE_CURRENT_SOURCE_DIR}/complex_wrapper.cpp -o ${devicelib-obj-complex} MAIN_DEPENDENCY complex_wrapper.cpp - DEPENDS device_complex.h clang + DEPENDS device_complex.h device.h clang VERBATIM) set(devicelib-obj-complex-fp64 ${binary_dir}/libsycl-complex-fp64.o) @@ -54,7 +57,7 @@ add_custom_command(OUTPUT ${devicelib-obj-complex-fp64} ${CMAKE_CURRENT_SOURCE_DIR}/complex_wrapper_fp64.cpp -o ${devicelib-obj-complex-fp64} MAIN_DEPENDENCY complex_wrapper_fp64.cpp - DEPENDS device_complex.h clang + DEPENDS device_complex.h device.h clang VERBATIM) set(devicelib-obj-cmath ${binary_dir}/libsycl-cmath.o) @@ -64,7 +67,7 @@ add_custom_command(OUTPUT ${devicelib-obj-cmath} ${CMAKE_CURRENT_SOURCE_DIR}/cmath_wrapper.cpp -o ${devicelib-obj-cmath} MAIN_DEPENDENCY cmath_wrapper.cpp - DEPENDS device_complex.h clang + DEPENDS device_math.h device.h clang VERBATIM) set(devicelib-obj-cmath-fp64 ${binary_dir}/libsycl-cmath-fp64.o) @@ -74,7 +77,7 @@ add_custom_command(OUTPUT ${devicelib-obj-cmath-fp64} ${CMAKE_CURRENT_SOURCE_DIR}/cmath_wrapper_fp64.cpp -o ${devicelib-obj-cmath-fp64} MAIN_DEPENDENCY cmath_wrapper_fp64.cpp - DEPENDS device_math.h clang + DEPENDS device_math.h device.h clang VERBATIM) add_custom_command(OUTPUT ${binary_dir}/libsycl-fallback-cassert.spv @@ -83,7 +86,7 @@ add_custom_command(OUTPUT ${binary_dir}/libsycl-fallback-cassert.spv ${CMAKE_CURRENT_SOURCE_DIR}/fallback-cassert.cpp -o ${binary_dir}/libsycl-fallback-cassert.spv MAIN_DEPENDENCY fallback-cassert.cpp - DEPENDS wrapper.h clang llvm-spirv + DEPENDS wrapper.h device.h clang llvm-spirv VERBATIM) add_custom_command(OUTPUT ${binary_dir}/libsycl-fallback-complex.spv @@ -92,7 +95,7 @@ add_custom_command(OUTPUT ${binary_dir}/libsycl-fallback-complex.spv ${CMAKE_CURRENT_SOURCE_DIR}/fallback-complex.cpp -o ${binary_dir}/libsycl-fallback-complex.spv MAIN_DEPENDENCY fallback-complex.cpp - DEPENDS device_math.h device_complex.h clang llvm-spirv + DEPENDS device_math.h device_complex.h device.h clang llvm-spirv VERBATIM) add_custom_command(OUTPUT ${binary_dir}/libsycl-fallback-complex-fp64.spv @@ -101,7 +104,7 @@ add_custom_command(OUTPUT ${binary_dir}/libsycl-fallback-complex-fp64.spv ${CMAKE_CURRENT_SOURCE_DIR}/fallback-complex-fp64.cpp -o ${binary_dir}/libsycl-fallback-complex-fp64.spv MAIN_DEPENDENCY fallback-complex-fp64.cpp - DEPENDS device_math.h device_complex.h clang llvm-spirv + DEPENDS device_math.h device_complex.h device.h clang llvm-spirv VERBATIM) add_custom_command(OUTPUT ${binary_dir}/libsycl-fallback-cmath.spv @@ -110,7 +113,7 @@ add_custom_command(OUTPUT ${binary_dir}/libsycl-fallback-cmath.spv ${CMAKE_CURRENT_SOURCE_DIR}/fallback-cmath.cpp -o ${binary_dir}/libsycl-fallback-cmath.spv MAIN_DEPENDENCY fallback-cmath.cpp - DEPENDS device_math.h clang llvm-spirv + DEPENDS device_math.h device.h clang llvm-spirv VERBATIM) add_custom_command(OUTPUT ${binary_dir}/libsycl-fallback-cmath-fp64.spv @@ -119,30 +122,31 @@ add_custom_command(OUTPUT ${binary_dir}/libsycl-fallback-cmath-fp64.spv ${CMAKE_CURRENT_SOURCE_DIR}/fallback-cmath-fp64.cpp -o ${binary_dir}/libsycl-fallback-cmath-fp64.spv MAIN_DEPENDENCY fallback-cmath-fp64.cpp - DEPENDS device_math.h clang llvm-spirv + DEPENDS device_math.h device.h clang llvm-spirv VERBATIM) -add_custom_target(devicelib-obj DEPENDS ${devicelib-obj-file} - ${devicelib-obj-complex} - ${devicelib-obj-complex-fp64} - ${devicelib-obj-cmath} - ${devicelib-obj-cmath-fp64}) -add_custom_target(devicelib-spv DEPENDS ${binary_dir}/libsycl-fallback-cassert.spv - ${binary_dir}/libsycl-fallback-complex.spv - ${binary_dir}/libsycl-fallback-complex-fp64.spv - ${binary_dir}/libsycl-fallback-cmath.spv - ${binary_dir}/libsycl-fallback-cmath-fp64.spv) -add_dependencies(sycl devicelib-obj devicelib-spv) -if (MSVC) - add_dependencies(sycld devicelib-obj devicelib-spv) -endif() +add_custom_target(libsycldevice-obj DEPENDS + ${devicelib-obj-file} + ${devicelib-obj-complex} + ${devicelib-obj-complex-fp64} + ${devicelib-obj-cmath} + ${devicelib-obj-cmath-fp64} +) +add_custom_target(libsycldevice-spv DEPENDS + ${binary_dir}/libsycl-fallback-cassert.spv + ${binary_dir}/libsycl-fallback-complex.spv + ${binary_dir}/libsycl-fallback-complex-fp64.spv + ${binary_dir}/libsycl-fallback-cmath.spv + ${binary_dir}/libsycl-fallback-cmath-fp64.spv +) +add_custom_target(libsycldevice DEPENDS libsycldevice-obj libsycldevice-spv) # Place device libraries near the libsycl.so library in an install # directory as well if (WIN32) - set(install_dest bin) + set(install_dest bin) else() - set(install_dest lib${LLVM_LIBDIR_SUFFIX}) + set(install_dest lib${LLVM_LIBDIR_SUFFIX}) endif() install(FILES ${devicelib-obj-file} @@ -156,4 +160,4 @@ install(FILES ${devicelib-obj-file} ${devicelib-obj-cmath-fp64} ${binary_dir}/libsycl-fallback-cmath-fp64.spv DESTINATION ${install_dest} - COMPONENT sycl) + COMPONENT libsycldevice) diff --git a/libdevice/cmath_wrapper.cpp b/libdevice/cmath_wrapper.cpp new file mode 100644 index 0000000000000..8a71985488606 --- /dev/null +++ b/libdevice/cmath_wrapper.cpp @@ -0,0 +1,130 @@ +//==--- cmath_wrapper.cpp - wrappers for C math library functions ----------==// +// +// 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 "device.h" +#include "device_math.h" + +DEVICE_EXTERN_C +float scalbnf(float x, int n) { return __devicelib_scalbnf(x, n); } + +DEVICE_EXTERN_C +float logf(float x) { return __devicelib_logf(x); } + +DEVICE_EXTERN_C +float expf(float x) { return __devicelib_expf(x); } + +DEVICE_EXTERN_C +float frexpf(float x, int *exp) { return __devicelib_frexpf(x, exp); } + +DEVICE_EXTERN_C +float ldexpf(float x, int exp) { return __devicelib_ldexpf(x, exp); } + +DEVICE_EXTERN_C +float log10f(float x) { return __devicelib_log10f(x); } + +DEVICE_EXTERN_C +float modff(float x, float *intpart) { return __devicelib_modff(x, intpart); } + +DEVICE_EXTERN_C +float exp2f(float x) { return __devicelib_exp2f(x); } + +DEVICE_EXTERN_C +float expm1f(float x) { return __devicelib_expm1f(x); } + +DEVICE_EXTERN_C +int ilogbf(float x) { return __devicelib_ilogbf(x); } + +DEVICE_EXTERN_C +float log1pf(float x) { return __devicelib_log1pf(x); } + +DEVICE_EXTERN_C +float log2f(float x) { return __devicelib_log2f(x); } + +DEVICE_EXTERN_C +float logbf(float x) { return __devicelib_logbf(x); } + +DEVICE_EXTERN_C +float sqrtf(float x) { return __devicelib_sqrtf(x); } + +DEVICE_EXTERN_C +float cbrtf(float x) { return __devicelib_cbrtf(x); } + +DEVICE_EXTERN_C +float hypotf(float x, float y) { return __devicelib_hypotf(x, y); } + +DEVICE_EXTERN_C +float erff(float x) { return __devicelib_erff(x); } + +DEVICE_EXTERN_C +float erfcf(float x) { return __devicelib_erfcf(x); } + +DEVICE_EXTERN_C +float tgammaf(float x) { return __devicelib_tgammaf(x); } + +DEVICE_EXTERN_C +float lgammaf(float x) { return __devicelib_lgammaf(x); } + +DEVICE_EXTERN_C +float fmodf(float x, float y) { return __devicelib_fmodf(x, y); } + +DEVICE_EXTERN_C +float remainderf(float x, float y) { return __devicelib_remainderf(x, y); } + +DEVICE_EXTERN_C +float remquof(float x, float y, int *q) { return __devicelib_remquof(x, y, q); } + +DEVICE_EXTERN_C +float nextafterf(float x, float y) { return __devicelib_nextafterf(x, y); } + +DEVICE_EXTERN_C +float fdimf(float x, float y) { return __devicelib_fdimf(x, y); } + +DEVICE_EXTERN_C +float fmaf(float x, float y, float z) { return __devicelib_fmaf(x, y, z); } + +DEVICE_EXTERN_C +float sinf(float x) { return __devicelib_sinf(x); } + +DEVICE_EXTERN_C +float cosf(float x) { return __devicelib_cosf(x); } + +DEVICE_EXTERN_C +float tanf(float x) { return __devicelib_tanf(x); } + +DEVICE_EXTERN_C +float powf(float x, float y) { return __devicelib_powf(x, y); } + +DEVICE_EXTERN_C +float acosf(float x) { return __devicelib_acosf(x); } + +DEVICE_EXTERN_C +float asinf(float x) { return __devicelib_asinf(x); } + +DEVICE_EXTERN_C +float atanf(float x) { return __devicelib_atanf(x); } + +DEVICE_EXTERN_C +float atan2f(float x, float y) { return __devicelib_atan2f(x, y); } + +DEVICE_EXTERN_C +float coshf(float x) { return __devicelib_coshf(x); } + +DEVICE_EXTERN_C +float sinhf(float x) { return __devicelib_sinhf(x); } + +DEVICE_EXTERN_C +float tanhf(float x) { return __devicelib_tanhf(x); } + +DEVICE_EXTERN_C +float acoshf(float x) { return __devicelib_acoshf(x); } + +DEVICE_EXTERN_C +float asinhf(float x) { return __devicelib_asinhf(x); } + +DEVICE_EXTERN_C +float atanhf(float x) { return __devicelib_atanhf(x); } diff --git a/libdevice/cmath_wrapper_fp64.cpp b/libdevice/cmath_wrapper_fp64.cpp new file mode 100644 index 0000000000000..ef8d8e6c50504 --- /dev/null +++ b/libdevice/cmath_wrapper_fp64.cpp @@ -0,0 +1,133 @@ +//==--- cmath_wrapper.cpp - wrappers for C math library functions ----------==// +// +// 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 "device.h" +#include "device_math.h" + +// All exported functions in math and complex device libraries are weak +// reference. If users provide their own math or complex functions(with +// the prototype), functions in device libraries will be ignored and +// overrided by users' version. +DEVICE_EXTERN_C +double log(double x) { return __devicelib_log(x); } + +DEVICE_EXTERN_C +double exp(double x) { return __devicelib_exp(x); } + +DEVICE_EXTERN_C +double frexp(double x, int *exp) { return __devicelib_frexp(x, exp); } + +DEVICE_EXTERN_C +double ldexp(double x, int exp) { return __devicelib_ldexp(x, exp); } + +DEVICE_EXTERN_C +double log10(double x) { return __devicelib_log10(x); } + +DEVICE_EXTERN_C +double modf(double x, double *intpart) { return __devicelib_modf(x, intpart); } + +DEVICE_EXTERN_C +double exp2(double x) { return __devicelib_exp2(x); } + +DEVICE_EXTERN_C +double expm1(double x) { return __devicelib_expm1(x); } + +DEVICE_EXTERN_C +int ilogb(double x) { return __devicelib_ilogb(x); } + +DEVICE_EXTERN_C +double log1p(double x) { return __devicelib_log1p(x); } + +DEVICE_EXTERN_C +double log2(double x) { return __devicelib_log2(x); } + +DEVICE_EXTERN_C +double logb(double x) { return __devicelib_logb(x); } + +DEVICE_EXTERN_C +double sqrt(double x) { return __devicelib_sqrt(x); } + +DEVICE_EXTERN_C +double cbrt(double x) { return __devicelib_cbrt(x); } + +DEVICE_EXTERN_C +double hypot(double x, double y) { return __devicelib_hypot(x, y); } + +DEVICE_EXTERN_C +double erf(double x) { return __devicelib_erf(x); } + +DEVICE_EXTERN_C +double erfc(double x) { return __devicelib_erfc(x); } + +DEVICE_EXTERN_C +double tgamma(double x) { return __devicelib_tgamma(x); } + +DEVICE_EXTERN_C +double lgamma(double x) { return __devicelib_lgamma(x); } + +DEVICE_EXTERN_C +double fmod(double x, double y) { return __devicelib_fmod(x, y); } + +DEVICE_EXTERN_C +double remainder(double x, double y) { return __devicelib_remainder(x, y); } + +DEVICE_EXTERN_C +double remquo(double x, double y, int *q) { + return __devicelib_remquo(x, y, q); +} + +DEVICE_EXTERN_C +double nextafter(double x, double y) { return __devicelib_nextafter(x, y); } + +DEVICE_EXTERN_C +double fdim(double x, double y) { return __devicelib_fdim(x, y); } + +DEVICE_EXTERN_C +double fma(double x, double y, double z) { return __devicelib_fma(x, y, z); } + +DEVICE_EXTERN_C +double sin(double x) { return __devicelib_sin(x); } + +DEVICE_EXTERN_C +double cos(double x) { return __devicelib_cos(x); } + +DEVICE_EXTERN_C +double tan(double x) { return __devicelib_tan(x); } + +DEVICE_EXTERN_C +double pow(double x, double y) { return __devicelib_pow(x, y); } + +DEVICE_EXTERN_C +double acos(double x) { return __devicelib_acos(x); } + +DEVICE_EXTERN_C +double asin(double x) { return __devicelib_asin(x); } + +DEVICE_EXTERN_C +double atan(double x) { return __devicelib_atan(x); } + +DEVICE_EXTERN_C +double atan2(double x, double y) { return __devicelib_atan2(x, y); } + +DEVICE_EXTERN_C +double cosh(double x) { return __devicelib_cosh(x); } + +DEVICE_EXTERN_C +double sinh(double x) { return __devicelib_sinh(x); } + +DEVICE_EXTERN_C +double tanh(double x) { return __devicelib_tanh(x); } + +DEVICE_EXTERN_C +double acosh(double x) { return __devicelib_acosh(x); } + +DEVICE_EXTERN_C +double asinh(double x) { return __devicelib_asinh(x); } + +DEVICE_EXTERN_C +double atanh(double x) { return __devicelib_atanh(x); } diff --git a/libdevice/complex_wrapper.cpp b/libdevice/complex_wrapper.cpp new file mode 100644 index 0000000000000..845aad2f5ecb7 --- /dev/null +++ b/libdevice/complex_wrapper.cpp @@ -0,0 +1,100 @@ +//==--- complex_wrapper.cpp - wrappers for C99 complex math functions ------==// +// +// 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 "device.h" +#include "device_complex.h" + +DEVICE_EXTERN_C +float cimagf(float __complex__ z) { return __devicelib_cimagf(z); } + +DEVICE_EXTERN_C +float crealf(float __complex__ z) { return __devicelib_crealf(z); } + +DEVICE_EXTERN_C +float cargf(float __complex__ z) { return __devicelib_cargf(z); } + +DEVICE_EXTERN_C +float cabsf(float __complex__ z) { return __devicelib_cabsf(z); } + +DEVICE_EXTERN_C +float __complex__ cprojf(float __complex__ z) { return __devicelib_cprojf(z); } + +DEVICE_EXTERN_C +float __complex__ cexpf(float __complex__ z) { return __devicelib_cexpf(z); } + +DEVICE_EXTERN_C +float __complex__ clogf(float __complex__ z) { return __devicelib_clogf(z); } + +DEVICE_EXTERN_C +float __complex__ cpowf(float __complex__ x, float __complex__ y) { + return __devicelib_cpowf(x, y); +} + +DEVICE_EXTERN_C +float __complex__ cpolarf(float rho, float theta) { + return __devicelib_cpolarf(rho, theta); +} + +DEVICE_EXTERN_C +float __complex__ csqrtf(float __complex__ z) { return __devicelib_csqrtf(z); } + +DEVICE_EXTERN_C +float __complex__ csinhf(float __complex__ z) { return __devicelib_csinhf(z); } + +DEVICE_EXTERN_C +float __complex__ ccoshf(float __complex__ z) { return __devicelib_ccoshf(z); } + +DEVICE_EXTERN_C +float __complex__ ctanhf(float __complex__ z) { return __devicelib_ctanhf(z); } + +DEVICE_EXTERN_C +float __complex__ csinf(float __complex__ z) { return __devicelib_csinf(z); } + +DEVICE_EXTERN_C +float __complex__ ccosf(float __complex__ z) { return __devicelib_ccosf(z); } + +DEVICE_EXTERN_C +float __complex__ ctanf(float __complex__ z) { return __devicelib_ctanf(z); } + +DEVICE_EXTERN_C +float __complex__ cacosf(float __complex__ z) { return __devicelib_cacosf(z); } + +DEVICE_EXTERN_C +float __complex__ casinhf(float __complex__ z) { + return __devicelib_casinhf(z); +} + +DEVICE_EXTERN_C +float __complex__ casinf(float __complex__ z) { return __devicelib_casinf(z); } + +DEVICE_EXTERN_C +float __complex__ cacoshf(float __complex__ z) { + return __devicelib_cacoshf(z); +} + +DEVICE_EXTERN_C +float __complex__ catanhf(float __complex__ z) { + return __devicelib_catanhf(z); +} + +DEVICE_EXTERN_C +float __complex__ catanf(float __complex__ z) { return __devicelib_catanf(z); } + +// __mulsc3 +// Returns: the product of a + ib and c + id +DEVICE_EXTERN_C +float __complex__ __mulsc3(float __a, float __b, float __c, float __d) { + return __devicelib___mulsc3(__a, __b, __c, __d); +} + +// __divsc3 +// Returns: the quotient of (a + ib) / (c + id) +DEVICE_EXTERN_C +float __complex__ __divsc3(float __a, float __b, float __c, float __d) { + return __devicelib___divsc3(__a, __b, __c, __d); +} diff --git a/libdevice/complex_wrapper_fp64.cpp b/libdevice/complex_wrapper_fp64.cpp new file mode 100644 index 0000000000000..d4dfe3733c2ed --- /dev/null +++ b/libdevice/complex_wrapper_fp64.cpp @@ -0,0 +1,100 @@ +//==--- complex_wrapper.cpp - wrappers for C99 complex math functions ------==// +// +// 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 "device.h" +#include "device_complex.h" + +DEVICE_EXTERN_C +double cimag(double __complex__ z) { return __devicelib_cimag(z); } + +DEVICE_EXTERN_C +double creal(double __complex__ z) { return __devicelib_creal(z); } + +DEVICE_EXTERN_C +double cabs(double __complex__ z) { return __devicelib_cabs(z); } + +DEVICE_EXTERN_C +double carg(double __complex__ z) { return __devicelib_carg(z); } + +DEVICE_EXTERN_C +double __complex__ cproj(double __complex__ z) { return __devicelib_cproj(z); } + +DEVICE_EXTERN_C +double __complex__ cexp(double __complex__ z) { return __devicelib_cexp(z); } + +DEVICE_EXTERN_C +double __complex__ clog(double __complex__ z) { return __devicelib_clog(z); } + +DEVICE_EXTERN_C +double __complex__ cpow(double __complex__ x, double __complex__ y) { + return __devicelib_cpow(x, y); +} + +DEVICE_EXTERN_C +double __complex__ cpolar(double rho, double theta) { + return __devicelib_cpolar(rho, theta); +} + +DEVICE_EXTERN_C +double __complex__ csqrt(double __complex__ z) { return __devicelib_csqrt(z); } + +DEVICE_EXTERN_C +double __complex__ csinh(double __complex__ z) { return __devicelib_csinh(z); } + +DEVICE_EXTERN_C +double __complex__ ccosh(double __complex__ z) { return __devicelib_ccosh(z); } + +DEVICE_EXTERN_C +double __complex__ ctanh(double __complex__ z) { return __devicelib_ctanh(z); } + +DEVICE_EXTERN_C +double __complex__ csin(double __complex__ z) { return __devicelib_csin(z); } + +DEVICE_EXTERN_C +double __complex__ ccos(double __complex__ z) { return __devicelib_ccos(z); } + +DEVICE_EXTERN_C +double __complex__ ctan(double __complex__ z) { return __devicelib_ctan(z); } + +DEVICE_EXTERN_C +double __complex__ cacos(double __complex__ z) { return __devicelib_cacos(z); } + +DEVICE_EXTERN_C +double __complex__ casinh(double __complex__ z) { + return __devicelib_casinh(z); +} + +DEVICE_EXTERN_C +double __complex__ casin(double __complex__ z) { return __devicelib_casin(z); } + +DEVICE_EXTERN_C +double __complex__ cacosh(double __complex__ z) { + return __devicelib_cacosh(z); +} + +DEVICE_EXTERN_C +double __complex__ catanh(double __complex__ z) { + return __devicelib_catanh(z); +} + +DEVICE_EXTERN_C +double __complex__ catan(double __complex__ z) { return __devicelib_catan(z); } + +// __muldc3 +// Returns: the product of a + ib and c + id +DEVICE_EXTERN_C +double __complex__ __muldc3(double __a, double __b, double __c, double __d) { + return __devicelib___muldc3(__a, __b, __c, __d); +} + +// __divdc3 +// Returns: the quotient of (a + ib) / (c + id) +DEVICE_EXTERN_C +double __complex__ __divdc3(double __a, double __b, double __c, double __d) { + return __devicelib___divdc3(__a, __b, __c, __d); +} diff --git a/libdevice/device.h b/libdevice/device.h new file mode 100644 index 0000000000000..1258deda031a4 --- /dev/null +++ b/libdevice/device.h @@ -0,0 +1,36 @@ +//==--- device.h - device definitions ------------------------*- C++ -*-----==// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +#ifndef __LIBDEVICE_DEVICE_H__ +#define __LIBDEVICE_DEVICE_H__ + +#ifdef __cplusplus +#define EXTERN_C extern "C" +#else // __cplusplus +#define EXTERN_C +#endif // __cplusplus + +#ifdef CL_SYCL_LANGUAGE_VERSION +#ifndef SYCL_EXTERNAL +#define SYCL_EXTERNAL +#endif // SYCL_EXTERNAL + +#ifdef __SYCL_DEVICE_ONLY__ +#define DEVICE_EXTERNAL SYCL_EXTERNAL __attribute__((weak)) +#else // __SYCL_DEVICE_ONLY__ +#define DEVICE_EXTERNAL static +#undef EXTERN_C +#define EXTERN_C +#endif // __SYCL_DEVICE_ONLY__ +#else // CL_SYCL_LANGUAGE_VERSION +#define DEVICE_EXTERNAL +#endif // CL_SYCL_LANGUAGE_VERSION + +#define DEVICE_EXTERN_C DEVICE_EXTERNAL EXTERN_C + +#endif // __LIBDEVICE_DEVICE_H__ diff --git a/libdevice/device_complex.h b/libdevice/device_complex.h new file mode 100644 index 0000000000000..ff8b4f0730d5d --- /dev/null +++ b/libdevice/device_complex.h @@ -0,0 +1,166 @@ +//==------- device_complex.h - complex devicelib functions declarations-----==// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//==------------------------------------------------------------------------==// +#ifndef __LIBDEVICE_DEVICE_COMPLEX_H_ +#define __LIBDEVICE_DEVICE_COMPLEX_H_ + +#include "device.h" + +// TODO: This needs to be more robust. +// clang doesn't recognize the c11 CMPLX macro, but it does have +// its own syntax extension for initializing a complex as a struct. +#ifndef CMPLX +#define CMPLX(r, i) ((double __complex__){(double)(r), (double)(i)}) +#endif +#ifndef CMPLXF +#define CMPLXF(r, i) ((float __complex__){(float)(r), (float)(i)}) +#endif + +DEVICE_EXTERN_C +double __devicelib_cimag(double __complex__ z); + +DEVICE_EXTERN_C +float __devicelib_cimagf(float __complex__ z); + +DEVICE_EXTERN_C +double __devicelib_creal(double __complex__ z); + +DEVICE_EXTERN_C +float __devicelib_crealf(float __complex__ z); + +DEVICE_EXTERN_C +double __devicelib_carg(double __complex__ z); + +DEVICE_EXTERN_C +float __devicelib_cargf(float __complex__ z); + +DEVICE_EXTERN_C +double __devicelib_cabs(double __complex__ z); + +DEVICE_EXTERN_C +float __devicelib_cabsf(float __complex__ z); + +DEVICE_EXTERN_C +double __complex__ __devicelib_cproj(double __complex__ z); + +DEVICE_EXTERN_C +float __complex__ __devicelib_cprojf(float __complex__ z); + +DEVICE_EXTERN_C +double __complex__ __devicelib_cexp(double __complex__ z); + +DEVICE_EXTERN_C +float __complex__ __devicelib_cexpf(float __complex__ z); + +DEVICE_EXTERN_C +double __complex__ __devicelib_clog(double __complex__ z); + +DEVICE_EXTERN_C +float __complex__ __devicelib_clogf(float __complex__ z); + +DEVICE_EXTERN_C +double __complex__ __devicelib_cpow(double __complex__ x, double __complex__ y); + +DEVICE_EXTERN_C +float __complex__ __devicelib_cpowf(float __complex__ x, float __complex__ y); + +DEVICE_EXTERN_C +double __complex__ __devicelib_cpolar(double x, double y); + +DEVICE_EXTERN_C +float __complex__ __devicelib_cpolarf(float x, float y); + +DEVICE_EXTERN_C +double __complex__ __devicelib_csqrt(double __complex__ z); + +DEVICE_EXTERN_C +float __complex__ __devicelib_csqrtf(float __complex__ z); + +DEVICE_EXTERN_C +double __complex__ __devicelib_csinh(double __complex__ z); + +DEVICE_EXTERN_C +float __complex__ __devicelib_csinhf(float __complex__ z); + +DEVICE_EXTERN_C +double __complex__ __devicelib_ccosh(double __complex__ z); + +DEVICE_EXTERN_C +float __complex__ __devicelib_ccoshf(float __complex__ z); + +DEVICE_EXTERN_C +double __complex__ __devicelib_ctanh(double __complex__ z); + +DEVICE_EXTERN_C +float __complex__ __devicelib_ctanhf(float __complex__ z); + +DEVICE_EXTERN_C +double __complex__ __devicelib_csin(double __complex__ z); + +DEVICE_EXTERN_C +float __complex__ __devicelib_csinf(float __complex__ z); + +DEVICE_EXTERN_C +double __complex__ __devicelib_ccos(double __complex__ z); + +DEVICE_EXTERN_C +float __complex__ __devicelib_ccosf(float __complex__ z); + +DEVICE_EXTERN_C +double __complex__ __devicelib_ctan(double __complex__ z); + +DEVICE_EXTERN_C +float __complex__ __devicelib_ctanf(float __complex__ z); + +DEVICE_EXTERN_C +double __complex__ __devicelib_cacos(double __complex__ z); + +DEVICE_EXTERN_C +float __complex__ __devicelib_cacosf(float __complex__ z); + +DEVICE_EXTERN_C +double __complex__ __devicelib_casinh(double __complex__ z); + +DEVICE_EXTERN_C +float __complex__ __devicelib_casinhf(float __complex__ z); + +DEVICE_EXTERN_C +double __complex__ __devicelib_casin(double __complex__ z); + +DEVICE_EXTERN_C +float __complex__ __devicelib_casinf(float __complex__ z); + +DEVICE_EXTERN_C +double __complex__ __devicelib_cacosh(double __complex__ z); + +DEVICE_EXTERN_C +float __complex__ __devicelib_cacoshf(float __complex__ z); + +DEVICE_EXTERN_C +double __complex__ __devicelib_catanh(double __complex__ z); + +DEVICE_EXTERN_C +float __complex__ __devicelib_catanhf(float __complex__ z); + +DEVICE_EXTERN_C +double __complex__ __devicelib_catan(double __complex__ z); + +DEVICE_EXTERN_C +float __complex__ __devicelib_catanf(float __complex__ z); + +DEVICE_EXTERN_C +double __complex__ __devicelib___muldc3(double a, double b, double c, double d); + +DEVICE_EXTERN_C +float __complex__ __devicelib___mulsc3(float a, float b, float c, float d); + +DEVICE_EXTERN_C +double __complex__ __devicelib___divdc3(double a, double b, double c, double d); + +DEVICE_EXTERN_C +float __complex__ __devicelib___divsc3(float a, float b, float c, float d); +#endif // __LIBDEVICE_DEVICE_COMPLEX_H_ diff --git a/libdevice/device_math.h b/libdevice/device_math.h new file mode 100644 index 0000000000000..a811ca4384b47 --- /dev/null +++ b/libdevice/device_math.h @@ -0,0 +1,358 @@ +//==------- device_math.h - math devicelib functions declarations-----------==// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//==------------------------------------------------------------------------==// + +#ifndef __LIBDEVICE_DEVICE_MATH_H__ +#define __LIBDEVICE_DEVICE_MATH_H__ + +#include "device.h" + +DEVICE_EXTERNAL double __spirv_ocl_log(double); +DEVICE_EXTERNAL double __spirv_ocl_sin(double); +DEVICE_EXTERNAL double __spirv_ocl_cos(double); +DEVICE_EXTERNAL double __spirv_ocl_sinh(double); +DEVICE_EXTERNAL double __spirv_ocl_cosh(double); +DEVICE_EXTERNAL double __spirv_ocl_tanh(double); +DEVICE_EXTERNAL double __spirv_ocl_exp(double); +DEVICE_EXTERNAL double __spirv_ocl_sqrt(double); +DEVICE_EXTERNAL bool __spirv_IsInf(double); +DEVICE_EXTERNAL bool __spirv_IsFinite(double); +DEVICE_EXTERNAL bool __spirv_IsNan(double); +DEVICE_EXTERNAL bool __spirv_IsNormal(double); +DEVICE_EXTERNAL bool __spirv_SignBitSet(double); +DEVICE_EXTERNAL double __spirv_ocl_hypot(double, double); +DEVICE_EXTERNAL double __spirv_ocl_atan2(double, double); +DEVICE_EXTERNAL double __spirv_ocl_pow(double, double); +DEVICE_EXTERNAL double __spirv_ocl_ldexp(double, int); +DEVICE_EXTERNAL double __spirv_ocl_copysign(double, double); +DEVICE_EXTERNAL double __spirv_ocl_fmax(double, double); +DEVICE_EXTERNAL double __spirv_ocl_fabs(double); +DEVICE_EXTERNAL double __spirv_ocl_tan(double); +DEVICE_EXTERNAL double __spirv_ocl_acos(double); +DEVICE_EXTERNAL double __spirv_ocl_asin(double); +DEVICE_EXTERNAL double __spirv_ocl_atan(double); +DEVICE_EXTERNAL double __spirv_ocl_atan2(double, double); +DEVICE_EXTERNAL double __spirv_ocl_cosh(double); +DEVICE_EXTERNAL double __spirv_ocl_sinh(double); +DEVICE_EXTERNAL double __spirv_ocl_tanh(double); +DEVICE_EXTERNAL double __spirv_ocl_acosh(double); +DEVICE_EXTERNAL double __spirv_ocl_asinh(double); +DEVICE_EXTERNAL double __spirv_ocl_atanh(double); +DEVICE_EXTERNAL double __spirv_ocl_frexp(double, int *); +DEVICE_EXTERNAL double __spirv_ocl_log10(double); +DEVICE_EXTERNAL double __spirv_ocl_modf(double, double *); +DEVICE_EXTERNAL double __spirv_ocl_exp2(double); +DEVICE_EXTERNAL double __spirv_ocl_expm1(double); +DEVICE_EXTERNAL int __spirv_ocl_ilogb(double); +DEVICE_EXTERNAL double __spriv_ocl_log1p(double); +DEVICE_EXTERNAL double __spirv_ocl_log2(double); +DEVICE_EXTERNAL double __spirv_ocl_logb(double); +DEVICE_EXTERNAL double __spirv_ocl_sqrt(double); +DEVICE_EXTERNAL double __spirv_ocl_cbrt(double); +DEVICE_EXTERNAL double __spirv_ocl_hypot(double); +DEVICE_EXTERNAL double __spirv_ocl_erf(double); +DEVICE_EXTERNAL double __spirv_ocl_erfc(double); +DEVICE_EXTERNAL double __spirv_ocl_tgamma(double); +DEVICE_EXTERNAL double __spirv_ocl_lgamma(double); +DEVICE_EXTERNAL double __spirv_ocl_fmod(double, double); +DEVICE_EXTERNAL double __spirv_ocl_remainder(double, double); +DEVICE_EXTERNAL double __spirv_ocl_remquo(double, double, int *); +DEVICE_EXTERNAL double __spirv_ocl_nextafter(double, double); +DEVICE_EXTERNAL double __spirv_ocl_fdim(double, double); +DEVICE_EXTERNAL double __spirv_ocl_fma(double, double, double); + +DEVICE_EXTERNAL float __spirv_ocl_log(float); +DEVICE_EXTERNAL float __spirv_ocl_logb(float); +DEVICE_EXTERNAL float __spirv_ocl_sin(float); +DEVICE_EXTERNAL float __spirv_ocl_cos(float); +DEVICE_EXTERNAL float __spirv_ocl_sinh(float); +DEVICE_EXTERNAL float __spirv_ocl_cosh(float); +DEVICE_EXTERNAL float __spirv_ocl_tanh(float); +DEVICE_EXTERNAL float __spirv_ocl_exp(float); +DEVICE_EXTERNAL float __spirv_ocl_sqrt(float); +DEVICE_EXTERNAL bool __spirv_IsInf(float); +DEVICE_EXTERNAL bool __spirv_IsFinite(float); +DEVICE_EXTERNAL bool __spirv_IsNan(float); +DEVICE_EXTERNAL bool __spirv_IsNormal(double); +DEVICE_EXTERNAL bool __spirv_SignBitSet(float); +DEVICE_EXTERNAL float __spirv_ocl_hypot(float, float); +DEVICE_EXTERNAL float __spirv_ocl_atan2(float, float); +DEVICE_EXTERNAL float __spirv_ocl_pow(float, float); +DEVICE_EXTERNAL float __spirv_ocl_ldexp(float, int); +DEVICE_EXTERNAL float __spirv_ocl_copysign(float, float); +DEVICE_EXTERNAL float __spirv_ocl_fmax(float, float); +DEVICE_EXTERNAL float __spirv_ocl_fabs(float); +DEVICE_EXTERNAL float __spirv_ocl_tan(float); +DEVICE_EXTERNAL float __spirv_ocl_acos(float); +DEVICE_EXTERNAL float __spirv_ocl_asin(float); +DEVICE_EXTERNAL float __spirv_ocl_atan(float); +DEVICE_EXTERNAL float __spirv_ocl_atan2(float, float); +DEVICE_EXTERNAL float __spirv_ocl_cosh(float); +DEVICE_EXTERNAL float __spirv_ocl_sinh(float); +DEVICE_EXTERNAL float __spirv_ocl_tanh(float); +DEVICE_EXTERNAL float __spirv_ocl_acosh(float); +DEVICE_EXTERNAL float __spirv_ocl_asinh(float); +DEVICE_EXTERNAL float __spirv_ocl_atanh(float); +DEVICE_EXTERNAL float __spirv_ocl_frexp(float, int *); +DEVICE_EXTERNAL float __spirv_ocl_log10(float); +DEVICE_EXTERNAL float __spirv_ocl_modf(float, float *); +DEVICE_EXTERNAL float __spirv_ocl_exp2(float); +DEVICE_EXTERNAL float __spirv_ocl_expm1(float); +DEVICE_EXTERNAL int __spirv_ocl_ilogb(float); +DEVICE_EXTERNAL float __spirv_ocl_log1p(float); +DEVICE_EXTERNAL float __spirv_ocl_log2(float); +DEVICE_EXTERNAL float __spirv_ocl_sqrt(float); +DEVICE_EXTERNAL float __spirv_ocl_cbrt(float); +DEVICE_EXTERNAL float __spirv_ocl_hypot(float); +DEVICE_EXTERNAL float __spirv_ocl_erf(float); +DEVICE_EXTERNAL float __spirv_ocl_erfc(float); +DEVICE_EXTERNAL float __spirv_ocl_tgamma(float); +DEVICE_EXTERNAL float __spirv_ocl_lgamma(float); +DEVICE_EXTERNAL float __spirv_ocl_fmod(float, float); +DEVICE_EXTERNAL float __spirv_ocl_remainder(float, float); +DEVICE_EXTERNAL float __spirv_ocl_remquo(float, float, int *); +DEVICE_EXTERNAL float __spirv_ocl_nextafter(float, float); +DEVICE_EXTERNAL float __spirv_ocl_fdim(float, float); +DEVICE_EXTERNAL float __spirv_ocl_fma(float, float, float); + +DEVICE_EXTERN_C +double __devicelib_log(double x); + +DEVICE_EXTERN_C +float __devicelib_logf(float x); + +DEVICE_EXTERN_C +double __devicelib_sin(double x); + +DEVICE_EXTERN_C +float __devicelib_sinf(float x); + +DEVICE_EXTERN_C +double __devicelib_cos(double x); + +DEVICE_EXTERN_C +float __devicelib_cosf(float x); + +DEVICE_EXTERN_C +double __devicelib_tan(double x); + +DEVICE_EXTERN_C +float __devicelib_tanf(float x); + +DEVICE_EXTERN_C +double __devicelib_acos(double x); + +DEVICE_EXTERN_C +float __devicelib_acosf(float x); + +DEVICE_EXTERN_C +double __devicelib_pow(double x, double y); + +DEVICE_EXTERN_C +float __devicelib_powf(float x, float y); + +DEVICE_EXTERN_C +double __devicelib_sqrt(double x); + +DEVICE_EXTERN_C +float __devicelib_sqrtf(float x); + +DEVICE_EXTERN_C +double __devicelib_cbrt(double x); + +DEVICE_EXTERN_C +float __devicelib_cbrtf(float x); + +DEVICE_EXTERN_C +double __devicelib_hypot(double x, double y); + +DEVICE_EXTERN_C +float __devicelib_hypotf(float x, float y); + +DEVICE_EXTERN_C +double __devicelib_erf(double x); + +DEVICE_EXTERN_C +float __devicelib_erff(float x); + +DEVICE_EXTERN_C +double __devicelib_erfc(double x); + +DEVICE_EXTERN_C +float __devicelib_erfcf(float x); + +DEVICE_EXTERN_C +double __devicelib_tgamma(double x); + +DEVICE_EXTERN_C +float __devicelib_tgammaf(float x); + +DEVICE_EXTERN_C +double __devicelib_lgamma(double x); + +DEVICE_EXTERN_C +float __devicelib_lgammaf(float x); + +DEVICE_EXTERN_C +double __devicelib_fmod(double x, double y); + +DEVICE_EXTERN_C +float __devicelib_fmodf(float x, float y); + +DEVICE_EXTERN_C +double __devicelib_remainder(double x, double y); + +DEVICE_EXTERN_C +float __devicelib_remainderf(float x, float y); + +DEVICE_EXTERN_C +double __devicelib_remquo(double x, double y, int *q); + +DEVICE_EXTERN_C +float __devicelib_remquof(float x, float y, int *q); + +DEVICE_EXTERN_C +double __devicelib_nextafter(double x, double y); + +DEVICE_EXTERN_C +float __devicelib_nextafterf(float x, float y); + +DEVICE_EXTERN_C +double __devicelib_fdim(double x, double y); + +DEVICE_EXTERN_C +float __devicelib_fdimf(float x, float y); + +DEVICE_EXTERN_C +double __devicelib_fma(double x, double y, double z); + +DEVICE_EXTERN_C +float __devicelib_fmaf(float x, float y, float z); + +DEVICE_EXTERN_C +float __devicelib_asinf(float x); + +DEVICE_EXTERN_C +double __devicelib_asin(double x); + +DEVICE_EXTERN_C +float __devicelib_atanf(float x); + +DEVICE_EXTERN_C +double __devicelib_atan(double x); + +DEVICE_EXTERN_C +float __devicelib_atan2f(float x, float y); + +DEVICE_EXTERN_C +double __devicelib_atan2(double x, double y); + +DEVICE_EXTERN_C +float __devicelib_coshf(float x); + +DEVICE_EXTERN_C +double __devicelib_cosh(double x); + +DEVICE_EXTERN_C +float __devicelib_sinhf(float x); + +DEVICE_EXTERN_C +double __devicelib_sinh(double x); + +DEVICE_EXTERN_C +float __devicelib_tanhf(float x); + +DEVICE_EXTERN_C +double __devicelib_tanh(double x); + +DEVICE_EXTERN_C +float __devicelib_acoshf(float x); + +DEVICE_EXTERN_C +double __devicelib_acosh(double x); + +DEVICE_EXTERN_C +float __devicelib_asinhf(float x); + +DEVICE_EXTERN_C +double __devicelib_asinh(double x); + +DEVICE_EXTERN_C +float __devicelib_atanhf(float x); + +DEVICE_EXTERN_C +double __devicelib_atanh(double x); + +DEVICE_EXTERN_C +double __devicelib_frexp(double x, int *exp); + +DEVICE_EXTERN_C +float __devicelib_frexpf(float x, int *exp); + +DEVICE_EXTERN_C +double __devicelib_ldexp(double x, int exp); + +DEVICE_EXTERN_C +float __devicelib_ldexpf(float x, int exp); + +DEVICE_EXTERN_C +double __devicelib_log10(double x); + +DEVICE_EXTERN_C +float __devicelib_log10f(float x); + +DEVICE_EXTERN_C +double __devicelib_modf(double x, double *intpart); + +DEVICE_EXTERN_C +float __devicelib_modff(float x, float *intpart); + +DEVICE_EXTERN_C +double __devicelib_exp(double x); + +DEVICE_EXTERN_C +float __devicelib_expf(float x); + +DEVICE_EXTERN_C +double __devicelib_exp2(double x); + +DEVICE_EXTERN_C +float __devicelib_exp2f(float x); + +DEVICE_EXTERN_C +double __devicelib_expm1(double x); + +DEVICE_EXTERN_C +float __devicelib_expm1f(float x); + +DEVICE_EXTERN_C +int __devicelib_ilogb(double x); + +DEVICE_EXTERN_C +int __devicelib_ilogbf(float x); + +DEVICE_EXTERN_C +double __devicelib_log1p(double x); + +DEVICE_EXTERN_C +float __devicelib_log1pf(float x); + +DEVICE_EXTERN_C +double __devicelib_log2(double x); + +DEVICE_EXTERN_C +float __devicelib_log2f(float x); + +DEVICE_EXTERN_C +double __devicelib_logb(double x); + +DEVICE_EXTERN_C +float __devicelib_logbf(float x); + +DEVICE_EXTERN_C +float __devicelib_scalbnf(float x, int n); +#endif // __LIBDEVICE_DEVICE_MATH_H__ diff --git a/sycl/source/detail/devicelib/fallback-cassert.cpp b/libdevice/fallback-cassert.cpp similarity index 59% rename from sycl/source/detail/devicelib/fallback-cassert.cpp rename to libdevice/fallback-cassert.cpp index f1b255a17a887..9225189b1f992 100644 --- a/sycl/source/detail/devicelib/fallback-cassert.cpp +++ b/libdevice/fallback-cassert.cpp @@ -8,31 +8,23 @@ #include "wrapper.h" -#include - static const __attribute__((opencl_constant)) char assert_fmt[] = "%s:%d: %s: global id: [%lu,%lu,%lu], local id: [%lu,%lu,%lu] " "Assertion `%s` failed.\n"; -SYCL_EXTERNAL -extern "C" void __devicelib_assert_fail( - const char *expr, const char *file, - int32_t line, const char *func, - uint64_t gid0, uint64_t gid1, uint64_t gid2, - uint64_t lid0, uint64_t lid1, uint64_t lid2) { +DEVICE_EXTERN_C void __devicelib_assert_fail(const char *expr, const char *file, + int32_t line, const char *func, + uint64_t gid0, uint64_t gid1, + uint64_t gid2, uint64_t lid0, + uint64_t lid1, uint64_t lid2) { // intX_t types are used instead of `int' and `long' because the format string // is defined in terms of *device* types (OpenCL types): %d matches a 32 bit // integer, %lu matches a 64 bit unsigned integer. Host `int' and // `long' types may be different, so we cannot use them. - __spirv_ocl_printf( - assert_fmt, - file, (int32_t)line, - // WORKAROUND: IGC does not handle this well - // (func) ? func : "", - func, - gid0, gid1, gid2, - lid0, lid1, lid2, - expr); + __spirv_ocl_printf(assert_fmt, file, (int32_t)line, + // WORKAROUND: IGC does not handle this well + // (func) ? func : "", + func, gid0, gid1, gid2, lid0, lid1, lid2, expr); // FIXME: call SPIR-V unreachable instead // volatile int *die = (int *)0x0; diff --git a/libdevice/fallback-cmath-fp64.cpp b/libdevice/fallback-cmath-fp64.cpp new file mode 100644 index 0000000000000..a0693d6b44c8a --- /dev/null +++ b/libdevice/fallback-cmath-fp64.cpp @@ -0,0 +1,140 @@ +//==--- fallback-cmath.cpp - fallback implementation of math functions -----==// +// +// 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 "device_math.h" + +DEVICE_EXTERN_C +double __devicelib_log(double x) { return __spirv_ocl_log(x); } + +DEVICE_EXTERN_C +double __devicelib_exp(double x) { return __spirv_ocl_exp(x); } + +DEVICE_EXTERN_C +double __devicelib_frexp(double x, int *exp) { + return __spirv_ocl_frexp(x, exp); +} + +DEVICE_EXTERN_C +double __devicelib_ldexp(double x, int exp) { + return __spirv_ocl_ldexp(x, exp); +} + +DEVICE_EXTERN_C +double __devicelib_log10(double x) { return __spirv_ocl_log10(x); } + +DEVICE_EXTERN_C +double __devicelib_modf(double x, double *intpart) { + return __spirv_ocl_modf(x, intpart); +} + +DEVICE_EXTERN_C +double __devicelib_exp2(double x) { return __spirv_ocl_exp2(x); } + +DEVICE_EXTERN_C +double __devicelib_expm1(double x) { return __spirv_ocl_expm1(x); } + +DEVICE_EXTERN_C +int __devicelib_ilogb(double x) { return __spirv_ocl_ilogb(x); } + +DEVICE_EXTERN_C +double __devicelib_log1p(double x) { return __spirv_ocl_log1p(x); } + +DEVICE_EXTERN_C +double __devicelib_log2(double x) { return __spirv_ocl_log2(x); } + +DEVICE_EXTERN_C +double __devicelib_logb(double x) { return __spirv_ocl_logb(x); } + +DEVICE_EXTERN_C +double __devicelib_sqrt(double x) { return __spirv_ocl_sqrt(x); } + +DEVICE_EXTERN_C +double __devicelib_cbrt(double x) { return __spirv_ocl_cbrt(x); } + +DEVICE_EXTERN_C +double __devicelib_hypot(double x, double y) { return __spirv_ocl_hypot(x, y); } + +DEVICE_EXTERN_C +double __devicelib_erf(double x) { return __spirv_ocl_erf(x); } + +DEVICE_EXTERN_C +double __devicelib_erfc(double x) { return __spirv_ocl_erfc(x); } + +DEVICE_EXTERN_C +double __devicelib_tgamma(double x) { return __spirv_ocl_tgamma(x); } + +DEVICE_EXTERN_C +double __devicelib_lgamma(double x) { return __spirv_ocl_lgamma(x); } + +DEVICE_EXTERN_C +double __devicelib_fmod(double x, double y) { return __spirv_ocl_fmod(x, y); } + +DEVICE_EXTERN_C +double __devicelib_remainder(double x, double y) { + return __spirv_ocl_remainder(x, y); +} + +DEVICE_EXTERN_C +double __devicelib_remquo(double x, double y, int *q) { + return __spirv_ocl_remquo(x, y, q); +} + +DEVICE_EXTERN_C +double __devicelib_nextafter(double x, double y) { + return __spirv_ocl_nextafter(x, y); +} + +DEVICE_EXTERN_C +double __devicelib_fdim(double x, double y) { return __spirv_ocl_fdim(x, y); } + +DEVICE_EXTERN_C +double __devicelib_fma(double x, double y, double z) { + return __spirv_ocl_fma(x, y, z); +} + +DEVICE_EXTERN_C +double __devicelib_sin(double x) { return __spirv_ocl_sin(x); } + +DEVICE_EXTERN_C +double __devicelib_cos(double x) { return __spirv_ocl_cos(x); } + +DEVICE_EXTERN_C +double __devicelib_tan(double x) { return __spirv_ocl_tan(x); } + +DEVICE_EXTERN_C +double __devicelib_pow(double x, double y) { return __spirv_ocl_pow(x, y); } + +DEVICE_EXTERN_C +double __devicelib_acos(double x) { return __spirv_ocl_acos(x); } + +DEVICE_EXTERN_C +double __devicelib_asin(double x) { return __spirv_ocl_asin(x); } + +DEVICE_EXTERN_C +double __devicelib_atan(double x) { return __spirv_ocl_atan(x); } + +DEVICE_EXTERN_C +double __devicelib_atan2(double x, double y) { return __spirv_ocl_atan2(x, y); } + +DEVICE_EXTERN_C +double __devicelib_cosh(double x) { return __spirv_ocl_cosh(x); } + +DEVICE_EXTERN_C +double __devicelib_sinh(double x) { return __spirv_ocl_sinh(x); } + +DEVICE_EXTERN_C +double __devicelib_tanh(double x) { return __spirv_ocl_tanh(x); } + +DEVICE_EXTERN_C +double __devicelib_acosh(double x) { return __spirv_ocl_acosh(x); } + +DEVICE_EXTERN_C +double __devicelib_asinh(double x) { return __spirv_ocl_asinh(x); } + +DEVICE_EXTERN_C +double __devicelib_atanh(double x) { return __spirv_ocl_atanh(x); } diff --git a/libdevice/fallback-cmath.cpp b/libdevice/fallback-cmath.cpp new file mode 100644 index 0000000000000..61904143a72f2 --- /dev/null +++ b/libdevice/fallback-cmath.cpp @@ -0,0 +1,141 @@ +//==--- fallback-cmath.cpp - fallback implementation of math functions -----==// +// +// 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 "device_math.h" + +DEVICE_EXTERN_C +float __devicelib_scalbnf(float x, int n) { return __spirv_ocl_ldexp(x, n); } + +DEVICE_EXTERN_C +float __devicelib_logf(float x) { return __spirv_ocl_log(x); } + +DEVICE_EXTERN_C +float __devicelib_expf(float x) { return __spirv_ocl_exp(x); } + +DEVICE_EXTERN_C +float __devicelib_frexpf(float x, int *exp) { + return __spirv_ocl_frexp(x, exp); +} + +DEVICE_EXTERN_C +float __devicelib_ldexpf(float x, int exp) { return __spirv_ocl_ldexp(x, exp); } + +DEVICE_EXTERN_C +float __devicelib_log10f(float x) { return __spirv_ocl_log10(x); } + +DEVICE_EXTERN_C +float __devicelib_modff(float x, float *intpart) { + return __spirv_ocl_modf(x, intpart); +} + +DEVICE_EXTERN_C +float __devicelib_exp2f(float x) { return __spirv_ocl_exp2(x); } + +DEVICE_EXTERN_C +float __devicelib_expm1f(float x) { return __spirv_ocl_expm1(x); } + +DEVICE_EXTERN_C +int __devicelib_ilogbf(float x) { return __spirv_ocl_ilogb(x); } + +DEVICE_EXTERN_C +float __devicelib_log1pf(float x) { return __spirv_ocl_log1p(x); } + +DEVICE_EXTERN_C +float __devicelib_log2f(float x) { return __spirv_ocl_log2(x); } + +DEVICE_EXTERN_C +float __devicelib_logbf(float x) { return __spirv_ocl_logb(x); } + +DEVICE_EXTERN_C +float __devicelib_sqrtf(float x) { return __spirv_ocl_sqrt(x); } + +DEVICE_EXTERN_C +float __devicelib_cbrtf(float x) { return __spirv_ocl_cbrt(x); } + +DEVICE_EXTERN_C +float __devicelib_hypotf(float x, float y) { return __spirv_ocl_hypot(x, y); } + +DEVICE_EXTERN_C +float __devicelib_erff(float x) { return __spirv_ocl_erf(x); } + +DEVICE_EXTERN_C +float __devicelib_erfcf(float x) { return __spirv_ocl_erfc(x); } + +DEVICE_EXTERN_C +float __devicelib_tgammaf(float x) { return __spirv_ocl_tgamma(x); } + +DEVICE_EXTERN_C +float __devicelib_lgammaf(float x) { return __spirv_ocl_lgamma(x); } + +DEVICE_EXTERN_C +float __devicelib_fmodf(float x, float y) { return __spirv_ocl_fmod(x, y); } + +DEVICE_EXTERN_C +float __devicelib_remainderf(float x, float y) { + return __spirv_ocl_remainder(x, y); +} + +DEVICE_EXTERN_C +float __devicelib_remquof(float x, float y, int *q) { + return __spirv_ocl_remquo(x, y, q); +} + +DEVICE_EXTERN_C +float __devicelib_nextafterf(float x, float y) { + return __spirv_ocl_nextafter(x, y); +} + +DEVICE_EXTERN_C +float __devicelib_fdimf(float x, float y) { return __spirv_ocl_fdim(x, y); } + +DEVICE_EXTERN_C +float __devicelib_fmaf(float x, float y, float z) { + return __spirv_ocl_fma(x, y, z); +} + +DEVICE_EXTERN_C +float __devicelib_sinf(float x) { return __spirv_ocl_sin(x); } + +DEVICE_EXTERN_C +float __devicelib_cosf(float x) { return __spirv_ocl_cos(x); } + +DEVICE_EXTERN_C +float __devicelib_tanf(float x) { return __spirv_ocl_tan(x); } + +DEVICE_EXTERN_C +float __devicelib_powf(float x, float y) { return __spirv_ocl_pow(x, y); } + +DEVICE_EXTERN_C +float __devicelib_acosf(float x) { return __spirv_ocl_acos(x); } + +DEVICE_EXTERN_C +float __devicelib_asinf(float x) { return __spirv_ocl_asin(x); } + +DEVICE_EXTERN_C +float __devicelib_atanf(float x) { return __spirv_ocl_atan(x); } + +DEVICE_EXTERN_C +float __devicelib_atan2f(float x, float y) { return __spirv_ocl_atan2(x, y); } + +DEVICE_EXTERN_C +float __devicelib_coshf(float x) { return __spirv_ocl_cosh(x); } + +DEVICE_EXTERN_C +float __devicelib_sinhf(float x) { return __spirv_ocl_sinh(x); } + +DEVICE_EXTERN_C +float __devicelib_tanhf(float x) { return __spirv_ocl_tanh(x); } + +DEVICE_EXTERN_C +float __devicelib_acoshf(float x) { return __spirv_ocl_acosh(x); } + +DEVICE_EXTERN_C +float __devicelib_asinhf(float x) { return __spirv_ocl_asinh(x); } + +DEVICE_EXTERN_C +float __devicelib_atanhf(float x) { return __spirv_ocl_atanh(x); } diff --git a/sycl/source/detail/devicelib/fallback-complex-fp64.cpp b/libdevice/fallback-complex-fp64.cpp similarity index 75% rename from sycl/source/detail/devicelib/fallback-complex-fp64.cpp rename to libdevice/fallback-complex-fp64.cpp index a8d64afee711e..69d23ea472c45 100644 --- a/sycl/source/detail/devicelib/fallback-complex-fp64.cpp +++ b/libdevice/fallback-complex-fp64.cpp @@ -1,30 +1,26 @@ -//==----- fallback-complex.cpp - complex math functions for SYCL device ----==// +//==----- fallback-complex.cpp - complex math functions for SPIR-V device --==// // // 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 __SYCL_DEVICE_ONLY__ -#include "device_math.h" + #include "device_complex.h" +#include "device_math.h" #include -extern "C" { -SYCL_EXTERNAL -double __devicelib_creal(double __complex__ z) { - return __real__(z); -} -SYCL_EXTERNAL -double __devicelib_cimag(double __complex__ z) { - return __imag__(z); -} +DEVICE_EXTERN_C +double __devicelib_creal(double __complex__ z) { return __real__(z); } + +DEVICE_EXTERN_C +double __devicelib_cimag(double __complex__ z) { return __imag__(z); } // __muldc3 // Returns: the product of a + ib and c + id -SYCL_EXTERNAL -double __complex__ __devicelib___muldc3(double __a, double __b, - double __c, double __d) { +DEVICE_EXTERN_C +double __complex__ __devicelib___muldc3(double __a, double __b, double __c, + double __d) { double __ac = __a * __c; double __bd = __b * __d; double __ad = __a * __d; @@ -74,12 +70,12 @@ double __complex__ __devicelib___muldc3(double __a, double __b, // __divdc3 // Returns: the quotient of (a + ib) / (c + id) -SYCL_EXTERNAL -double __complex__ __devicelib___divdc3(double __a, double __b, - double __c, double __d) { +DEVICE_EXTERN_C +double __complex__ __devicelib___divdc3(double __a, double __b, double __c, + double __d) { int __ilogbw = 0; - double __logbw = __spirv_ocl_logb(__spirv_ocl_fmax(__spirv_ocl_fabs(__c), - __spirv_ocl_fabs(__d))); + double __logbw = __spirv_ocl_logb( + __spirv_ocl_fmax(__spirv_ocl_fabs(__c), __spirv_ocl_fabs(__d))); if (__spirv_IsFinite(__logbw)) { __ilogbw = (int)__logbw; __c = __spirv_ocl_ldexp(__c, -__ilogbw); @@ -87,8 +83,10 @@ double __complex__ __devicelib___divdc3(double __a, double __b, } double __denom = __c * __c + __d * __d; double __complex__ z; - double z_real = __spirv_ocl_ldexp((__a*__c+__b*__d) / __denom, -__ilogbw); - double z_imag = __spirv_ocl_ldexp((__b*__c-__a*__d) / __denom, -__ilogbw); + double z_real = + __spirv_ocl_ldexp((__a * __c + __b * __d) / __denom, -__ilogbw); + double z_imag = + __spirv_ocl_ldexp((__b * __c - __a * __d) / __denom, -__ilogbw); z = CMPLX(z_real, z_imag); if (__spirv_IsNan(z_real) && __spirv_IsNan(z_imag)) { if ((__denom == 0.0) && (!__spirv_IsNan(__a) || !__spirv_IsNan(__b))) { @@ -96,16 +94,14 @@ double __complex__ __devicelib___divdc3(double __a, double __b, z_imag = __spirv_ocl_copysign((double)INFINITY, __c) * __b; z = CMPLX(z_real, z_imag); } else if ((__spirv_IsInf(__a) || __spirv_IsInf(__b)) && - __spirv_IsFinite(__c) && - __spirv_IsFinite(__d)) { + __spirv_IsFinite(__c) && __spirv_IsFinite(__d)) { __a = __spirv_ocl_copysign(__spirv_IsInf(__a) ? 1.0 : 0.0, __a); __b = __spirv_ocl_copysign(__spirv_IsInf(__b) ? 1.0 : 0.0, __b); z_real = INFINITY * (__a * __c + __b * __d); z_imag = INFINITY * (__b * __c - __a * __d); z = CMPLX(z_real, z_imag); - } else if (__spirv_IsInf(__logbw) && - __logbw > 0.0 && __spirv_IsFinite(__a) && - __spirv_IsFinite(__b)) { + } else if (__spirv_IsInf(__logbw) && __logbw > 0.0 && + __spirv_IsFinite(__a) && __spirv_IsFinite(__b)) { __c = __spirv_ocl_copysign(__spirv_IsInf(__c) ? 1.0 : 0.0, __c); __d = __spirv_ocl_copysign(__spirv_IsInf(__d) ? 1.0 : 0.0, __d); z_real = 0.0 * (__a * __c + __b * __d); @@ -116,19 +112,17 @@ double __complex__ __devicelib___divdc3(double __a, double __b, return z; } -SYCL_EXTERNAL +DEVICE_EXTERN_C double __devicelib_cabs(double __complex__ z) { - return __spirv_ocl_hypot(__devicelib_creal(z), - __devicelib_cimag(z)); + return __spirv_ocl_hypot(__devicelib_creal(z), __devicelib_cimag(z)); } -SYCL_EXTERNAL +DEVICE_EXTERN_C double __devicelib_carg(double __complex__ z) { - return __spirv_ocl_atan2(__devicelib_cimag(z), - __devicelib_creal(z)); + return __spirv_ocl_atan2(__devicelib_cimag(z), __devicelib_creal(z)); } -SYCL_EXTERNAL +DEVICE_EXTERN_C double __complex__ __devicelib_cproj(double __complex__ z) { double __complex__ r = z; if (__spirv_IsInf(__devicelib_creal(z)) || @@ -137,7 +131,7 @@ double __complex__ __devicelib_cproj(double __complex__ z) { return r; } -SYCL_EXTERNAL +DEVICE_EXTERN_C double __complex__ __devicelib_cexp(double __complex__ z) { double z_imag = __devicelib_cimag(z); double z_real = __devicelib_creal(z); @@ -158,24 +152,22 @@ double __complex__ __devicelib_cexp(double __complex__ z) { (__e * __spirv_ocl_sin(z_imag))); } - -SYCL_EXTERNAL +DEVICE_EXTERN_C double __complex__ __devicelib_clog(double __complex__ z) { return CMPLX(__spirv_ocl_log(__devicelib_cabs(z)), __devicelib_carg(z)); } -SYCL_EXTERNAL +DEVICE_EXTERN_C double __complex__ __devicelib_cpow(double __complex__ x, double __complex__ y) { double __complex__ t = __devicelib_clog(x); - double __complex__ w = __devicelib___muldc3(__devicelib_creal(y), - __devicelib_cimag(y), - __devicelib_creal(t), - __devicelib_cimag(t)); + double __complex__ w = + __devicelib___muldc3(__devicelib_creal(y), __devicelib_cimag(y), + __devicelib_creal(t), __devicelib_cimag(t)); return __devicelib_cexp(w); } -SYCL_EXTERNAL +DEVICE_EXTERN_C double __complex__ __devicelib_cpolar(double rho, double theta) { if (__spirv_IsNan(rho) || __spirv_SignBitSet(rho)) return CMPLX(NAN, NAN); @@ -198,18 +190,17 @@ double __complex__ __devicelib_cpolar(double rho, double theta) { return CMPLX(x, y); } -SYCL_EXTERNAL -double __complex__ __devicelib_csqrt(double __complex__ z) -{ +DEVICE_EXTERN_C +double __complex__ __devicelib_csqrt(double __complex__ z) { double z_real = __devicelib_creal(z); double z_imag = __devicelib_cimag(z); if (__spirv_IsInf(z_imag)) return CMPLX(INFINITY, z_imag); if (__spirv_IsInf(z_real)) { if (z_real > 0.0) - return CMPLX(z_real, - __spirv_IsNan(z_imag) ? z_imag - : __spirv_ocl_copysign(0.0, z_imag)); + return CMPLX(z_real, __spirv_IsNan(z_imag) + ? z_imag + : __spirv_ocl_copysign(0.0, z_imag)); return CMPLX(__spirv_IsNan(z_imag) ? z_imag : 0.0, __spirv_ocl_copysign(z_real, z_imag)); } @@ -217,7 +208,7 @@ double __complex__ __devicelib_csqrt(double __complex__ z) __devicelib_carg(z) / 2.0); } -SYCL_EXTERNAL +DEVICE_EXTERN_C double __complex__ __devicelib_csinh(double __complex__ z) { double z_real = __devicelib_creal(z); double z_imag = __devicelib_cimag(z); @@ -231,7 +222,7 @@ double __complex__ __devicelib_csinh(double __complex__ z) { __spirv_ocl_cosh(z_real) * __spirv_ocl_sin(z_imag)); } -SYCL_EXTERNAL +DEVICE_EXTERN_C double __complex__ __devicelib_ccosh(double __complex__ z) { double z_real = __devicelib_creal(z); double z_imag = __devicelib_cimag(z); @@ -247,7 +238,7 @@ double __complex__ __devicelib_ccosh(double __complex__ z) { __spirv_ocl_sinh(z_real) * __spirv_ocl_sin(z_imag)); } -SYCL_EXTERNAL +DEVICE_EXTERN_C double __complex__ __devicelib_ctanh(double __complex__ z) { double z_real = __devicelib_creal(z); double z_imag = __devicelib_cimag(z); @@ -263,40 +254,37 @@ double __complex__ __devicelib_ctanh(double __complex__ z) { double __d(__spirv_ocl_cosh(__2r) + __spirv_ocl_cos(__2i)); double __2rsh(__spirv_ocl_sinh(__2r)); if (__spirv_IsInf(__2rsh) && __spirv_IsInf(__d)) - return CMPLX(((__2rsh > 0.0) ? 1.0 : -1.0), - ((__2i > 0.0) ? 0.0 : -0.0)); - return CMPLX(__2rsh/__d, __spirv_ocl_sin(__2i)/__d); + return CMPLX(((__2rsh > 0.0) ? 1.0 : -1.0), ((__2i > 0.0) ? 0.0 : -0.0)); + return CMPLX(__2rsh / __d, __spirv_ocl_sin(__2i) / __d); } -SYCL_EXTERNAL +DEVICE_EXTERN_C double __complex__ __devicelib_csin(double __complex__ z) { - double __complex__ w = __devicelib_csinh(CMPLX(-__devicelib_cimag(z), - __devicelib_creal(z))); + double __complex__ w = + __devicelib_csinh(CMPLX(-__devicelib_cimag(z), __devicelib_creal(z))); return CMPLX(__devicelib_cimag(w), -__devicelib_creal(w)); } -SYCL_EXTERNAL +DEVICE_EXTERN_C double __complex__ __devicelib_ccos(double __complex__ z) { - return __devicelib_ccosh(CMPLX(-__devicelib_cimag(z), - __devicelib_creal(z))); + return __devicelib_ccosh(CMPLX(-__devicelib_cimag(z), __devicelib_creal(z))); } -SYCL_EXTERNAL +DEVICE_EXTERN_C double __complex__ __devicelib_ctan(double __complex__ z) { - double __complex__ w = __devicelib_ctanh(CMPLX(-__devicelib_cimag(z), - __devicelib_creal(z))); + double __complex__ w = + __devicelib_ctanh(CMPLX(-__devicelib_cimag(z), __devicelib_creal(z))); return CMPLX(__devicelib_cimag(w), -__devicelib_creal(w)); } -SYCL_EXTERNAL +DEVICE_EXTERN_C double __complex__ __sqr(double __complex__ z) { double z_real = __devicelib_creal(z); double z_imag = __devicelib_cimag(z); - return CMPLX((z_real + z_imag) * (z_real - z_imag), - 2.0 * z_real * z_imag); + return CMPLX((z_real + z_imag) * (z_real - z_imag), 2.0 * z_real * z_imag); } -SYCL_EXTERNAL +DEVICE_EXTERN_C double __complex__ __devicelib_cacos(double __complex__ z) { double z_real = __devicelib_creal(z); double z_imag = __devicelib_cimag(z); @@ -319,11 +307,11 @@ double __complex__ __devicelib_cacos(double __complex__ z) { return CMPLX(z_real, z_real); } if (__spirv_IsInf(z_real)) - return CMPLX(__pi/2.0, -z_real); + return CMPLX(__pi / 2.0, -z_real); if (z_real == 0 && (z_imag == 0 || __spirv_IsNan(z_imag))) - return CMPLX(__pi/2.0, -z_imag); - double __complex__ w = __devicelib_clog(z + - __devicelib_csqrt(__sqr(z) - 1.0)); + return CMPLX(__pi / 2.0, -z_imag); + double __complex__ w = + __devicelib_clog(z + __devicelib_csqrt(__sqr(z) - 1.0)); if (__spirv_SignBitSet(z_imag)) return CMPLX(__spirv_ocl_fabs(__devicelib_cimagf(w)), __spirv_ocl_fabs(__devicelib_creal(w))); @@ -331,7 +319,7 @@ double __complex__ __devicelib_cacos(double __complex__ z) { -__spirv_ocl_fabs(__devicelib_creal(w))); } -SYCL_EXTERNAL +DEVICE_EXTERN_C double __complex__ __devicelib_casinh(double __complex__ z) { double z_real = __devicelib_creal(z); double z_imag = __devicelib_cimag(z); @@ -352,20 +340,21 @@ double __complex__ __devicelib_casinh(double __complex__ z) { } if (__spirv_IsInf(z_imag)) return CMPLX(__spirv_ocl_copysign(z_imag, z_real), - __spirv_ocl_copysign(__pi/2.0, z_imag)); - double __complex__ w = __devicelib_clog(z + __devicelib_csqrt(__sqr(z)+1.0)); + __spirv_ocl_copysign(__pi / 2.0, z_imag)); + double __complex__ w = + __devicelib_clog(z + __devicelib_csqrt(__sqr(z) + 1.0)); return CMPLX(__spirv_ocl_copysign(__devicelib_creal(w), z_real), __spirv_ocl_copysign(__devicelib_cimag(w), z_imag)); } -SYCL_EXTERNAL +DEVICE_EXTERN_C double __complex__ __devicelib_casin(double __complex__ z) { - double __complex__ w = __devicelib_casinh(CMPLX(-__devicelib_cimag(z), - __devicelib_creal(z))); + double __complex__ w = + __devicelib_casinh(CMPLX(-__devicelib_cimag(z), __devicelib_creal(z))); return CMPLX(__devicelib_cimag(w), -__devicelib_creal(w)); } -SYCL_EXTERNAL +DEVICE_EXTERN_C double __complex__ __devicelib_cacosh(double __complex__ z) { double z_real = __devicelib_creal(z); double z_imag = __devicelib_cimag(z); @@ -389,20 +378,22 @@ double __complex__ __devicelib_cacosh(double __complex__ z) { return CMPLX(z_real, z_real); } if (__spirv_IsInf(z_imag)) - return CMPLX(__spirv_ocl_fabs(z_imag), __spirv_ocl_copysign(__pi/2.0, z_imag)); - double __complex__ w = __devicelib_clog(z + __devicelib_csqrt(__sqr(z) - 1.0)); + return CMPLX(__spirv_ocl_fabs(z_imag), + __spirv_ocl_copysign(__pi / 2.0, z_imag)); + double __complex__ w = + __devicelib_clog(z + __devicelib_csqrt(__sqr(z) - 1.0)); return CMPLX(__spirv_ocl_copysign(__devicelib_creal(w), 0.0), __spirv_ocl_copysign(__devicelib_cimag(w), z_imag)); } -SYCL_EXTERNAL +DEVICE_EXTERN_C double __complex__ __devicelib_catanh(double __complex__ z) { double z_real = __devicelib_creal(z); double z_imag = __devicelib_cimag(z); const double __pi(__spirv_ocl_atan2(+0.0, -0.0)); if (__spirv_IsInf(z_imag)) return CMPLX(__spirv_ocl_copysign(0.0, z_real), - __spirv_ocl_copysign(__pi/2.0, z_imag)); + __spirv_ocl_copysign(__pi / 2.0, z_imag)); if (__spirv_IsNan(z_imag)) { if (__spirv_IsInf(z_real) || z_real == 0) return CMPLX(__spirv_ocl_copysign(0.0, z_real), z_imag); @@ -412,27 +403,23 @@ double __complex__ __devicelib_catanh(double __complex__ z) { return CMPLX(z_real, z_real); if (__spirv_IsInf(z_real)) return CMPLX(__spirv_ocl_copysign(0.0, z_real), - __spirv_ocl_copysign(__pi/2.0, z_imag)); + __spirv_ocl_copysign(__pi / 2.0, z_imag)); if (__spirv_ocl_fabs(z_real) == 1.0 && z_imag == 0.0) return CMPLX(__spirv_ocl_copysign(static_cast(INFINITY), z_real), __spirv_ocl_copysign(0.0, z_imag)); double __complex__ t1 = 1.0 + z; double __complex__ t2 = 1.0 - z; - double __complex__ t3 = __devicelib___divdc3(__devicelib_creal(t1), - __devicelib_cimag(t1), - __devicelib_creal(t2), - __devicelib_cimag(t2)); + double __complex__ t3 = + __devicelib___divdc3(__devicelib_creal(t1), __devicelib_cimag(t1), + __devicelib_creal(t2), __devicelib_cimag(t2)); double __complex__ w = __devicelib_clog(t3) / 2.0; return CMPLX(__spirv_ocl_copysign(__devicelib_creal(w), z_real), __spirv_ocl_copysign(__devicelib_cimag(w), z_imag)); } -SYCL_EXTERNAL +DEVICE_EXTERN_C double __complex__ __devicelib_catan(double __complex__ z) { - double __complex__ w = __devicelib_catanh(CMPLX(-__devicelib_cimag(z), - __devicelib_creal(z))); + double __complex__ w = + __devicelib_catanh(CMPLX(-__devicelib_cimag(z), __devicelib_creal(z))); return CMPLX(__devicelib_cimag(w), -__devicelib_creal(w)); } - -} // extern "C" -#endif diff --git a/sycl/source/detail/devicelib/fallback-complex.cpp b/libdevice/fallback-complex.cpp similarity index 75% rename from sycl/source/detail/devicelib/fallback-complex.cpp rename to libdevice/fallback-complex.cpp index bb0620c3af6d0..e83856dd469cf 100644 --- a/sycl/source/detail/devicelib/fallback-complex.cpp +++ b/libdevice/fallback-complex.cpp @@ -1,30 +1,26 @@ -//==----- fallback-complex.cpp - complex math functions for SYCL device ----==// +//==----- fallback-complex.cpp - complex math functions for SPIR-V device --==// // // 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 __SYCL_DEVICE_ONLY__ -#include "device_math.h" + #include "device_complex.h" +#include "device_math.h" #include -extern "C" { -SYCL_EXTERNAL -float __devicelib_crealf(float __complex__ z) { - return __real__(z); -} -SYCL_EXTERNAL -float __devicelib_cimagf(float __complex__ z) { - return __imag__(z); -} +DEVICE_EXTERN_C +float __devicelib_crealf(float __complex__ z) { return __real__(z); } + +DEVICE_EXTERN_C +float __devicelib_cimagf(float __complex__ z) { return __imag__(z); } // __mulsc3 // Returns: the product of a + ib and c + id -SYCL_EXTERNAL -float __complex__ __devicelib___mulsc3(float __a, float __b, - float __c, float __d) { +DEVICE_EXTERN_C +float __complex__ __devicelib___mulsc3(float __a, float __b, float __c, + float __d) { float __ac = __a * __c; float __bd = __b * __d; float __ad = __a * __d; @@ -76,12 +72,12 @@ float __complex__ __devicelib___mulsc3(float __a, float __b, // Returns: the quotient of (a + ib) / (c + id) // FIXME: divsc3/divdc3 have overflow issue when dealing with large number. // And this overflow issue is from libc++/compiler-rt's implementation. -SYCL_EXTERNAL -float __complex__ __devicelib___divsc3(float __a, float __b, - float __c, float __d) { +DEVICE_EXTERN_C +float __complex__ __devicelib___divsc3(float __a, float __b, float __c, + float __d) { int __ilogbw = 0; - float __logbw = __spirv_ocl_logb(__spirv_ocl_fmax(__spirv_ocl_fabs(__c), - __spirv_ocl_fabs(__d))); + float __logbw = __spirv_ocl_logb( + __spirv_ocl_fmax(__spirv_ocl_fabs(__c), __spirv_ocl_fabs(__d))); if (__spirv_IsFinite(__logbw)) { __ilogbw = (int)__logbw; __c = __spirv_ocl_ldexp(__c, -__ilogbw); @@ -89,8 +85,10 @@ float __complex__ __devicelib___divsc3(float __a, float __b, } float __denom = __c * __c + __d * __d; float __complex__ z; - float z_real = __spirv_ocl_ldexp((__a *__c+__b*__d) / __denom, -__ilogbw); - float z_imag = __spirv_ocl_ldexp((__b *__c-__a*__d) / __denom, -__ilogbw); + float z_real = + __spirv_ocl_ldexp((__a * __c + __b * __d) / __denom, -__ilogbw); + float z_imag = + __spirv_ocl_ldexp((__b * __c - __a * __d) / __denom, -__ilogbw); z = CMPLXF(z_real, z_imag); if (__spirv_IsNan(z_real) && __spirv_IsNan(z_imag)) { if ((__denom == 0.0f) && (!__spirv_IsNan(__a) || !__spirv_IsNan(__b))) { @@ -98,16 +96,14 @@ float __complex__ __devicelib___divsc3(float __a, float __b, z_imag = __spirv_ocl_copysign(INFINITY, __c) * __b; z = CMPLXF(z_real, z_imag); } else if ((__spirv_IsInf(__a) || __spirv_IsInf(__b)) && - __spirv_IsFinite(__c) && - __spirv_IsFinite(__d)) { + __spirv_IsFinite(__c) && __spirv_IsFinite(__d)) { __a = __spirv_ocl_copysign(__spirv_IsInf(__a) ? 1.0f : 0.0f, __a); __b = __spirv_ocl_copysign(__spirv_IsInf(__b) ? 1.0f : 0.0f, __b); z_real = INFINITY * (__a * __c + __b * __d); z_imag = INFINITY * (__b * __c - __a * __d); z = CMPLXF(z_real, z_imag); } else if (__spirv_IsInf(__logbw) && __logbw > 0.0f && - __spirv_IsFinite(__a) && - __spirv_IsFinite(__b)) { + __spirv_IsFinite(__a) && __spirv_IsFinite(__b)) { __c = __spirv_ocl_copysign(__spirv_IsInf(__c) ? 1.0f : 0.0f, __c); __d = __spirv_ocl_copysign(__spirv_IsInf(__d) ? 1.0f : 0.0f, __d); z_real = 0.0f * (__a * __c + __b * __d); @@ -118,19 +114,17 @@ float __complex__ __devicelib___divsc3(float __a, float __b, return z; } -SYCL_EXTERNAL +DEVICE_EXTERN_C float __devicelib_cargf(float __complex__ z) { - return __spirv_ocl_atan2(__devicelib_cimagf(z), - __devicelib_crealf(z)); + return __spirv_ocl_atan2(__devicelib_cimagf(z), __devicelib_crealf(z)); } -SYCL_EXTERNAL +DEVICE_EXTERN_C float __devicelib_cabsf(float __complex__ z) { - return __spirv_ocl_hypot(__devicelib_crealf(z), - __devicelib_cimagf(z)); + return __spirv_ocl_hypot(__devicelib_crealf(z), __devicelib_cimagf(z)); } -SYCL_EXTERNAL +DEVICE_EXTERN_C float __complex__ __devicelib_cprojf(float __complex__ z) { float __complex__ r = z; if (__spirv_IsInf(__devicelib_crealf(z)) || @@ -139,7 +133,7 @@ float __complex__ __devicelib_cprojf(float __complex__ z) { return r; } -SYCL_EXTERNAL +DEVICE_EXTERN_C float __complex__ __devicelib_cexpf(float __complex__ z) { float z_imag = __devicelib_cimagf(z); float z_real = __devicelib_crealf(z); @@ -160,23 +154,21 @@ float __complex__ __devicelib_cexpf(float __complex__ z) { (__e * __spirv_ocl_sin(z_imag))); } -SYCL_EXTERNAL +DEVICE_EXTERN_C float __complex__ __devicelib_clogf(float __complex__ z) { return CMPLXF(__spirv_ocl_log(__devicelib_cabsf(z)), __devicelib_cargf(z)); } -SYCL_EXTERNAL -float __complex__ __devicelib_cpowf(float __complex__ x, - float __complex__ y) { +DEVICE_EXTERN_C +float __complex__ __devicelib_cpowf(float __complex__ x, float __complex__ y) { float __complex__ t = __devicelib_clogf(x); - float __complex__ w = __devicelib___mulsc3(__devicelib_crealf(y), - __devicelib_cimagf(y), - __devicelib_crealf(t), - __devicelib_cimagf(t)); + float __complex__ w = + __devicelib___mulsc3(__devicelib_crealf(y), __devicelib_cimagf(y), + __devicelib_crealf(t), __devicelib_cimagf(t)); return __devicelib_cexpf(w); } -SYCL_EXTERNAL +DEVICE_EXTERN_C float __complex__ __devicelib_cpolarf(float rho, float theta) { if (__spirv_IsNan(rho) || __spirv_SignBitSet(rho)) return CMPLXF(NAN, NAN); @@ -199,18 +191,17 @@ float __complex__ __devicelib_cpolarf(float rho, float theta) { return CMPLXF(x, y); } -SYCL_EXTERNAL -float __complex__ __devicelib_csqrtf(float __complex__ z) -{ +DEVICE_EXTERN_C +float __complex__ __devicelib_csqrtf(float __complex__ z) { float z_real = __devicelib_crealf(z); float z_imag = __devicelib_cimagf(z); if (__spirv_IsInf(z_imag)) return CMPLXF(INFINITY, z_imag); if (__spirv_IsInf(z_real)) { if (z_real > 0.0f) - return CMPLXF(z_real, - __spirv_IsNan(z_imag) ? z_imag - : __spirv_ocl_copysign(0.0f, z_imag)); + return CMPLXF(z_real, __spirv_IsNan(z_imag) + ? z_imag + : __spirv_ocl_copysign(0.0f, z_imag)); return CMPLXF(__spirv_IsNan(z_imag) ? z_imag : 0.0f, __spirv_ocl_copysign(z_real, z_imag)); } @@ -218,7 +209,7 @@ float __complex__ __devicelib_csqrtf(float __complex__ z) __devicelib_cargf(z) / 2.0f); } -SYCL_EXTERNAL +DEVICE_EXTERN_C float __complex__ __devicelib_csinhf(float __complex__ z) { float z_real = __devicelib_crealf(z); float z_imag = __devicelib_cimagf(z); @@ -232,7 +223,7 @@ float __complex__ __devicelib_csinhf(float __complex__ z) { __spirv_ocl_cosh(z_real) * __spirv_ocl_sin(z_imag)); } -SYCL_EXTERNAL +DEVICE_EXTERN_C float __complex__ __devicelib_ccoshf(float __complex__ z) { float z_real = __devicelib_crealf(z); float z_imag = __devicelib_cimagf(z); @@ -248,15 +239,15 @@ float __complex__ __devicelib_ccoshf(float __complex__ z) { __spirv_ocl_sinh(z_real) * __spirv_ocl_sin(z_imag)); } -SYCL_EXTERNAL +DEVICE_EXTERN_C float __complex__ __devicelib_ctanhf(float __complex__ z) { float z_real = __devicelib_crealf(z); float z_imag = __devicelib_cimagf(z); if (__spirv_IsInf(z_real)) { if (!__spirv_IsFinite(z_imag)) return CMPLXF(1.0f, 0.0f); - return CMPLXF(1.0f, __spirv_ocl_copysign(0.0f, - __spirv_ocl_sin(2.0f * z_imag))); + return CMPLXF(1.0f, + __spirv_ocl_copysign(0.0f, __spirv_ocl_sin(2.0f * z_imag))); } if (__spirv_IsNan(z_real) && z_imag == 0) return z; @@ -267,38 +258,37 @@ float __complex__ __devicelib_ctanhf(float __complex__ z) { if (__spirv_IsInf(__2rsh) && __spirv_IsInf(__d)) return CMPLXF(((__2rsh > 0.0f) ? 1.0f : -1.0f), ((__2i > 0.0f) ? 0.0f : -0.0f)); - return CMPLXF(__2rsh/__d, __spirv_ocl_sin(__2i)/__d); + return CMPLXF(__2rsh / __d, __spirv_ocl_sin(__2i) / __d); } -SYCL_EXTERNAL +DEVICE_EXTERN_C float __complex__ __devicelib_csinf(float __complex__ z) { - float __complex__ w = __devicelib_csinhf(CMPLXF(-__devicelib_cimagf(z), - __devicelib_crealf(z))); + float __complex__ w = + __devicelib_csinhf(CMPLXF(-__devicelib_cimagf(z), __devicelib_crealf(z))); return CMPLXF(__devicelib_cimagf(w), -__devicelib_crealf(w)); } -SYCL_EXTERNAL +DEVICE_EXTERN_C float __complex__ __devicelib_ccosf(float __complex__ z) { - return __devicelib_ccoshf(CMPLXF(-__devicelib_cimagf(z), - __devicelib_crealf(z))); + return __devicelib_ccoshf( + CMPLXF(-__devicelib_cimagf(z), __devicelib_crealf(z))); } -SYCL_EXTERNAL +DEVICE_EXTERN_C float __complex__ __devicelib_ctanf(float __complex__ z) { - float __complex__ w = __devicelib_ctanhf(CMPLXF(-__devicelib_cimagf(z), - __devicelib_crealf(z))); + float __complex__ w = + __devicelib_ctanhf(CMPLXF(-__devicelib_cimagf(z), __devicelib_crealf(z))); return CMPLXF(__devicelib_cimagf(w), -__devicelib_crealf(w)); } -SYCL_EXTERNAL +DEVICE_EXTERN_C float __complex__ __sqrf(float __complex__ z) { float z_real = __devicelib_crealf(z); float z_imag = __devicelib_cimagf(z); - return CMPLXF((z_real + z_imag) * (z_real - z_imag), - 2.0 * z_real * z_imag); + return CMPLXF((z_real + z_imag) * (z_real - z_imag), 2.0 * z_real * z_imag); } -SYCL_EXTERNAL +DEVICE_EXTERN_C float __complex__ __devicelib_cacosf(float __complex__ z) { float z_real = __devicelib_crealf(z); float z_imag = __devicelib_cimagf(z); @@ -321,11 +311,11 @@ float __complex__ __devicelib_cacosf(float __complex__ z) { return CMPLXF(z_real, z_real); } if (__spirv_IsInf(z_imag)) - return CMPLXF(__pi/2.0f, -z_imag); + return CMPLXF(__pi / 2.0f, -z_imag); if (z_real == 0 && (z_imag == 0 || __spirv_IsNan(z_imag))) - return CMPLXF(__pi/2.0f, -z_imag); - float __complex__ w = __devicelib_clogf(z + - __devicelib_csqrtf(__sqrf(z) - 1.0f)); + return CMPLXF(__pi / 2.0f, -z_imag); + float __complex__ w = + __devicelib_clogf(z + __devicelib_csqrtf(__sqrf(z) - 1.0f)); if (__spirv_SignBitSet(z_imag)) return CMPLXF(__spirv_ocl_fabs(__devicelib_cimagf(w)), __spirv_ocl_fabs(__devicelib_crealf(w))); @@ -333,7 +323,7 @@ float __complex__ __devicelib_cacosf(float __complex__ z) { -__spirv_ocl_fabs(__devicelib_crealf(w))); } -SYCL_EXTERNAL +DEVICE_EXTERN_C float __complex__ __devicelib_casinhf(float __complex__ z) { float z_real = __devicelib_crealf(z); float z_imag = __devicelib_cimagf(z); @@ -354,21 +344,21 @@ float __complex__ __devicelib_casinhf(float __complex__ z) { } if (__spirv_IsInf(z_imag)) return CMPLXF(__spirv_ocl_copysign(z_imag, z_real), - __spirv_ocl_copysign(__pi/2.0f, z_imag)); - float __complex__ w = __devicelib_clogf(z + - __devicelib_csqrtf(__sqrf(z) + 1.0f)); + __spirv_ocl_copysign(__pi / 2.0f, z_imag)); + float __complex__ w = + __devicelib_clogf(z + __devicelib_csqrtf(__sqrf(z) + 1.0f)); return CMPLXF(__spirv_ocl_copysign(__devicelib_crealf(w), z_real), __spirv_ocl_copysign(__devicelib_cimagf(w), z_imag)); } -SYCL_EXTERNAL +DEVICE_EXTERN_C float __complex__ __devicelib_casinf(float __complex__ z) { - float __complex__ w = __devicelib_casinhf(CMPLXF(-__devicelib_cimagf(z), - __devicelib_crealf(z))); + float __complex__ w = __devicelib_casinhf( + CMPLXF(-__devicelib_cimagf(z), __devicelib_crealf(z))); return CMPLXF(__devicelib_cimagf(w), -__devicelib_crealf(w)); } -SYCL_EXTERNAL +DEVICE_EXTERN_C float __complex__ __devicelib_cacoshf(float __complex__ z) { float z_real = __devicelib_crealf(z); float z_imag = __devicelib_cimagf(z); @@ -392,20 +382,22 @@ float __complex__ __devicelib_cacoshf(float __complex__ z) { return CMPLXF(z_real, z_real); } if (__spirv_IsInf(z_imag)) - return CMPLXF(__spirv_ocl_fabs(z_imag), __spirv_ocl_copysign(__pi/2.0f, z_imag)); - float __complex__ w = __devicelib_clogf(z + __devicelib_csqrtf(__sqrf(z) - 1.0f)); + return CMPLXF(__spirv_ocl_fabs(z_imag), + __spirv_ocl_copysign(__pi / 2.0f, z_imag)); + float __complex__ w = + __devicelib_clogf(z + __devicelib_csqrtf(__sqrf(z) - 1.0f)); return CMPLXF(__spirv_ocl_copysign(__devicelib_crealf(w), 0.0f), __spirv_ocl_copysign(__devicelib_cimagf(w), z_imag)); } -SYCL_EXTERNAL +DEVICE_EXTERN_C float __complex__ __devicelib_catanhf(float __complex__ z) { float z_real = __devicelib_crealf(z); float z_imag = __devicelib_cimagf(z); const float __pi(__spirv_ocl_atan2(+0.0f, -0.0f)); if (__spirv_IsInf(z_imag)) return CMPLXF(__spirv_ocl_copysign(0.0f, z_real), - __spirv_ocl_copysign(__pi/2.0f, z_imag)); + __spirv_ocl_copysign(__pi / 2.0f, z_imag)); if (__spirv_IsNan(z_imag)) { if (__spirv_IsInf(z_real) || z_real == 0) return CMPLXF(__spirv_ocl_copysign(0.0f, z_real), z_imag); @@ -415,27 +407,23 @@ float __complex__ __devicelib_catanhf(float __complex__ z) { return CMPLXF(z_real, z_real); if (__spirv_IsInf(z_real)) return CMPLXF(__spirv_ocl_copysign(0.0f, z_real), - __spirv_ocl_copysign(__pi/2.0f, z_imag)); + __spirv_ocl_copysign(__pi / 2.0f, z_imag)); if (__spirv_ocl_fabs(z_real) == 1.0f && z_imag == 0.0f) return CMPLXF(__spirv_ocl_copysign(INFINITY, z_real), __spirv_ocl_copysign(0.0f, z_imag)); float __complex__ t1 = 1.0f + z; float __complex__ t2 = 1.0f - z; - float __complex__ t3 = __devicelib___divsc3(__devicelib_crealf(t1), - __devicelib_cimagf(t1), - __devicelib_crealf(t2), - __devicelib_cimagf(t2)); + float __complex__ t3 = + __devicelib___divsc3(__devicelib_crealf(t1), __devicelib_cimagf(t1), + __devicelib_crealf(t2), __devicelib_cimagf(t2)); float __complex__ w = __devicelib_clogf(t3) / 2.0f; return CMPLXF(__spirv_ocl_copysign(__devicelib_crealf(w), z_real), __spirv_ocl_copysign(__devicelib_cimagf(w), z_imag)); } -SYCL_EXTERNAL +DEVICE_EXTERN_C float __complex__ __devicelib_catanf(float __complex__ z) { - float __complex__ w = __devicelib_catanhf(CMPLXF(-__devicelib_cimagf(z), - __devicelib_crealf(z))); + float __complex__ w = __devicelib_catanhf( + CMPLXF(-__devicelib_cimagf(z), __devicelib_crealf(z))); return CMPLXF(__devicelib_cimagf(w), -__devicelib_crealf(w)); } - -} // extern "C" -#endif diff --git a/libdevice/glibc_wrapper.cpp b/libdevice/glibc_wrapper.cpp new file mode 100644 index 0000000000000..1d0d1e4fa694d --- /dev/null +++ b/libdevice/glibc_wrapper.cpp @@ -0,0 +1,20 @@ +//==--- glibc_wrapper.cpp - wrappers for Glibc internal functions ----------==// +// +// 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 "device.h" +#include "wrapper.h" + +DEVICE_EXTERN_C +void __assert_fail(const char *expr, const char *file, unsigned int line, + const char *func) { + __devicelib_assert_fail( + expr, file, line, func, __spirv_GlobalInvocationId_x(), + __spirv_GlobalInvocationId_y(), __spirv_GlobalInvocationId_z(), + __spirv_LocalInvocationId_x(), __spirv_LocalInvocationId_y(), + __spirv_LocalInvocationId_z()); +} diff --git a/sycl/source/detail/devicelib/msvc_wrapper.cpp b/libdevice/msvc_wrapper.cpp similarity index 64% rename from sycl/source/detail/devicelib/msvc_wrapper.cpp rename to libdevice/msvc_wrapper.cpp index 686f504169d4e..61f357d8899fd 100644 --- a/sycl/source/detail/devicelib/msvc_wrapper.cpp +++ b/libdevice/msvc_wrapper.cpp @@ -6,12 +6,9 @@ // //===----------------------------------------------------------------------===// -#ifdef __SYCL_DEVICE_ONLY__ +#include "device.h" #include "wrapper.h" -#include // for __spirv_BuiltInGlobalInvocationId, - // __spirv_BuiltInLocalInvocationId - // Truncates a wide (16 or 32 bit) string (wstr) into an ASCII string (str). // Any non-ASCII characters are replaced by question mark '?'. static void __truncate_wchar_char_str(const wchar_t *wstr, char *str, @@ -25,7 +22,7 @@ static void __truncate_wchar_char_str(const wchar_t *wstr, char *str, *str = '\0'; } -extern "C" SYCL_EXTERNAL +DEVICE_EXTERN_C void _wassert(const wchar_t *wexpr, const wchar_t *wfile, unsigned line) { // Paths and expressions that are longer than 256 characters are going to be // truncated. @@ -34,12 +31,9 @@ void _wassert(const wchar_t *wexpr, const wchar_t *wfile, unsigned line) { char expr[256]; __truncate_wchar_char_str(wexpr, expr, sizeof(expr)); - __devicelib_assert_fail(expr, file, line, /*func=*/nullptr, - __spirv_GlobalInvocationId_x(), - __spirv_GlobalInvocationId_y(), - __spirv_GlobalInvocationId_z(), - __spirv_LocalInvocationId_x(), - __spirv_LocalInvocationId_y(), - __spirv_LocalInvocationId_z()); + __devicelib_assert_fail( + expr, file, line, /*func=*/nullptr, __spirv_GlobalInvocationId_x(), + __spirv_GlobalInvocationId_y(), __spirv_GlobalInvocationId_z(), + __spirv_LocalInvocationId_x(), __spirv_LocalInvocationId_y(), + __spirv_LocalInvocationId_z()); } -#endif // __SYCL_DEVICE_ONLY__ diff --git a/libdevice/wrapper.h b/libdevice/wrapper.h new file mode 100644 index 0000000000000..e91a47d5fd3c3 --- /dev/null +++ b/libdevice/wrapper.h @@ -0,0 +1,33 @@ +//==--- wrapper.h - declarations for devicelib functions -----*- C++ -*-----==// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +#ifndef __LIBDEVICE_WRAPPER_H__ +#define __LIBDEVICE_WRAPPER_H__ + +#include "device.h" +#include +#include + +DEVICE_EXTERNAL size_t __spirv_GlobalInvocationId_x(); +DEVICE_EXTERNAL size_t __spirv_GlobalInvocationId_y(); +DEVICE_EXTERNAL size_t __spirv_GlobalInvocationId_z(); + +DEVICE_EXTERNAL size_t __spirv_LocalInvocationId_x(); +DEVICE_EXTERNAL size_t __spirv_LocalInvocationId_y(); +DEVICE_EXTERNAL size_t __spirv_LocalInvocationId_z(); + +DEVICE_EXTERNAL int +__spirv_ocl_printf(const __attribute__((opencl_constant)) char *fmt, ...); + +DEVICE_EXTERN_C +void __devicelib_assert_fail(const char *expr, const char *file, int32_t line, + const char *func, uint64_t gid0, uint64_t gid1, + uint64_t gid2, uint64_t lid0, uint64_t lid1, + uint64_t lid2); + +#endif // __LIBDEVICE_WRAPPER_H__ diff --git a/sycl/CMakeLists.txt b/sycl/CMakeLists.txt index 4a311d271cdb3..c41be541e6497 100644 --- a/sycl/CMakeLists.txt +++ b/sycl/CMakeLists.txt @@ -228,6 +228,13 @@ if (SYCL_ENABLE_XPTI_TRACING) endif() endif() +# Enable new IN_LIST operator. +cmake_policy(SET CMP0057 NEW) + +if (libdevice IN_LIST LLVM_ENABLE_PROJECTS) + add_dependencies(sycl-toolchain libsycldevice) +endif() + if (NOT DEFINED LLVM_INCLUDE_TESTS) set(LLVM_INCLUDE_TESTS ON) endif() @@ -270,6 +277,7 @@ set( SYCL_TOOLCHAIN_DEPLOY_COMPONENTS sycl-headers-extras sycl pi_opencl + libsycldevice ) diff --git a/sycl/source/CMakeLists.txt b/sycl/source/CMakeLists.txt index 8c64509b4e0e6..ef94f3c4ec837 100644 --- a/sycl/source/CMakeLists.txt +++ b/sycl/source/CMakeLists.txt @@ -185,4 +185,3 @@ install(TARGETS ${SYCL_RT_LIBS} ARCHIVE DESTINATION "lib${LLVM_LIBDIR_SUFFIX}" COMPONENT sycl LIBRARY DESTINATION "lib${LLVM_LIBDIR_SUFFIX}" COMPONENT sycl RUNTIME DESTINATION "bin" COMPONENT sycl) -add_subdirectory(detail/devicelib) diff --git a/sycl/source/detail/devicelib/cmath_wrapper.cpp b/sycl/source/detail/devicelib/cmath_wrapper.cpp deleted file mode 100644 index b76a103c80359..0000000000000 --- a/sycl/source/detail/devicelib/cmath_wrapper.cpp +++ /dev/null @@ -1,211 +0,0 @@ -//==--- cmath_wrapper.cpp - wrappers for C math library functions ----------==// -// -// 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 __SYCL_DEVICE_ONLY__ -#include "device_math.h" -extern "C" { -SYCL_EXTERNAL -float __attribute__((weak)) scalbnf(float x, int n) { - return __devicelib_scalbnf(x, n); -} - -SYCL_EXTERNAL -float __attribute__((weak)) logf(float x) { - return __devicelib_logf(x); -} - -SYCL_EXTERNAL -float __attribute__((weak)) expf(float x) { - return __devicelib_expf(x); -} - -SYCL_EXTERNAL -float __attribute__((weak)) frexpf(float x, int *exp) { - return __devicelib_frexpf(x, exp); -} - -SYCL_EXTERNAL -float __attribute__((weak)) ldexpf(float x, int exp) { - return __devicelib_ldexpf(x, exp); -} - -SYCL_EXTERNAL -float __attribute__((weak)) log10f(float x) { - return __devicelib_log10f(x); -} - -SYCL_EXTERNAL -float __attribute__((weak)) modff(float x, float *intpart) { - return __devicelib_modff(x, intpart); -} - -SYCL_EXTERNAL -float __attribute__((weak)) exp2f(float x) { - return __devicelib_exp2f(x); -} - -SYCL_EXTERNAL -float __attribute__((weak)) expm1f(float x) { - return __devicelib_expm1f(x); -} - -SYCL_EXTERNAL -int __attribute__((weak)) ilogbf(float x) { - return __devicelib_ilogbf(x); -} - -SYCL_EXTERNAL -float __attribute__((weak)) log1pf(float x) { - return __devicelib_log1pf(x); -} - -SYCL_EXTERNAL -float __attribute__((weak)) log2f(float x) { - return __devicelib_log2f(x); -} - -SYCL_EXTERNAL -float __attribute__((weak)) logbf(float x) { - return __devicelib_logbf(x); -} - -SYCL_EXTERNAL -float __attribute__((weak)) sqrtf(float x) { - return __devicelib_sqrtf(x); -} - -SYCL_EXTERNAL -float __attribute__((weak)) cbrtf(float x) { - return __devicelib_cbrtf(x); -} - -SYCL_EXTERNAL -float __attribute__((weak)) hypotf(float x, float y) { - return __devicelib_hypotf(x, y); -} - -SYCL_EXTERNAL -float __attribute__((weak)) erff(float x) { - return __devicelib_erff(x); -} - -SYCL_EXTERNAL -float __attribute__((weak)) erfcf(float x) { - return __devicelib_erfcf(x); -} - -SYCL_EXTERNAL -float __attribute__((weak)) tgammaf(float x) { - return __devicelib_tgammaf(x); -} - -SYCL_EXTERNAL -float __attribute__((weak)) lgammaf(float x) { - return __devicelib_lgammaf(x); -} - -SYCL_EXTERNAL -float __attribute__((weak)) fmodf(float x, float y) { - return __devicelib_fmodf(x, y); -} - -SYCL_EXTERNAL -float __attribute__((weak)) remainderf(float x, float y) { - return __devicelib_remainderf(x, y); -} - -SYCL_EXTERNAL -float __attribute__((weak)) remquof(float x, float y, int *q) { - return __devicelib_remquof(x, y, q); -} - -SYCL_EXTERNAL -float __attribute__((weak)) nextafterf(float x, float y) { - return __devicelib_nextafterf(x, y); -} - -SYCL_EXTERNAL -float __attribute__((weak)) fdimf(float x, float y) { - return __devicelib_fdimf(x, y); -} - -SYCL_EXTERNAL -float __attribute__((weak)) fmaf(float x, float y, float z) { - return __devicelib_fmaf(x, y, z); -} - -SYCL_EXTERNAL -float __attribute__((weak)) sinf(float x) { - return __devicelib_sinf(x); -} - -SYCL_EXTERNAL -float __attribute__((weak)) cosf(float x) { - return __devicelib_cosf(x); -} - -SYCL_EXTERNAL -float __attribute__((weak)) tanf(float x) { - return __devicelib_tanf(x); -} - -SYCL_EXTERNAL -float __attribute__((weak)) powf(float x, float y) { - return __devicelib_powf(x, y); -} - -SYCL_EXTERNAL -float __attribute__ ((weak)) acosf(float x) { - return __devicelib_acosf(x); -} - -SYCL_EXTERNAL -float __attribute__((weak)) asinf(float x) { - return __devicelib_asinf(x); -} - -SYCL_EXTERNAL -float __attribute__((weak)) atanf(float x) { - return __devicelib_atanf(x); -} - -SYCL_EXTERNAL -float __attribute__((weak)) atan2f(float x, float y) { - return __devicelib_atan2f(x, y); -} - -SYCL_EXTERNAL -float __attribute__((weak)) coshf(float x) { - return __devicelib_coshf(x); -} - -SYCL_EXTERNAL -float __attribute__((weak)) sinhf(float x) { - return __devicelib_sinhf(x); -} - -SYCL_EXTERNAL -float __attribute__((weak)) tanhf(float x) { - return __devicelib_tanhf(x); -} - -SYCL_EXTERNAL -float __attribute__((weak)) acoshf(float x) { - return __devicelib_acoshf(x); -} - -SYCL_EXTERNAL -float __attribute__((weak)) asinhf(float x) { - return __devicelib_asinhf(x); -} - -SYCL_EXTERNAL -float __attribute__((weak)) atanhf(float x) { - return __devicelib_atanhf(x); -} -} -#endif diff --git a/sycl/source/detail/devicelib/cmath_wrapper_fp64.cpp b/sycl/source/detail/devicelib/cmath_wrapper_fp64.cpp deleted file mode 100644 index 87665aa727388..0000000000000 --- a/sycl/source/detail/devicelib/cmath_wrapper_fp64.cpp +++ /dev/null @@ -1,210 +0,0 @@ -//==--- cmath_wrapper.cpp - wrappers for C math library functions ----------==// -// -// 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 __SYCL_DEVICE_ONLY__ -#include "device_math.h" -extern "C" { -// All exported functions in math and complex device libraries are weak -// reference. If users provide their own math or complex functions(with -// the prototype), functions in device libraries will be ignored and -// overrided by users' version. -SYCL_EXTERNAL -double __attribute__((weak)) log(double x) { - return __devicelib_log(x); -} - -SYCL_EXTERNAL -double __attribute__((weak)) exp(double x) { - return __devicelib_exp(x); -} - -SYCL_EXTERNAL -double __attribute__((weak)) frexp(double x, int *exp) { - return __devicelib_frexp(x, exp); -} - -SYCL_EXTERNAL -double __attribute__((weak)) ldexp(double x, int exp) { - return __devicelib_ldexp(x, exp); -} - -SYCL_EXTERNAL -double __attribute__((weak)) log10(double x) { - return __devicelib_log10(x); -} - -SYCL_EXTERNAL -double __attribute__((weak)) modf(double x, double *intpart) { - return __devicelib_modf(x, intpart); -} - -SYCL_EXTERNAL -double __attribute__((weak)) exp2(double x) { - return __devicelib_exp2(x); -} - -SYCL_EXTERNAL -double __attribute__((weak)) expm1(double x) { - return __devicelib_expm1(x); -} - -SYCL_EXTERNAL -int __attribute__((weak)) ilogb(double x) { - return __devicelib_ilogb(x); -} - -SYCL_EXTERNAL -double __attribute__((weak)) log1p(double x) { - return __devicelib_log1p(x); -} - -SYCL_EXTERNAL -double __attribute__((weak)) log2(double x) { - return __devicelib_log2(x); -} - -SYCL_EXTERNAL -double __attribute__((weak)) logb(double x) { - return __devicelib_logb(x); -} - -SYCL_EXTERNAL -double __attribute__((weak)) sqrt(double x) { - return __devicelib_sqrt(x); -} - -SYCL_EXTERNAL -double __attribute__((weak)) cbrt(double x) { - return __devicelib_cbrt(x); -} - -SYCL_EXTERNAL -double __attribute__((weak)) hypot(double x, double y) { - return __devicelib_hypot(x, y); -} - -SYCL_EXTERNAL -double __attribute__((weak)) erf(double x) { - return __devicelib_erf(x); -} - -SYCL_EXTERNAL -double __attribute__((weak)) erfc(double x) { - return __devicelib_erfc(x); -} - -SYCL_EXTERNAL -double __attribute__((weak)) tgamma(double x) { - return __devicelib_tgamma(x); -} - -SYCL_EXTERNAL -double __attribute__((weak)) lgamma(double x) { - return __devicelib_lgamma(x); -} - -SYCL_EXTERNAL -double __attribute__((weak)) fmod(double x, double y) { - return __devicelib_fmod(x, y); -} - -SYCL_EXTERNAL -double __attribute__((weak)) remainder(double x, double y) { - return __devicelib_remainder(x, y); -} - -SYCL_EXTERNAL -double __attribute__((weak)) remquo(double x, double y, int *q) { - return __devicelib_remquo(x, y, q); -} - -SYCL_EXTERNAL -double __attribute__((weak)) nextafter(double x, double y) { - return __devicelib_nextafter(x, y); -} - -SYCL_EXTERNAL -double __attribute__((weak)) fdim(double x, double y) { - return __devicelib_fdim(x, y); -} - -SYCL_EXTERNAL -double __attribute__((weak)) fma(double x, double y, double z) { - return __devicelib_fma(x, y, z); -} - -SYCL_EXTERNAL -double __attribute__((weak)) sin(double x) { - return __devicelib_sin(x); -} - -SYCL_EXTERNAL -double __attribute__((weak)) cos(double x) { - return __devicelib_cos(x); -} - -SYCL_EXTERNAL -double __attribute__((weak)) tan(double x) { - return __devicelib_tan(x); -} - -SYCL_EXTERNAL -double __attribute__((weak)) pow(double x, double y) { - return __devicelib_pow(x, y); -} - -SYCL_EXTERNAL -double __attribute__ ((weak)) acos(double x) { - return __devicelib_acos(x); -} - -SYCL_EXTERNAL -double __attribute__((weak)) asin(double x) { - return __devicelib_asin(x); -} - -SYCL_EXTERNAL -double __attribute__((weak)) atan(double x) { - return __devicelib_atan(x); -} - -SYCL_EXTERNAL -double __attribute__((weak)) atan2(double x, double y) { - return __devicelib_atan2(x, y); -} - -SYCL_EXTERNAL -double __attribute__((weak)) cosh(double x) { - return __devicelib_cosh(x); -} - -SYCL_EXTERNAL -double __attribute__((weak)) sinh(double x) { - return __devicelib_sinh(x); -} - -SYCL_EXTERNAL -double __attribute__((weak)) tanh(double x) { - return __devicelib_tanh(x); -} - -SYCL_EXTERNAL -double __attribute__((weak)) acosh(double x) { - return __devicelib_acosh(x); -} - -SYCL_EXTERNAL -double __attribute__((weak)) asinh(double x) { - return __devicelib_asinh(x); -} - -SYCL_EXTERNAL -double __attribute__((weak)) atanh(double x) { - return __devicelib_atanh(x); -} -} -#endif diff --git a/sycl/source/detail/devicelib/complex_wrapper.cpp b/sycl/source/detail/devicelib/complex_wrapper.cpp deleted file mode 100644 index f84874a5ede11..0000000000000 --- a/sycl/source/detail/devicelib/complex_wrapper.cpp +++ /dev/null @@ -1,138 +0,0 @@ -//==--- complex_wrapper.cpp - wrappers for C99 complex math functions ------==// -// -// 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 __SYCL_DEVICE_ONLY__ -#include "device_complex.h" -extern "C" { -SYCL_EXTERNAL -float __attribute__((weak)) cimagf(float __complex__ z) { - return __devicelib_cimagf(z); -} - -SYCL_EXTERNAL -float __attribute__((weak)) crealf(float __complex__ z) { - return __devicelib_crealf(z); -} - -SYCL_EXTERNAL -float __attribute__((weak)) cargf(float __complex__ z) { - return __devicelib_cargf(z); -} - -SYCL_EXTERNAL -float __attribute__((weak)) cabsf(float __complex__ z) { - return __devicelib_cabsf(z); -} - -SYCL_EXTERNAL -float __complex__ __attribute__((weak)) cprojf(float __complex__ z) { - return __devicelib_cprojf(z); -} - -SYCL_EXTERNAL -float __complex__ __attribute__((weak)) cexpf(float __complex__ z) { - return __devicelib_cexpf(z); -} - -SYCL_EXTERNAL -float __complex__ __attribute__((weak)) clogf(float __complex__ z) { - return __devicelib_clogf(z); -} - -SYCL_EXTERNAL -float __complex__ __attribute__((weak)) cpowf(float __complex__ x, - float __complex__ y) { - return __devicelib_cpowf(x, y); -} - -SYCL_EXTERNAL -float __complex__ __attribute__((weak)) cpolarf(float rho, float theta) { - return __devicelib_cpolarf(rho, theta); -} - -SYCL_EXTERNAL -float __complex__ __attribute__((weak)) csqrtf(float __complex__ z) { - return __devicelib_csqrtf(z); -} - -SYCL_EXTERNAL -float __complex__ __attribute__((weak)) csinhf(float __complex__ z) { - return __devicelib_csinhf(z); -} - -SYCL_EXTERNAL -float __complex__ __attribute__((weak)) ccoshf(float __complex__ z) { - return __devicelib_ccoshf(z); -} - -SYCL_EXTERNAL -float __complex__ __attribute__((weak)) ctanhf(float __complex__ z) { - return __devicelib_ctanhf(z); -} - -SYCL_EXTERNAL -float __complex__ __attribute__((weak)) csinf(float __complex__ z) { - return __devicelib_csinf(z); -} - -SYCL_EXTERNAL -float __complex__ __attribute__((weak)) ccosf(float __complex__ z) { - return __devicelib_ccosf(z); -} - -SYCL_EXTERNAL -float __complex__ __attribute__((weak)) ctanf(float __complex__ z) { - return __devicelib_ctanf(z); -} - -SYCL_EXTERNAL -float __complex__ __attribute__((weak)) cacosf(float __complex__ z) { - return __devicelib_cacosf(z); -} - -SYCL_EXTERNAL -float __complex__ __attribute__((weak)) casinhf(float __complex__ z) { - return __devicelib_casinhf(z); -} - -SYCL_EXTERNAL -float __complex__ __attribute__((weak)) casinf(float __complex__ z) { - return __devicelib_casinf(z); -} - -SYCL_EXTERNAL -float __complex__ __attribute__((weak)) cacoshf(float __complex__ z) { - return __devicelib_cacoshf(z); -} - -SYCL_EXTERNAL -float __complex__ __attribute__((weak)) catanhf(float __complex__ z) { - return __devicelib_catanhf(z); -} - -SYCL_EXTERNAL -float __complex__ __attribute__((weak)) catanf(float __complex__ z) { - return __devicelib_catanf(z); -} - -// __mulsc3 -// Returns: the product of a + ib and c + id -SYCL_EXTERNAL -float __complex__ __attribute__((weak)) __mulsc3(float __a, float __b, - float __c, float __d) { - return __devicelib___mulsc3(__a, __b, __c, __d); -} - -// __divsc3 -// Returns: the quotient of (a + ib) / (c + id) -SYCL_EXTERNAL -float __complex__ __attribute__((weak)) __divsc3(float __a, float __b, - float __c, float __d) { - return __devicelib___divsc3(__a, __b, __c, __d); -} -} -#endif diff --git a/sycl/source/detail/devicelib/complex_wrapper_fp64.cpp b/sycl/source/detail/devicelib/complex_wrapper_fp64.cpp deleted file mode 100644 index f02dd6f18a203..0000000000000 --- a/sycl/source/detail/devicelib/complex_wrapper_fp64.cpp +++ /dev/null @@ -1,139 +0,0 @@ -//==--- complex_wrapper.cpp - wrappers for C99 complex math functions ------==// -// -// 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 __SYCL_DEVICE_ONLY__ -#include "device_complex.h" -extern "C" { -SYCL_EXTERNAL -double __attribute__((weak)) cimag(double __complex__ z) { - return __devicelib_cimag(z); -} - -SYCL_EXTERNAL -double __attribute__((weak)) creal(double __complex__ z) { - return __devicelib_creal(z); -} - -SYCL_EXTERNAL -double __attribute__((weak)) cabs(double __complex__ z) { - return __devicelib_cabs(z); -} - -SYCL_EXTERNAL -double __attribute__((weak)) carg(double __complex__ z) { - return __devicelib_carg(z); -} - -SYCL_EXTERNAL -double __complex__ __attribute__((weak)) cproj(double __complex__ z) { - return __devicelib_cproj(z); -} - -SYCL_EXTERNAL -double __complex__ __attribute__((weak)) cexp(double __complex__ z) { - return __devicelib_cexp(z); -} - -SYCL_EXTERNAL -double __complex__ __attribute__((weak)) clog(double __complex__ z) { - return __devicelib_clog(z); -} - -SYCL_EXTERNAL -double __complex__ __attribute__((weak)) cpow(double __complex__ x, - double __complex__ y) { - return __devicelib_cpow(x, y); -} - -SYCL_EXTERNAL -double __complex__ __attribute__((weak)) cpolar(double rho, double theta) { - return __devicelib_cpolar(rho, theta); -} - -SYCL_EXTERNAL -double __complex__ __attribute__((weak)) csqrt(double __complex__ z) { - return __devicelib_csqrt(z); -} - -SYCL_EXTERNAL -double __complex__ __attribute__((weak)) csinh(double __complex__ z) { - return __devicelib_csinh(z); -} - -SYCL_EXTERNAL -double __complex__ __attribute__((weak)) ccosh(double __complex__ z) { - return __devicelib_ccosh(z); -} - -SYCL_EXTERNAL -double __complex__ __attribute__((weak)) ctanh(double __complex__ z) { - return __devicelib_ctanh(z); -} - -SYCL_EXTERNAL -double __complex__ __attribute__((weak)) csin(double __complex__ z) { - return __devicelib_csin(z); -} - -SYCL_EXTERNAL -double __complex__ __attribute__((weak)) ccos(double __complex__ z) { - return __devicelib_ccos(z); -} - -SYCL_EXTERNAL -double __complex__ __attribute__((weak)) ctan(double __complex__ z) { - return __devicelib_ctan(z); -} - -SYCL_EXTERNAL -double __complex__ __attribute__((weak)) cacos(double __complex__ z) { - return __devicelib_cacos(z); -} - -SYCL_EXTERNAL -double __complex__ __attribute__((weak)) casinh(double __complex__ z) { - return __devicelib_casinh(z); -} - -SYCL_EXTERNAL -double __complex__ __attribute__((weak)) casin(double __complex__ z) { - return __devicelib_casin(z); -} - -SYCL_EXTERNAL -double __complex__ __attribute__((weak)) cacosh(double __complex__ z) { - return __devicelib_cacosh(z); -} - -SYCL_EXTERNAL -double __complex__ __attribute__((weak)) catanh(double __complex__ z) { - return __devicelib_catanh(z); -} - -SYCL_EXTERNAL -double __complex__ __attribute__((weak)) catan(double __complex__ z) { - return __devicelib_catan(z); -} - -// __muldc3 -// Returns: the product of a + ib and c + id -SYCL_EXTERNAL -double __complex__ __attribute__((weak)) __muldc3(double __a, double __b, - double __c, double __d) { - return __devicelib___muldc3(__a, __b, __c, __d); -} - -// __divdc3 -// Returns: the quotient of (a + ib) / (c + id) -SYCL_EXTERNAL -double __complex__ __attribute__((weak)) __divdc3(double __a, double __b, - double __c, double __d) { - return __devicelib___divdc3(__a, __b, __c, __d); -} - -} -#endif diff --git a/sycl/source/detail/devicelib/device_complex.h b/sycl/source/detail/devicelib/device_complex.h deleted file mode 100644 index 51a2610394f5f..0000000000000 --- a/sycl/source/detail/devicelib/device_complex.h +++ /dev/null @@ -1,170 +0,0 @@ -//==------- device_complex.h - complex devicelib functions declarations-----==// -// -// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. -// See https://llvm.org/LICENSE.txt for license information. -// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception -// -//==------------------------------------------------------------------------==// -#ifndef __SYCL_COMPLEX_WRAPPER_H_ -#define __SYCL_COMPLEX_WRAPPER_H_ - -// TODO: This needs to be more robust. -// clang doesn't recognize the c11 CMPLX macro, but it does have -// its own syntax extension for initializing a complex as a struct. -#ifndef CMPLX -#define CMPLX(r, i) ((double __complex__){ (double)r, (double)i }) -#endif -#ifndef CMPLXF -#define CMPLXF(r, i) ((float __complex__){ (float)r, (float)i }) -#endif - -SYCL_EXTERNAL -extern "C" double __devicelib_cimag(double __complex__ z); - -SYCL_EXTERNAL -extern "C" float __devicelib_cimagf(float __complex__ z); - -SYCL_EXTERNAL -extern "C" double __devicelib_creal(double __complex__ z); - -SYCL_EXTERNAL -extern "C" float __devicelib_crealf(float __complex__ z); - -SYCL_EXTERNAL -extern "C" double __devicelib_carg(double __complex__ z); - -SYCL_EXTERNAL -extern "C" float __devicelib_cargf(float __complex__ z); - -SYCL_EXTERNAL -extern "C" double __devicelib_cabs(double __complex__ z); - -SYCL_EXTERNAL -extern "C" float __devicelib_cabsf(float __complex__ z); - -SYCL_EXTERNAL -extern "C" double __complex__ __devicelib_cproj(double __complex__ z); - -SYCL_EXTERNAL -extern "C" float __complex__ __devicelib_cprojf(float __complex__ z); - -SYCL_EXTERNAL -extern "C" double __complex__ __devicelib_cexp(double __complex__ z); - -SYCL_EXTERNAL -extern "C" float __complex__ __devicelib_cexpf(float __complex__ z); - -SYCL_EXTERNAL -extern "C" double __complex__ __devicelib_clog(double __complex__ z); - -SYCL_EXTERNAL -extern "C" float __complex__ __devicelib_clogf(float __complex__ z); - -SYCL_EXTERNAL -extern "C" double __complex__ __devicelib_cpow(double __complex__ x, - double __complex__ y); - -SYCL_EXTERNAL -extern "C" float __complex__ __devicelib_cpowf(float __complex__ x, - float __complex__ y); - -SYCL_EXTERNAL -extern "C" double __complex__ __devicelib_cpolar(double x, double y); - -SYCL_EXTERNAL -extern "C" float __complex__ __devicelib_cpolarf(float x, float y); - -SYCL_EXTERNAL -extern "C" double __complex__ __devicelib_csqrt(double __complex__ z); - -SYCL_EXTERNAL -extern "C" float __complex__ __devicelib_csqrtf(float __complex__ z); - -SYCL_EXTERNAL -extern "C" double __complex__ __devicelib_csinh(double __complex__ z); - -SYCL_EXTERNAL -extern "C" float __complex__ __devicelib_csinhf(float __complex__ z); - -SYCL_EXTERNAL -extern "C" double __complex__ __devicelib_ccosh(double __complex__ z); - -SYCL_EXTERNAL -extern "C" float __complex__ __devicelib_ccoshf(float __complex__ z); - -SYCL_EXTERNAL -extern "C" double __complex__ __devicelib_ctanh(double __complex__ z); - -SYCL_EXTERNAL -extern "C" float __complex__ __devicelib_ctanhf(float __complex__ z); - -SYCL_EXTERNAL -extern "C" double __complex__ __devicelib_csin(double __complex__ z); - -SYCL_EXTERNAL -extern "C" float __complex__ __devicelib_csinf(float __complex__ z); - -SYCL_EXTERNAL -extern "C" double __complex__ __devicelib_ccos(double __complex__ z); - -SYCL_EXTERNAL -extern "C" float __complex__ __devicelib_ccosf(float __complex__ z); - -SYCL_EXTERNAL -extern "C" double __complex__ __devicelib_ctan(double __complex__ z); - -SYCL_EXTERNAL -extern "C" float __complex__ __devicelib_ctanf(float __complex__ z); - -SYCL_EXTERNAL -extern "C" double __complex__ __devicelib_cacos(double __complex__ z); - -SYCL_EXTERNAL -extern "C" float __complex__ __devicelib_cacosf(float __complex__ z); - -SYCL_EXTERNAL -extern "C" double __complex__ __devicelib_casinh(double __complex__ z); - -SYCL_EXTERNAL -extern "C" float __complex__ __devicelib_casinhf(float __complex__ z); - -SYCL_EXTERNAL -extern "C" double __complex__ __devicelib_casin(double __complex__ z); - -SYCL_EXTERNAL -extern "C" float __complex__ __devicelib_casinf(float __complex__ z); - -SYCL_EXTERNAL -extern "C" double __complex__ __devicelib_cacosh(double __complex__ z); - -SYCL_EXTERNAL -extern "C" float __complex__ __devicelib_cacoshf(float __complex__ z); - -SYCL_EXTERNAL -extern "C" double __complex__ __devicelib_catanh(double __complex__ z); - -SYCL_EXTERNAL -extern "C" float __complex__ __devicelib_catanhf(float __complex__ z); - -SYCL_EXTERNAL -extern "C" double __complex__ __devicelib_catan(double __complex__ z); - -SYCL_EXTERNAL -extern "C" float __complex__ __devicelib_catanf(float __complex__ z); - -SYCL_EXTERNAL -extern "C" double __complex__ __devicelib___muldc3(double a, double b, - double c, double d); - -SYCL_EXTERNAL -extern "C" float __complex__ __devicelib___mulsc3(float a, float b, - float c, float d); - -SYCL_EXTERNAL -extern "C" double __complex__ __devicelib___divdc3(double a, double b, - double c, double d); - -SYCL_EXTERNAL -extern "C" float __complex__ __devicelib___divsc3(float a, float b, - float c, float d); -#endif diff --git a/sycl/source/detail/devicelib/device_math.h b/sycl/source/detail/devicelib/device_math.h deleted file mode 100644 index 89ddcdc37f4b3..0000000000000 --- a/sycl/source/detail/devicelib/device_math.h +++ /dev/null @@ -1,356 +0,0 @@ -//==------- device_math.h - math devicelib functions declarations-----------==// -// -// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. -// See https://llvm.org/LICENSE.txt for license information. -// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception -// -//==------------------------------------------------------------------------==// - -#ifndef __SYCL_CMATH_WRAPPER_H__ -#define __SYCL_CMATH_WRAPPER_H__ - -SYCL_EXTERNAL double __spirv_ocl_log(double); -SYCL_EXTERNAL double __spirv_ocl_sin(double); -SYCL_EXTERNAL double __spirv_ocl_cos(double); -SYCL_EXTERNAL double __spirv_ocl_sinh(double); -SYCL_EXTERNAL double __spirv_ocl_cosh(double); -SYCL_EXTERNAL double __spirv_ocl_tanh(double); -SYCL_EXTERNAL double __spirv_ocl_exp(double); -SYCL_EXTERNAL double __spirv_ocl_sqrt(double); -SYCL_EXTERNAL bool __spirv_IsInf(double); -SYCL_EXTERNAL bool __spirv_IsFinite(double); -SYCL_EXTERNAL bool __spirv_IsNan(double); -SYCL_EXTERNAL bool __spirv_IsNormal(double); -SYCL_EXTERNAL bool __spirv_SignBitSet(double); -SYCL_EXTERNAL double __spirv_ocl_hypot(double, double); -SYCL_EXTERNAL double __spirv_ocl_atan2(double, double); -SYCL_EXTERNAL double __spirv_ocl_pow(double, double); -SYCL_EXTERNAL double __spirv_ocl_ldexp(double, int); -SYCL_EXTERNAL double __spirv_ocl_copysign(double, double); -SYCL_EXTERNAL double __spirv_ocl_fmax(double, double); -SYCL_EXTERNAL double __spirv_ocl_fabs(double); -SYCL_EXTERNAL double __spirv_ocl_tan(double); -SYCL_EXTERNAL double __spirv_ocl_acos(double); -SYCL_EXTERNAL double __spirv_ocl_asin(double); -SYCL_EXTERNAL double __spirv_ocl_atan(double); -SYCL_EXTERNAL double __spirv_ocl_atan2(double, double); -SYCL_EXTERNAL double __spirv_ocl_cosh(double); -SYCL_EXTERNAL double __spirv_ocl_sinh(double); -SYCL_EXTERNAL double __spirv_ocl_tanh(double); -SYCL_EXTERNAL double __spirv_ocl_acosh(double); -SYCL_EXTERNAL double __spirv_ocl_asinh(double); -SYCL_EXTERNAL double __spirv_ocl_atanh(double); -SYCL_EXTERNAL double __spirv_ocl_frexp(double, int *); -SYCL_EXTERNAL double __spirv_ocl_log10(double); -SYCL_EXTERNAL double __spirv_ocl_modf(double, double *); -SYCL_EXTERNAL double __spirv_ocl_exp2(double); -SYCL_EXTERNAL double __spirv_ocl_expm1(double); -SYCL_EXTERNAL int __spirv_ocl_ilogb(double); -SYCL_EXTERNAL double __spriv_ocl_log1p(double); -SYCL_EXTERNAL double __spirv_ocl_log2(double); -SYCL_EXTERNAL double __spirv_ocl_logb(double); -SYCL_EXTERNAL double __spirv_ocl_sqrt(double); -SYCL_EXTERNAL double __spirv_ocl_cbrt(double); -SYCL_EXTERNAL double __spirv_ocl_hypot(double); -SYCL_EXTERNAL double __spirv_ocl_erf(double); -SYCL_EXTERNAL double __spirv_ocl_erfc(double); -SYCL_EXTERNAL double __spirv_ocl_tgamma(double); -SYCL_EXTERNAL double __spirv_ocl_lgamma(double); -SYCL_EXTERNAL double __spirv_ocl_fmod(double, double); -SYCL_EXTERNAL double __spirv_ocl_remainder(double, double); -SYCL_EXTERNAL double __spirv_ocl_remquo(double, double, int *); -SYCL_EXTERNAL double __spirv_ocl_nextafter(double, double); -SYCL_EXTERNAL double __spirv_ocl_fdim(double, double); -SYCL_EXTERNAL double __spirv_ocl_fma(double, double, double); - -SYCL_EXTERNAL float __spirv_ocl_log(float); -SYCL_EXTERNAL float __spirv_ocl_logb(float); -SYCL_EXTERNAL float __spirv_ocl_sin(float); -SYCL_EXTERNAL float __spirv_ocl_cos(float); -SYCL_EXTERNAL float __spirv_ocl_sinh(float); -SYCL_EXTERNAL float __spirv_ocl_cosh(float); -SYCL_EXTERNAL float __spirv_ocl_tanh(float); -SYCL_EXTERNAL float __spirv_ocl_exp(float); -SYCL_EXTERNAL float __spirv_ocl_sqrt(float); -SYCL_EXTERNAL bool __spirv_IsInf(float); -SYCL_EXTERNAL bool __spirv_IsFinite(float); -SYCL_EXTERNAL bool __spirv_IsNan(float); -SYCL_EXTERNAL bool __spirv_IsNormal(double); -SYCL_EXTERNAL bool __spirv_SignBitSet(float); -SYCL_EXTERNAL float __spirv_ocl_hypot(float, float); -SYCL_EXTERNAL float __spirv_ocl_atan2(float, float); -SYCL_EXTERNAL float __spirv_ocl_pow(float, float); -SYCL_EXTERNAL float __spirv_ocl_ldexp(float, int); -SYCL_EXTERNAL float __spirv_ocl_copysign(float, float); -SYCL_EXTERNAL float __spirv_ocl_fmax(float, float); -SYCL_EXTERNAL float __spirv_ocl_fabs(float); -SYCL_EXTERNAL float __spirv_ocl_tan(float); -SYCL_EXTERNAL float __spirv_ocl_acos(float); -SYCL_EXTERNAL float __spirv_ocl_asin(float); -SYCL_EXTERNAL float __spirv_ocl_atan(float); -SYCL_EXTERNAL float __spirv_ocl_atan2(float, float); -SYCL_EXTERNAL float __spirv_ocl_cosh(float); -SYCL_EXTERNAL float __spirv_ocl_sinh(float); -SYCL_EXTERNAL float __spirv_ocl_tanh(float); -SYCL_EXTERNAL float __spirv_ocl_acosh(float); -SYCL_EXTERNAL float __spirv_ocl_asinh(float); -SYCL_EXTERNAL float __spirv_ocl_atanh(float); -SYCL_EXTERNAL float __spirv_ocl_frexp(float, int *); -SYCL_EXTERNAL float __spirv_ocl_log10(float); -SYCL_EXTERNAL float __spirv_ocl_modf(float, float *); -SYCL_EXTERNAL float __spirv_ocl_exp2(float); -SYCL_EXTERNAL float __spirv_ocl_expm1(float); -SYCL_EXTERNAL int __spirv_ocl_ilogb(float); -SYCL_EXTERNAL float __spirv_ocl_log1p(float); -SYCL_EXTERNAL float __spirv_ocl_log2(float); -SYCL_EXTERNAL float __spirv_ocl_sqrt(float); -SYCL_EXTERNAL float __spirv_ocl_cbrt(float); -SYCL_EXTERNAL float __spirv_ocl_hypot(float); -SYCL_EXTERNAL float __spirv_ocl_erf(float); -SYCL_EXTERNAL float __spirv_ocl_erfc(float); -SYCL_EXTERNAL float __spirv_ocl_tgamma(float); -SYCL_EXTERNAL float __spirv_ocl_lgamma(float); -SYCL_EXTERNAL float __spirv_ocl_fmod(float, float); -SYCL_EXTERNAL float __spirv_ocl_remainder(float, float); -SYCL_EXTERNAL float __spirv_ocl_remquo(float, float, int *); -SYCL_EXTERNAL float __spirv_ocl_nextafter(float, float); -SYCL_EXTERNAL float __spirv_ocl_fdim(float, float); -SYCL_EXTERNAL float __spirv_ocl_fma(float, float, float); - -SYCL_EXTERNAL -extern "C" double __devicelib_log(double x); - -SYCL_EXTERNAL -extern "C" float __devicelib_logf(float x); - -SYCL_EXTERNAL -extern "C" double __devicelib_sin(double x); - -SYCL_EXTERNAL -extern "C" float __devicelib_sinf(float x); - -SYCL_EXTERNAL -extern "C" double __devicelib_cos(double x); - -SYCL_EXTERNAL -extern "C" float __devicelib_cosf(float x); - -SYCL_EXTERNAL -extern "C" double __devicelib_tan(double x); - -SYCL_EXTERNAL -extern "C" float __devicelib_tanf(float x); - -SYCL_EXTERNAL -extern "C" double __devicelib_acos(double x); - -SYCL_EXTERNAL -extern "C" float __devicelib_acosf(float x); - -SYCL_EXTERNAL -extern "C" double __devicelib_pow(double x, double y); - -SYCL_EXTERNAL -extern "C" float __devicelib_powf(float x, float y); - -SYCL_EXTERNAL -extern "C" double __devicelib_sqrt(double x); - -SYCL_EXTERNAL -extern "C" float __devicelib_sqrtf(float x); - -SYCL_EXTERNAL -extern "C" double __devicelib_cbrt(double x); - -SYCL_EXTERNAL -extern "C" float __devicelib_cbrtf(float x); - -SYCL_EXTERNAL -extern "C" double __devicelib_hypot(double x, double y); - -SYCL_EXTERNAL -extern "C" float __devicelib_hypotf(float x, float y); - -SYCL_EXTERNAL -extern "C" double __devicelib_erf(double x); - -SYCL_EXTERNAL -extern "C" float __devicelib_erff(float x); - -SYCL_EXTERNAL -extern "C" double __devicelib_erfc(double x); - -SYCL_EXTERNAL -extern "C" float __devicelib_erfcf(float x); - -SYCL_EXTERNAL -extern "C" double __devicelib_tgamma(double x); - -SYCL_EXTERNAL -extern "C" float __devicelib_tgammaf(float x); - -SYCL_EXTERNAL -extern "C" double __devicelib_lgamma(double x); - -SYCL_EXTERNAL -extern "C" float __devicelib_lgammaf(float x); - -SYCL_EXTERNAL -extern "C" double __devicelib_fmod(double x, double y); - -SYCL_EXTERNAL -extern "C" float __devicelib_fmodf(float x, float y); - -SYCL_EXTERNAL -extern "C" double __devicelib_remainder(double x, double y); - -SYCL_EXTERNAL -extern "C" float __devicelib_remainderf(float x, float y); - -SYCL_EXTERNAL -extern "C" double __devicelib_remquo(double x, double y, int *q); - -SYCL_EXTERNAL -extern "C" float __devicelib_remquof(float x, float y, int *q); - -SYCL_EXTERNAL -extern "C" double __devicelib_nextafter(double x, double y); - -SYCL_EXTERNAL -extern "C" float __devicelib_nextafterf(float x, float y); - -SYCL_EXTERNAL -extern "C" double __devicelib_fdim(double x, double y); - -SYCL_EXTERNAL -extern "C" float __devicelib_fdimf(float x, float y); - -SYCL_EXTERNAL -extern "C" double __devicelib_fma(double x, double y, double z); - -SYCL_EXTERNAL -extern "C" float __devicelib_fmaf(float x, float y, float z); - -SYCL_EXTERNAL -extern "C" float __devicelib_asinf(float x); - -SYCL_EXTERNAL -extern "C" double __devicelib_asin(double x); - -SYCL_EXTERNAL -extern "C" float __devicelib_atanf(float x); - -SYCL_EXTERNAL -extern "C" double __devicelib_atan(double x); - -SYCL_EXTERNAL -extern "C" float __devicelib_atan2f(float x, float y); - -SYCL_EXTERNAL -extern "C" double __devicelib_atan2(double x, double y); - -SYCL_EXTERNAL -extern "C" float __devicelib_coshf(float x); - -SYCL_EXTERNAL -extern "C" double __devicelib_cosh(double x); - -SYCL_EXTERNAL -extern "C" float __devicelib_sinhf(float x); - -SYCL_EXTERNAL -extern "C" double __devicelib_sinh(double x); - -SYCL_EXTERNAL -extern "C" float __devicelib_tanhf(float x); - -SYCL_EXTERNAL -extern "C" double __devicelib_tanh(double x); - -SYCL_EXTERNAL -extern "C" float __devicelib_acoshf(float x); - -SYCL_EXTERNAL -extern "C" double __devicelib_acosh(double x); - -SYCL_EXTERNAL -extern "C" float __devicelib_asinhf(float x); - -SYCL_EXTERNAL -extern "C" double __devicelib_asinh(double x); - -SYCL_EXTERNAL -extern "C" float __devicelib_atanhf(float x); - -SYCL_EXTERNAL -extern "C" double __devicelib_atanh(double x); - -SYCL_EXTERNAL -extern "C" double __devicelib_frexp(double x, int *exp); - -SYCL_EXTERNAL -extern "C" float __devicelib_frexpf(float x, int *exp); - -SYCL_EXTERNAL -extern "C" double __devicelib_ldexp(double x, int exp); - -SYCL_EXTERNAL -extern "C" float __devicelib_ldexpf(float x, int exp); - -SYCL_EXTERNAL -extern "C" double __devicelib_log10(double x); - -SYCL_EXTERNAL -extern "C" float __devicelib_log10f(float x); - -SYCL_EXTERNAL -extern "C" double __devicelib_modf(double x, double *intpart); - -SYCL_EXTERNAL -extern "C" float __devicelib_modff(float x, float *intpart); - -SYCL_EXTERNAL -extern "C" double __devicelib_exp(double x); - -SYCL_EXTERNAL -extern "C" float __devicelib_expf(float x); - -SYCL_EXTERNAL -extern "C" double __devicelib_exp2(double x); - -SYCL_EXTERNAL -extern "C" float __devicelib_exp2f(float x); - -SYCL_EXTERNAL -extern "C" double __devicelib_expm1(double x); - -SYCL_EXTERNAL -extern "C" float __devicelib_expm1f(float x); - -SYCL_EXTERNAL -extern "C" int __devicelib_ilogb(double x); - -SYCL_EXTERNAL -extern "C" int __devicelib_ilogbf(float x); - -SYCL_EXTERNAL -extern "C" double __devicelib_log1p(double x); - -SYCL_EXTERNAL -extern "C" float __devicelib_log1pf(float x); - -SYCL_EXTERNAL -extern "C" double __devicelib_log2(double x); - -SYCL_EXTERNAL -extern "C" float __devicelib_log2f(float x); - -SYCL_EXTERNAL -extern "C" double __devicelib_logb(double x); - -SYCL_EXTERNAL -extern "C" float __devicelib_logbf(float x); - -SYCL_EXTERNAL -extern "C" float __devicelib_scalbnf(float x, int n); -#endif diff --git a/sycl/source/detail/devicelib/fallback-cmath-fp64.cpp b/sycl/source/detail/devicelib/fallback-cmath-fp64.cpp deleted file mode 100644 index a30fc2a9d831a..0000000000000 --- a/sycl/source/detail/devicelib/fallback-cmath-fp64.cpp +++ /dev/null @@ -1,206 +0,0 @@ -//==--- fallback-cmath.cpp - fallback implementation of math functions -----==// -// -// 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 __SYCL_DEVICE_ONLY__ -#include "device_math.h" -extern "C" { -SYCL_EXTERNAL -double __devicelib_log(double x) { - return __spirv_ocl_log(x); -} - -SYCL_EXTERNAL -double __devicelib_exp(double x) { - return __spirv_ocl_exp(x); -} - -SYCL_EXTERNAL -double __devicelib_frexp(double x, int *exp) { - return __spirv_ocl_frexp(x, exp); -} - -SYCL_EXTERNAL -double __devicelib_ldexp(double x, int exp) { - return __spirv_ocl_ldexp(x, exp); -} - -SYCL_EXTERNAL -double __devicelib_log10(double x) { - return __spirv_ocl_log10(x); -} - -SYCL_EXTERNAL -double __devicelib_modf(double x, double *intpart) { - return __spirv_ocl_modf(x, intpart); -} - -SYCL_EXTERNAL -double __devicelib_exp2(double x) { - return __spirv_ocl_exp2(x); -} - -SYCL_EXTERNAL -double __devicelib_expm1(double x) { - return __spirv_ocl_expm1(x); -} - -SYCL_EXTERNAL -int __devicelib_ilogb(double x) { - return __spirv_ocl_ilogb(x); -} - -SYCL_EXTERNAL -double __devicelib_log1p(double x) { - return __spirv_ocl_log1p(x); -} - -SYCL_EXTERNAL -double __devicelib_log2(double x) { - return __spirv_ocl_log2(x); -} - -SYCL_EXTERNAL -double __devicelib_logb(double x) { - return __spirv_ocl_logb(x); -} - -SYCL_EXTERNAL -double __devicelib_sqrt(double x) { - return __spirv_ocl_sqrt(x); -} - -SYCL_EXTERNAL -double __devicelib_cbrt(double x) { - return __spirv_ocl_cbrt(x); -} - -SYCL_EXTERNAL -double __devicelib_hypot(double x, double y) { - return __spirv_ocl_hypot(x, y); -} - -SYCL_EXTERNAL -double __devicelib_erf(double x) { - return __spirv_ocl_erf(x); -} - -SYCL_EXTERNAL -double __devicelib_erfc(double x) { - return __spirv_ocl_erfc(x); -} - -SYCL_EXTERNAL -double __devicelib_tgamma(double x) { - return __spirv_ocl_tgamma(x); -} - -SYCL_EXTERNAL -double __devicelib_lgamma(double x) { - return __spirv_ocl_lgamma(x); -} - -SYCL_EXTERNAL -double __devicelib_fmod(double x, double y) { - return __spirv_ocl_fmod(x, y); -} - -SYCL_EXTERNAL -double __devicelib_remainder(double x, double y) { - return __spirv_ocl_remainder(x, y); -} - -SYCL_EXTERNAL -double __devicelib_remquo(double x, double y, int *q) { - return __spirv_ocl_remquo(x, y, q); -} - -SYCL_EXTERNAL -double __devicelib_nextafter(double x, double y) { - return __spirv_ocl_nextafter(x, y); -} - -SYCL_EXTERNAL -double __devicelib_fdim(double x, double y) { - return __spirv_ocl_fdim(x, y); -} - -SYCL_EXTERNAL -double __devicelib_fma(double x, double y, double z) { - return __spirv_ocl_fma(x, y, z); -} - -SYCL_EXTERNAL -double __devicelib_sin(double x) { - return __spirv_ocl_sin(x); -} - -SYCL_EXTERNAL -double __devicelib_cos(double x) { - return __spirv_ocl_cos(x); -} - -SYCL_EXTERNAL -double __devicelib_tan(double x) { - return __spirv_ocl_tan(x); -} - -SYCL_EXTERNAL -double __devicelib_pow(double x, double y) { - return __spirv_ocl_pow(x, y); -} - -SYCL_EXTERNAL -double __devicelib_acos(double x) { - return __spirv_ocl_acos(x); -} - -SYCL_EXTERNAL -double __devicelib_asin(double x) { - return __spirv_ocl_asin(x); -} - -SYCL_EXTERNAL -double __devicelib_atan(double x) { - return __spirv_ocl_atan(x); -} - -SYCL_EXTERNAL -double __devicelib_atan2(double x, double y) { - return __spirv_ocl_atan2(x, y); -} - -SYCL_EXTERNAL -double __devicelib_cosh(double x) { - return __spirv_ocl_cosh(x); -} - -SYCL_EXTERNAL -double __devicelib_sinh(double x) { - return __spirv_ocl_sinh(x); -} - -SYCL_EXTERNAL -double __devicelib_tanh(double x) { - return __spirv_ocl_tanh(x); -} - -SYCL_EXTERNAL -double __devicelib_acosh(double x) { - return __spirv_ocl_acosh(x); -} - -SYCL_EXTERNAL -double __devicelib_asinh(double x) { - return __spirv_ocl_asinh(x); -} - -SYCL_EXTERNAL -double __devicelib_atanh(double x) { - return __spirv_ocl_atanh(x); -} -} -#endif diff --git a/sycl/source/detail/devicelib/fallback-cmath.cpp b/sycl/source/detail/devicelib/fallback-cmath.cpp deleted file mode 100644 index 24a4ebf23c4f2..0000000000000 --- a/sycl/source/detail/devicelib/fallback-cmath.cpp +++ /dev/null @@ -1,211 +0,0 @@ -//==--- fallback-cmath.cpp - fallback implementation of math functions -----==// -// -// 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 __SYCL_DEVICE_ONLY__ -#include "device_math.h" -extern "C" { -SYCL_EXTERNAL -float __devicelib_scalbnf(float x, int n) { - return __spirv_ocl_ldexp(x, n); -} - -SYCL_EXTERNAL -float __devicelib_logf(float x) { - return __spirv_ocl_log(x); -} - -SYCL_EXTERNAL -float __devicelib_expf(float x) { - return __spirv_ocl_exp(x); -} - -SYCL_EXTERNAL -float __devicelib_frexpf(float x, int *exp) { - return __spirv_ocl_frexp(x, exp); -} - -SYCL_EXTERNAL -float __devicelib_ldexpf(float x, int exp) { - return __spirv_ocl_ldexp(x, exp); -} - -SYCL_EXTERNAL -float __devicelib_log10f(float x) { - return __spirv_ocl_log10(x); -} - -SYCL_EXTERNAL -float __devicelib_modff(float x, float *intpart) { - return __spirv_ocl_modf(x, intpart); -} - -SYCL_EXTERNAL -float __devicelib_exp2f(float x) { - return __spirv_ocl_exp2(x); -} - -SYCL_EXTERNAL -float __devicelib_expm1f(float x) { - return __spirv_ocl_expm1(x); -} - -SYCL_EXTERNAL -int __devicelib_ilogbf(float x) { - return __spirv_ocl_ilogb(x); -} - -SYCL_EXTERNAL -float __devicelib_log1pf(float x) { - return __spirv_ocl_log1p(x); -} - -SYCL_EXTERNAL -float __devicelib_log2f(float x) { - return __spirv_ocl_log2(x); -} - -SYCL_EXTERNAL -float __devicelib_logbf(float x) { - return __spirv_ocl_logb(x); -} - -SYCL_EXTERNAL -float __devicelib_sqrtf(float x) { - return __spirv_ocl_sqrt(x); -} - -SYCL_EXTERNAL -float __devicelib_cbrtf(float x) { - return __spirv_ocl_cbrt(x); -} - -SYCL_EXTERNAL -float __devicelib_hypotf(float x, float y) { - return __spirv_ocl_hypot(x, y); -} - -SYCL_EXTERNAL -float __devicelib_erff(float x) { - return __spirv_ocl_erf(x); -} - -SYCL_EXTERNAL -float __devicelib_erfcf(float x) { - return __spirv_ocl_erfc(x); -} - -SYCL_EXTERNAL -float __devicelib_tgammaf(float x) { - return __spirv_ocl_tgamma(x); -} - -SYCL_EXTERNAL -float __devicelib_lgammaf(float x) { - return __spirv_ocl_lgamma(x); -} - -SYCL_EXTERNAL -float __devicelib_fmodf(float x, float y) { - return __spirv_ocl_fmod(x, y); -} - -SYCL_EXTERNAL -float __devicelib_remainderf(float x, float y) { - return __spirv_ocl_remainder(x, y); -} - -SYCL_EXTERNAL -float __devicelib_remquof(float x, float y, int *q) { - return __spirv_ocl_remquo(x, y, q); -} - -SYCL_EXTERNAL -float __devicelib_nextafterf(float x, float y) { - return __spirv_ocl_nextafter(x, y); -} - -SYCL_EXTERNAL -float __devicelib_fdimf(float x, float y) { - return __spirv_ocl_fdim(x, y); -} - -SYCL_EXTERNAL -float __devicelib_fmaf(float x, float y, float z) { - return __spirv_ocl_fma(x, y, z); -} - -SYCL_EXTERNAL -float __devicelib_sinf(float x) { - return __spirv_ocl_sin(x); -} - -SYCL_EXTERNAL -float __devicelib_cosf(float x) { - return __spirv_ocl_cos(x); -} - -SYCL_EXTERNAL -float __devicelib_tanf(float x) { - return __spirv_ocl_tan(x); -} - -SYCL_EXTERNAL -float __devicelib_powf(float x, float y) { - return __spirv_ocl_pow(x, y); -} - -SYCL_EXTERNAL -float __devicelib_acosf(float x) { - return __spirv_ocl_acos(x); -} - -SYCL_EXTERNAL -float __devicelib_asinf(float x) { - return __spirv_ocl_asin(x); -} - -SYCL_EXTERNAL -float __devicelib_atanf(float x) { - return __spirv_ocl_atan(x); -} - -SYCL_EXTERNAL -float __devicelib_atan2f(float x, float y) { - return __spirv_ocl_atan2(x, y); -} - -SYCL_EXTERNAL -float __devicelib_coshf(float x) { - return __spirv_ocl_cosh(x); -} - -SYCL_EXTERNAL -float __devicelib_sinhf(float x) { - return __spirv_ocl_sinh(x); -} - -SYCL_EXTERNAL -float __devicelib_tanhf(float x) { - return __spirv_ocl_tanh(x); -} - -SYCL_EXTERNAL -float __devicelib_acoshf(float x) { - return __spirv_ocl_acosh(x); -} - -SYCL_EXTERNAL -float __devicelib_asinhf(float x) { - return __spirv_ocl_asinh(x); -} - -SYCL_EXTERNAL -float __devicelib_atanhf(float x) { - return __spirv_ocl_atanh(x); -} -} -#endif diff --git a/sycl/source/detail/devicelib/glibc_wrapper.cpp b/sycl/source/detail/devicelib/glibc_wrapper.cpp deleted file mode 100644 index 4d3114013ff26..0000000000000 --- a/sycl/source/detail/devicelib/glibc_wrapper.cpp +++ /dev/null @@ -1,26 +0,0 @@ -//==--- glibc_wrapper.cpp - wrappers for Glibc internal functions ----------==// -// -// 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 __SYCL_DEVICE_ONLY__ -#include "wrapper.h" - -#include // for __spirv_BuiltInGlobalInvocationId, - // __spirv_BuiltInLocalInvocationId - -extern "C" SYCL_EXTERNAL -void __assert_fail(const char *expr, const char *file, - unsigned int line, const char *func) { - __devicelib_assert_fail(expr, file, line, func, - __spirv_GlobalInvocationId_x(), - __spirv_GlobalInvocationId_y(), - __spirv_GlobalInvocationId_z(), - __spirv_LocalInvocationId_x(), - __spirv_LocalInvocationId_y(), - __spirv_LocalInvocationId_z()); -} -#endif // __SYCL_DEVICE_ONLY__ diff --git a/sycl/source/detail/devicelib/wrapper.h b/sycl/source/detail/devicelib/wrapper.h deleted file mode 100644 index b541cb9880c6c..0000000000000 --- a/sycl/source/detail/devicelib/wrapper.h +++ /dev/null @@ -1,22 +0,0 @@ -//==--- wrapper.h - declarations for devicelib functions -----*- C++ -*-----==// -// -// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. -// See https://llvm.org/LICENSE.txt for license information. -// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception -// -//===----------------------------------------------------------------------===// - -#ifndef __SYCL_WRAPPERS_H__ -#define __SYCL_WRAPPERS_H__ - -#include -#include - -SYCL_EXTERNAL -extern "C" void __devicelib_assert_fail( - const char *expr, const char *file, - int32_t line, const char *func, - uint64_t gid0, uint64_t gid1, uint64_t gid2, - uint64_t lid0, uint64_t lid1, uint64_t lid2); - -#endif // __SYCL_WRAPPERS_H__