CUDA: Support CMP0105 on Clang

Add link flags during the "device compile" step.

Enabled the relevant tests. The disable reasons regarding separable compilation
were outdated and the actual failure case was device link flags support.

Help/release/dev/cuda-clang-device-link-flags.rst

@@ -0,0 +1,7 @@
+cuda-clang-device-link-flags
+----------------------------
+
+* Policy :policy:`CMP0105` and the ``$<DEVICE_LINK:...>`` and
+  ``$<HOST_LINK:...>``
+  :manual:`generator expressions <cmake-generator-expressions(7)>`
+  are now supported for Clang.

Modules/CMakeCUDAInformation.cmake

@@ -198,7 +198,7 @@ endif()
 
 # Used when device linking is handled by CMake.
 if(NOT CMAKE_CUDA_DEVICE_LINK_COMPILE)
-  set(CMAKE_CUDA_DEVICE_LINK_COMPILE "<CMAKE_CUDA_COMPILER> ${_CMAKE_CUDA_EXTRA_FLAGS} <FLAGS> -D__CUDA_INCLUDE_COMPILER_INTERNAL_HEADERS__ -D__NV_EXTRA_INITIALIZATION=\"\" -D__NV_EXTRA_FINALIZATION=\"\" -DREGISTERLINKBINARYFILE=\\\"<REGISTER_FILE>\\\" -DFATBINFILE=\\\"<FATBINARY>\\\" ${_CMAKE_COMPILE_AS_CUDA_FLAG} -c \"${CMAKE_CUDA_COMPILER_TOOLKIT_LIBRARY_ROOT}/bin/crt/link.stub\" -o <OBJECT>")
+  set(CMAKE_CUDA_DEVICE_LINK_COMPILE "<CMAKE_CUDA_COMPILER> ${_CMAKE_CUDA_EXTRA_FLAGS} <FLAGS> <LINK_FLAGS> -D__CUDA_INCLUDE_COMPILER_INTERNAL_HEADERS__ -D__NV_EXTRA_INITIALIZATION=\"\" -D__NV_EXTRA_FINALIZATION=\"\" -DREGISTERLINKBINARYFILE=\\\"<REGISTER_FILE>\\\" -DFATBINFILE=\\\"<FATBINARY>\\\" ${_CMAKE_COMPILE_AS_CUDA_FLAG} -c \"${CMAKE_CUDA_COMPILER_TOOLKIT_LIBRARY_ROOT}/bin/crt/link.stub\" -o <OBJECT>")
 endif()
 
 unset(__IMPLICIT_DLINK_FLAGS)

Modules/Compiler/Clang-CUDA.cmake

@@ -22,6 +22,10 @@ set(_CMAKE_CUDA_WHOLE_FLAG "-c")
 set(_CMAKE_CUDA_RDC_FLAG "-fgpu-rdc")
 set(_CMAKE_CUDA_PTX_FLAG "--cuda-device-only -S")
 
+# Device linking is just regular linking so these are the same.
+set(CMAKE_CUDA_DEVICE_LINKER_WRAPPER_FLAG ${CMAKE_CUDA_LINKER_WRAPPER_FLAG})
+set(CMAKE_CUDA_DEVICE_LINKER_WRAPPER_FLAG_SEP ${CMAKE_CUDA_LINKER_WRAPPER_FLAG_SEP})
+
 # RulePlaceholderExpander expands crosscompile variables like sysroot and target only for CMAKE_<LANG>_COMPILER. Override the default.
 set(CMAKE_CUDA_LINK_EXECUTABLE "<CMAKE_CUDA_COMPILER> <LINK_FLAGS> <OBJECTS> -o <TARGET> <LINK_LIBRARIES>${__IMPLICIT_LINKS}")
 set(CMAKE_CUDA_CREATE_SHARED_LIBRARY "<CMAKE_CUDA_COMPILER> <CMAKE_SHARED_LIBRARY_CUDA_FLAGS> <LINK_FLAGS> <CMAKE_SHARED_LIBRARY_CREATE_CUDA_FLAGS> <SONAME_FLAG><TARGET_SONAME> -o <TARGET> <OBJECTS> <LINK_LIBRARIES>${__IMPLICIT_LINKS}")

