[libc] Search for the CUDA patch explicitly when testing

[jhuber6]

Summary

The packaged version of the libc library does not depend on the CUDA
installation because it only uses clang and emits LLVM-IR. However,
for testing we directly need the CUDA toolkit to emit and execute the
files. This patch explicitly passes --cuda-path to the relevant
compilations for NVPTX testing.

[tra]

libc/cmake/modules/prepare_libc_gpu_build.cmake

105

Nit: .. may potentially backfire if we're operating on a tree of symlinks, depending on whether cmake would actually traverse the filesystem, or process the ,, itself and just stripping one path component.

It may be safer to calculate absolute path to CUDAToolkit_BIN_DIR and then use get_filename_component(DIRECTORY) on it.

libc/cmake/modules/LLVMLibCObjectRules.cmake

add_library(
       ${ADD_GPU_OBJ_SRCS}
       ${ADD_GPU_OBJ_HDRS}
     )
     target_compile_options(${internal_target_name} BEFORE PRIVATE
                            ${common_compile_options} --target=${LIBC_GPU_TARGET_TRIPLE})
     if(LIBC_GPU_TARGET_ARCHITECTURE_IS_AMDGPU)
       target_compile_options(${internal_target_name} PRIVATE -mcpu=${LIBC_GPU_TARGET_ARCHITECTURE} -flto)
     elseif(LIBC_GPU_TARGET_ARCHITECTURE_IS_NVPTX)
-      target_compile_options(${internal_target_name} PRIVATE -march=${LIBC_GPU_TARGET_ARCHITECTURE})
+      target_compile_options(${internal_target_name} PRIVATE
+                             -march=${LIBC_GPU_TARGET_ARCHITECTURE}
+                             --cuda-path=${LIBC_CUDA_ROOT})
     endif()
     target_include_directories(${internal_target_name} PRIVATE ${include_dirs})
     if(full_deps_list)
       add_dependencies(${internal_target_name} ${full_deps_list})
     endif()
   endif()
 endfunction()
 

libc/cmake/modules/LLVMLibCTestRules.cmake

target_compile_options(${fq_build_target_name}
                          PRIVATE -fpie -ffreestanding ${INTEGRATION_TEST_COMPILE_OPTIONS})
   # The GPU build requires overriding the default CMake triple and architecture.
   if(LIBC_GPU_TARGET_ARCHITECTURE_IS_AMDGPU)
     target_compile_options(${fq_build_target_name} PRIVATE
                            -mcpu=${LIBC_GPU_TARGET_ARCHITECTURE} -flto
                            --target=${LIBC_GPU_TARGET_TRIPLE})
   elseif(LIBC_GPU_TARGET_ARCHITECTURE_IS_NVPTX)
     target_compile_options(${fq_build_target_name} PRIVATE
+                           --cuda-path=${LIBC_CUDA_ROOT}
                            -march=${LIBC_GPU_TARGET_ARCHITECTURE}
                            --target=${LIBC_GPU_TARGET_TRIPLE})
   endif()
 
   target_link_options(${fq_build_target_name} PRIVATE -nostdlib -static)
   target_link_libraries(
     ${fq_build_target_name}
     # The NVIDIA 'nvlink' linker does not currently support static libraries.

libc/cmake/modules/prepare_libc_gpu_build.cmake

if("${gpu_test_architecture}" IN_LIST all_amdgpu_architectures)
   set(LIBC_GPU_TARGET_ARCHITECTURE "${gpu_test_architecture}")
 elseif("${gpu_test_architecture}" IN_LIST all_nvptx_architectures)
   set(LIBC_GPU_TARGET_ARCHITECTURE_IS_NVPTX TRUE)
   set(LIBC_GPU_TARGET_TRIPLE "nvptx64-nvidia-cuda")
   set(LIBC_GPU_TARGET_ARCHITECTURE "${gpu_test_architecture}")
 else()
   message(FATAL_ERROR "Unknown GPU architecture '${gpu_test_architecture}'")
 endif()
+
+if(LIBC_GPU_TARGET_ARCHITECTURE_IS_NVPTX)
+  find_package(CUDAToolkit QUIET)
+  if(CUDAToolkit_FOUND)
+    get_filename_component(LIBC_CUDA_ROOT "${CUDAToolkit_BIN_DIR}" DIRECTORY ABSOLUTE)
+    message(WARNING ${LIBC_CUDA_ROOT})
+  endif()
+endif()

libc/startup/gpu/nvptx/CMakeLists.txt

 add_startup_object(
   crt1
   SRC
     start.cpp
   DEPENDS
     libc.src.__support.RPC.rpc_client
   COMPILE_OPTIONS
     -ffreestanding # To avoid compiler warnings about calling the main function.
     -fno-builtin
     -nogpulib # Do not include any GPU vendor libraries.
     -march=${LIBC_GPU_TARGET_ARCHITECTURE}
     --target=${LIBC_GPU_TARGET_TRIPLE}
+    --cuda-path=${LIBC_CUDA_ROOT}
   NO_GPU_BUNDLE # Compile this file directly without special GPU handling.
 )
 get_fq_target_name(crt1 fq_name)
 
 # Ensure that clang uses the correct linker for this object type.
 target_link_libraries(${fq_name}
   PUBLIC
   "-march=${LIBC_GPU_TARGET_ARCHITECTURE}"
   "--target=${LIBC_GPU_TARGET_TRIPLE}"
+  "--cuda-path=${LIBC_CUDA_ROOT}"
 )

libc/test/IntegrationTest/CMakeLists.txt

 if(LIBC_GPU_TARGET_ARCHITECTURE_IS_AMDGPU)
   set(TEST_COMPILE_FLAGS
     -mcpu=${LIBC_GPU_TARGET_ARCHITECTURE}
     -emit-llvm # AMDGPU's intermediate object file format is bitcode.
     --target=${LIBC_GPU_TARGET_TRIPLE}
   )
 elseif(LIBC_GPU_TARGET_ARCHITECTURE_IS_NVPTX)
   set(TEST_COMPILE_FLAGS
     -march=${LIBC_GPU_TARGET_ARCHITECTURE}
     --target=${LIBC_GPU_TARGET_TRIPLE}
+    --cuda-path=${LIBC_CUDA_ROOT}
   )
 endif()
 
 add_object_library(
   test
   SRCS
     test.cpp
   COMPILE_OPTIONS
     ${TEST_COMPILE_FLAGS}
   HDRS
     test.h
   DEPENDS
     libc.src.__support.OSUtil.osutil
   NO_GPU_BUNDLE # Compile this file directly without special GPU handling.
 )