[libc] Add initial support for a libc implementation for the GPU

[jhuber6]

Summary

This patch contains the initial support for building LLVM's libc as a
target for the GPU. Currently this only supports a handful of very basic
functions that can be implemented without an operating system. The GPU
code is build using the existing OpenMP toolchain. This allows us to
minimally change the existing codebase and get a functioning static
library. This patch allows users to create a static library called
libcgpu.a that contains fat binaries containing device IR.

Current limitations are the lack of test support and the fact that only
one target OS can be built at a time. That is, the user cannot get a
libc for Linux and one for the GPU simultaneously.

This introduces two new CMake variables to control the behavior
LLVM_LIBC_TARET_OS is exported so the user can now specify it to equal
"gpu". LLVM_LIBC_GPU_ARCHITECTURES is also used to configure how
many targets to build for at once.

Depends on D138607

[jdoerfert]

This patch allows users to create a static library called libcpu.a that contains fat binaries containing device IR.

libcgpu.a, right?

[sivachandra]

Thanks for the patch. The mechanical aspects of it LGTM but I have a few administrative questions and points to make:

1. You should add a doc in the docs directory describing what exactly is a GPU build, its status, how to build and and how to test. You don't have to cram all of this in this patch, but I would like to hear that you do intend to follow up with appropriate documentation.
2. What is the CI story for the GPU build? Everything, from who will own and maintain the CI builders, to the action that is to be taken if a patch breaks the GPU CI builders. Again, you don't have to stand up a GPU builders right away. You can choose to include the plan in the above documentation and work separately in setting up the buidlers.

[jhuber6]

In D138608#3952535, @sivachandra wrote:

Thanks for the patch. The mechanical aspects of it LGTM but I have a few administrative questions and points to make:

1. You should add a doc in the docs directory describing what exactly is a GPU build, its status, how to build and and how to test. You don't have to cram all of this in this patch, but I would like to hear that you do intend to follow up with appropriate documentation.

Yes, I can add some documentation for how to run this build and how to use it.

2. What is the CI story for the GPU build? Everything, from who will own and maintain the CI builders, to the action that is to be taken if a patch breaks the GPU CI builders. Again, you don't have to stand up a GPU builders right away. You can choose to include the plan in the above documentation and work separately in setting up the buidlers.

AMD has an active buildbot for testing the OpenMP runtime we could use for this. I haven't yet decided the best way to stand up tests for the GPU however. We can either use OpenMP offloading and modify the source code to run the region under test on the device or simply write GPU exclusive tests, maybe in another project. The problem with the former is it's not guaranteed to work as many existing test codes most likely contain code that can't be run on the GPU so we may still need some separation.

[jdoerfert]

For the short term we should make the AMD GPU bot compile the GPU libc, then include it and run some tests on the functions we support. Long term we need a dedicated GPU buildbot for this (and other generic parts).

[sivachandra]

In D138608#3953107, @jhuber6 wrote:

In D138608#3952535, @sivachandra wrote:

2. What is the CI story for the GPU build? Everything, from who will own and maintain the CI builders, to the action that is to be taken if a patch breaks the GPU CI builders. Again, you don't have to stand up a GPU builders right away. You can choose to include the plan in the above documentation and work separately in setting up the buidlers.

AMD has an active buildbot for testing the OpenMP runtime we could use for this. I haven't yet decided the best way to stand up tests for the GPU however. We can either use OpenMP offloading and modify the source code to run the region under test on the device or simply write GPU exclusive tests, maybe in another project. The problem with the former is it's not guaranteed to work as many existing test codes most likely contain code that can't be run on the GPU so we may still need some separation.

I am accepting this patch. We should follow up with the following actions:

1. Add clear documentation about what and how of GPU build. Like, how to build, test etc.
2. Get a CI builder building and testing the GPU build. If this is being done on a non-libc builder, we should call it out somewhere in the libc documentation so that libc developers can find all the relevant information.
3. About tests, we should really be putting effort to use the same test code on all platforms. Different tests/systems for different platforms is added developer burden wrt writing them multiple times and then maintaining those multiple flavors.

There should be some sort of urgency in addressing the above items. Need not happen now/today/tomorrow, but I think a reasonable time frame is that all of the above should be addressed within a month of landing this patch.

[jhuber6]

In D138608#3954164, @sivachandra wrote:

I am accepting this patch. We should follow up with the following actions:

Thanks for being open to these additions to LLVM's libc.

1. Add clear documentation about what and how of GPU build. Like, how to build, test etc.

