Populating 'libmgpu.a' for math on the GPU

[AntonRydahl]

Summary

This commit adresses the discussions from patch D152575. From previous discussions, we agreed that __builtin math functions should be used as
long as they would compile to NVPTX and AMD-GCN/AMD-HSA targets. I found that the __builtin functions compiled to GPU code in all cases. That was tested in the following way:

bash
clang++ -O3 -pthread -fno-dwarf2-cfi-asm -fno-asynchronous-unwind-tables -mcpu=gfx1100 --target=amdgcn-amd-amdhsa -nogpulib -I../llvm-project/libc -fno-pie -emit-llvm -S
<file>.cpp -o <file>.ll
llvm-as <file>.ll -o <file>.bc
llc -mcpu=gfx1100 -filetype=obj -relocation-model=pic <file>.bc -o <file>.o

However, I have not tested if the code performed well on the GPU target or if it compiles to NVPTX.

__builtin Functions

The following __builtin functions were added.

• Added modf and modff.
• Added nearbyint and nearbyintf.
• Added nextafter and nextafterf.
• Added remainder and remainderf.
• Added remquo and remquof.
• Added rint and rintf.
• Added scalbn and scalbnf.
• Added sinh and sinhf.
• Added sqrt and sqrtf.
• Added tan and tanf.
• Added tanh and tanhf.
• Added trunc and truncf.

Vendor Functions

The following vendor functions were added, because the __builtin versions do not exist in the LLVM project, as far as I am aware.

• Added sincos and sincosf.

libc Header Files

The following header files were introduced to libc:

• sinh.
• tanh.

[jhuber6]

I'm wondering in general if we should bother supporting the long double variants of some of these. Both AMDGPU and NVPTX explicitly state that long double is just double on the GPU architecture so they're equivalent to the regular doubleversions.

[jdoerfert]

In D153395#4436654, @jhuber6 wrote:

I'm wondering in general if we should bother supporting the long double variants of some of these. Both AMDGPU and NVPTX explicitly state that long double is just double on the GPU architecture so they're equivalent to the regular doubleversions.

I don't think we should, at least not by default. It would be very surprising, IMHO.

[jhuber6]

In D153395#4436706, @jdoerfert wrote:

I don't think we should, at least not by default. It would be very surprising, IMHO.

Agreed, I think having these default to a linker failure is a good way to state that it's not supported. IIRC CUDA's nvcc gives you warnings if you use a long double since it's just a double. So, please remove the long double variants from this patch for now.

[AntonRydahl]

Thank you! I see that it does not make sense to have the long double versions if a long double is equivalent to a double on the GPUs. I will remove them later today.

[AntonRydahl]

As suggested, the long double versions of the math functions were removed in this commit.

[jhuber6]

libc/src/math/gpu/sqrt.cpp

14

According to @arsenm these aren't correct now so we should proabably use the vendor versions for now.

[arsenm]

libc/src/math/gpu/sqrt.cpp

14

The f64 sqrt patch is basically postable now (the basic correct path is done, fast math 1 / sqrt(x)) folds still need to be done)

[arsenm]

libc/src/math/gpu/sqrt.cpp

14

D153472

[AntonRydahl]

libc/src/math/gpu/sqrt.cpp

14

Should I also add the vendor versions of the trigonometric functions such as sinh and tan?

14

Should I just add D153472 as a parent of this patch?

[arsenm]

libc/src/math/gpu/sqrt.cpp

14

Sure why not, they're there. Depends how much you want to put in one patch.

Nobody's reliant on this code right now so I don't think it matter which lands first

[AntonRydahl]

Added vendor versions of trigonometric functions as some of them do not compile to NVPTX.

[jhuber6]

Looks reasonable, we will definitely need some tests for these soon.

[AntonRydahl]

Rebased the patch on upstream LLVM.

[arsenm]

libc/src/math/gpu/vendor/amdgpu/amdgpu.h

59

I thought I had already added an ocml_sincos_stret but I guess not, should switch to that whenever that gets added

