Modules/CMakeCUDAInformation.cmake

   1 # Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
   2 # file Copyright.txt or https://cmake.org/licensing for details.
   3
   4 if(UNIX)
   5   set(CMAKE_CUDA_OUTPUT_EXTENSION .o)
   6 else()
   7   set(CMAKE_CUDA_OUTPUT_EXTENSION .obj)
   8 endif()
   9 set(CMAKE_INCLUDE_FLAG_CUDA "-I")
  10
  11 # Set implicit links early so compiler-specific modules can use them.
  12 set(__IMPLICIT_LINKS)
  13 foreach(dir ${CMAKE_CUDA_HOST_IMPLICIT_LINK_DIRECTORIES})
  14   string(APPEND __IMPLICIT_LINKS " -L\"${dir}\"")
  15 endforeach()
  16 foreach(lib ${CMAKE_CUDA_HOST_IMPLICIT_LINK_LIBRARIES})
  17   if(${lib} MATCHES "/")
  18     string(APPEND __IMPLICIT_LINKS " \"${lib}\"")
  19   else()
  20     string(APPEND __IMPLICIT_LINKS " -l${lib}")
  21   endif()
  22 endforeach()
  23
  24 # Load compiler-specific information.
  25 if(CMAKE_CUDA_COMPILER_ID)
  26   include(Compiler/${CMAKE_CUDA_COMPILER_ID}-CUDA OPTIONAL)
  27 endif()
  28
  29 # load the system- and compiler specific files
  30 if(CMAKE_CUDA_COMPILER_ID)
  31   # load a hardware specific file, mostly useful for embedded compilers
  32   if(CMAKE_SYSTEM_PROCESSOR)
  33     include(Platform/${CMAKE_EFFECTIVE_SYSTEM_NAME}-${CMAKE_CUDA_COMPILER_ID}-CUDA-${CMAKE_SYSTEM_PROCESSOR} OPTIONAL)
  34   endif()
  35   include(Platform/${CMAKE_EFFECTIVE_SYSTEM_NAME}-${CMAKE_CUDA_COMPILER_ID}-CUDA OPTIONAL)
  36 endif()
  37
  38
  39 # This should be included before the _INIT variables are
  40 # used to initialize the cache.  Since the rule variables
  41 # have if blocks on them, users can still define them here.
  42 # But, it should still be after the platform file so changes can
  43 # be made to those values.
  44
  45 if(CMAKE_USER_MAKE_RULES_OVERRIDE)
  46   # Save the full path of the file so try_compile can use it.
  47   include(${CMAKE_USER_MAKE_RULES_OVERRIDE} RESULT_VARIABLE _override)
  48   set(CMAKE_USER_MAKE_RULES_OVERRIDE "${_override}")
  49 endif()
  50
  51 if(CMAKE_USER_MAKE_RULES_OVERRIDE_CUDA)
  52   # Save the full path of the file so try_compile can use it.
  53   include(${CMAKE_USER_MAKE_RULES_OVERRIDE_CUDA} RESULT_VARIABLE _override)
  54   set(CMAKE_USER_MAKE_RULES_OVERRIDE_CUDA "${_override}")
  55 endif()
  56
  57
  58 if(NOT CMAKE_SHARED_LIBRARY_RUNTIME_CUDA_FLAG)
  59   set(CMAKE_SHARED_LIBRARY_RUNTIME_CUDA_FLAG ${CMAKE_SHARED_LIBRARY_RUNTIME_C_FLAG})
  60 endif()
  61
  62 if(NOT CMAKE_SHARED_LIBRARY_RUNTIME_CUDA_FLAG_SEP)
  63   set(CMAKE_SHARED_LIBRARY_RUNTIME_CUDA_FLAG_SEP ${CMAKE_SHARED_LIBRARY_RUNTIME_C_FLAG_SEP})
  64 endif()
  65
  66 if(NOT CMAKE_SHARED_LIBRARY_RPATH_LINK_CUDA_FLAG)
  67   set(CMAKE_SHARED_LIBRARY_RPATH_LINK_CUDA_FLAG ${CMAKE_SHARED_LIBRARY_RPATH_LINK_C_FLAG})
  68 endif()
  69
  70 if(NOT DEFINED CMAKE_EXE_EXPORTS_CUDA_FLAG)
  71   set(CMAKE_EXE_EXPORTS_CUDA_FLAG ${CMAKE_EXE_EXPORTS_C_FLAG})
  72 endif()
  73
  74 if(NOT DEFINED CMAKE_SHARED_LIBRARY_SONAME_CUDA_FLAG)
  75   set(CMAKE_SHARED_LIBRARY_SONAME_CUDA_FLAG ${CMAKE_SHARED_LIBRARY_SONAME_C_FLAG})
  76 endif()
  77
  78 if(NOT CMAKE_EXECUTABLE_RUNTIME_CUDA_FLAG)
  79   set(CMAKE_EXECUTABLE_RUNTIME_CUDA_FLAG ${CMAKE_SHARED_LIBRARY_RUNTIME_CUDA_FLAG})
  80 endif()
  81
  82 if(NOT CMAKE_EXECUTABLE_RUNTIME_CUDA_FLAG_SEP)
  83   set(CMAKE_EXECUTABLE_RUNTIME_CUDA_FLAG_SEP ${CMAKE_SHARED_LIBRARY_RUNTIME_CUDA_FLAG_SEP})
  84 endif()
  85
  86 if(NOT CMAKE_EXECUTABLE_RPATH_LINK_CUDA_FLAG)
  87   set(CMAKE_EXECUTABLE_RPATH_LINK_CUDA_FLAG ${CMAKE_SHARED_LIBRARY_RPATH_LINK_CUDA_FLAG})
  88 endif()
  89
  90 if(NOT DEFINED CMAKE_SHARED_LIBRARY_LINK_CUDA_WITH_RUNTIME_PATH)
  91   set(CMAKE_SHARED_LIBRARY_LINK_CUDA_WITH_RUNTIME_PATH ${CMAKE_SHARED_LIBRARY_LINK_C_WITH_RUNTIME_PATH})
  92 endif()
  93
  94
  95 # for most systems a module is the same as a shared library
  96 # so unless the variable CMAKE_MODULE_EXISTS is set just
  97 # copy the values from the LIBRARY variables
  98 if(NOT CMAKE_MODULE_EXISTS)
  99   set(CMAKE_SHARED_MODULE_CUDA_FLAGS ${CMAKE_SHARED_LIBRARY_CUDA_FLAGS})
 100   set(CMAKE_SHARED_MODULE_CREATE_CUDA_FLAGS ${CMAKE_SHARED_LIBRARY_CREATE_CUDA_FLAGS})
 101 endif()
 102
 103 if(CMAKE_EXECUTABLE_FORMAT STREQUAL "ELF")
 104   if(NOT DEFINED CMAKE_CUDA_LINK_WHAT_YOU_USE_FLAG)
 105     set(CMAKE_CUDA_LINK_WHAT_YOU_USE_FLAG "LINKER:--no-as-needed")
 106   endif()
 107   if(NOT DEFINED CMAKE_LINK_WHAT_YOU_USE_CHECK)
 108     set(CMAKE_LINK_WHAT_YOU_USE_CHECK ldd -u -r)
 109   endif()
 110 endif()
 111
 112 # add the flags to the cache based
 113 # on the initial values computed in the platform/*.cmake files
 114 # use _INIT variables so that this only happens the first time
 115 # and you can set these flags in the cmake cache
 116 set(CMAKE_CUDA_FLAGS_INIT "$ENV{CUDAFLAGS} ${CMAKE_CUDA_FLAGS_INIT}")
 117
 118 cmake_initialize_per_config_variable(CMAKE_CUDA_FLAGS "Flags used by the CUDA compiler")
 119
 120 if(CMAKE_CUDA_STANDARD_LIBRARIES_INIT)
 121   set(CMAKE_CUDA_STANDARD_LIBRARIES "${CMAKE_CUDA_STANDARD_LIBRARIES_INIT}"
 122     CACHE STRING "Libraries linked by default with all CUDA applications.")
 123   mark_as_advanced(CMAKE_CUDA_STANDARD_LIBRARIES)
 124 endif()
 125
 126 if(NOT CMAKE_CUDA_COMPILER_LAUNCHER AND DEFINED ENV{CMAKE_CUDA_COMPILER_LAUNCHER})
 127   set(CMAKE_CUDA_COMPILER_LAUNCHER "$ENV{CMAKE_CUDA_COMPILER_LAUNCHER}"
 128     CACHE STRING "Compiler launcher for CUDA.")
 129 endif()
 130
 131 include(CMakeCommonLanguageInclude)
 132
 133 # now define the following rules:
 134 # CMAKE_CUDA_CREATE_SHARED_LIBRARY
 135 # CMAKE_CUDA_CREATE_SHARED_MODULE
 136 # CMAKE_CUDA_COMPILE_WHOLE_COMPILATION
 137 # CMAKE_CUDA_COMPILE_SEPARABLE_COMPILATION
 138 # CMAKE_CUDA_LINK_EXECUTABLE
 139
 140 # create a shared library
 141 if(NOT CMAKE_CUDA_CREATE_SHARED_LIBRARY)
 142   set(CMAKE_CUDA_CREATE_SHARED_LIBRARY
 143       "<CMAKE_CUDA_HOST_LINK_LAUNCHER> <CMAKE_SHARED_LIBRARY_CUDA_FLAGS> <LINK_FLAGS> <CMAKE_SHARED_LIBRARY_CREATE_CUDA_FLAGS> <SONAME_FLAG><TARGET_SONAME> -o <TARGET> <OBJECTS> <LINK_LIBRARIES>${__IMPLICIT_LINKS}")
 144 endif()
 145
 146 # create a shared module copy the shared library rule by default
 147 if(NOT CMAKE_CUDA_CREATE_SHARED_MODULE)
 148   set(CMAKE_CUDA_CREATE_SHARED_MODULE ${CMAKE_CUDA_CREATE_SHARED_LIBRARY})
 149 endif()
 150
 151 # Create a static archive incrementally for large object file counts.
 152 if(NOT DEFINED CMAKE_CUDA_ARCHIVE_CREATE)
 153   set(CMAKE_CUDA_ARCHIVE_CREATE "<CMAKE_AR> qc <TARGET> <LINK_FLAGS> <OBJECTS>")
 154 endif()
 155 if(NOT DEFINED CMAKE_CUDA_ARCHIVE_APPEND)
 156   set(CMAKE_CUDA_ARCHIVE_APPEND "<CMAKE_AR> q <TARGET> <LINK_FLAGS> <OBJECTS>")
 157 endif()
 158 if(NOT DEFINED CMAKE_CUDA_ARCHIVE_FINISH)
 159   set(CMAKE_CUDA_ARCHIVE_FINISH "<CMAKE_RANLIB> <TARGET>")
 160 endif()
 161
 162 if(NOT CMAKE_CUDA_COMPILE_OBJECT)
 163   set(CMAKE_CUDA_COMPILE_OBJECT
 164     "<CMAKE_CUDA_COMPILER> ${_CMAKE_CUDA_EXTRA_FLAGS} <DEFINES> <INCLUDES> <FLAGS> ${_CMAKE_COMPILE_AS_CUDA_FLAG} <CUDA_COMPILE_MODE> <SOURCE> -o <OBJECT>")
 165 endif()
 166
 167 # compile a cu file into an executable
 168 if(NOT CMAKE_CUDA_LINK_EXECUTABLE)
 169   set(CMAKE_CUDA_LINK_EXECUTABLE
 170     "<CMAKE_CUDA_HOST_LINK_LAUNCHER> <LINK_FLAGS> <OBJECTS> -o <TARGET> <LINK_LIBRARIES>${__IMPLICIT_LINKS}")
 171 endif()
 172
 173 # Add implicit host link directories that contain device libraries
 174 # to the device link line.
 175 set(__IMPLICIT_DLINK_DIRS ${CMAKE_CUDA_IMPLICIT_LINK_DIRECTORIES})
 176 if(__IMPLICIT_DLINK_DIRS)
 177   list(REMOVE_ITEM __IMPLICIT_DLINK_DIRS ${CMAKE_CUDA_HOST_IMPLICIT_LINK_DIRECTORIES})
 178 endif()
 179 set(__IMPLICIT_DLINK_FLAGS)
 180 foreach(dir ${__IMPLICIT_DLINK_DIRS})
 181   if(EXISTS "${dir}/libcurand_static.a")
 182     string(APPEND __IMPLICIT_DLINK_FLAGS " -L\"${dir}\"")
 183   endif()
 184 endforeach()
 185 unset(__IMPLICIT_DLINK_DIRS)
 186
 187
 188 #These are used when linking relocatable (dc) cuda code
 189 if(NOT CMAKE_CUDA_DEVICE_LINK_LIBRARY)
 190   set(CMAKE_CUDA_DEVICE_LINK_LIBRARY
 191     "<CMAKE_CUDA_COMPILER> ${_CMAKE_CUDA_EXTRA_FLAGS} <LANGUAGE_COMPILE_FLAGS> <LINK_FLAGS> ${CMAKE_CUDA_COMPILE_OPTIONS_PIC} ${_CMAKE_CUDA_EXTRA_DEVICE_LINK_FLAGS} -shared -dlink <OBJECTS> -o <TARGET> <LINK_LIBRARIES>${__IMPLICIT_DLINK_FLAGS}")
 192 endif()
 193 if(NOT CMAKE_CUDA_DEVICE_LINK_EXECUTABLE)
 194   set(CMAKE_CUDA_DEVICE_LINK_EXECUTABLE
 195     "<CMAKE_CUDA_COMPILER> ${_CMAKE_CUDA_EXTRA_FLAGS} <LANGUAGE_COMPILE_FLAGS> <LINK_FLAGS> ${CMAKE_CUDA_COMPILE_OPTIONS_PIC} ${_CMAKE_CUDA_EXTRA_DEVICE_LINK_FLAGS} -shared -dlink <OBJECTS> -o <TARGET> <LINK_LIBRARIES>${__IMPLICIT_DLINK_FLAGS}")
 196 endif()
 197
 198 # Used when device linking is handled by CMake.
 199 if(NOT CMAKE_CUDA_DEVICE_LINK_COMPILE)
 200   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>")
 201 endif()
 202
 203 unset(__IMPLICIT_DLINK_FLAGS)
 204
 205 set(CMAKE_CUDA_INFORMATION_LOADED 1)