I'll try to add some basic documentation and include a list of supported functions soon.

2. Get a CI builder building and testing the GPU build. If this is being done on a non-libc builder, we should call it out somewhere in the libc documentation so that libc developers can find all the relevant information.
3. About tests, we should really be putting effort to use the same test code on all platforms. Different tests/systems for different platforms is added developer burden wrt writing them multiple times and then maintaining those multiple flavors.

Keeping the code common would be ideal. One problem is that the GPU currently doesn't support aliases, but there's less ambiguity on the GPU side when it comes to the libc functions so we may not need them to test. We may also want to avoid relying on other runtimes like OpenMP which may introduce their own bugs so it may be worthwhile to include our own launcher inside the test infrastructure. I'll look into it further as we definitely need tests.

There should be some sort of urgency in addressing the above items. Need not happen now/today/tomorrow, but I think a reasonable time frame is that all of the above should be addressed within a month of landing this patch.

That should be doable.

libc/CMakeLists.txt

 if ("libc" IN_LIST LLVM_ENABLE_RUNTIMES)
   include(TableGen)
   set(LLVM_LIBC_INCLUDE_DIRS ${LLVM_MAIN_INCLUDE_DIR} ${LLVM_BINARY_DIR}/include)
 endif()
 
 # Path libc/scripts directory.
 set(LIBC_BUILD_SCRIPTS_DIR "${LIBC_SOURCE_DIR}/utils/build_scripts")
 