libc/src/math/gpu/vendor/amdgpu/declarations.h

47

This won't actually work, the underlying pointer uses a private pointer. you can't simply declare as flat and call it. Probably should just define the struct return variant and use that. it's a lot less ugly than dealing with the pointer wrapping

[jhuber6]

libc/src/math/gpu/vendor/amdgpu/declarations.h

47

Variables declared on the stack should be private as far as I know. I figured the semantics are the same as the regular sincos where we just write to whatever pointer we're given. If it's a stack pointer it'll be private, if it's a global it won't be and it'll be up to the user to not have that conlift.

[arsenm]

libc/src/math/gpu/vendor/amdgpu/declarations.h

47

The ocml functions aren’t magic. This is declared with the wrong type

[jhuber6]

libc/src/math/gpu/vendor/amdgpu/declarations.h

47

Ah, so internally it expects private pointers and we need to make sure that whatever address space cast is required is done prior to calling it? I'm assuming that'll be something like __attribute__((address_space(5))) and we'll need to manually convert from it. I may need to have some utility header that assigns global, private, and local address spaces depending on the target since this is all pure C++ without the standard address space checks you'd get in OpenCL or something.

[arsenm]

libc/src/math/gpu/vendor/amdgpu/declarations.h

47

Yes. I'm looking into adding the stret variants but having a naming things is hard problem

[AntonRydahl]

We found that __builtin_nextafter and __builtin_nextafter were not correctly lowered. Therefore, they have been replaced with vendor versions.

[arsenm]

In D153395#4548952, @AntonRydahl wrote:

We found that __builtin_nextafter and __builtin_nextafter were not correctly lowered. Therefore, they have been replaced with vendor versions.

nextafter isn't that complicated to implement, could just write one

[jhuber6]

In D153395#4548955, @arsenm wrote:

In D153395#4548952, @AntonRydahl wrote:

We found that __builtin_nextafter and __builtin_nextafter were not correctly lowered. Therefore, they have been replaced with vendor versions.

nextafter isn't that complicated to implement, could just write one

The libc library has a generic version that's most likely suitable to use. If we just list nextafter in entrypoints.txt but do not provide a vendor or gpu implementation it should be used.

[arsenm]

In D153395#4548960, @jhuber6 wrote:

In D153395#4548955, @arsenm wrote:

In D153395#4548952, @AntonRydahl wrote:

We found that __builtin_nextafter and __builtin_nextafter were not correctly lowered. Therefore, they have been replaced with vendor versions.

nextafter isn't that complicated to implement, could just write one

The libc library has a generic version that's most likely suitable to use. If we just list nextafter in entrypoints.txt but do not provide a vendor or gpu implementation it should be used.

Looks a branchy/early-returny in ways the optimizer isn't aggressive enough at speculating

[jhuber6]

In D153395#4548963, @arsenm wrote:

Looks a branchy/early-returny in ways the optimizer isn't aggressive enough at speculating

Yeah, probably something we could ask @lntue about. Looking at https://github.com/RadeonOpenCompute/ROCm-Device-Libs/blob/c1a736ae458f49e526932b3da611f6bd571a1c47/ocml/src/nextafterD.cl#L4 it looks much less branchy, presumably all the ternaries will get put into predicate registers for AMDGPU / NVPTX.

[AntonRydahl]

Shall I just update the patch to include the entry points generic.nextafter and generic.nextafterf rather than the vendor versions?

[jhuber6]

We can probably just go with the generic version even if it may be a little slow, more likely to pass the tests. Probably just worth noting we could implement it more optimally later.

[arsenm]

In D153395#4550720, @jhuber6 wrote:

We can probably just go with the generic version even if it may be a little slow, more likely to pass the tests. Probably just worth noting we could implement it more optimally later.

I’d just go for the overload for now

[AntonRydahl]

In D153395#4551023, @arsenm wrote:

In D153395#4550720, @jhuber6 wrote:

We can probably just go with the generic version even if it may be a little slow, more likely to pass the tests. Probably just worth noting we could implement it more optimally later.

I’d just go for the overload for now

I am sorry, but I don't understand what you mean by overloading in this context. Could you please phrase it in another way?

[arsenm]

In D153395#4551304, @AntonRydahl wrote:

In D153395#4551023, @arsenm wrote:

In D153395#4550720, @jhuber6 wrote:

We can probably just go with the generic version even if it may be a little slow, more likely to pass the tests. Probably just worth noting we could implement it more optimally later.

I’d just go for the overload for now

I am sorry, but I don't understand what you mean by overloading in this context. Could you please phrase it in another way?

Leave what you have calling the ocml nextafter

[AntonRydahl]

In D153395#4551428, @arsenm wrote:

In D153395#4551304, @AntonRydahl wrote:

In D153395#4551023, @arsenm wrote:

In D153395#4550720, @jhuber6 wrote:

We can probably just go with the generic version even if it may be a little slow, more likely to pass the tests. Probably just worth noting we could implement it more optimally later.

I’d just go for the overload for now

I am sorry, but I don't understand what you mean by overloading in this context. Could you please phrase it in another way?

Leave what you have calling the ocml nextafter

Thanks for the clarification!

libc/config/gpu/entrypoints.txt

set(TARGET_LIBM_ENTRYPOINTS
     libc.src.math.ldexpf
     libc.src.math.llrint
     libc.src.math.llrintf
     libc.src.math.llround
     libc.src.math.llroundf
     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
   ${TARGET_LIBC_ENTRYPOINTS}
   ${TARGET_LIBM_ENTRYPOINTS}
 )

libc/src/math/CMakeLists.txt

 add_math_entrypoint_object(scalbn)
 add_math_entrypoint_object(scalbnf)
 add_math_entrypoint_object(scalbnl)
 
 add_math_entrypoint_object(sincosf)
 
 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)
 add_math_entrypoint_object(sqrtf)
 add_math_entrypoint_object(sqrtl)
 
 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)
 add_math_entrypoint_object(truncf)
 add_math_entrypoint_object(truncl)

libc/src/math/gpu/CMakeLists.txt

SRCS
     frexpf.cpp
   HDRS
     ../frexpf.h
   COMPILE_OPTIONS
     -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
     round.cpp
   HDRS
     ../round.h
   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

libc/src/math/gpu/modf.cpp

-//===-- 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.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
-#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

libc/src/math/gpu/modff.cpp

-//===-- 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.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
-#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

libc/src/math/gpu/nearbyint.cpp

-//===-- 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.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
-#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

libc/src/math/gpu/nearbyintf.cpp

-//===-- 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.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
-#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

libc/src/math/gpu/remainder.cpp

-//===-- 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.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
-#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

libc/src/math/gpu/remainderf.cpp

-//===-- 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.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
-#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

libc/src/math/gpu/remquo.cpp

-//===-- 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.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
-#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

libc/src/math/gpu/remquof.cpp

-//===-- 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.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
-#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

libc/src/math/gpu/rint.cpp

-//===-- 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.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
-#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

libc/src/math/gpu/rintf.cpp

-//===-- 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.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
-#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

libc/src/math/gpu/scalbn.cpp

-//===-- 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.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
-#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

libc/src/math/gpu/scalbnf.cpp

-//===-- 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.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
-#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

libc/src/math/gpu/sinh.cpp

-//===-- 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.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
-#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

libc/src/math/gpu/sinhf.cpp

-//===-- 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.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
-#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

libc/src/math/gpu/sqrt.cpp

-//===-- 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.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
-#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

libc/src/math/gpu/sqrtf.cpp

-//===-- 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.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
-#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

libc/src/math/gpu/tan.cpp

-//===-- 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.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
-#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

libc/src/math/gpu/tanf.cpp

-//===-- 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.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
-#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

libc/src/math/gpu/tanh.cpp

-//===-- 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.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
-#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

