diff --git a/libc/config/gpu/entrypoints.txt b/libc/config/gpu/entrypoints.txt --- a/libc/config/gpu/entrypoints.txt +++ b/libc/config/gpu/entrypoints.txt @@ -150,9 +150,32 @@ libc.src.math.pow libc.src.math.powf libc.src.math.sin + libc.src.math.modf + libc.src.math.modff + libc.src.math.nearbyint + libc.src.math.nearbyintf + libc.src.math.nextafter + libc.src.math.nextafterf + libc.src.math.remainder + libc.src.math.remainderf + libc.src.math.remquo + libc.src.math.remquof + libc.src.math.rint + libc.src.math.rintf libc.src.math.round libc.src.math.roundf - libc.src.math.roundl + libc.src.math.scalbn + libc.src.math.scalbnf + libc.src.math.sinh + libc.src.math.sinhf + libc.src.math.sqrt + libc.src.math.sqrtf + libc.src.math.tan + libc.src.math.tanf + libc.src.math.tanh + libc.src.math.tanhf + libc.src.math.trunc + libc.src.math.truncf ) set(TARGET_LLVMLIBC_ENTRYPOINTS diff --git a/libc/src/math/CMakeLists.txt b/libc/src/math/CMakeLists.txt --- a/libc/src/math/CMakeLists.txt +++ b/libc/src/math/CMakeLists.txt @@ -198,6 +198,8 @@ add_math_entrypoint_object(sin) add_math_entrypoint_object(sinf) + +add_math_entrypoint_object(sinh) add_math_entrypoint_object(sinhf) add_math_entrypoint_object(sqrt) @@ -206,6 +208,8 @@ add_math_entrypoint_object(tan) add_math_entrypoint_object(tanf) + +add_math_entrypoint_object(tanh) add_math_entrypoint_object(tanhf) add_math_entrypoint_object(trunc) diff --git a/libc/src/math/gpu/CMakeLists.txt b/libc/src/math/gpu/CMakeLists.txt --- a/libc/src/math/gpu/CMakeLists.txt +++ b/libc/src/math/gpu/CMakeLists.txt @@ -203,6 +203,106 @@ -O2 ) +add_math_entrypoint_gpu_object( + modf + SRCS + modf.cpp + HDRS + ../modf.h + COMPILE_OPTIONS + -O2 +) + +add_math_entrypoint_gpu_object( + modff + SRCS + modff.cpp + HDRS + ../modff.h + COMPILE_OPTIONS + -O2 +) + +add_math_entrypoint_gpu_object( + nearbyint + SRCS + nearbyint.cpp + HDRS + ../nearbyint.h + COMPILE_OPTIONS + -O2 +) + +add_math_entrypoint_gpu_object( + nearbyintf + SRCS + nearbyintf.cpp + HDRS + ../nearbyintf.h + COMPILE_OPTIONS + -O2 +) + +add_math_entrypoint_gpu_object( + remainder + SRCS + remainder.cpp + HDRS + ../remainder.h + COMPILE_OPTIONS + -O2 +) + +add_math_entrypoint_gpu_object( + remainderf + SRCS + remainderf.cpp + HDRS + ../remainderf.h + COMPILE_OPTIONS + -O2 +) + +add_math_entrypoint_gpu_object( + remquo + SRCS + remquo.cpp + HDRS + ../remquo.h + COMPILE_OPTIONS + -O2 +) + +add_math_entrypoint_gpu_object( + remquof + SRCS + remquof.cpp + HDRS + ../remquof.h + COMPILE_OPTIONS + -O2 +) + +add_math_entrypoint_gpu_object( + rint + SRCS + rint.cpp + HDRS + ../rint.h + COMPILE_OPTIONS + -O2 +) + +add_math_entrypoint_gpu_object( + rintf + SRCS + rintf.cpp + HDRS + ../rintf.h + COMPILE_OPTIONS + -O2 +) + add_math_entrypoint_gpu_object( round SRCS @@ -212,3 +312,123 @@ COMPILE_OPTIONS -O2 ) + +add_math_entrypoint_gpu_object( + scalbn + SRCS + scalbn.cpp + HDRS + ../scalbn.h + COMPILE_OPTIONS + -O2 +) + +add_math_entrypoint_gpu_object( + scalbnf + SRCS + scalbnf.cpp + HDRS + ../scalbnf.h + COMPILE_OPTIONS + -O2 +) + +add_math_entrypoint_gpu_object( + sinh + SRCS + sinh.cpp + HDRS + ../sinh.h + COMPILE_OPTIONS + -O2 +) + +add_math_entrypoint_gpu_object( + sinhf + SRCS + sinhf.cpp + HDRS + ../sinhf.h + COMPILE_OPTIONS + -O2 +) + +add_math_entrypoint_gpu_object( + sqrt + SRCS + sqrt.cpp + HDRS + ../sqrt.h + COMPILE_OPTIONS + -O2 +) + +add_math_entrypoint_gpu_object( + sqrtf + SRCS + sqrtf.cpp + HDRS + ../sqrtf.h + COMPILE_OPTIONS + -O2 +) + +add_math_entrypoint_gpu_object( + tan + SRCS + tan.cpp + HDRS + ../tan.h + COMPILE_OPTIONS + -O2 +) + +add_math_entrypoint_gpu_object( + tanf + SRCS + tanf.cpp + HDRS + ../tanf.h + COMPILE_OPTIONS + -O2 +) + +add_math_entrypoint_gpu_object( + tanh + SRCS + tanh.cpp + HDRS + ../tanh.h + COMPILE_OPTIONS + -O2 +) + +add_math_entrypoint_gpu_object( + tanhf + SRCS + tanhf.cpp + HDRS + ../tanhf.h + COMPILE_OPTIONS + -O2 +) + +add_math_entrypoint_gpu_object( + trunc + SRCS + trunc.cpp + HDRS + ../trunc.h + COMPILE_OPTIONS + -O2 +) + +add_math_entrypoint_gpu_object( + truncf + SRCS + truncf.cpp + HDRS + ../truncf.h + COMPILE_OPTIONS + -O2 +) \ No newline at end of file diff --git a/libc/src/math/gpu/roundl.cpp b/libc/src/math/gpu/modf.cpp rename from libc/src/math/gpu/roundl.cpp rename to libc/src/math/gpu/modf.cpp --- a/libc/src/math/gpu/roundl.cpp +++ b/libc/src/math/gpu/modf.cpp @@ -1,4 +1,4 @@ -//===-- Implementation of the GPU roundl function -------------------------===// +//===-- Implementation of the GPU modf function ---------------------------===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. @@ -6,18 +6,13 @@ // //===----------------------------------------------------------------------===// -#include "src/math/roundl.h" -#include "src/__support/FPUtil/PlatformDefs.h" +#include "src/math/modf.h" #include "src/__support/common.h" namespace __llvm_libc { -#ifndef LONG_DOUBLE_IS_DOUBLE -#error "GPU targets do not support long doubles" -#endif - -LLVM_LIBC_FUNCTION(long double, roundl, (long double x)) { - return __builtin_round(x); +LLVM_LIBC_FUNCTION(double, modf, (double x, double *iptr)) { + return __builtin_modf(x, iptr); } } // namespace __llvm_libc diff --git a/libc/src/math/gpu/roundl.cpp b/libc/src/math/gpu/modff.cpp copy from libc/src/math/gpu/roundl.cpp copy to libc/src/math/gpu/modff.cpp --- a/libc/src/math/gpu/roundl.cpp +++ b/libc/src/math/gpu/modff.cpp @@ -1,4 +1,4 @@ -//===-- Implementation of the GPU roundl function -------------------------===// +//===-- Implementation of the GPU modff function --------------------------===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. @@ -6,18 +6,13 @@ // //===----------------------------------------------------------------------===// -#include "src/math/roundl.h" -#include "src/__support/FPUtil/PlatformDefs.h" +#include "src/math/modff.h" #include "src/__support/common.h" namespace __llvm_libc { -#ifndef LONG_DOUBLE_IS_DOUBLE -#error "GPU targets do not support long doubles" -#endif - -LLVM_LIBC_FUNCTION(long double, roundl, (long double x)) { - return __builtin_round(x); +LLVM_LIBC_FUNCTION(float, modff, (float x, float *iptr)) { + return __builtin_modff(x, iptr); } } // namespace __llvm_libc diff --git a/libc/src/math/gpu/roundl.cpp b/libc/src/math/gpu/nearbyint.cpp copy from libc/src/math/gpu/roundl.cpp copy to libc/src/math/gpu/nearbyint.cpp --- a/libc/src/math/gpu/roundl.cpp +++ b/libc/src/math/gpu/nearbyint.cpp @@ -1,4 +1,4 @@ -//===-- Implementation of the GPU roundl function -------------------------===// +//===-- Implementation of the GPU nearbyint function ----------------------===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. @@ -6,18 +6,13 @@ // //===----------------------------------------------------------------------===// -#include "src/math/roundl.h" -#include "src/__support/FPUtil/PlatformDefs.h" +#include "src/math/nearbyint.h" #include "src/__support/common.h" namespace __llvm_libc { -#ifndef LONG_DOUBLE_IS_DOUBLE -#error "GPU targets do not support long doubles" -#endif - -LLVM_LIBC_FUNCTION(long double, roundl, (long double x)) { - return __builtin_round(x); +LLVM_LIBC_FUNCTION(double, nearbyint, (double x)) { + return __builtin_nearbyint(x); } } // namespace __llvm_libc diff --git a/libc/src/math/gpu/roundl.cpp b/libc/src/math/gpu/nearbyintf.cpp copy from libc/src/math/gpu/roundl.cpp copy to libc/src/math/gpu/nearbyintf.cpp --- a/libc/src/math/gpu/roundl.cpp +++ b/libc/src/math/gpu/nearbyintf.cpp @@ -1,4 +1,4 @@ -//===-- Implementation of the GPU roundl function -------------------------===// +//===-- Implementation of the GPU nearbyintf function ---------------------===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. @@ -6,18 +6,13 @@ // //===----------------------------------------------------------------------===// -#include "src/math/roundl.h" -#include "src/__support/FPUtil/PlatformDefs.h" +#include "src/math/nearbyintf.h" #include "src/__support/common.h" namespace __llvm_libc { -#ifndef LONG_DOUBLE_IS_DOUBLE -#error "GPU targets do not support long doubles" -#endif - -LLVM_LIBC_FUNCTION(long double, roundl, (long double x)) { - return __builtin_round(x); +LLVM_LIBC_FUNCTION(float, nearbyintf, (float x)) { + return __builtin_nearbyintf(x); } } // namespace __llvm_libc diff --git a/libc/src/math/gpu/roundl.cpp b/libc/src/math/gpu/remainder.cpp copy from libc/src/math/gpu/roundl.cpp copy to libc/src/math/gpu/remainder.cpp --- a/libc/src/math/gpu/roundl.cpp +++ b/libc/src/math/gpu/remainder.cpp @@ -1,4 +1,4 @@ -//===-- Implementation of the GPU roundl function -------------------------===// +//===-- Implementation of the GPU remainder function ----------------------===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. @@ -6,18 +6,13 @@ // //===----------------------------------------------------------------------===// -#include "src/math/roundl.h" -#include "src/__support/FPUtil/PlatformDefs.h" +#include "src/math/remainder.h" #include "src/__support/common.h" namespace __llvm_libc { -#ifndef LONG_DOUBLE_IS_DOUBLE -#error "GPU targets do not support long doubles" -#endif - -LLVM_LIBC_FUNCTION(long double, roundl, (long double x)) { - return __builtin_round(x); +LLVM_LIBC_FUNCTION(double, remainder, (double x, double y)) { + return __builtin_remainder(x, y); } } // namespace __llvm_libc diff --git a/libc/src/math/gpu/roundl.cpp b/libc/src/math/gpu/remainderf.cpp copy from libc/src/math/gpu/roundl.cpp copy to libc/src/math/gpu/remainderf.cpp --- a/libc/src/math/gpu/roundl.cpp +++ b/libc/src/math/gpu/remainderf.cpp @@ -1,4 +1,4 @@ -//===-- Implementation of the GPU roundl function -------------------------===// +//===-- Implementation of the GPU remainderf function ---------------------===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. @@ -6,18 +6,13 @@ // //===----------------------------------------------------------------------===// -#include "src/math/roundl.h" -#include "src/__support/FPUtil/PlatformDefs.h" +#include "src/math/remainderf.h" #include "src/__support/common.h" namespace __llvm_libc { -#ifndef LONG_DOUBLE_IS_DOUBLE -#error "GPU targets do not support long doubles" -#endif - -LLVM_LIBC_FUNCTION(long double, roundl, (long double x)) { - return __builtin_round(x); +LLVM_LIBC_FUNCTION(float, remainderf, (float x, float y)) { + return __builtin_remainderf(x, y); } } // namespace __llvm_libc diff --git a/libc/src/math/gpu/roundl.cpp b/libc/src/math/gpu/remquo.cpp copy from libc/src/math/gpu/roundl.cpp copy to libc/src/math/gpu/remquo.cpp --- a/libc/src/math/gpu/roundl.cpp +++ b/libc/src/math/gpu/remquo.cpp @@ -1,4 +1,4 @@ -//===-- Implementation of the GPU roundl function -------------------------===// +//===-- Implementation of the GPU remquo function -------------------------===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. @@ -6,18 +6,13 @@ // //===----------------------------------------------------------------------===// -#include "src/math/roundl.h" -#include "src/__support/FPUtil/PlatformDefs.h" +#include "src/math/remquo.h" #include "src/__support/common.h" namespace __llvm_libc { -#ifndef LONG_DOUBLE_IS_DOUBLE -#error "GPU targets do not support long doubles" -#endif - -LLVM_LIBC_FUNCTION(long double, roundl, (long double x)) { - return __builtin_round(x); +LLVM_LIBC_FUNCTION(double, remquo, (double x, double y, int *quo)) { + return __builtin_remquo(x, y, quo); } } // namespace __llvm_libc diff --git a/libc/src/math/gpu/roundl.cpp b/libc/src/math/gpu/remquof.cpp copy from libc/src/math/gpu/roundl.cpp copy to libc/src/math/gpu/remquof.cpp --- a/libc/src/math/gpu/roundl.cpp +++ b/libc/src/math/gpu/remquof.cpp @@ -1,4 +1,4 @@ -//===-- Implementation of the GPU roundl function -------------------------===// +//===-- Implementation of the GPU remquof function ------------------------===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. @@ -6,18 +6,13 @@ // //===----------------------------------------------------------------------===// -#include "src/math/roundl.h" -#include "src/__support/FPUtil/PlatformDefs.h" +#include "src/math/remquof.h" #include "src/__support/common.h" namespace __llvm_libc { -#ifndef LONG_DOUBLE_IS_DOUBLE -#error "GPU targets do not support long doubles" -#endif - -LLVM_LIBC_FUNCTION(long double, roundl, (long double x)) { - return __builtin_round(x); +LLVM_LIBC_FUNCTION(float, remquof, (float x, float y, int *quo)) { + return __builtin_remquof(x, y, quo); } } // namespace __llvm_libc diff --git a/libc/src/math/gpu/roundl.cpp b/libc/src/math/gpu/rint.cpp copy from libc/src/math/gpu/roundl.cpp copy to libc/src/math/gpu/rint.cpp --- a/libc/src/math/gpu/roundl.cpp +++ b/libc/src/math/gpu/rint.cpp @@ -1,4 +1,4 @@ -//===-- Implementation of the GPU roundl function -------------------------===// +//===-- Implementation of the GPU rint function ---------------------------===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. @@ -6,18 +6,11 @@ // //===----------------------------------------------------------------------===// -#include "src/math/roundl.h" -#include "src/__support/FPUtil/PlatformDefs.h" +#include "src/math/rint.h" #include "src/__support/common.h" namespace __llvm_libc { -#ifndef LONG_DOUBLE_IS_DOUBLE -#error "GPU targets do not support long doubles" -#endif - -LLVM_LIBC_FUNCTION(long double, roundl, (long double x)) { - return __builtin_round(x); -} +LLVM_LIBC_FUNCTION(double, rint, (double x)) { return __builtin_rint(x); } } // namespace __llvm_libc diff --git a/libc/src/math/gpu/roundl.cpp b/libc/src/math/gpu/rintf.cpp copy from libc/src/math/gpu/roundl.cpp copy to libc/src/math/gpu/rintf.cpp --- a/libc/src/math/gpu/roundl.cpp +++ b/libc/src/math/gpu/rintf.cpp @@ -1,4 +1,4 @@ -//===-- Implementation of the GPU roundl function -------------------------===// +//===-- Implementation of the GPU rintf function --------------------------===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. @@ -6,18 +6,11 @@ // //===----------------------------------------------------------------------===// -#include "src/math/roundl.h" -#include "src/__support/FPUtil/PlatformDefs.h" +#include "src/math/rintf.h" #include "src/__support/common.h" namespace __llvm_libc { -#ifndef LONG_DOUBLE_IS_DOUBLE -#error "GPU targets do not support long doubles" -#endif - -LLVM_LIBC_FUNCTION(long double, roundl, (long double x)) { - return __builtin_round(x); -} +LLVM_LIBC_FUNCTION(float, rintf, (float x)) { return __builtin_rintf(x); } } // namespace __llvm_libc diff --git a/libc/src/math/gpu/roundl.cpp b/libc/src/math/gpu/scalbn.cpp copy from libc/src/math/gpu/roundl.cpp copy to libc/src/math/gpu/scalbn.cpp --- a/libc/src/math/gpu/roundl.cpp +++ b/libc/src/math/gpu/scalbn.cpp @@ -1,4 +1,4 @@ -//===-- Implementation of the GPU roundl function -------------------------===// +//===-- Implementation of the GPU scalbn function -------------------------===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. @@ -6,18 +6,13 @@ // //===----------------------------------------------------------------------===// -#include "src/math/roundl.h" -#include "src/__support/FPUtil/PlatformDefs.h" +#include "src/math/scalbn.h" #include "src/__support/common.h" namespace __llvm_libc { -#ifndef LONG_DOUBLE_IS_DOUBLE -#error "GPU targets do not support long doubles" -#endif - -LLVM_LIBC_FUNCTION(long double, roundl, (long double x)) { - return __builtin_round(x); +LLVM_LIBC_FUNCTION(double, scalbn, (double x, int y)) { + return __builtin_scalbn(x, y); } } // namespace __llvm_libc diff --git a/libc/src/math/gpu/roundl.cpp b/libc/src/math/gpu/scalbnf.cpp copy from libc/src/math/gpu/roundl.cpp copy to libc/src/math/gpu/scalbnf.cpp --- a/libc/src/math/gpu/roundl.cpp +++ b/libc/src/math/gpu/scalbnf.cpp @@ -1,4 +1,4 @@ -//===-- Implementation of the GPU roundl function -------------------------===// +//===-- Implementation of the GPU scalbnf function ------------------------===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. @@ -6,18 +6,13 @@ // //===----------------------------------------------------------------------===// -#include "src/math/roundl.h" -#include "src/__support/FPUtil/PlatformDefs.h" +#include "src/math/scalbnf.h" #include "src/__support/common.h" namespace __llvm_libc { -#ifndef LONG_DOUBLE_IS_DOUBLE -#error "GPU targets do not support long doubles" -#endif - -LLVM_LIBC_FUNCTION(long double, roundl, (long double x)) { - return __builtin_round(x); +LLVM_LIBC_FUNCTION(float, scalbnf, (float x, int y)) { + return __builtin_scalbnf(x, y); } } // namespace __llvm_libc diff --git a/libc/src/math/gpu/roundl.cpp b/libc/src/math/gpu/sinh.cpp copy from libc/src/math/gpu/roundl.cpp copy to libc/src/math/gpu/sinh.cpp --- a/libc/src/math/gpu/roundl.cpp +++ b/libc/src/math/gpu/sinh.cpp @@ -1,4 +1,4 @@ -//===-- Implementation of the GPU roundl function -------------------------===// +//===-- Implementation of the GPU sinh function ---------------------------===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. @@ -6,18 +6,11 @@ // //===----------------------------------------------------------------------===// -#include "src/math/roundl.h" -#include "src/__support/FPUtil/PlatformDefs.h" +#include "src/math/sinh.h" #include "src/__support/common.h" namespace __llvm_libc { -#ifndef LONG_DOUBLE_IS_DOUBLE -#error "GPU targets do not support long doubles" -#endif - -LLVM_LIBC_FUNCTION(long double, roundl, (long double x)) { - return __builtin_round(x); -} +LLVM_LIBC_FUNCTION(double, sinh, (double x)) { return __builtin_sinh(x); } } // namespace __llvm_libc diff --git a/libc/src/math/gpu/roundl.cpp b/libc/src/math/gpu/sinhf.cpp copy from libc/src/math/gpu/roundl.cpp copy to libc/src/math/gpu/sinhf.cpp --- a/libc/src/math/gpu/roundl.cpp +++ b/libc/src/math/gpu/sinhf.cpp @@ -1,4 +1,4 @@ -//===-- Implementation of the GPU roundl function -------------------------===// +//===-- Implementation of the GPU sinhf function --------------------------===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. @@ -6,18 +6,11 @@ // //===----------------------------------------------------------------------===// -#include "src/math/roundl.h" -#include "src/__support/FPUtil/PlatformDefs.h" +#include "src/math/sinhf.h" #include "src/__support/common.h" namespace __llvm_libc { -#ifndef LONG_DOUBLE_IS_DOUBLE -#error "GPU targets do not support long doubles" -#endif - -LLVM_LIBC_FUNCTION(long double, roundl, (long double x)) { - return __builtin_round(x); -} +LLVM_LIBC_FUNCTION(float, sinhf, (float x)) { return __builtin_sinhf(x); } } // namespace __llvm_libc diff --git a/libc/src/math/gpu/roundl.cpp b/libc/src/math/gpu/sqrt.cpp copy from libc/src/math/gpu/roundl.cpp copy to libc/src/math/gpu/sqrt.cpp --- a/libc/src/math/gpu/roundl.cpp +++ b/libc/src/math/gpu/sqrt.cpp @@ -1,4 +1,4 @@ -//===-- Implementation of the GPU roundl function -------------------------===// +//===-- Implementation of the GPU sqrt function ---------------------------===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. @@ -6,18 +6,11 @@ // //===----------------------------------------------------------------------===// -#include "src/math/roundl.h" -#include "src/__support/FPUtil/PlatformDefs.h" +#include "src/math/sqrt.h" #include "src/__support/common.h" namespace __llvm_libc { -#ifndef LONG_DOUBLE_IS_DOUBLE -#error "GPU targets do not support long doubles" -#endif - -LLVM_LIBC_FUNCTION(long double, roundl, (long double x)) { - return __builtin_round(x); -} +LLVM_LIBC_FUNCTION(double, sqrt, (double x)) { return __builtin_sqrt(x); } } // namespace __llvm_libc diff --git a/libc/src/math/gpu/roundl.cpp b/libc/src/math/gpu/sqrtf.cpp copy from libc/src/math/gpu/roundl.cpp copy to libc/src/math/gpu/sqrtf.cpp --- a/libc/src/math/gpu/roundl.cpp +++ b/libc/src/math/gpu/sqrtf.cpp @@ -1,4 +1,4 @@ -//===-- Implementation of the GPU roundl function -------------------------===// +//===-- Implementation of the GPU sqrtf function --------------------------===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. @@ -6,18 +6,11 @@ // //===----------------------------------------------------------------------===// -#include "src/math/roundl.h" -#include "src/__support/FPUtil/PlatformDefs.h" +#include "src/math/sqrtf.h" #include "src/__support/common.h" namespace __llvm_libc { -#ifndef LONG_DOUBLE_IS_DOUBLE -#error "GPU targets do not support long doubles" -#endif - -LLVM_LIBC_FUNCTION(long double, roundl, (long double x)) { - return __builtin_round(x); -} +LLVM_LIBC_FUNCTION(float, sqrtf, (float x)) { return __builtin_sqrtf(x); } } // namespace __llvm_libc diff --git a/libc/src/math/gpu/roundl.cpp b/libc/src/math/gpu/tan.cpp copy from libc/src/math/gpu/roundl.cpp copy to libc/src/math/gpu/tan.cpp --- a/libc/src/math/gpu/roundl.cpp +++ b/libc/src/math/gpu/tan.cpp @@ -1,4 +1,4 @@ -//===-- Implementation of the GPU roundl function -------------------------===// +//===-- Implementation of the GPU tan function ----------------------------===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. @@ -6,18 +6,11 @@ // //===----------------------------------------------------------------------===// -#include "src/math/roundl.h" -#include "src/__support/FPUtil/PlatformDefs.h" +#include "src/math/tan.h" #include "src/__support/common.h" namespace __llvm_libc { -#ifndef LONG_DOUBLE_IS_DOUBLE -#error "GPU targets do not support long doubles" -#endif - -LLVM_LIBC_FUNCTION(long double, roundl, (long double x)) { - return __builtin_round(x); -} +LLVM_LIBC_FUNCTION(double, tan, (double x)) { return __builtin_tan(x); } } // namespace __llvm_libc diff --git a/libc/src/math/gpu/roundl.cpp b/libc/src/math/gpu/tanf.cpp copy from libc/src/math/gpu/roundl.cpp copy to libc/src/math/gpu/tanf.cpp --- a/libc/src/math/gpu/roundl.cpp +++ b/libc/src/math/gpu/tanf.cpp @@ -1,4 +1,4 @@ -//===-- Implementation of the GPU roundl function -------------------------===// +//===-- Implementation of the GPU tanf function ---------------------------===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. @@ -6,18 +6,11 @@ // //===----------------------------------------------------------------------===// -#include "src/math/roundl.h" -#include "src/__support/FPUtil/PlatformDefs.h" +#include "src/math/tanf.h" #include "src/__support/common.h" namespace __llvm_libc { -#ifndef LONG_DOUBLE_IS_DOUBLE -#error "GPU targets do not support long doubles" -#endif - -LLVM_LIBC_FUNCTION(long double, roundl, (long double x)) { - return __builtin_round(x); -} +LLVM_LIBC_FUNCTION(float, tanf, (float x)) { return __builtin_tanf(x); } } // namespace __llvm_libc diff --git a/libc/src/math/gpu/roundl.cpp b/libc/src/math/gpu/tanh.cpp copy from libc/src/math/gpu/roundl.cpp copy to libc/src/math/gpu/tanh.cpp --- a/libc/src/math/gpu/roundl.cpp +++ b/libc/src/math/gpu/tanh.cpp @@ -1,4 +1,4 @@ -//===-- Implementation of the GPU roundl function -------------------------===// +//===-- Implementation of the GPU tanh function ---------------------------===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. @@ -6,18 +6,11 @@ // //===----------------------------------------------------------------------===// -#include "src/math/roundl.h" -#include "src/__support/FPUtil/PlatformDefs.h" +#include "src/math/tanh.h" #include "src/__support/common.h" namespace __llvm_libc { -#ifndef LONG_DOUBLE_IS_DOUBLE -#error "GPU targets do not support long doubles" -#endif - -LLVM_LIBC_FUNCTION(long double, roundl, (long double x)) { - return __builtin_round(x); -} +LLVM_LIBC_FUNCTION(double, tanh, (double x)) { return __builtin_tanh(x); } } // namespace __llvm_libc diff --git a/libc/src/math/gpu/roundl.cpp b/libc/src/math/gpu/tanhf.cpp copy from libc/src/math/gpu/roundl.cpp copy to libc/src/math/gpu/tanhf.cpp --- a/libc/src/math/gpu/roundl.cpp +++ b/libc/src/math/gpu/tanhf.cpp @@ -1,4 +1,4 @@ -//===-- Implementation of the GPU roundl function -------------------------===// +//===-- Implementation of the GPU tanhf function --------------------------===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. @@ -6,18 +6,11 @@ // //===----------------------------------------------------------------------===// -#include "src/math/roundl.h" -#include "src/__support/FPUtil/PlatformDefs.h" +#include "src/math/tanhf.h" #include "src/__support/common.h" namespace __llvm_libc { -#ifndef LONG_DOUBLE_IS_DOUBLE -#error "GPU targets do not support long doubles" -#endif - -LLVM_LIBC_FUNCTION(long double, roundl, (long double x)) { - return __builtin_round(x); -} +LLVM_LIBC_FUNCTION(float, tanhf, (float x)) { return __builtin_tanhf(x); } } // namespace __llvm_libc diff --git a/libc/src/math/gpu/roundl.cpp b/libc/src/math/gpu/trunc.cpp copy from libc/src/math/gpu/roundl.cpp copy to libc/src/math/gpu/trunc.cpp --- a/libc/src/math/gpu/roundl.cpp +++ b/libc/src/math/gpu/trunc.cpp @@ -1,4 +1,4 @@ -//===-- Implementation of the GPU roundl function -------------------------===// +//===-- Implementation of the GPU trunc function --------------------------===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. @@ -6,18 +6,11 @@ // //===----------------------------------------------------------------------===// -#include "src/math/roundl.h" -#include "src/__support/FPUtil/PlatformDefs.h" +#include "src/math/trunc.h" #include "src/__support/common.h" namespace __llvm_libc { -#ifndef LONG_DOUBLE_IS_DOUBLE -#error "GPU targets do not support long doubles" -#endif - -LLVM_LIBC_FUNCTION(long double, roundl, (long double x)) { - return __builtin_round(x); -} +LLVM_LIBC_FUNCTION(double, trunc, (double x)) { return __builtin_trunc(x); } } // namespace __llvm_libc diff --git a/libc/src/math/gpu/roundl.cpp b/libc/src/math/gpu/truncf.cpp copy from libc/src/math/gpu/roundl.cpp copy to libc/src/math/gpu/truncf.cpp --- a/libc/src/math/gpu/roundl.cpp +++ b/libc/src/math/gpu/truncf.cpp @@ -1,4 +1,4 @@ -//===-- Implementation of the GPU roundl function -------------------------===// +//===-- Implementation of the GPU truncf function -------------------------===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. @@ -6,18 +6,11 @@ // //===----------------------------------------------------------------------===// -#include "src/math/roundl.h" -#include "src/__support/FPUtil/PlatformDefs.h" +#include "src/math/truncf.h" #include "src/__support/common.h" namespace __llvm_libc { -#ifndef LONG_DOUBLE_IS_DOUBLE -#error "GPU targets do not support long doubles" -#endif - -LLVM_LIBC_FUNCTION(long double, roundl, (long double x)) { - return __builtin_round(x); -} +LLVM_LIBC_FUNCTION(float, truncf, (float x)) { return __builtin_truncf(x); } } // namespace __llvm_libc diff --git a/libc/src/math/gpu/vendor/CMakeLists.txt b/libc/src/math/gpu/vendor/CMakeLists.txt --- a/libc/src/math/gpu/vendor/CMakeLists.txt +++ b/libc/src/math/gpu/vendor/CMakeLists.txt @@ -315,6 +315,28 @@ -O2 ) +add_entrypoint_object( + nextafter + SRCS + nextafter.cpp + HDRS + ../../nextafter.h + COMPILE_OPTIONS + ${bitcode_link_flags} + -O2 +) + +add_entrypoint_object( + nextafterf + SRCS + nextafterf.cpp + HDRS + ../../nextafterf.h + COMPILE_OPTIONS + ${bitcode_link_flags} + -O2 +) + add_entrypoint_object( pow SRCS @@ -347,3 +369,102 @@ ${bitcode_link_flags} -O2 ) + +add_entrypoint_object( + sinf + SRCS + sinf.cpp + HDRS + ../../sinf.h + COMPILE_OPTIONS + ${bitcode_link_flags} + -O2 +) + +add_entrypoint_object( + sincos + SRCS + sincos.cpp + HDRS + ../../sincos.h + COMPILE_OPTIONS + ${bitcode_link_flags} + -O2 +) + +add_entrypoint_object( + sincosf + SRCS + sincosf.cpp + HDRS + ../../sincosf.h + COMPILE_OPTIONS + ${bitcode_link_flags} + -O2 +) + +add_entrypoint_object( + sinh + SRCS + sinh.cpp + HDRS + ../../sinh.h + COMPILE_OPTIONS + ${bitcode_link_flags} + -O2 +) + +add_entrypoint_object( + sinhf + SRCS + sinhf.cpp + HDRS + ../../sinhf.h + COMPILE_OPTIONS + ${bitcode_link_flags} + -O2 +) + +add_entrypoint_object( + tan + SRCS + tan.cpp + HDRS + ../../tan.h + COMPILE_OPTIONS + ${bitcode_link_flags} + -O2 +) + +add_entrypoint_object( + tanf + SRCS + tanf.cpp + HDRS + ../../tanf.h + COMPILE_OPTIONS + ${bitcode_link_flags} + -O2 +) + +add_entrypoint_object( + tanh + SRCS + tanh.cpp + HDRS + ../../tanh.h + COMPILE_OPTIONS + ${bitcode_link_flags} + -O2 +) + +add_entrypoint_object( + tanhf + SRCS + tanhf.cpp + HDRS + ../../tanhf.h + COMPILE_OPTIONS + ${bitcode_link_flags} + -O2 +) \ No newline at end of file diff --git a/libc/src/math/gpu/vendor/amdgpu/amdgpu.h b/libc/src/math/gpu/vendor/amdgpu/amdgpu.h --- a/libc/src/math/gpu/vendor/amdgpu/amdgpu.h +++ b/libc/src/math/gpu/vendor/amdgpu/amdgpu.h @@ -42,9 +42,28 @@ LIBC_INLINE long long llrintf(float x) { return __builtin_rintf(x); } LIBC_INLINE long long llround(double x) { return __builtin_round(x); } LIBC_INLINE long long llroundf(float x) { return __builtin_roundf(x); } +LIBC_INLINE double nextafter(double x, double y) { + return __ocml_nextafter_f64(x, y); +} +LIBC_INLINE float nextafterf(float x, float y) { + return __ocml_nextafter_f32(x, y); +} LIBC_INLINE double pow(double x, double y) { return __ocml_pow_f64(x, y); } LIBC_INLINE float powf(float x, float y) { return __ocml_pow_f32(x, y); } LIBC_INLINE double sin(double x) { return __ocml_sin_f64(x); } +LIBC_INLINE float sinf(float x) { return __ocml_sin_f32(x); } +LIBC_INLINE void sincos(double x, double *sinptr, double *cosptr) { + *sinptr = __ocml_sincos_f64(x, cosptr); +} +LIBC_INLINE void sincosf(float x, float *sinptr, float *cosptr) { + *sinptr = __ocml_sincos_f32(x, cosptr); +} +LIBC_INLINE double sinh(double x) { return __ocml_sinh_f64(x); } +LIBC_INLINE float sinhf(float x) { return __ocml_sinh_f32(x); } +LIBC_INLINE double tan(double x) { return __ocml_tan_f64(x); } +LIBC_INLINE float tanf(float x) { return __ocml_tan_f32(x); } +LIBC_INLINE double tanh(double x) { return __ocml_tanh_f64(x); } +LIBC_INLINE float tanhf(float x) { return __ocml_tanh_f32(x); } } // namespace internal } // namespace __llvm_libc diff --git a/libc/src/math/gpu/vendor/amdgpu/declarations.h b/libc/src/math/gpu/vendor/amdgpu/declarations.h --- a/libc/src/math/gpu/vendor/amdgpu/declarations.h +++ b/libc/src/math/gpu/vendor/amdgpu/declarations.h @@ -34,13 +34,24 @@ int __ocml_ilogb_f32(float); float __ocml_ldexp_f32(float, int); double __ocml_ldexp_f64(double, int); +float __ocml_nextafter_f32(float, float); +double __ocml_nextafter_f64(double, double); float __ocml_pow_f32(float, float); double __ocml_pow_f64(double, double); double __ocml_rint_f64(double); float __ocml_rint_f32(float); double __ocml_round_f64(double); float __ocml_round_f32(float); +float __ocml_sin_f32(float); double __ocml_sin_f64(double); +float __ocml_sincos_f32(float, float *); +double __ocml_sincos_f64(double, double *); +float __ocml_sinh_f32(float); +double __ocml_sinh_f64(double); +float __ocml_tan_f32(float); +double __ocml_tan_f64(double); +float __ocml_tanh_f32(float); +double __ocml_tanh_f64(double); } } // namespace __llvm_libc diff --git a/libc/src/math/gpu/roundl.cpp b/libc/src/math/gpu/vendor/nextafter.cpp copy from libc/src/math/gpu/roundl.cpp copy to libc/src/math/gpu/vendor/nextafter.cpp --- a/libc/src/math/gpu/roundl.cpp +++ b/libc/src/math/gpu/vendor/nextafter.cpp @@ -1,4 +1,4 @@ -//===-- Implementation of the GPU roundl function -------------------------===// +//===-- Implementation of the nextafter function for GPU ------------------===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. @@ -6,18 +6,15 @@ // //===----------------------------------------------------------------------===// -#include "src/math/roundl.h" -#include "src/__support/FPUtil/PlatformDefs.h" +#include "src/math/nextafter.h" #include "src/__support/common.h" -namespace __llvm_libc { +#include "common.h" -#ifndef LONG_DOUBLE_IS_DOUBLE -#error "GPU targets do not support long doubles" -#endif +namespace __llvm_libc { -LLVM_LIBC_FUNCTION(long double, roundl, (long double x)) { - return __builtin_round(x); +LLVM_LIBC_FUNCTION(double, nextafter, (double x, double y)) { + return internal::nextafter(x, y); } } // namespace __llvm_libc diff --git a/libc/src/math/gpu/roundl.cpp b/libc/src/math/gpu/vendor/nextafterf.cpp copy from libc/src/math/gpu/roundl.cpp copy to libc/src/math/gpu/vendor/nextafterf.cpp --- a/libc/src/math/gpu/roundl.cpp +++ b/libc/src/math/gpu/vendor/nextafterf.cpp @@ -1,4 +1,4 @@ -//===-- Implementation of the GPU roundl function -------------------------===// +//===-- Implementation of the nextafterf function for GPU -----------------===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. @@ -6,18 +6,15 @@ // //===----------------------------------------------------------------------===// -#include "src/math/roundl.h" -#include "src/__support/FPUtil/PlatformDefs.h" +#include "src/math/nextafterf.h" #include "src/__support/common.h" -namespace __llvm_libc { +#include "common.h" -#ifndef LONG_DOUBLE_IS_DOUBLE -#error "GPU targets do not support long doubles" -#endif +namespace __llvm_libc { -LLVM_LIBC_FUNCTION(long double, roundl, (long double x)) { - return __builtin_round(x); +LLVM_LIBC_FUNCTION(float, nextafterf, (float x, float y)) { + return internal::nextafterf(x, y); } } // namespace __llvm_libc diff --git a/libc/src/math/gpu/vendor/nvptx/declarations.h b/libc/src/math/gpu/vendor/nvptx/declarations.h --- a/libc/src/math/gpu/vendor/nvptx/declarations.h +++ b/libc/src/math/gpu/vendor/nvptx/declarations.h @@ -38,9 +38,20 @@ long long __nv_llrintf(float); long long __nv_llround(double); long long __nv_llroundf(float); +double __nv_nextafter(double, double); +float __nv_nextafterf(float, float); double __nv_pow(double, double); float __nv_powf(float, float); double __nv_sin(double); +float __nv_sinf(float); +void __nv_sincos(double, double *, double *); +void __nv_sincosf(float, float *, float *); +double __nv_sinh(double); +float __nv_sinhf(float); +double __nv_tan(double); +float __nv_tanf(float); +double __nv_tanh(double); +float __nv_tanhf(float); } } // namespace __llvm_libc diff --git a/libc/src/math/gpu/vendor/nvptx/nvptx.h b/libc/src/math/gpu/vendor/nvptx/nvptx.h --- a/libc/src/math/gpu/vendor/nvptx/nvptx.h +++ b/libc/src/math/gpu/vendor/nvptx/nvptx.h @@ -41,9 +41,26 @@ LIBC_INLINE long long llrintf(float x) { return __nv_llrintf(x); } LIBC_INLINE long long llround(double x) { return __nv_llround(x); } LIBC_INLINE long long llroundf(float x) { return __nv_llroundf(x); } +LIBC_INLINE double nextafter(double x, double y) { + return __nv_nextafter(x, y); +} +LIBC_INLINE float nextafterf(float x, float y) { return __nv_nextafterf(x, y); } LIBC_INLINE double pow(double x, double y) { return __nv_pow(x, y); } LIBC_INLINE float powf(float x, float y) { return __nv_powf(x, y); } LIBC_INLINE double sin(double x) { return __nv_sin(x); } +LIBC_INLINE float sinf(float x) { return __nv_sinf(x); } +LIBC_INLINE void sincos(double x, double *sinptr, double *cosptr) { + return __nv_sincos(x, sinptr, cosptr); +} +LIBC_INLINE void sincosf(float x, float *sinptr, float *cosptr) { + return __nv_sincosf(x, sinptr, cosptr); +} +LIBC_INLINE double sinh(double x) { return __nv_sinh(x); } +LIBC_INLINE float sinhf(float x) { return __nv_sinhf(x); } +LIBC_INLINE double tan(double x) { return __nv_tan(x); } +LIBC_INLINE float tanf(float x) { return __nv_tanf(x); } +LIBC_INLINE double tanh(double x) { return __nv_tanh(x); } +LIBC_INLINE float tanhf(float x) { return __nv_tanhf(x); } } // namespace internal } // namespace __llvm_libc diff --git a/libc/src/math/gpu/roundl.cpp b/libc/src/math/gpu/vendor/sincos.cpp copy from libc/src/math/gpu/roundl.cpp copy to libc/src/math/gpu/vendor/sincos.cpp --- a/libc/src/math/gpu/roundl.cpp +++ b/libc/src/math/gpu/vendor/sincos.cpp @@ -1,4 +1,4 @@ -//===-- Implementation of the GPU roundl function -------------------------===// +//===-- Implementation of the sincos function for GPU ---------------------===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. @@ -6,18 +6,15 @@ // //===----------------------------------------------------------------------===// -#include "src/math/roundl.h" -#include "src/__support/FPUtil/PlatformDefs.h" +#include "src/math/sincos.h" #include "src/__support/common.h" -namespace __llvm_libc { +#include "common.h" -#ifndef LONG_DOUBLE_IS_DOUBLE -#error "GPU targets do not support long doubles" -#endif +namespace __llvm_libc { -LLVM_LIBC_FUNCTION(long double, roundl, (long double x)) { - return __builtin_round(x); +LLVM_LIBC_FUNCTION(void, sincos, (double x, double *sinptr, double *cosptr)) { + return internal::sincos(x, sinptr, cosptr); } } // namespace __llvm_libc diff --git a/libc/src/math/gpu/roundl.cpp b/libc/src/math/gpu/vendor/sincosf.cpp copy from libc/src/math/gpu/roundl.cpp copy to libc/src/math/gpu/vendor/sincosf.cpp --- a/libc/src/math/gpu/roundl.cpp +++ b/libc/src/math/gpu/vendor/sincosf.cpp @@ -1,4 +1,4 @@ -//===-- Implementation of the GPU roundl function -------------------------===// +//===-- Implementation of the sincosf function for GPU --------------------===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. @@ -6,18 +6,15 @@ // //===----------------------------------------------------------------------===// -#include "src/math/roundl.h" -#include "src/__support/FPUtil/PlatformDefs.h" +#include "src/math/sincosf.h" #include "src/__support/common.h" -namespace __llvm_libc { +#include "common.h" -#ifndef LONG_DOUBLE_IS_DOUBLE -#error "GPU targets do not support long doubles" -#endif +namespace __llvm_libc { -LLVM_LIBC_FUNCTION(long double, roundl, (long double x)) { - return __builtin_round(x); +LLVM_LIBC_FUNCTION(void, sincosf, (float x, float *sinptr, float *cosptr)) { + return internal::sincosf(x, sinptr, cosptr); } } // namespace __llvm_libc diff --git a/libc/src/math/gpu/roundl.cpp b/libc/src/math/gpu/vendor/sinf.cpp copy from libc/src/math/gpu/roundl.cpp copy to libc/src/math/gpu/vendor/sinf.cpp --- a/libc/src/math/gpu/roundl.cpp +++ b/libc/src/math/gpu/vendor/sinf.cpp @@ -1,4 +1,4 @@ -//===-- Implementation of the GPU roundl function -------------------------===// +//===-- Implementation of the sinf function for GPU -----------------------===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. @@ -6,18 +6,13 @@ // //===----------------------------------------------------------------------===// -#include "src/math/roundl.h" -#include "src/__support/FPUtil/PlatformDefs.h" +#include "src/math/sinf.h" #include "src/__support/common.h" -namespace __llvm_libc { +#include "common.h" -#ifndef LONG_DOUBLE_IS_DOUBLE -#error "GPU targets do not support long doubles" -#endif +namespace __llvm_libc { -LLVM_LIBC_FUNCTION(long double, roundl, (long double x)) { - return __builtin_round(x); -} +LLVM_LIBC_FUNCTION(float, sinf, (float x)) { return internal::sinf(x); } } // namespace __llvm_libc diff --git a/libc/src/math/gpu/roundl.cpp b/libc/src/math/gpu/vendor/sinh.cpp copy from libc/src/math/gpu/roundl.cpp copy to libc/src/math/gpu/vendor/sinh.cpp --- a/libc/src/math/gpu/roundl.cpp +++ b/libc/src/math/gpu/vendor/sinh.cpp @@ -1,4 +1,4 @@ -//===-- Implementation of the GPU roundl function -------------------------===// +//===-- Implementation of the sinh function for GPU -----------------------===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. @@ -6,18 +6,13 @@ // //===----------------------------------------------------------------------===// -#include "src/math/roundl.h" -#include "src/__support/FPUtil/PlatformDefs.h" +#include "src/math/sinh.h" #include "src/__support/common.h" -namespace __llvm_libc { +#include "common.h" -#ifndef LONG_DOUBLE_IS_DOUBLE -#error "GPU targets do not support long doubles" -#endif +namespace __llvm_libc { -LLVM_LIBC_FUNCTION(long double, roundl, (long double x)) { - return __builtin_round(x); -} +LLVM_LIBC_FUNCTION(double, sinh, (double x)) { return internal::sinh(x); } } // namespace __llvm_libc diff --git a/libc/src/math/gpu/roundl.cpp b/libc/src/math/gpu/vendor/sinhf.cpp copy from libc/src/math/gpu/roundl.cpp copy to libc/src/math/gpu/vendor/sinhf.cpp --- a/libc/src/math/gpu/roundl.cpp +++ b/libc/src/math/gpu/vendor/sinhf.cpp @@ -1,4 +1,4 @@ -//===-- Implementation of the GPU roundl function -------------------------===// +//===-- Implementation of the sinhf function for GPU ----------------------===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. @@ -6,18 +6,13 @@ // //===----------------------------------------------------------------------===// -#include "src/math/roundl.h" -#include "src/__support/FPUtil/PlatformDefs.h" +#include "src/math/sinhf.h" #include "src/__support/common.h" -namespace __llvm_libc { +#include "common.h" -#ifndef LONG_DOUBLE_IS_DOUBLE -#error "GPU targets do not support long doubles" -#endif +namespace __llvm_libc { -LLVM_LIBC_FUNCTION(long double, roundl, (long double x)) { - return __builtin_round(x); -} +LLVM_LIBC_FUNCTION(float, sinhf, (float x)) { return internal::sinhf(x); } } // namespace __llvm_libc diff --git a/libc/src/math/gpu/roundl.cpp b/libc/src/math/gpu/vendor/tan.cpp copy from libc/src/math/gpu/roundl.cpp copy to libc/src/math/gpu/vendor/tan.cpp --- a/libc/src/math/gpu/roundl.cpp +++ b/libc/src/math/gpu/vendor/tan.cpp @@ -1,4 +1,4 @@ -//===-- Implementation of the GPU roundl function -------------------------===// +//===-- Implementation of the tan function for GPU ------------------------===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. @@ -6,18 +6,13 @@ // //===----------------------------------------------------------------------===// -#include "src/math/roundl.h" -#include "src/__support/FPUtil/PlatformDefs.h" +#include "src/math/tan.h" #include "src/__support/common.h" -namespace __llvm_libc { +#include "common.h" -#ifndef LONG_DOUBLE_IS_DOUBLE -#error "GPU targets do not support long doubles" -#endif +namespace __llvm_libc { -LLVM_LIBC_FUNCTION(long double, roundl, (long double x)) { - return __builtin_round(x); -} +LLVM_LIBC_FUNCTION(double, tan, (double x)) { return internal::tan(x); } } // namespace __llvm_libc diff --git a/libc/src/math/gpu/roundl.cpp b/libc/src/math/gpu/vendor/tanf.cpp copy from libc/src/math/gpu/roundl.cpp copy to libc/src/math/gpu/vendor/tanf.cpp --- a/libc/src/math/gpu/roundl.cpp +++ b/libc/src/math/gpu/vendor/tanf.cpp @@ -1,4 +1,4 @@ -//===-- Implementation of the GPU roundl function -------------------------===// +//===-- Implementation of the tanf function for GPU -----------------------===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. @@ -6,18 +6,13 @@ // //===----------------------------------------------------------------------===// -#include "src/math/roundl.h" -#include "src/__support/FPUtil/PlatformDefs.h" +#include "src/math/tanf.h" #include "src/__support/common.h" -namespace __llvm_libc { +#include "common.h" -#ifndef LONG_DOUBLE_IS_DOUBLE -#error "GPU targets do not support long doubles" -#endif +namespace __llvm_libc { -LLVM_LIBC_FUNCTION(long double, roundl, (long double x)) { - return __builtin_round(x); -} +LLVM_LIBC_FUNCTION(float, tanf, (float x)) { return internal::tanf(x); } } // namespace __llvm_libc diff --git a/libc/src/math/gpu/roundl.cpp b/libc/src/math/gpu/vendor/tanh.cpp copy from libc/src/math/gpu/roundl.cpp copy to libc/src/math/gpu/vendor/tanh.cpp --- a/libc/src/math/gpu/roundl.cpp +++ b/libc/src/math/gpu/vendor/tanh.cpp @@ -1,4 +1,4 @@ -//===-- Implementation of the GPU roundl function -------------------------===// +//===-- Implementation of the tanh function for GPU -----------------------===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. @@ -6,18 +6,13 @@ // //===----------------------------------------------------------------------===// -#include "src/math/roundl.h" -#include "src/__support/FPUtil/PlatformDefs.h" +#include "src/math/tanh.h" #include "src/__support/common.h" -namespace __llvm_libc { +#include "common.h" -#ifndef LONG_DOUBLE_IS_DOUBLE -#error "GPU targets do not support long doubles" -#endif +namespace __llvm_libc { -LLVM_LIBC_FUNCTION(long double, roundl, (long double x)) { - return __builtin_round(x); -} +LLVM_LIBC_FUNCTION(double, tanh, (double x)) { return internal::tanh(x); } } // namespace __llvm_libc diff --git a/libc/src/math/gpu/roundl.cpp b/libc/src/math/gpu/vendor/tanhf.cpp rename from libc/src/math/gpu/roundl.cpp rename to libc/src/math/gpu/vendor/tanhf.cpp --- a/libc/src/math/gpu/roundl.cpp +++ b/libc/src/math/gpu/vendor/tanhf.cpp @@ -1,4 +1,4 @@ -//===-- Implementation of the GPU roundl function -------------------------===// +//===-- Implementation of the tanhf function for GPU ----------------------===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. @@ -6,18 +6,13 @@ // //===----------------------------------------------------------------------===// -#include "src/math/roundl.h" -#include "src/__support/FPUtil/PlatformDefs.h" +#include "src/math/tanhf.h" #include "src/__support/common.h" -namespace __llvm_libc { +#include "common.h" -#ifndef LONG_DOUBLE_IS_DOUBLE -#error "GPU targets do not support long doubles" -#endif +namespace __llvm_libc { -LLVM_LIBC_FUNCTION(long double, roundl, (long double x)) { - return __builtin_round(x); -} +LLVM_LIBC_FUNCTION(float, tanhf, (float x)) { return internal::tanhf(x); } } // namespace __llvm_libc diff --git a/libc/src/math/sinh.h b/libc/src/math/sinh.h new file mode 100644 --- /dev/null +++ b/libc/src/math/sinh.h @@ -0,0 +1,18 @@ +//===-- Implementation header for sinh --------------------------*- 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 LLVM_LIBC_SRC_MATH_SINH_H +#define LLVM_LIBC_SRC_MATH_SINH_H + +namespace __llvm_libc { + +double sinh(double x); + +} // namespace __llvm_libc + +#endif // LLVM_LIBC_SRC_MATH_SINH_H diff --git a/libc/src/math/tanh.h b/libc/src/math/tanh.h new file mode 100644 --- /dev/null +++ b/libc/src/math/tanh.h @@ -0,0 +1,18 @@ +//===-- Implementation header for tanh --------------------------*- 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 LLVM_LIBC_SRC_MATH_TANH_H +#define LLVM_LIBC_SRC_MATH_TANH_H + +namespace __llvm_libc { + +double tanh(double x); + +} // namespace __llvm_libc + +#endif // LLVM_LIBC_SRC_MATH_TANH_H