-set(LIBC_TARGET_OS ${CMAKE_SYSTEM_NAME})
-string(TOLOWER ${LIBC_TARGET_OS} LIBC_TARGET_OS)
-
-# Defines LIBC_TARGET_ARCHITECTURE and associated macros.
-include(LLVMLibCArchitectures)
-include(LLVMLibCCheckMPFR)
-
 # Flags to pass down to the compiler while building the libc functions.
 set(LIBC_COMPILE_OPTIONS_DEFAULT "" CACHE STRING "Architecture to tell clang to optimize for (e.g. -march=... or -mcpu=...)")
 
 # Check --print-resource-dir to find the compiler resource dir if this flag
 # is supported by the compiler.
 execute_process(
   OUTPUT_STRIP_TRAILING_WHITESPACE
   COMMAND ${CMAKE_CXX_COMPILER} --print-resource-dir
else()
   message(STATUS "COMPILER_RESOURCE_DIR not set
                   --print-resource-dir not supported by host compiler")
 endif()
 
 option(LLVM_LIBC_FULL_BUILD "Build and test LLVM libc as if it is the full libc" OFF)
 option(LLVM_LIBC_IMPLEMENTATION_DEFINED_TEST_BEHAVIOR "Build LLVM libc tests assuming our implementation-defined behavior" ON)
 option(LLVM_LIBC_ENABLE_LINTING "Enables linting of libc source files" OFF)
 
+# Set up the target architectures to build for the GPU
+set(ALL_GPU_ARCHITECTURES "sm_35;sm_37;sm_50;sm_52;sm_53;sm_60;sm_61;sm_62;sm_70;sm_72;sm_75;sm_80;sm_86;gfx700;gfx701;gfx801;gfx803;gfx900;gfx902;gfx906;gfx908;gfx90a;gfx90c;gfx940;gfx1010;gfx1030;gfx1031;gfx1032;gfx1033;gfx1034;gfx1035;gfx1036;gfx1100;gfx1101;gfx1102;gfx1103")
+set(LLVM_LIBC_GPU_ARCHITECTURES ${ALL_GPU_ARCHITECTURES} CACHE STRING "List of GPU architectures to support in LLVM libc")
+if (LLVM_LIBC_GPU_ARCHITECTURES STREQUAL "all")
+  set(LIBC_GPU_ARCHITECTURES ${ALL_GPU_ARCHITECTURES})
+else()
+  set(LIBC_GPU_ARCHITECTURES ${LLVM_LIBC_GPU_ARCHITECTURES})
+endif()
+
+set(LLVM_LIBC_TARGET_OS ${CMAKE_SYSTEM_NAME} CACHE STRING "Target operating system for LLVM libc")
+string(TOLOWER ${LLVM_LIBC_TARGET_OS} LIBC_TARGET_OS)
+
+# Defines LIBC_TARGET_ARCHITECTURE and associated macros.
+include(LLVMLibCArchitectures)
+include(LLVMLibCCheckMPFR)
+
+# Ensure the compiler is a valid clang when building the GPU target.
+if(LIBC_TARGET_ARCHITECTURE_IS_GPU AND NOT (CMAKE_CXX_COMPILER_ID MATCHES "[Cc]lang" AND 
+  ${CMAKE_CXX_COMPILER_VERSION} VERSION_EQUAL "${LLVM_VERSION_MAJOR}.${LLVM_VERSION_MINOR}.${LLVM_VERSION_PATCH}"))
+  message(FATAL_ERROR "Cannot build GPU library, CMake compiler '${CMAKE_CXX_COMPILER_ID} ${CMAKE_CXX_COMPILER_VERSION}' is not `Clang ${LLVM_VERSION_MAJOR}.${LLVM_VERSION_MINOR}.${LLVM_VERSION_PATCH}`")
+endif()
+if(LIBC_TARGET_ARCHITECTURE_IS_GPU AND NOT LLVM_LIBC_FULL_BUILD)
+  message(FATAL_ERROR "Cannot build GPU library, LLVM_LIBC_FULL_BUILD must be enabled")
+endif()
+
 if(LLVM_LIBC_CLANG_TIDY)
   set(LLVM_LIBC_ENABLE_LINTING ON)
 endif()
 
 if(LLVM_LIBC_ENABLE_LINTING)
   if(NOT CMAKE_CXX_COMPILER_ID STREQUAL "Clang")
     set(LLVM_LIBC_ENABLE_LINTING OFF)
     message(WARNING "C++ compiler is not clang++, linting with be disabled.")

 set(LIBC_COMPONENT)
 set(LIBC_INSTALL_DEPENDS)
 set(LIBC_INSTALL_TARGET)
 if(LLVM_LIBC_FULL_BUILD)
   set(LIBC_TARGET libc)
   set(LIBC_COMPONENT libc)
   set(LIBC_INSTALL_DEPENDS "libc;install-libc-headers;libc-startup")
   set(LIBC_INSTALL_TARGET install-libc)
+  if(LIBC_TARGET_ARCHITECTURE_IS_GPU)
+    set(LIBC_ARCHIVE_NAME cgpu)
+  else()
     set(LIBC_ARCHIVE_NAME c)
+  endif()
 else()
   set(LIBC_TARGET llvmlibc)
   set(LIBC_COMPONENT llvmlibc)
   set(LIBC_INSTALL_DEPENDS llvmlibc)
   set(LIBC_INSTALL_TARGET install-llvmlibc)
   set(LIBC_ARCHIVE_NAME llvmlibc)
 endif()
 
 add_subdirectory(include)
 add_subdirectory(config)
 add_subdirectory(src)
 add_subdirectory(utils)
 
 if(LLVM_LIBC_FULL_BUILD)
   # The loader can potentially depend on the library components so add it
   # after the library implementation directories.
   add_subdirectory(loader)
 endif()
 
 # The lib and test directories are added at the very end as tests
 # and libraries potentially draw from the components present in all
 # of the other directories.
+# TODO: Add testing support for the libc GPU target.
 add_subdirectory(lib)
-if(LLVM_INCLUDE_TESTS)
+if(LLVM_INCLUDE_TESTS AND NOT LIBC_TARGET_ARCHITECTURE_IS_GPU)
   add_subdirectory(test)
   add_subdirectory(fuzzing)
 endif()
 
 if(LIBC_INCLUDE_BENCHMARKS)
   add_subdirectory(benchmarks)
 endif()
 

libc/cmake/modules/LLVMLibCArchitectures.cmake

 # ------------------------------------------------------------------------------
 # Architecture definitions
 # ------------------------------------------------------------------------------
 
-if(CMAKE_SYSTEM_PROCESSOR MATCHES "^mips")
+if(LIBC_TARGET_OS MATCHES "gpu")
+  set(LIBC_TARGET_ARCHITECTURE_IS_GPU TRUE)
+  set(LIBC_TARGET_ARCHITECTURE "gpu")
+elseif(CMAKE_SYSTEM_PROCESSOR MATCHES "^mips")
   set(LIBC_TARGET_ARCHITECTURE_IS_MIPS TRUE)
   set(LIBC_TARGET_ARCHITECTURE "mips")
 elseif(CMAKE_SYSTEM_PROCESSOR MATCHES "^arm")
   set(LIBC_TARGET_ARCHITECTURE_IS_ARM TRUE)
   set(LIBC_TARGET_ARCHITECTURE "arm")
 elseif(CMAKE_SYSTEM_PROCESSOR MATCHES "^aarch64")
   set(LIBC_TARGET_ARCHITECTURE_IS_AARCH64 TRUE)
   set(LIBC_TARGET_ARCHITECTURE "aarch64")

libc/cmake/modules/LLVMLibCObjectRules.cmake

if(LLVM_COMPILER_IS_GCC_COMPATIBLE)
     endif()
   elseif(MSVC)
     list(APPEND compile_options "/EHs-c-")
     list(APPEND compile_options "/GR-")
     if(ADD_FMA_FLAG)
       list(APPEND compile_options "/arch:AVX2")
     endif()
   endif()
+  if (LIBC_TARGET_ARCHITECTURE_IS_GPU)
+    list(APPEND compile_options "-fopenmp")
+    list(APPEND compile_options "-fopenmp-cuda-mode")
+    foreach(gpu_arch ${LIBC_GPU_ARCHITECTURES})
+      list(APPEND compile_options "--offload-arch=${gpu_arch}")
+    endforeach()
+    list(APPEND compile_options "-nogpulib")
+    list(APPEND compile_options "-nogpuinc")
+    list(APPEND compile_options "-fvisibility=hidden")
+    list(APPEND compile_options "-foffload-lto")
+  endif()
   set(${output_var} ${compile_options} PARENT_SCOPE)
 endfunction()
 
 # Rule which is essentially a wrapper over add_library to compile a set of
 # sources to object files.
 # Usage:
 #     add_object_library(
 #       <target_name>

libc/config/gpu/api.td

+include "config/public_api.td"
+
+include "spec/stdc.td"
+
+def NullMacro : MacroDef<"NULL"> {
+  let Defn = [{
+    #define __need_NULL
+    #include <stddef.h>
+  }];
+}
+
+def StringAPI : PublicAPI<"string.h"> {
+  let Types = ["size_t"];
+
+  let Macros = [
+    NullMacro,
+  ];
+}

libc/config/gpu/entrypoints.txt

+set(TARGET_LIBC_ENTRYPOINTS
+    # ctype.h entrypoints
+    libc.src.ctype.isalnum
+    libc.src.ctype.isalpha
+    libc.src.ctype.isascii
+    libc.src.ctype.isblank
+    libc.src.ctype.iscntrl
+    libc.src.ctype.isdigit
+    libc.src.ctype.isgraph
+    libc.src.ctype.islower
+    libc.src.ctype.isprint
+    libc.src.ctype.ispunct
+    libc.src.ctype.isspace
+    libc.src.ctype.isupper
+    libc.src.ctype.isxdigit
+    libc.src.ctype.toascii
+    libc.src.ctype.tolower
+    libc.src.ctype.toupper
+
+    # string.h entrypoints
+    libc.src.string.bcmp
+    libc.src.string.bzero
+    libc.src.string.memccpy
+    libc.src.string.memchr
+    libc.src.string.memcmp
+    libc.src.string.memcpy
+    libc.src.string.memmove
+    libc.src.string.mempcpy
+    libc.src.string.memrchr
+    libc.src.string.memset
+    libc.src.string.stpcpy
+    libc.src.string.stpncpy
+    libc.src.string.strcat
+    libc.src.string.strchr
+    libc.src.string.strcmp
+    libc.src.string.strcpy
+    libc.src.string.strcspn
+    libc.src.string.strlcat
+    libc.src.string.strlcpy
+    libc.src.string.strlen
+    libc.src.string.strncat
+    libc.src.string.strncmp
+    libc.src.string.strncpy
+    libc.src.string.strnlen
+    libc.src.string.strpbrk
+    libc.src.string.strrchr
+    libc.src.string.strspn
+    libc.src.string.strstr
+    libc.src.string.strtok
+    libc.src.string.strtok_r
+)
+
+set(TARGET_LLVMLIBC_ENTRYPOINTS
+  ${TARGET_LIBC_ENTRYPOINTS}
+)
+

libc/config/gpu/headers.txt

+set(TARGET_PUBLIC_HEADERS
+    libc.include.ctype
+    libc.include.string
+)

libc/src/__support/architectures.h

 //===-- Compile time architecture detection ---------------------*- 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_SUPPORT_ARCHITECTURES_H
 #define LLVM_LIBC_SUPPORT_ARCHITECTURES_H
 
-#if defined(__pnacl__) || defined(__CLR_VER)
+#if defined(__AMDGPU__)
+#define LLVM_LIBC_ARCH_AMDGPU
+#endif
+
+#if defined(__NVPTX__)
+#define LLVM_LIBC_ARCH_NVPTX
+#endif
+
+#if defined(LLVM_LIBC_ARCH_NVPTX) || defined(LLVM_LIBC_ARCH_AMDGPU)
+#define LLVM_LIBC_ARCH_GPU
+#endif
+
+#if defined(__pnacl__) || defined(__CLR_VER) || defined(LLVM_LIBC_ARCH_GPU)
 #define LLVM_LIBC_ARCH_VM
 #endif
 
 #if (defined(_M_IX86) || defined(__i386__)) && !defined(LLVM_LIBC_ARCH_VM)
 #define LLVM_LIBC_ARCH_X86_32
 #endif
 
 #if (defined(_M_X64) || defined(__x86_64__)) && !defined(LLVM_LIBC_ARCH_VM)

libc/src/__support/common.h

 #ifndef UNUSED
 #define UNUSED __attribute__((unused))
 #endif
 
 #ifndef LLVM_LIBC_FUNCTION_ATTR
 #define LLVM_LIBC_FUNCTION_ATTR
 #endif
 
+// We use OpenMP to declare these functions on the device.
+#define STR(X) #X
+#define LLVM_LIBC_DECLARE_DEVICE(name)                                         \
+  _Pragma(STR(omp declare target to(name) device_type(nohost)))
+
+// GPU targets do not support aliasing and must be declared on the device.
+#if defined(LLVM_LIBC_PUBLIC_PACKAGING) && defined(_OPENMP)
+#define LLVM_LIBC_FUNCTION(type, name, arglist)                                \
+  LLVM_LIBC_FUNCTION_ATTR decltype(__llvm_libc::name)                          \
+      __##name##_impl__ __asm__(#name);                                        \
+  LLVM_LIBC_DECLARE_DEVICE(__##name##_impl__)                                  \
+  type __##name##_impl__ arglist
 // MacOS needs to be excluded because it does not support aliasing.
-#if defined(LLVM_LIBC_PUBLIC_PACKAGING) && (!defined(__APPLE__))
+#elif defined(LLVM_LIBC_PUBLIC_PACKAGING) && (!defined(__APPLE__))
 #define LLVM_LIBC_FUNCTION(type, name, arglist)                                \
   LLVM_LIBC_FUNCTION_ATTR decltype(__llvm_libc::name)                          \
       __##name##_impl__ __asm__(#name);                                        \
   decltype(__llvm_libc::name) name [[gnu::alias(#name)]];                      \
   type __##name##_impl__ arglist
 #else
 #define LLVM_LIBC_FUNCTION(type, name, arglist) type name arglist
 #endif

libc/src/string/memory_utils/bcmp_implementations.h

 
 static inline BcmpReturnType inline_bcmp(CPtr p1, CPtr p2, size_t count) {
 #if defined(LLVM_LIBC_ARCH_X86)
   return inline_bcmp_x86(p1, p2, count);
 #elif defined(LLVM_LIBC_ARCH_AARCH64)
   return inline_bcmp_aarch64(p1, p2, count);
 #elif defined(LLVM_LIBC_ARCH_ARM)
   return inline_bcmp_embedded_tiny(p1, p2, count);
+#elif defined(LLVM_LIBC_ARCH_GPU)
+  return inline_bcmp_embedded_tiny(p1, p2, count);
 #else
 #error "Unsupported platform"
 #endif
 }
 
 static inline int inline_bcmp(const void *p1, const void *p2, size_t count) {
   return static_cast<int>(inline_bcmp(reinterpret_cast<CPtr>(p1),
                                       reinterpret_cast<CPtr>(p2), count));
 }
 
 } // namespace __llvm_libc
 
 #endif // LLVM_LIBC_SRC_STRING_MEMORY_UTILS_BCMP_IMPLEMENTATIONS_H

libc/src/string/memory_utils/memcmp_implementations.h

 #elif defined(LLVM_LIBC_ARCH_AARCH64)
   if constexpr (aarch64::kNeon)
     return inline_memcmp_aarch64_neon_gt16(p1, p2, count);
   else
     return inline_memcmp_generic_gt16(p1, p2, count);
 #endif
 #elif defined(LLVM_LIBC_ARCH_ARM)
   return inline_memcmp_embedded_tiny(p1, p2, count);
+#elif defined(LLVM_LIBC_ARCH_GPU)
+  return inline_memcmp_embedded_tiny(p1, p2, count);
 #else
 #error "Unsupported platform"
 #endif
 }
 
 static inline int inline_memcmp(const void *p1, const void *p2, size_t count) {
   return static_cast<int>(inline_memcmp(reinterpret_cast<CPtr>(p1),
                                         reinterpret_cast<CPtr>(p2), count));
 }
 
 } // namespace __llvm_libc
 
 #endif // LLVM_LIBC_SRC_STRING_MEMORY_UTILS_MEMCMP_IMPLEMENTATIONS_H

libc/src/string/memory_utils/memcpy_implementations.h

static inline void inline_memcpy(Ptr __restrict dst, CPtr __restrict src,
                                  size_t count) {
   using namespace __llvm_libc::builtin;
 #if defined(LLVM_LIBC_ARCH_X86)
   return inline_memcpy_x86_maybe_interpose_repmovsb(dst, src, count);
 #elif defined(LLVM_LIBC_ARCH_AARCH64)
   return inline_memcpy_aarch64(dst, src, count);
 #elif defined(LLVM_LIBC_ARCH_ARM)
   return inline_memcpy_embedded_tiny(dst, src, count);
+#elif defined(LLVM_LIBC_ARCH_GPU)
+  return inline_memcpy_embedded_tiny(dst, src, count);
 #else
 #error "Unsupported platform"
 #endif
 }
 
 static inline void inline_memcpy(void *__restrict dst,
                                  const void *__restrict src, size_t count) {
   inline_memcpy(reinterpret_cast<Ptr>(dst), reinterpret_cast<CPtr>(src), count);
 }
 
 } // namespace __llvm_libc
 
 #endif // LLVM_LIBC_SRC_STRING_MEMORY_UTILS_MEMCPY_IMPLEMENTATIONS_H

libc/src/string/memory_utils/memmove_implementations.h

return generic::Memmove<64, kMaxSize>::loop_and_tail_forward(dst, src,
                                                                  count);
   } else {
     generic::Memmove<32, kMaxSize>::align_backward<Arg::Src>(dst, src, count);
     return generic::Memmove<64, kMaxSize>::loop_and_tail_backward(dst, src,
                                                                   count);
   }
 #elif defined(LLVM_LIBC_ARCH_ARM)
   return inline_memmove_embedded_tiny(dst, src, count);
+#elif defined(LLVM_LIBC_ARCH_GPU)
+  return inline_memmove_embedded_tiny(dst, src, count);
 #else
 #error "Unsupported platform"
 #endif
 }
 
 static inline void inline_memmove(void *dst, const void *src, size_t count) {
   inline_memmove(reinterpret_cast<Ptr>(dst), reinterpret_cast<CPtr>(src),
                  count);
 }
 
 } // namespace __llvm_libc
 
 #endif /* LLVM_LIBC_SRC_STRING_MEMORY_UTILS_MEMMOVE_IMPLEMENTATIONS_H */