Source/cmMakefileTargetGenerator.cxx

@@ -1624,6 +1624,10 @@ void cmMakefileTargetGenerator::WriteDeviceLinkRule(
   vars.Fatbinary = fatbinaryOutput.c_str();
   vars.RegisterFile = registerFile.c_str();
 
+  std::string linkFlags;
+  this->GetDeviceLinkFlags(linkFlags, "CUDA");
+  vars.LinkFlags = linkFlags.c_str();
+
   std::string flags = this->GetFlags("CUDA", this->GetConfigName());
   vars.Flags = flags.c_str();
 

Source/cmNinjaNormalTargetGenerator.cxx

@@ -326,6 +326,7 @@ void cmNinjaNormalTargetGenerator::WriteDeviceLinkRules(
   vars.Object = "$out";
   vars.Fatbinary = "$FATBIN";
   vars.RegisterFile = "$REGISTER";
+  vars.LinkFlags = "$LINK_FLAGS";
 
   std::string flags = this->GetFlags("CUDA", config);
   vars.Flags = flags.c_str();
@@ -794,6 +795,20 @@ void cmNinjaNormalTargetGenerator::WriteDeviceLinkStatements(
     cmStrCat(objectDir, "/cmake_cuda_fatbin.h"), cmOutputConverter::SHELL);
   dcompile.Variables["REGISTER"] = localGen->ConvertToOutputFormat(
     cmStrCat(objectDir, "/cmake_cuda_register.h"), cmOutputConverter::SHELL);
+
+  cmNinjaLinkLineDeviceComputer linkLineComputer(
+    localGen, localGen->GetStateSnapshot().GetDirectory(), globalGen);
+  linkLineComputer.SetUseNinjaMulti(globalGen->IsMultiConfig());
+
+  // Link libraries and paths are only used during the final executable/library
+  // link.
+  std::string frameworkPath;
+  std::string linkPath;
+  std::string linkLibs;
+  localGen->GetDeviceLinkFlags(linkLineComputer, config, linkLibs,
+                               dcompile.Variables["LINK_FLAGS"], frameworkPath,
+                               linkPath, this->GetGeneratorTarget());
+
   globalGen->WriteBuild(this->GetCommonFileStream(), dcompile);
 }
 

Tests/RunCMake/NinjaMultiConfig/RunCMakeTest.cmake

@@ -448,7 +448,7 @@ run_cmake_command(NoUnusedVariables ${CMAKE_COMMAND} ${CMAKE_CURRENT_LIST_DIR}
   )
 
 # CudaSimple uses separable compilation, which is currently only supported on NVCC.
-if(CMake_TEST_CUDA AND NOT CMake_TEST_CUDA STREQUAL "Clang")
+if(CMake_TEST_CUDA)
   set(RunCMake_TEST_BINARY_DIR ${RunCMake_BINARY_DIR}/CudaSimple-build)
   run_cmake_configure(CudaSimple)
   include(${RunCMake_TEST_BINARY_DIR}/target_files.cmake)

Tests/RunCMake/target_link_options/RunCMakeTest.cmake

@@ -53,16 +53,13 @@ if (NOT CMAKE_C_COMPILER_ID STREQUAL "Intel")
   run_cmake_target(genex_DEVICE_LINK interface LinkOptions_shared_interface --config Release)
   run_cmake_target(genex_DEVICE_LINK private LinkOptions_private --config Release)
   if (CMake_TEST_CUDA)
-    # Separable compilation is only supported on NVCC.
-    if(NOT CMake_TEST_CUDA STREQUAL "Clang")
-      run_cmake_target(genex_DEVICE_LINK CMP0105_UNSET LinkOptions_CMP0105_UNSET --config Release)
-      run_cmake_target(genex_DEVICE_LINK CMP0105_OLD LinkOptions_CMP0105_OLD --config Release)
-      run_cmake_target(genex_DEVICE_LINK CMP0105_NEW LinkOptions_CMP0105_NEW --config Release)
-      run_cmake_target(genex_DEVICE_LINK device LinkOptions_device --config Release)
-
-      if (RunCMake_GENERATOR MATCHES "(Ninja|Unix Makefiles)")
-        run_cmake_target(genex_DEVICE_LINK host_link_options LinkOptions_host_link_options --config Release ${VERBOSE})
-      endif()
+    run_cmake_target(genex_DEVICE_LINK CMP0105_UNSET LinkOptions_CMP0105_UNSET --config Release)
+    run_cmake_target(genex_DEVICE_LINK CMP0105_OLD LinkOptions_CMP0105_OLD --config Release)
+    run_cmake_target(genex_DEVICE_LINK CMP0105_NEW LinkOptions_CMP0105_NEW --config Release)
+    run_cmake_target(genex_DEVICE_LINK device LinkOptions_device --config Release)
+
+    if (RunCMake_GENERATOR MATCHES "(Ninja|Unix Makefiles)")
+      run_cmake_target(genex_DEVICE_LINK host_link_options LinkOptions_host_link_options --config Release ${VERBOSE})
     endif()
 
     run_cmake_target(genex_DEVICE_LINK no_device LinkOptions_no_device --config Release)

Tests/RunCMake/target_link_options/genex_DEVICE_LINK-host_link_options-check.cmake

@@ -1,4 +1,9 @@
+if(CMake_TEST_CUDA STREQUAL "NVIDIA")
+  set(expected "-Xlinker=OPT1 -Xlinker=OPT2 -Xlinker=OPT3 -Xlinker=OPT4 -Xlinker=OPT5")
+elseif(CMake_TEST_CUDA STREQUAL "Clang")
+  set(expected "-Wl,OPT1 -Xlinker OPT2 -Xlinker OPT3 -Xlinker OPT4")
+endif()
 
-if (NOT actual_stdout MATCHES "-Xlinker=OPT1 -Xlinker=OPT2 -Xlinker=OPT3 -Xlinker=OPT4 -Xlinker=OPT5")
-    set (RunCMake_TEST_FAILED "Not found expected '-Xlinker=OPT1 -Xlinker=OPT2 -Xlinker=OPT3 -Xlinker=OPT4 -Xlinker=OPT5'.")
+if(NOT actual_stdout MATCHES "${expected}")
+    set(RunCMake_TEST_FAILED "Not found expected '${expected}'")
 endif()

Tests/RunCMake/target_link_options/genex_DEVICE_LINK.cmake

@@ -25,32 +25,33 @@ target_link_options (LinkOptions_private PRIVATE $<DEVICE_LINK:${pre}BADFLAG_DEV
 if (CMake_TEST_CUDA)
   enable_language(CUDA)
 
-  # Separable compilation is only supported on NVCC.
-  if(NOT CMake_TEST_CUDA STREQUAL "Clang")
-    add_executable(LinkOptions_CMP0105_UNSET LinkOptionsDevice.cu)
-    set_property(TARGET LinkOptions_CMP0105_UNSET PROPERTY CUDA_SEPARABLE_COMPILATION ON)
-    target_link_options(LinkOptions_CMP0105_UNSET PRIVATE $<DEVICE_LINK:${pre}BADFLAG_DEVICE_LINK${obj}>)
+  add_executable(LinkOptions_CMP0105_UNSET LinkOptionsDevice.cu)
+  set_property(TARGET LinkOptions_CMP0105_UNSET PROPERTY CUDA_SEPARABLE_COMPILATION ON)
+  target_link_options(LinkOptions_CMP0105_UNSET PRIVATE $<DEVICE_LINK:${pre}BADFLAG_DEVICE_LINK${obj}>)
 
-    cmake_policy(SET CMP0105 OLD)
+  cmake_policy(SET CMP0105 OLD)
 
-    add_executable(LinkOptions_CMP0105_OLD LinkOptionsDevice.cu)
-    set_property(TARGET LinkOptions_CMP0105_OLD PROPERTY CUDA_SEPARABLE_COMPILATION ON)
-    target_link_options(LinkOptions_CMP0105_OLD PRIVATE $<DEVICE_LINK:${pre}BADFLAG_DEVICE_LINK${obj}>)
+  add_executable(LinkOptions_CMP0105_OLD LinkOptionsDevice.cu)
+  set_property(TARGET LinkOptions_CMP0105_OLD PROPERTY CUDA_SEPARABLE_COMPILATION ON)
+  target_link_options(LinkOptions_CMP0105_OLD PRIVATE $<DEVICE_LINK:${pre}BADFLAG_DEVICE_LINK${obj}>)
 
-    cmake_policy(SET CMP0105 NEW)
+  cmake_policy(SET CMP0105 NEW)
 
-    add_executable(LinkOptions_CMP0105_NEW LinkOptionsDevice.cu)
-    set_property(TARGET LinkOptions_CMP0105_NEW PROPERTY CUDA_SEPARABLE_COMPILATION ON)
-    target_link_options(LinkOptions_CMP0105_NEW PRIVATE $<DEVICE_LINK:${pre}BADFLAG_DEVICE_LINK${obj}>)
+  add_executable(LinkOptions_CMP0105_NEW LinkOptionsDevice.cu)
+  set_property(TARGET LinkOptions_CMP0105_NEW PROPERTY CUDA_SEPARABLE_COMPILATION ON)
+  target_link_options(LinkOptions_CMP0105_NEW PRIVATE $<DEVICE_LINK:${pre}BADFLAG_DEVICE_LINK${obj}>)
 
-    add_executable(LinkOptions_device LinkOptionsDevice.cu)
-    set_property(TARGET LinkOptions_device PROPERTY CUDA_SEPARABLE_COMPILATION ON)
-    target_link_options(LinkOptions_device PRIVATE $<DEVICE_LINK:${pre}BADFLAG_DEVICE_LINK${obj}>
-                                                  $<HOST_LINK:${pre}BADFLAG_NORMAL_LINK${obj}>)
+  add_executable(LinkOptions_device LinkOptionsDevice.cu)
+  set_property(TARGET LinkOptions_device PROPERTY CUDA_SEPARABLE_COMPILATION ON)
+  target_link_options(LinkOptions_device PRIVATE $<DEVICE_LINK:${pre}BADFLAG_DEVICE_LINK${obj}>
+                                                 $<HOST_LINK:${pre}BADFLAG_NORMAL_LINK${obj}>)
 
-    add_executable(LinkOptions_host_link_options LinkOptionsDevice.cu)
-    set_property(TARGET LinkOptions_host_link_options PROPERTY CUDA_SEPARABLE_COMPILATION ON)
+  add_executable(LinkOptions_host_link_options LinkOptionsDevice.cu)
+  set_property(TARGET LinkOptions_host_link_options PROPERTY CUDA_SEPARABLE_COMPILATION ON)
+  if(CMake_TEST_CUDA STREQUAL "NVIDIA")
     target_link_options(LinkOptions_host_link_options PRIVATE -Wl,OPT1 -Xlinker=OPT2 "SHELL:-Xlinker OPT3" "SHELL:LINKER:OPT4 LINKER:OPT5")
+  elseif(CMake_TEST_CUDA STREQUAL "Clang")
+    target_link_options(LinkOptions_host_link_options PRIVATE -Wl,OPT1 "SHELL:-Xlinker OPT2" "SHELL:LINKER:OPT3 LINKER:OPT4")
   endif()
 
   add_executable(LinkOptions_no_device LinkOptionsDevice.cu)