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

26

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

18

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

18

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

18

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

[jhuber6]

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

18

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

18

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_LIBC_ENTRYPOINTS
     libc.src.gpu.rpc_reset
 )
 
 set(TARGET_LIBM_ENTRYPOINTS
     # math.h entrypoints
     libc.src.math.fma
     libc.src.math.fmaf
     libc.src.math.sin
+    libc.src.math.modf
+    libc.src.math.modff
+    libc.src.math.modfl
+    libc.src.math.nearbyint
+    libc.src.math.nearbyintf
+    libc.src.math.nearbyintl
+    libc.src.math.nextafter
+    libc.src.math.nextafterf
+    libc.src.math.nextafterl
+    libc.src.math.remainder
+    libc.src.math.remainderf
+    libc.src.math.remainderl
+    libc.src.math.remquo
+    libc.src.math.remquof
+    libc.src.math.remquol
+    libc.src.math.rint
+    libc.src.math.rintf
+    libc.src.math.rintl
     libc.src.math.round
     libc.src.math.roundf
     libc.src.math.roundl
+    libc.src.math.scalbn
+    libc.src.math.scalbnf
+    libc.src.math.scalbnl
+    libc.src.math.sinh
+    libc.src.math.sinhf
+    libc.src.math.sinhl
+    libc.src.math.sqrt
+    libc.src.math.sqrtf
+    libc.src.math.sqrtl
+    libc.src.math.tan
+    libc.src.math.tanf
+    libc.src.math.tanl
+    libc.src.math.tanh
+    libc.src.math.tanhf
+    libc.src.math.tanhl
+    libc.src.math.trunc
+    libc.src.math.truncf
+    libc.src.math.truncl
 )
 
 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(sinhl)
 
 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(tanl)
+
+add_math_entrypoint_object(tanh)
 add_math_entrypoint_object(tanhf)
+add_math_entrypoint_object(tanhl)
 
 add_math_entrypoint_object(trunc)
 add_math_entrypoint_object(truncf)
 add_math_entrypoint_object(truncl)

libc/src/math/gpu/CMakeLists.txt

