libc/cmake/modules/prepare_libc_gpu_build.cmake

if(NOT LIBC_TARGET_OS_IS_GPU)
  message(FATAL_ERROR
          "libc build: Invalid attempt to set up GPU architectures.")
endif()

# Ensure the compiler is a valid clang when building the GPU target.
set(req_ver "${LLVM_VERSION_MAJOR}.${LLVM_VERSION_MINOR}.${LLVM_VERSION_PATCH}")
if(LLVM_VERSION_MAJOR AND NOT (CMAKE_CXX_COMPILER_ID MATCHES "[Cc]lang" AND
   ${CMAKE_CXX_COMPILER_VERSION} VERSION_EQUAL "${req_ver}"))
   message(WARNING "libc for GPU requires an up-to-date clang. CMake compiler "
                      "'${CMAKE_CXX_COMPILER_ID} ${CMAKE_CXX_COMPILER_VERSION}' "
                      " is not 'Clang ${req_ver}'.")
endif()
if(NOT LLVM_LIBC_FULL_BUILD)
  message(FATAL_ERROR "LLVM_LIBC_FULL_BUILD must be enabled to build libc for "
                      "GPU.")
endif()

# Set the required flags globally so standard CMake utilities can compile.
if(NOT CMAKE_CXX_COMPILER_TARGET)
  set(CMAKE_REQUIRED_FLAGS "${LIBC_COMPILE_OPTIONS_DEFAULT}")
endif()

# Optionally set up a job pool to limit the number of GPU tests run in parallel.
# This is sometimes necessary as running too many tests in parallel can cause
# the GPU or driver to run out of resources.
set(LIBC_GPU_TEST_JOBS "" CACHE STRING "Number of jobs to use for GPU tests")
if(LIBC_GPU_TEST_JOBS)
  set_property(GLOBAL PROPERTY JOB_POOLS LIBC_GPU_TEST_POOL=${LIBC_GPU_TEST_JOBS})
  set(LIBC_HERMETIC_TEST_JOB_POOL JOB_POOL LIBC_GPU_TEST_POOL)
else()
  set(LIBC_GPU_TEST_JOBS 1)
  set_property(GLOBAL PROPERTY JOB_POOLS LIBC_GPU_TEST_POOL=1)
  set(LIBC_HERMETIC_TEST_JOB_POOL JOB_POOL LIBC_GPU_TEST_POOL)
endif()

set(LIBC_GPU_TEST_ARCHITECTURE "" CACHE STRING "Architecture for the GPU tests")
if(LIBC_TARGET_ARCHITECTURE_IS_AMDGPU)
  check_cxx_compiler_flag(-mcpu=native PLATFORM_HAS_GPU)
elseif(LIBC_TARGET_ARCHITECTURE_IS_NVPTX)
  check_cxx_compiler_flag(-march=native PLATFORM_HAS_GPU)
endif()

set(gpu_test_architecture "")
if(DEFINED LLVM_TARGETS_TO_BUILD AND LIBC_TARGET_ARCHITECTURE_IS_AMDGPU
   AND NOT "AMDGPU" IN_LIST LLVM_TARGETS_TO_BUILD)
  set(LIBC_GPU_TESTS_DISABLED TRUE)
  message(STATUS "AMDGPU backend is not available, tests will not be built")
elseif(DEFINED LLVM_TARGETS_TO_BUILD AND LIBC_TARGET_ARCHITECTURE_IS_NVPTX
       AND NOT "NVPTX" IN_LIST LLVM_TARGETS_TO_BUILD)
  set(LIBC_GPU_TESTS_DISABLED TRUE)
  message(STATUS "NVPTX backend is not available, tests will not be built")
elseif(LIBC_GPU_TEST_ARCHITECTURE)
  set(LIBC_GPU_TESTS_DISABLED FALSE)
  set(gpu_test_architecture ${LIBC_GPU_TEST_ARCHITECTURE})
  message(STATUS "Using user-specified GPU architecture for testing: "
                 "'${gpu_test_architecture}'")
elseif(PLATFORM_HAS_GPU)
  set(LIBC_GPU_TESTS_DISABLED FALSE)
  set(gpu_test_architecture "native")
  message(STATUS "Using GPU architecture detected on the system for testing: "
                 "'native'")
else()
  set(LIBC_GPU_TESTS_DISABLED TRUE)
  message(STATUS "No GPU architecture detected or provided, tests will not be "
                 "built")
endif()
set(LIBC_GPU_TARGET_ARCHITECTURE "${gpu_test_architecture}")

# The AMDGPU environment uses different code objects to encode the ABI for
# kernel calls and intrinsic functions. We want to expose this to conform to
# whatever the test suite was built to handle.
set(LIBC_GPU_CODE_OBJECT_VERSION "6" CACHE STRING "AMDGPU Code object ABI to use")

if(LIBC_TARGET_ARCHITECTURE_IS_NVPTX)
  # Respect the standard CUDAToolkit_ROOT override if the user provided one,
  # otherwise ask the compiler which CUDA installation it detected.
  if(CUDAToolkit_ROOT)
    set(LIBC_CUDA_ROOT "${CUDAToolkit_ROOT}")
  else()
    execute_process(
      COMMAND ${CMAKE_CXX_COMPILER} -v --print-resource-dir
      OUTPUT_QUIET ERROR_VARIABLE cuda_search_output)
    string(REGEX MATCH "Found CUDA installation: ([^,]+), version"
      cuda_search_match "${cuda_search_output}")
    if(CMAKE_MATCH_1)
      set(LIBC_CUDA_ROOT "${CMAKE_MATCH_1}")
    endif()
  endif()
endif()