libc/src/math/gpu/tanhf.cpp

-//===-- 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.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
-#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

libc/src/math/gpu/trunc.cpp

-//===-- 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.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
-#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

libc/src/math/gpu/truncf.cpp

-//===-- 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.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
-#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

libc/src/math/gpu/vendor/CMakeLists.txt

add_entrypoint_object(
   HDRS
     ../../llroundf.h
   COMPILE_OPTIONS
     ${bitcode_link_flags}
     -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
     pow.cpp
   HDRS
     ../../pow.h
   COMPILE_OPTIONS
     ${bitcode_link_flags}
     -O2
add_entrypoint_object(
   SRCS
     sin.cpp
   HDRS
     ../../sin.h
   COMPILE_OPTIONS
     ${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

libc/src/math/gpu/vendor/amdgpu/amdgpu.h

 LIBC_INLINE int ilogb(double x) { return __ocml_ilogb_f64(x); }
 LIBC_INLINE int ilogbf(float x) { return __ocml_ilogb_f32(x); }
 LIBC_INLINE double ldexp(double x, int i) { return __builtin_ldexp(x, i); }
 LIBC_INLINE float ldexpf(float x, int i) { return __builtin_ldexpf(x, i); }
 LIBC_INLINE long long llrint(double x) { return __builtin_rint(x); }
 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
 
 #endif // LLVM_LIBC_SRC_MATH_GPU_AMDGPU_H

libc/src/math/gpu/vendor/amdgpu/declarations.h

 float __ocml_fdim_f32(float, float);
 double __ocml_fdim_f64(double, double);
 double __ocml_hypot_f64(double, double);
 float __ocml_hypot_f32(float, float);
 int __ocml_ilogb_f64(double);
 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
 
 #endif // LLVM_LIBC_SRC_MATH_GPU_AMDGPU_DECLARATIONS_H

libc/src/math/gpu/vendor/nextafter.cpp

-//===-- 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.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
-#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

libc/src/math/gpu/vendor/nextafterf.cpp

-//===-- 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.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
-#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

libc/src/math/gpu/vendor/nvptx/declarations.h

 int __nv_ilogb(double);
 int __nv_ilogbf(float);
 double __nv_ldexp(double, int);
 float __nv_ldexpf(float, int);
 long long __nv_llrint(double);
 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
 
 #endif // LLVM_LIBC_SRC_MATH_GPU_NVPTX_DECLARATIONS_H

libc/src/math/gpu/vendor/nvptx/nvptx.h

 LIBC_INLINE int ilogb(double x) { return __nv_ilogb(x); }
 LIBC_INLINE int ilogbf(float x) { return __nv_ilogbf(x); }
 LIBC_INLINE double ldexp(double x, int i) { return __nv_ldexp(x, i); }
 LIBC_INLINE float ldexpf(float x, int i) { return __nv_ldexpf(x, i); }
 LIBC_INLINE long long llrint(double x) { return __nv_llrint(x); }
 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
 
 #endif // LLVM_LIBC_SRC_MATH_GPU_NVPTX_H

libc/src/math/gpu/vendor/sincos.cpp

-//===-- 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.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
-#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

libc/src/math/gpu/vendor/sincosf.cpp

-//===-- 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.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
-#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

libc/src/math/gpu/vendor/sinf.cpp

-//===-- 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.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
-#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

libc/src/math/gpu/vendor/sinh.cpp

-//===-- 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.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
-#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

libc/src/math/gpu/vendor/sinhf.cpp

-//===-- 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.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
-#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

libc/src/math/gpu/vendor/tan.cpp

-//===-- 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.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
-#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

libc/src/math/gpu/vendor/tanf.cpp

-//===-- 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.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
-#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

libc/src/math/gpu/vendor/tanh.cpp

-//===-- 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.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
-#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

libc/src/math/gpu/vendor/tanhf.cpp

-//===-- 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.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
-#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

libc/src/math/sinh.h

+//===-- 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

libc/src/math/tanh.h

+//===-- 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