function(add_math_entrypoint_gpu_object name)
 
   add_entrypoint_object(
     ${name}
     ${ARGN}
   )
 endfunction()
 
 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(
+  modfl
+  SRCS
+    modfl.cpp
+  HDRS
+    ../modfl.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(
+  nearbyintl
+  SRCS
+    nearbyintl.cpp
+  HDRS
+    ../nearbyintl.h
+  COMPILE_OPTIONS
+    -O2
+)
+
+add_math_entrypoint_gpu_object(
+  nextafter
+  SRCS
+    nextafter.cpp
+  HDRS
+    ../nextafter.h
+  COMPILE_OPTIONS
+    -O2
+)
+
+add_math_entrypoint_gpu_object(
+  nextafterf
+  SRCS
+    nextafterf.cpp
+  HDRS
+    ../nextafterf.h
+  COMPILE_OPTIONS
+    -O2
+)
+
+add_math_entrypoint_gpu_object(
+  nextafterl
+  SRCS
+    nextafterl.cpp
+  HDRS
+    ../nextafterl.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(
+  remainderl
+  SRCS
+    remainderl.cpp
+  HDRS
+    ../remainderl.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(
+  remquol
+  SRCS
+    remquol.cpp
+  HDRS
+    ../remquol.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(
+  rintl
+  SRCS
+    rintl.cpp
+  HDRS
+    ../rintl.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(
+  scalbnl
+  SRCS
+    scalbnl.cpp
+  HDRS
+    ../scalbnl.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(
+  sinhl
+  SRCS
+    sinhl.cpp
+  HDRS
+    ../sinhl.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(
+  sqrtl
+  SRCS
+    sqrtl.cpp
+  HDRS
+    ../sqrtl.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(
+  tanl
+  SRCS
+    tanl.cpp
+  HDRS
+    ../tanl.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(
+  tanhl
+  SRCS
+    tanhl.cpp
+  HDRS
+    ../tanhl.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
+)
+
+add_math_entrypoint_gpu_object(
+  truncl
+  SRCS
+    truncl.cpp
+  HDRS
+    ../truncl.h
+  COMPILE_OPTIONS
+    -O2
+)
 No newline at end of file

libc/src/math/gpu/modf.cpp

-//===-- NVPTX specific declarations for math support ----------------------===//
+//===-- 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
 //
 //===----------------------------------------------------------------------===//
 
-#ifndef LLVM_LIBC_SRC_MATH_GPU_NVPTX_DECLARATIONS_H
-#define LLVM_LIBC_SRC_MATH_GPU_NVPTX_DECLARATIONS_H
+#include "src/math/modf.h"
+#include "src/__support/common.h"
 
 namespace __llvm_libc {
 
-extern "C" {
-double __nv_sin(double);
+LLVM_LIBC_FUNCTION(double, modf, (double x, double *iptr)) {
+  return __builtin_modf(x, iptr);
 }
 
 } // namespace __llvm_libc
-
-#endif // LLVM_LIBC_SRC_MATH_GPU_NVPTX_DECLARATIONS_H

libc/src/math/gpu/modff.cpp

-//===-- NVPTX specific declarations for math support ----------------------===//
+//===-- 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
 //
 //===----------------------------------------------------------------------===//
 
-#ifndef LLVM_LIBC_SRC_MATH_GPU_NVPTX_DECLARATIONS_H
-#define LLVM_LIBC_SRC_MATH_GPU_NVPTX_DECLARATIONS_H
+#include "src/math/modff.h"
+#include "src/__support/common.h"
 
 namespace __llvm_libc {
 
-extern "C" {
-double __nv_sin(double);
+LLVM_LIBC_FUNCTION(float, modff, (float x, float *iptr)) {
+  return __builtin_modff(x, iptr);
 }
 
 } // namespace __llvm_libc
-
-#endif // LLVM_LIBC_SRC_MATH_GPU_NVPTX_DECLARATIONS_H

libc/src/math/gpu/modfl.cpp

-//===-- NVPTX specific declarations for math support ----------------------===//
+//===-- Implementation of the GPU modfl 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
 //
 //===----------------------------------------------------------------------===//
 
-#ifndef LLVM_LIBC_SRC_MATH_GPU_NVPTX_DECLARATIONS_H
-#define LLVM_LIBC_SRC_MATH_GPU_NVPTX_DECLARATIONS_H
+#include "src/math/modfl.h"
+#include "src/__support/common.h"
 
 namespace __llvm_libc {
 
-extern "C" {
-double __nv_sin(double);
+LLVM_LIBC_FUNCTION(long double, modfl, (long double x, long double *iptr)) {
+  return __builtin_modfl(x, iptr);
 }
 
 } // namespace __llvm_libc
-
-#endif // LLVM_LIBC_SRC_MATH_GPU_NVPTX_DECLARATIONS_H

libc/src/math/gpu/nearbyint.cpp

-//===-- NVPTX specific declarations for math support ----------------------===//
+//===-- 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
 //
 //===----------------------------------------------------------------------===//
 
-#ifndef LLVM_LIBC_SRC_MATH_GPU_NVPTX_DECLARATIONS_H
-#define LLVM_LIBC_SRC_MATH_GPU_NVPTX_DECLARATIONS_H
+#include "src/math/nearbyint.h"
+#include "src/__support/common.h"
 
 namespace __llvm_libc {
 
-extern "C" {
-double __nv_sin(double);
+LLVM_LIBC_FUNCTION(double, nearbyint, (double x)) {
+  return __builtin_nearbyint(x);
 }
 
 } // namespace __llvm_libc
-
-#endif // LLVM_LIBC_SRC_MATH_GPU_NVPTX_DECLARATIONS_H

libc/src/math/gpu/nearbyintf.cpp

-//===-- NVPTX specific declarations for math support ----------------------===//
+//===-- 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
 //
 //===----------------------------------------------------------------------===//
 
-#ifndef LLVM_LIBC_SRC_MATH_GPU_NVPTX_DECLARATIONS_H
-#define LLVM_LIBC_SRC_MATH_GPU_NVPTX_DECLARATIONS_H
+#include "src/math/nearbyintf.h"
+#include "src/__support/common.h"
 
 namespace __llvm_libc {
 
-extern "C" {
-double __nv_sin(double);
+LLVM_LIBC_FUNCTION(float, nearbyintf, (float x)) {
+  return __builtin_nearbyintf(x);
 }
 
 } // namespace __llvm_libc
-
-#endif // LLVM_LIBC_SRC_MATH_GPU_NVPTX_DECLARATIONS_H

libc/src/math/gpu/nearbyintl.cpp

-//===-- NVPTX specific declarations for math support ----------------------===//
+//===-- Implementation of the GPU nearbyintl 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
 //
 //===----------------------------------------------------------------------===//
 
-#ifndef LLVM_LIBC_SRC_MATH_GPU_NVPTX_DECLARATIONS_H
-#define LLVM_LIBC_SRC_MATH_GPU_NVPTX_DECLARATIONS_H
+#include "src/math/nearbyintl.h"
+#include "src/__support/common.h"
 
 namespace __llvm_libc {
 
-extern "C" {
-double __nv_sin(double);
+LLVM_LIBC_FUNCTION(long double, nearbyintl, (long double x)) {
+  return __builtin_nearbyintl(x);
 }
 
 } // namespace __llvm_libc
-
-#endif // LLVM_LIBC_SRC_MATH_GPU_NVPTX_DECLARATIONS_H

libc/src/math/gpu/nextafter.cpp

-//===-- NVPTX specific declarations for math support ----------------------===//
+//===-- Implementation of the GPU nextafter 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
 //
 //===----------------------------------------------------------------------===//
 
-#ifndef LLVM_LIBC_SRC_MATH_GPU_NVPTX_DECLARATIONS_H
-#define LLVM_LIBC_SRC_MATH_GPU_NVPTX_DECLARATIONS_H
+#include "src/math/nextafter.h"
+#include "src/__support/common.h"
 
 namespace __llvm_libc {
 
-extern "C" {
-double __nv_sin(double);
+LLVM_LIBC_FUNCTION(double, nextafter, (double x, double y)) {
+  return __builtin_nextafter(x, y);
 }
 
 } // namespace __llvm_libc
-
-#endif // LLVM_LIBC_SRC_MATH_GPU_NVPTX_DECLARATIONS_H

libc/src/math/gpu/nextafterf.cpp

-//===-- NVPTX specific declarations for math support ----------------------===//
+//===-- Implementation of the GPU nextafterf 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
 //
 //===----------------------------------------------------------------------===//
 
-#ifndef LLVM_LIBC_SRC_MATH_GPU_NVPTX_DECLARATIONS_H
-#define LLVM_LIBC_SRC_MATH_GPU_NVPTX_DECLARATIONS_H
+#include "src/math/nextafterf.h"
+#include "src/__support/common.h"
 
 namespace __llvm_libc {
 
-extern "C" {
-double __nv_sin(double);
+LLVM_LIBC_FUNCTION(float, nextafterf, (float x, float y)) {
+  return __builtin_nextafterf(x, y);
 }
 
 } // namespace __llvm_libc
-
-#endif // LLVM_LIBC_SRC_MATH_GPU_NVPTX_DECLARATIONS_H

libc/src/math/gpu/nextafterl.cpp

-//===-- NVPTX specific declarations for math support ----------------------===//
+//===-- Implementation of the GPU nextafterl 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
 //
 //===----------------------------------------------------------------------===//
 
-#ifndef LLVM_LIBC_SRC_MATH_GPU_NVPTX_DECLARATIONS_H
-#define LLVM_LIBC_SRC_MATH_GPU_NVPTX_DECLARATIONS_H
+#include "src/math/nextafterl.h"
+#include "src/__support/common.h"
 
 namespace __llvm_libc {
 
-extern "C" {
-double __nv_sin(double);
+LLVM_LIBC_FUNCTION(long double, nextafterl, (long double x, long double y)) {
+  return __builtin_nextafterl(x, y);
 }
 
 } // namespace __llvm_libc
-
-#endif // LLVM_LIBC_SRC_MATH_GPU_NVPTX_DECLARATIONS_H

libc/src/math/gpu/remainder.cpp

-//===-- NVPTX specific declarations for math support ----------------------===//
+//===-- 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
 //
 //===----------------------------------------------------------------------===//
 
-#ifndef LLVM_LIBC_SRC_MATH_GPU_NVPTX_DECLARATIONS_H
-#define LLVM_LIBC_SRC_MATH_GPU_NVPTX_DECLARATIONS_H
+#include "src/math/remainder.h"
+#include "src/__support/common.h"
 
 namespace __llvm_libc {
 
-extern "C" {
-double __nv_sin(double);
+LLVM_LIBC_FUNCTION(double, remainder, (double x, double y)) {
+  return __builtin_remainder(x, y);
 }
 
 } // namespace __llvm_libc
-
-#endif // LLVM_LIBC_SRC_MATH_GPU_NVPTX_DECLARATIONS_H

libc/src/math/gpu/remainderf.cpp

-//===-- NVPTX specific declarations for math support ----------------------===//
+//===-- 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
 //
 //===----------------------------------------------------------------------===//
 
-#ifndef LLVM_LIBC_SRC_MATH_GPU_NVPTX_DECLARATIONS_H
-#define LLVM_LIBC_SRC_MATH_GPU_NVPTX_DECLARATIONS_H
+#include "src/math/remainderf.h"
+#include "src/__support/common.h"
 
 namespace __llvm_libc {
 
-extern "C" {
-double __nv_sin(double);
+LLVM_LIBC_FUNCTION(float, remainderf, (float x, float y)) {
+  return __builtin_remainderf(x, y);
 }
 
 } // namespace __llvm_libc
-
-#endif // LLVM_LIBC_SRC_MATH_GPU_NVPTX_DECLARATIONS_H

libc/src/math/gpu/remainderl.cpp

-//===-- NVPTX specific declarations for math support ----------------------===//
+//===-- Implementation of the GPU remainderl 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
 //
 //===----------------------------------------------------------------------===//
 
-#ifndef LLVM_LIBC_SRC_MATH_GPU_NVPTX_DECLARATIONS_H
-#define LLVM_LIBC_SRC_MATH_GPU_NVPTX_DECLARATIONS_H
+#include "src/math/remainderl.h"
+#include "src/__support/common.h"
 
 namespace __llvm_libc {
 
-extern "C" {
-double __nv_sin(double);
+LLVM_LIBC_FUNCTION(long double, remainderl, (long double x, long double y)) {
+  return __builtin_remainderl(x, y);
 }
 
 } // namespace __llvm_libc
-
-#endif // LLVM_LIBC_SRC_MATH_GPU_NVPTX_DECLARATIONS_H

libc/src/math/gpu/remquo.cpp

-//===-- NVPTX specific declarations for math support ----------------------===//
+//===-- 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
 //
 //===----------------------------------------------------------------------===//
 
-#ifndef LLVM_LIBC_SRC_MATH_GPU_NVPTX_DECLARATIONS_H
-#define LLVM_LIBC_SRC_MATH_GPU_NVPTX_DECLARATIONS_H
+#include "src/math/remquo.h"
+#include "src/__support/common.h"
 
 namespace __llvm_libc {
 
-extern "C" {
-double __nv_sin(double);
+LLVM_LIBC_FUNCTION(double, remquo, (double x, double y, int *quo)) {
+  return __builtin_remquo(x, y, quo);
 }
 
 } // namespace __llvm_libc
-
-#endif // LLVM_LIBC_SRC_MATH_GPU_NVPTX_DECLARATIONS_H

libc/src/math/gpu/remquof.cpp

-//===-- NVPTX specific declarations for math support ----------------------===//
+//===-- 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
 //
 //===----------------------------------------------------------------------===//
 
-#ifndef LLVM_LIBC_SRC_MATH_GPU_NVPTX_DECLARATIONS_H
-#define LLVM_LIBC_SRC_MATH_GPU_NVPTX_DECLARATIONS_H
+#include "src/math/remquof.h"
+#include "src/__support/common.h"
 
 namespace __llvm_libc {
 
-extern "C" {
-double __nv_sin(double);
+LLVM_LIBC_FUNCTION(float, remquof, (float x, float y, int *quo)) {
+  return __builtin_remquof(x, y, quo);
 }
 
 } // namespace __llvm_libc
-
-#endif // LLVM_LIBC_SRC_MATH_GPU_NVPTX_DECLARATIONS_H

libc/src/math/gpu/remquol.cpp

-//===-- AMDGPU specific declarations for math support ---------------------===//
+//===-- Implementation of the GPU remquol 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
 //
 //===----------------------------------------------------------------------===//
 
-#ifndef LLVM_LIBC_SRC_MATH_GPU_AMDGPU_DECLARATIONS_H
-#define LLVM_LIBC_SRC_MATH_GPU_AMDGPU_DECLARATIONS_H
+#include "src/math/remquol.h"
+#include "src/__support/common.h"
 
 namespace __llvm_libc {
 
-extern "C" {
-double __ocml_sin_f64(double);
+LLVM_LIBC_FUNCTION(long double, remquol,
+                   (long double x, long double y, int *quo)) {
+  return __builtin_remquol(x, y, quo);
 }
 
 } // namespace __llvm_libc
-
-#endif // LLVM_LIBC_SRC_MATH_GPU_AMDGPU_DECLARATIONS_H

libc/src/math/gpu/rint.cpp

-//===-- NVPTX specific declarations for math support ----------------------===//
+//===-- 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
 //
 //===----------------------------------------------------------------------===//
 
-#ifndef LLVM_LIBC_SRC_MATH_GPU_NVPTX_DECLARATIONS_H
-#define LLVM_LIBC_SRC_MATH_GPU_NVPTX_DECLARATIONS_H
+#include "src/math/rint.h"
+#include "src/__support/common.h"
 
 namespace __llvm_libc {
 
-extern "C" {
-double __nv_sin(double);
-}
+LLVM_LIBC_FUNCTION(double, rint, (double x)) { return __builtin_rint(x); }
 
 } // namespace __llvm_libc
-
-#endif // LLVM_LIBC_SRC_MATH_GPU_NVPTX_DECLARATIONS_H

libc/src/math/gpu/rintf.cpp

-//===-- NVPTX specific declarations for math support ----------------------===//
+//===-- 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
 //
 //===----------------------------------------------------------------------===//
 
-#ifndef LLVM_LIBC_SRC_MATH_GPU_NVPTX_DECLARATIONS_H
-#define LLVM_LIBC_SRC_MATH_GPU_NVPTX_DECLARATIONS_H
+#include "src/math/rintf.h"
+#include "src/__support/common.h"
 
 namespace __llvm_libc {
 
-extern "C" {
-double __nv_sin(double);
-}
+LLVM_LIBC_FUNCTION(float, rintf, (float x)) { return __builtin_rintf(x); }
 
 } // namespace __llvm_libc
-
-#endif // LLVM_LIBC_SRC_MATH_GPU_NVPTX_DECLARATIONS_H

libc/src/math/gpu/rintl.cpp

-//===-- NVPTX specific declarations for math support ----------------------===//
+//===-- Implementation of the GPU rintl 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
 //
 //===----------------------------------------------------------------------===//
 
-#ifndef LLVM_LIBC_SRC_MATH_GPU_NVPTX_DECLARATIONS_H
-#define LLVM_LIBC_SRC_MATH_GPU_NVPTX_DECLARATIONS_H
+#include "src/math/rintl.h"
+#include "src/__support/common.h"
 
 namespace __llvm_libc {
 
-extern "C" {
-double __nv_sin(double);
+LLVM_LIBC_FUNCTION(long double, rintl, (long double x)) {
+  return __builtin_rintl(x);
 }
 
 } // namespace __llvm_libc
-
-#endif // LLVM_LIBC_SRC_MATH_GPU_NVPTX_DECLARATIONS_H

libc/src/math/gpu/scalbn.cpp

-//===-- NVPTX specific declarations for math support ----------------------===//
+//===-- 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
 //
 //===----------------------------------------------------------------------===//
 
-#ifndef LLVM_LIBC_SRC_MATH_GPU_NVPTX_DECLARATIONS_H
-#define LLVM_LIBC_SRC_MATH_GPU_NVPTX_DECLARATIONS_H
+#include "src/math/scalbn.h"
+#include "src/__support/common.h"
 
 namespace __llvm_libc {
 
-extern "C" {
-double __nv_sin(double);
+LLVM_LIBC_FUNCTION(double, scalbn, (double x, int y)) {
+  return __builtin_scalbn(x, y);
 }
 
 } // namespace __llvm_libc
-
-#endif // LLVM_LIBC_SRC_MATH_GPU_NVPTX_DECLARATIONS_H

libc/src/math/gpu/scalbnf.cpp

-//===-- NVPTX specific declarations for math support ----------------------===//
+//===-- 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
 //
 //===----------------------------------------------------------------------===//
 
-#ifndef LLVM_LIBC_SRC_MATH_GPU_NVPTX_DECLARATIONS_H
-#define LLVM_LIBC_SRC_MATH_GPU_NVPTX_DECLARATIONS_H
+#include "src/math/scalbnf.h"
+#include "src/__support/common.h"
 
 namespace __llvm_libc {
 
-extern "C" {
-double __nv_sin(double);
+LLVM_LIBC_FUNCTION(float, scalbnf, (float x, int y)) {
+  return __builtin_scalbnf(x, y);
 }
 
 } // namespace __llvm_libc
-
-#endif // LLVM_LIBC_SRC_MATH_GPU_NVPTX_DECLARATIONS_H

libc/src/math/gpu/scalbnl.cpp

-//===-- NVPTX specific declarations for math support ----------------------===//
+//===-- Implementation of the GPU scalbnl 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
 //
 //===----------------------------------------------------------------------===//
 
-#ifndef LLVM_LIBC_SRC_MATH_GPU_NVPTX_DECLARATIONS_H
-#define LLVM_LIBC_SRC_MATH_GPU_NVPTX_DECLARATIONS_H
+#include "src/__support/common.h"
+#include "src/math/scalbn.h"
 
 namespace __llvm_libc {
 
-extern "C" {
-double __nv_sin(double);
+LLVM_LIBC_FUNCTION(long double, scalbn, (long double x, int y)) {
+  return __builtin_scalbnl(x, y);
 }
 
 } // namespace __llvm_libc
-
-#endif // LLVM_LIBC_SRC_MATH_GPU_NVPTX_DECLARATIONS_H

libc/src/math/gpu/sinh.cpp

-//===-- NVPTX specific declarations for math support ----------------------===//
+//===-- 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
 //
 //===----------------------------------------------------------------------===//
 
-#ifndef LLVM_LIBC_SRC_MATH_GPU_NVPTX_DECLARATIONS_H
-#define LLVM_LIBC_SRC_MATH_GPU_NVPTX_DECLARATIONS_H
+#include "src/math/sinh.h"
+#include "src/__support/common.h"
 
 namespace __llvm_libc {
 
-extern "C" {
-double __nv_sin(double);
-}
+LLVM_LIBC_FUNCTION(double, sinh, (double x)) { return __builtin_sinh(x); }
 
 } // namespace __llvm_libc
-
-#endif // LLVM_LIBC_SRC_MATH_GPU_NVPTX_DECLARATIONS_H

libc/src/math/gpu/sinhf.cpp

-//===-- NVPTX specific declarations for math support ----------------------===//
+//===-- 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
 //
 //===----------------------------------------------------------------------===//
 
-#ifndef LLVM_LIBC_SRC_MATH_GPU_NVPTX_DECLARATIONS_H
-#define LLVM_LIBC_SRC_MATH_GPU_NVPTX_DECLARATIONS_H
+#include "src/math/sinhf.h"
+#include "src/__support/common.h"
 
 namespace __llvm_libc {
 
-extern "C" {
-double __nv_sin(double);
-}
+LLVM_LIBC_FUNCTION(float, sinhf, (float x)) { return __builtin_sinhf(x); }
 
 } // namespace __llvm_libc
-
-#endif // LLVM_LIBC_SRC_MATH_GPU_NVPTX_DECLARATIONS_H

libc/src/math/gpu/sinhl.cpp

-//===-- NVPTX specific declarations for math support ----------------------===//
+//===-- Implementation of the GPU sinhl 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
 //
 //===----------------------------------------------------------------------===//
 
-#ifndef LLVM_LIBC_SRC_MATH_GPU_NVPTX_DECLARATIONS_H
-#define LLVM_LIBC_SRC_MATH_GPU_NVPTX_DECLARATIONS_H
+#include "src/math/sinhl.h"
+#include "src/__support/common.h"
 
 namespace __llvm_libc {
 
-extern "C" {
-double __nv_sin(double);
+LLVM_LIBC_FUNCTION(long double, sinhl, (long double x)) {
+  return __builtin_sinhl(x);
 }
 
 } // namespace __llvm_libc
-
-#endif // LLVM_LIBC_SRC_MATH_GPU_NVPTX_DECLARATIONS_H

libc/src/math/gpu/sqrt.cpp

-//===-- NVPTX specific declarations for math support ----------------------===//
+//===-- 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
 //
 //===----------------------------------------------------------------------===//
 
-#ifndef LLVM_LIBC_SRC_MATH_GPU_NVPTX_DECLARATIONS_H
-#define LLVM_LIBC_SRC_MATH_GPU_NVPTX_DECLARATIONS_H
+#include "src/math/sqrt.h"
+#include "src/__support/common.h"
 
 namespace __llvm_libc {
 
-extern "C" {
-double __nv_sin(double);
-}
+LLVM_LIBC_FUNCTION(double, sqrt, (double x)) { return __builtin_sqrt(x); }
 
 } // namespace __llvm_libc
-
-#endif // LLVM_LIBC_SRC_MATH_GPU_NVPTX_DECLARATIONS_H

libc/src/math/gpu/sqrtf.cpp

-//===-- NVPTX specific declarations for math support ----------------------===//
+//===-- 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
 //
 //===----------------------------------------------------------------------===//
 
-#ifndef LLVM_LIBC_SRC_MATH_GPU_NVPTX_DECLARATIONS_H
-#define LLVM_LIBC_SRC_MATH_GPU_NVPTX_DECLARATIONS_H
+#include "src/math/sqrtf.h"
+#include "src/__support/common.h"
 
 namespace __llvm_libc {
 
-extern "C" {
-double __nv_sin(double);
-}
+LLVM_LIBC_FUNCTION(float, sqrtf, (float x)) { return __builtin_sqrtf(x); }
 
 } // namespace __llvm_libc
-
-#endif // LLVM_LIBC_SRC_MATH_GPU_NVPTX_DECLARATIONS_H

libc/src/math/gpu/sqrtl.cpp

-//===-- NVPTX specific declarations for math support ----------------------===//
+//===-- Implementation of the GPU sqrtl 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
 //
 //===----------------------------------------------------------------------===//
 
-#ifndef LLVM_LIBC_SRC_MATH_GPU_NVPTX_DECLARATIONS_H
-#define LLVM_LIBC_SRC_MATH_GPU_NVPTX_DECLARATIONS_H
+#include "src/math/sqrtl.h"
+#include "src/__support/common.h"
 
 namespace __llvm_libc {
 
-extern "C" {
-double __nv_sin(double);
+LLVM_LIBC_FUNCTION(long double, sqrtl, (long double x)) {
+  return __builtin_sqrtl(x);
 }
 
 } // namespace __llvm_libc
-
-#endif // LLVM_LIBC_SRC_MATH_GPU_NVPTX_DECLARATIONS_H

libc/src/math/gpu/tan.cpp

-//===-- NVPTX specific declarations for math support ----------------------===//
+//===-- 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
 //
 //===----------------------------------------------------------------------===//
 
-#ifndef LLVM_LIBC_SRC_MATH_GPU_NVPTX_DECLARATIONS_H
-#define LLVM_LIBC_SRC_MATH_GPU_NVPTX_DECLARATIONS_H
+#include "src/math/tan.h"
+#include "src/__support/common.h"
 
 namespace __llvm_libc {
 
-extern "C" {
-double __nv_sin(double);
-}
+LLVM_LIBC_FUNCTION(double, tan, (double x)) { return __builtin_tan(x); }
 
 } // namespace __llvm_libc
-
-#endif // LLVM_LIBC_SRC_MATH_GPU_NVPTX_DECLARATIONS_H

libc/src/math/gpu/tanf.cpp

-//===-- NVPTX specific declarations for math support ----------------------===//
+//===-- 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
 //
 //===----------------------------------------------------------------------===//
 
-#ifndef LLVM_LIBC_SRC_MATH_GPU_NVPTX_DECLARATIONS_H
-#define LLVM_LIBC_SRC_MATH_GPU_NVPTX_DECLARATIONS_H
+#include "src/math/tanf.h"
+#include "src/__support/common.h"
 
 namespace __llvm_libc {
 
-extern "C" {
-double __nv_sin(double);
-}
+LLVM_LIBC_FUNCTION(float, tanf, (float x)) { return __builtin_tanf(x); }
 
 } // namespace __llvm_libc
-
-#endif // LLVM_LIBC_SRC_MATH_GPU_NVPTX_DECLARATIONS_H

libc/src/math/gpu/tanh.cpp

-//===-- NVPTX specific declarations for math support ----------------------===//
+//===-- 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
 //
 //===----------------------------------------------------------------------===//
 
-#ifndef LLVM_LIBC_SRC_MATH_GPU_NVPTX_DECLARATIONS_H
-#define LLVM_LIBC_SRC_MATH_GPU_NVPTX_DECLARATIONS_H
+#include "src/math/tanh.h"
+#include "src/__support/common.h"
 
 namespace __llvm_libc {
 
-extern "C" {
-double __nv_sin(double);
-}
+LLVM_LIBC_FUNCTION(double, tanh, (double x)) { return __builtin_tanh(x); }
 
 } // namespace __llvm_libc
-
-#endif // LLVM_LIBC_SRC_MATH_GPU_NVPTX_DECLARATIONS_H

libc/src/math/gpu/tanhf.cpp

-//===-- NVPTX specific declarations for math support ----------------------===//
+//===-- 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
 //
 //===----------------------------------------------------------------------===//
 
-#ifndef LLVM_LIBC_SRC_MATH_GPU_NVPTX_DECLARATIONS_H
-#define LLVM_LIBC_SRC_MATH_GPU_NVPTX_DECLARATIONS_H
+#include "src/math/tanhf.h"
+#include "src/__support/common.h"
 
 namespace __llvm_libc {
 
-extern "C" {
-double __nv_sin(double);
-}
+LLVM_LIBC_FUNCTION(float, tanhf, (float x)) { return __builtin_tanhf(x); }
 
 } // namespace __llvm_libc
-
-#endif // LLVM_LIBC_SRC_MATH_GPU_NVPTX_DECLARATIONS_H

libc/src/math/gpu/tanhl.cpp

-//===-- NVPTX specific declarations for math support ----------------------===//
+//===-- Implementation of the GPU tanhl 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
 //
 //===----------------------------------------------------------------------===//
 
-#ifndef LLVM_LIBC_SRC_MATH_GPU_NVPTX_DECLARATIONS_H
-#define LLVM_LIBC_SRC_MATH_GPU_NVPTX_DECLARATIONS_H
+#include "src/math/tanhl.h"
+#include "src/__support/common.h"
 
 namespace __llvm_libc {
 
-extern "C" {
-double __nv_sin(double);
+LLVM_LIBC_FUNCTION(long double, tanhl, (long double x)) {
+  return __builtin_tanhl(x);
 }
 
 } // namespace __llvm_libc
-
-#endif // LLVM_LIBC_SRC_MATH_GPU_NVPTX_DECLARATIONS_H

libc/src/math/gpu/tanl.cpp

-//===-- NVPTX specific declarations for math support ----------------------===//
+//===-- Implementation of the GPU tanl 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
 //
 //===----------------------------------------------------------------------===//
 
-#ifndef LLVM_LIBC_SRC_MATH_GPU_NVPTX_DECLARATIONS_H
-#define LLVM_LIBC_SRC_MATH_GPU_NVPTX_DECLARATIONS_H
+#include "src/math/tanl.h"
+#include "src/__support/common.h"
 
 namespace __llvm_libc {
 
-extern "C" {
-double __nv_sin(double);
+LLVM_LIBC_FUNCTION(long double, tanl, (long double x)) {
+  return __builtin_tanl(x);
 }
 
 } // namespace __llvm_libc
-
-#endif // LLVM_LIBC_SRC_MATH_GPU_NVPTX_DECLARATIONS_H

libc/src/math/gpu/trunc.cpp

-//===-- NVPTX specific declarations for math support ----------------------===//
+//===-- 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
 //
 //===----------------------------------------------------------------------===//
 
-#ifndef LLVM_LIBC_SRC_MATH_GPU_NVPTX_DECLARATIONS_H
-#define LLVM_LIBC_SRC_MATH_GPU_NVPTX_DECLARATIONS_H
+#include "src/math/trunc.h"
+#include "src/__support/common.h"
 
 namespace __llvm_libc {
 
-extern "C" {
-double __nv_sin(double);
-}
+LLVM_LIBC_FUNCTION(double, trunc, (double x)) { return __builtin_trunc(x); }
 
 } // namespace __llvm_libc
-
-#endif // LLVM_LIBC_SRC_MATH_GPU_NVPTX_DECLARATIONS_H

libc/src/math/gpu/truncf.cpp

-//===-- NVPTX specific declarations for math support ----------------------===//
+//===-- 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
 //
 //===----------------------------------------------------------------------===//
 
-#ifndef LLVM_LIBC_SRC_MATH_GPU_NVPTX_DECLARATIONS_H
-#define LLVM_LIBC_SRC_MATH_GPU_NVPTX_DECLARATIONS_H
+#include "src/math/truncf.h"
+#include "src/__support/common.h"
 
 namespace __llvm_libc {
 
-extern "C" {
-double __nv_sin(double);
-}
+LLVM_LIBC_FUNCTION(double, truncf, (double x)) { return __builtin_truncf(x); }
 
 } // namespace __llvm_libc
-
-#endif // LLVM_LIBC_SRC_MATH_GPU_NVPTX_DECLARATIONS_H

libc/src/math/gpu/truncl.cpp

-//===-- NVPTX specific declarations for math support ----------------------===//
+//===-- Implementation of the GPU truncl 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
 //
 //===----------------------------------------------------------------------===//
 
-#ifndef LLVM_LIBC_SRC_MATH_GPU_NVPTX_DECLARATIONS_H
-#define LLVM_LIBC_SRC_MATH_GPU_NVPTX_DECLARATIONS_H
+#include "src/math/truncl.h"
+#include "src/__support/common.h"
 
 namespace __llvm_libc {
 
-extern "C" {
-double __nv_sin(double);
-}
+LLVM_LIBC_FUNCTION(double, truncl, (double x)) { return __builtin_truncl(x); }
 
 } // namespace __llvm_libc
-
-#endif // LLVM_LIBC_SRC_MATH_GPU_NVPTX_DECLARATIONS_H

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

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
+)
 No newline at end of file

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

 #include "platform.h"
 
 #include "src/__support/macros/attributes.h"
 
 namespace __llvm_libc {
 namespace internal {
 
 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);
+}
 
 } // namespace internal
 } // namespace __llvm_libc
 
 #endif // LLVM_LIBC_SRC_MATH_GPU_AMDGPU_H

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

 //===-- AMDGPU specific declarations for math support ---------------------===//
 //
 // 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_GPU_AMDGPU_DECLARATIONS_H
 #define LLVM_LIBC_SRC_MATH_GPU_AMDGPU_DECLARATIONS_H
 
 namespace __llvm_libc {
 
 extern "C" {
+
+float __ocml_sin_f32(float);
 double __ocml_sin_f64(double);
+float __ocml_sincos_f32(float, float *);
+double __ocml_sincos_f64(double, double *);
 }
 
 } // namespace __llvm_libc
 
 #endif // LLVM_LIBC_SRC_MATH_GPU_AMDGPU_DECLARATIONS_H

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

 //===-- NVPTX specific declarations for math support ----------------------===//
 //
 // 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_GPU_NVPTX_DECLARATIONS_H
 #define LLVM_LIBC_SRC_MATH_GPU_NVPTX_DECLARATIONS_H
 
 namespace __llvm_libc {
 
 extern "C" {
 double __nv_sin(double);
+float __nv_sinf(float);
+void __nv_sincos(double, double *, double *);
+void __nv_sincosf(float, float *, float *);
 }
 
 } // namespace __llvm_libc
 
 #endif // LLVM_LIBC_SRC_MATH_GPU_NVPTX_DECLARATIONS_H

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

 #include "declarations.h"
 
 #include "src/__support/macros/attributes.h"
 
 namespace __llvm_libc {
 namespace internal {
 
 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);
+}
 
 } // namespace internal
 } // namespace __llvm_libc
 
 #endif // LLVM_LIBC_SRC_MATH_GPU_NVPTX_H

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

-//===-- AMDGPU specific declarations for math support ---------------------===//
+//===-- 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
 //
 //===----------------------------------------------------------------------===//
 
-#ifndef LLVM_LIBC_SRC_MATH_GPU_AMDGPU_DECLARATIONS_H
-#define LLVM_LIBC_SRC_MATH_GPU_AMDGPU_DECLARATIONS_H
+#include "src/math/sincos.h"
+#include "src/__support/common.h"
+
+#include "common.h"
 
 namespace __llvm_libc {
 
-extern "C" {
-double __ocml_sin_f64(double);
+LLVM_LIBC_FUNCTION(void, sincos, (double x, double *sinptr, double *cosptr)) {
+  return internal::sincos(x, sinptr, cosptr);
 }
 
 } // namespace __llvm_libc
-
-#endif // LLVM_LIBC_SRC_MATH_GPU_AMDGPU_DECLARATIONS_H

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

-//===-- AMDGPU specific declarations for math support ---------------------===//
+//===-- 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
 //
 //===----------------------------------------------------------------------===//
 
-#ifndef LLVM_LIBC_SRC_MATH_GPU_AMDGPU_DECLARATIONS_H
-#define LLVM_LIBC_SRC_MATH_GPU_AMDGPU_DECLARATIONS_H
+#include "src/math/sincosf.h"
+#include "src/__support/common.h"
+
+#include "common.h"
 
 namespace __llvm_libc {
 
-extern "C" {
-double __ocml_sin_f64(double);
+LLVM_LIBC_FUNCTION(void, sincosf, (float x, float *sinptr, float *cosptr)) {
+  return internal::sincosf(x, sinptr, cosptr);
 }
 
 } // namespace __llvm_libc
-
-#endif // LLVM_LIBC_SRC_MATH_GPU_AMDGPU_DECLARATIONS_H

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

-//===-- NVPTX specific declarations for math support ----------------------===//
+//===-- 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
 //
 //===----------------------------------------------------------------------===//
 
-#ifndef LLVM_LIBC_SRC_MATH_GPU_NVPTX_DECLARATIONS_H
-#define LLVM_LIBC_SRC_MATH_GPU_NVPTX_DECLARATIONS_H
+#include "src/math/sinf.h"
+#include "src/__support/common.h"
+
+#include "common.h"
 
 namespace __llvm_libc {
 
-extern "C" {
-double __nv_sin(double);
-}
+LLVM_LIBC_FUNCTION(float, sinf, (float x)) { return internal::sinf(x); }
 
 } // namespace __llvm_libc
-
-#endif // LLVM_LIBC_SRC_MATH_GPU_NVPTX_DECLARATIONS_H

libc/src/math/sinh.h

-//===-- NVPTX specific declarations for math support ----------------------===//
+//===-- 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_GPU_NVPTX_DECLARATIONS_H
-#define LLVM_LIBC_SRC_MATH_GPU_NVPTX_DECLARATIONS_H
+#ifndef LLVM_LIBC_SRC_MATH_SINH_H
+#define LLVM_LIBC_SRC_MATH_SINH_H
 
 namespace __llvm_libc {
 
-extern "C" {
-double __nv_sin(double);
-}
+double sinh(double x);
 
 } // namespace __llvm_libc
 
-#endif // LLVM_LIBC_SRC_MATH_GPU_NVPTX_DECLARATIONS_H
+#endif // LLVM_LIBC_SRC_MATH_SINH_H

libc/src/math/sinhl.h

-//===-- NVPTX specific declarations for math support ----------------------===//
+//===-- Implementation header for sinhl -------------------------*- 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_GPU_NVPTX_DECLARATIONS_H
-#define LLVM_LIBC_SRC_MATH_GPU_NVPTX_DECLARATIONS_H
+#ifndef LLVM_LIBC_SRC_MATH_SINHL_H
+#define LLVM_LIBC_SRC_MATH_SINHL_H
 
 namespace __llvm_libc {
 
-extern "C" {
-double __nv_sin(double);
-}
+long double sinhl(long double x);
 
 } // namespace __llvm_libc
 
-#endif // LLVM_LIBC_SRC_MATH_GPU_NVPTX_DECLARATIONS_H
+#endif // LLVM_LIBC_SRC_MATH_SINFL_H

libc/src/math/tanh.h

-//===-- NVPTX specific declarations for math support ----------------------===//
+//===-- 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_GPU_NVPTX_DECLARATIONS_H
-#define LLVM_LIBC_SRC_MATH_GPU_NVPTX_DECLARATIONS_H
+#ifndef LLVM_LIBC_SRC_MATH_TANH_H
+#define LLVM_LIBC_SRC_MATH_TANH_H
 
 namespace __llvm_libc {
 
-extern "C" {
-double __nv_sin(double);
-}
+double tanh(double x);
 
 } // namespace __llvm_libc
 
-#endif // LLVM_LIBC_SRC_MATH_GPU_NVPTX_DECLARATIONS_H
+#endif // LLVM_LIBC_SRC_MATH_TANH_H

libc/src/math/tanhl.h

-//===-- NVPTX specific declarations for math support ----------------------===//
+//===-- Implementation header for tanhl -------------------------*- 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_GPU_NVPTX_DECLARATIONS_H
-#define LLVM_LIBC_SRC_MATH_GPU_NVPTX_DECLARATIONS_H
+#ifndef LLVM_LIBC_SRC_MATH_TANHL_H
+#define LLVM_LIBC_SRC_MATH_TANHL_H
 
 namespace __llvm_libc {
 
-extern "C" {
-double __nv_sin(double);
-}
+long double tanhl(long double x);
 
 } // namespace __llvm_libc
 
-#endif // LLVM_LIBC_SRC_MATH_GPU_NVPTX_DECLARATIONS_H
+#endif // LLVM_LIBC_SRC_MATH_TANHL_H

libc/src/math/tanl.h

-//===-- NVPTX specific declarations for math support ----------------------===//
+//===-- Implementation header for tanl --------------------------*- 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_GPU_NVPTX_DECLARATIONS_H
-#define LLVM_LIBC_SRC_MATH_GPU_NVPTX_DECLARATIONS_H
+#ifndef LLVM_LIBC_SRC_MATH_TANL_H
+#define LLVM_LIBC_SRC_MATH_TANL_H
 
 namespace __llvm_libc {
 
-extern "C" {
-double __nv_sin(double);
-}
+long double tanl(long double x);
 
 } // namespace __llvm_libc
 
-#endif // LLVM_LIBC_SRC_MATH_GPU_NVPTX_DECLARATIONS_H
+#endif // LLVM_LIBC_SRC_MATH_TANL_H