libc/src/string/memory_utils/memset_implementations.h

static constexpr size_t kMaxSize = x86::kAvx512F ? 64
                                      : x86::kSse2  ? 16
                                                    : 8;
   return inline_memset_x86<kMaxSize>(dst, value, count);
 #elif defined(LLVM_LIBC_ARCH_AARCH64)
   static constexpr size_t kMaxSize = aarch64::kNeon ? 16 : 8;
   return inline_memset_aarch64<kMaxSize>(dst, value, count);
 #elif defined(LLVM_LIBC_ARCH_ARM)
   return inline_memset_embedded_tiny(dst, value, count);
+#elif defined(LLVM_LIBC_ARCH_GPU)
+  return inline_memset_embedded_tiny(dst, value, count);
 #else
 #error "Unsupported platform"
 #endif
 }
 
 inline static void inline_memset(void *dst, uint8_t value, size_t count) {
   inline_memset(reinterpret_cast<Ptr>(dst), value, count);
 }
 
 } // namespace __llvm_libc
 
 #endif // LLVM_LIBC_SRC_STRING_MEMORY_UTILS_MEMSET_IMPLEMENTATIONS_H

libc/utils/CMakeLists.txt

 add_subdirectory(MPFRWrapper)
 add_subdirectory(testutils)
 add_subdirectory(UnitTest)
 
-if(LLVM_LIBC_FULL_BUILD)
+if(LLVM_LIBC_FULL_BUILD AND NOT LIBC_TARGET_ARCHITECTURE_IS_GPU)
   add_subdirectory(IntegrationTest)
   add_subdirectory(tools)
 endif()