Modules/FindCUDA.cmake

   1 #[=======================================================================[.rst:
   2 FindCUDA
   3 --------
   4
   5 .. warning:: *Deprecated since version 3.10.*
   6
   7 It is no longer necessary to use this module or call ``find_package(CUDA)``
   8 for compiling CUDA code. Instead, list ``CUDA`` among the languages named
   9 in the top-level call to the :command:`project` command, or call the
  10 :command:`enable_language` command with ``CUDA``.
  11 Then one can add CUDA (``.cu``) sources directly to targets similar to other
  12 languages.
  13
  14 .. versionadded:: 3.17
  15   To find and use the CUDA toolkit libraries manually, use the
  16   :module:`FindCUDAToolkit` module instead.  It works regardless of the
  17   ``CUDA`` language being enabled.
  18
  19 Documentation of Deprecated Usage
  20 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
  21
  22 Tools for building CUDA C files: libraries and build dependencies.
  23
  24 This script locates the NVIDIA CUDA C tools.  It should work on Linux,
  25 Windows, and macOS and should be reasonably up to date with CUDA C
  26 releases.
  27
  28 .. versionadded:: 3.19
  29   QNX support.
  30
  31 This script makes use of the standard :command:`find_package` arguments of
  32 ``<VERSION>``, ``REQUIRED`` and ``QUIET``.  ``CUDA_FOUND`` will report if an
  33 acceptable version of CUDA was found.
  34
  35 The script will prompt the user to specify ``CUDA_TOOLKIT_ROOT_DIR`` if
  36 the prefix cannot be determined by the location of nvcc in the system
  37 path and ``REQUIRED`` is specified to :command:`find_package`.  To use
  38 a different installed version of the toolkit set the environment variable
  39 ``CUDA_BIN_PATH`` before running cmake (e.g.
  40 ``CUDA_BIN_PATH=/usr/local/cuda1.0`` instead of the default
  41 ``/usr/local/cuda``) or set ``CUDA_TOOLKIT_ROOT_DIR`` after configuring.  If
  42 you change the value of ``CUDA_TOOLKIT_ROOT_DIR``, various components that
  43 depend on the path will be relocated.
  44
  45 It might be necessary to set ``CUDA_TOOLKIT_ROOT_DIR`` manually on certain
  46 platforms, or to use a CUDA runtime not installed in the default
  47 location.  In newer versions of the toolkit the CUDA library is
  48 included with the graphics driver -- be sure that the driver version
  49 matches what is needed by the CUDA runtime version.
  50
  51 Input Variables
  52 """""""""""""""
  53
  54 The following variables affect the behavior of the macros in the
  55 script (in alphabetical order).  Note that any of these flags can be
  56 changed multiple times in the same directory before calling
  57 ``cuda_add_executable()``, ``cuda_add_library()``, ``cuda_compile()``,
  58 ``cuda_compile_ptx()``, ``cuda_compile_fatbin()``, ``cuda_compile_cubin()``
  59 or ``cuda_wrap_srcs()``:
  60
  61 ``CUDA_64_BIT_DEVICE_CODE`` (Default: host bit size)
  62   Set to ``ON`` to compile for 64 bit device code, OFF for 32 bit device code.
  63   Note that making this different from the host code when generating object
  64   or C files from CUDA code just won't work, because size_t gets defined by
  65   nvcc in the generated source.  If you compile to PTX and then load the
  66   file yourself, you can mix bit sizes between device and host.
  67
  68 ``CUDA_ATTACH_VS_BUILD_RULE_TO_CUDA_FILE`` (Default: ``ON``)
  69   Set to ``ON`` if you want the custom build rule to be attached to the source
  70   file in Visual Studio.  Turn OFF if you add the same cuda file to multiple
  71   targets.
  72
  73   This allows the user to build the target from the CUDA file; however, bad
  74   things can happen if the CUDA source file is added to multiple targets.
  75   When performing parallel builds it is possible for the custom build
  76   command to be run more than once and in parallel causing cryptic build
  77   errors.  VS runs the rules for every source file in the target, and a
  78   source can have only one rule no matter how many projects it is added to.
  79   When the rule is run from multiple targets race conditions can occur on
  80   the generated file.  Eventually everything will get built, but if the user
  81   is unaware of this behavior, there may be confusion.  It would be nice if
  82   this script could detect the reuse of source files across multiple targets
  83   and turn the option off for the user, but no good solution could be found.
  84
  85 ``CUDA_BUILD_CUBIN`` (Default: ``OFF``)
  86   Set to ``ON`` to enable and extra compilation pass with the ``-cubin`` option in
  87   Device mode. The output is parsed and register, shared memory usage is
  88   printed during build.
  89
  90 ``CUDA_BUILD_EMULATION`` (Default: ``OFF`` for device mode)
  91   Set to ``ON`` for Emulation mode. ``-D_DEVICEEMU`` is defined for CUDA C files
  92   when ``CUDA_BUILD_EMULATION`` is ``TRUE``.
  93
  94 ``CUDA_LINK_LIBRARIES_KEYWORD`` (Default: ``""``)
  95   .. versionadded:: 3.9
  96
  97   The ``<PRIVATE|PUBLIC|INTERFACE>`` keyword to use for internal
  98   :command:`target_link_libraries` calls. The default is to use no keyword which
  99   uses the old "plain" form of :command:`target_link_libraries`. Note that is matters
 100   because whatever is used inside the ``FindCUDA`` module must also be used
 101   outside - the two forms of :command:`target_link_libraries` cannot be mixed.
 102
 103 ``CUDA_GENERATED_OUTPUT_DIR`` (Default: :variable:`CMAKE_CURRENT_BINARY_DIR`)
 104   Set to the path you wish to have the generated files placed.  If it is
 105   blank output files will be placed in :variable:`CMAKE_CURRENT_BINARY_DIR`.
 106   Intermediate files will always be placed in
 107   ``CMAKE_CURRENT_BINARY_DIR/CMakeFiles``.
 108
 109 ``CUDA_HOST_COMPILATION_CPP`` (Default: ``ON``)
 110   Set to ``OFF`` for C compilation of host code.
 111
 112 ``CUDA_HOST_COMPILER`` (Default: ``CMAKE_C_COMPILER``)
 113   Set the host compiler to be used by nvcc.  Ignored if ``-ccbin`` or
 114   ``--compiler-bindir`` is already present in the ``CUDA_NVCC_FLAGS`` or
 115   ``CUDA_NVCC_FLAGS_<CONFIG>`` variables.  For Visual Studio targets,
 116   the host compiler is constructed with one or more visual studio macros
 117   such as ``$(VCInstallDir)``, that expands out to the path when
 118   the command is run from within VS.
 119
 120   .. versionadded:: 3.13
 121     If the :envvar:`CUDAHOSTCXX` environment variable is set it will
 122     be used as the default.
 123
 124 ``CUDA_NVCC_FLAGS``, ``CUDA_NVCC_FLAGS_<CONFIG>``
 125   Additional NVCC command line arguments.  NOTE: multiple arguments must be
 126   semi-colon delimited (e.g. ``--compiler-options;-Wall``)
 127
 128   .. versionadded:: 3.6
 129     Contents of these variables may use
 130     :manual:`generator expressions <cmake-generator-expressions(7)>`.
 131
 132 ``CUDA_PROPAGATE_HOST_FLAGS`` (Default: ``ON``)
 133   Set to ``ON`` to propagate :variable:`CMAKE_{C,CXX}_FLAGS <CMAKE_<LANG>_FLAGS>` and their configuration
 134   dependent counterparts (e.g. ``CMAKE_C_FLAGS_DEBUG``) automatically to the
 135   host compiler through nvcc's ``-Xcompiler`` flag.  This helps make the
 136   generated host code match the rest of the system better.  Sometimes
 137   certain flags give nvcc problems, and this will help you turn the flag
 138   propagation off.  This does not affect the flags supplied directly to nvcc
 139   via ``CUDA_NVCC_FLAGS`` or through the ``OPTION`` flags specified through
 140   ``cuda_add_library()``, ``cuda_add_executable()``, or ``cuda_wrap_srcs()``.  Flags used for
 141   shared library compilation are not affected by this flag.
 142
 143 ``CUDA_SEPARABLE_COMPILATION`` (Default: ``OFF``)
 144   If set this will enable separable compilation for all CUDA runtime object
 145   files.  If used outside of ``cuda_add_executable()`` and ``cuda_add_library()``
 146   (e.g. calling ``cuda_wrap_srcs()`` directly),
 147   ``cuda_compute_separable_compilation_object_file_name()`` and
 148   ``cuda_link_separable_compilation_objects()`` should be called.
 149
 150 ``CUDA_SOURCE_PROPERTY_FORMAT``
 151   .. versionadded:: 3.3
 152
 153   If this source file property is set, it can override the format specified
 154   to ``cuda_wrap_srcs()`` (``OBJ``, ``PTX``, ``CUBIN``, or ``FATBIN``).  If an input source file
 155   is not a ``.cu`` file, setting this file will cause it to be treated as a ``.cu``
 156   file. See documentation for set_source_files_properties on how to set
 157   this property.
 158
 159 ``CUDA_USE_STATIC_CUDA_RUNTIME`` (Default: ``ON``)
 160   .. versionadded:: 3.3
 161
 162   When enabled the static version of the CUDA runtime library will be used
 163   in ``CUDA_LIBRARIES``.  If the version of CUDA configured doesn't support
 164   this option, then it will be silently disabled.
 165
 166 ``CUDA_VERBOSE_BUILD`` (Default: ``OFF``)
 167   Set to ``ON`` to see all the commands used when building the CUDA file.  When
 168   using a Makefile generator the value defaults to ``VERBOSE`` (run
 169   ``make VERBOSE=1`` to see output), although setting ``CUDA_VERBOSE_BUILD`` to ``ON`` will
 170   always print the output.
 171
 172 Commands
 173 """"""""
 174
 175 The script creates the following functions and macros (in alphabetical order):
 176
 177 .. code-block:: cmake
 178
 179   cuda_add_cufft_to_target(<cuda_target>)
 180
 181 Adds the cufft library to the target (can be any target).  Handles whether
 182 you are in emulation mode or not.
 183
 184 .. code-block:: cmake
 185
 186   cuda_add_cublas_to_target(<cuda_target>)
 187
 188 Adds the cublas library to the target (can be any target).  Handles
 189 whether you are in emulation mode or not.
 190
 191 .. code-block:: cmake
 192
 193   cuda_add_executable(<cuda_target> <file>...
 194                       [WIN32] [MACOSX_BUNDLE] [EXCLUDE_FROM_ALL] [OPTIONS ...])
 195
 196 Creates an executable ``<cuda_target>`` which is made up of the files
 197 specified.  All of the non CUDA C files are compiled using the standard
 198 build rules specified by CMake and the CUDA files are compiled to object
 199 files using nvcc and the host compiler.  In addition ``CUDA_INCLUDE_DIRS`` is
 200 added automatically to :command:`include_directories`.  Some standard CMake target
 201 calls can be used on the target after calling this macro
 202 (e.g. :command:`set_target_properties` and :command:`target_link_libraries`), but setting
 203 properties that adjust compilation flags will not affect code compiled by
 204 nvcc.  Such flags should be modified before calling ``cuda_add_executable()``,
 205 ``cuda_add_library()`` or ``cuda_wrap_srcs()``.
 206
 207 .. code-block:: cmake
 208
 209   cuda_add_library(<cuda_target> <file>...
 210                    [STATIC | SHARED | MODULE] [EXCLUDE_FROM_ALL] [OPTIONS ...])
 211
 212 Same as ``cuda_add_executable()`` except that a library is created.
 213
 214 .. code-block:: cmake
 215
 216   cuda_build_clean_target()
 217
 218 Creates a convenience target that deletes all the dependency files
 219 generated.  You should make clean after running this target to ensure the
 220 dependency files get regenerated.
 221
 222 .. code-block:: cmake
 223
 224   cuda_compile(<generated_files> <file>... [STATIC | SHARED | MODULE]
 225                [OPTIONS ...])
 226
 227 Returns a list of generated files from the input source files to be used
 228 with :command:`add_library` or :command:`add_executable`.
 229
 230 .. code-block:: cmake
 231
 232   cuda_compile_ptx(<generated_files> <file>... [OPTIONS ...])
 233
 234 Returns a list of ``PTX`` files generated from the input source files.
 235
 236 .. code-block:: cmake
 237
 238   cuda_compile_fatbin(<generated_files> <file>... [OPTIONS ...])
 239
 240 .. versionadded:: 3.1
 241
 242 Returns a list of ``FATBIN`` files generated from the input source files.
 243
 244 .. code-block:: cmake
 245
 246   cuda_compile_cubin(<generated_files> <file>... [OPTIONS ...])
 247
 248 .. versionadded:: 3.1
 249
 250 Returns a list of ``CUBIN`` files generated from the input source files.
 251
 252 .. code-block:: cmake
 253
 254   cuda_compute_separable_compilation_object_file_name(<output_file_var>
 255                                                       <cuda_target>
 256                                                       <object_files>)
 257
 258 Compute the name of the intermediate link file used for separable
 259 compilation.  This file name is typically passed into
 260 ``CUDA_LINK_SEPARABLE_COMPILATION_OBJECTS``.  output_file_var is produced
 261 based on cuda_target the list of objects files that need separable
 262 compilation as specified by ``<object_files>``.  If the ``<object_files>`` list is
 263 empty, then ``<output_file_var>`` will be empty.  This function is called
 264 automatically for ``cuda_add_library()`` and ``cuda_add_executable()``.  Note that
 265 this is a function and not a macro.
 266
 267 .. code-block:: cmake
 268
 269   cuda_include_directories(path0 path1 ...)
 270
 271 Sets the directories that should be passed to nvcc
 272 (e.g. ``nvcc -Ipath0 -Ipath1 ...``). These paths usually contain other ``.cu``
 273 files.
 274
 275 .. code-block:: cmake
 276
 277   cuda_link_separable_compilation_objects(<output_file_var> <cuda_target>
 278                                           <nvcc_flags> <object_files>)
 279
 280 Generates the link object required by separable compilation from the given
 281 object files.  This is called automatically for ``cuda_add_executable()`` and
 282 ``cuda_add_library()``, but can be called manually when using ``cuda_wrap_srcs()``
 283 directly.  When called from ``cuda_add_library()`` or ``cuda_add_executable()`` the
 284 ``<nvcc_flags>`` passed in are the same as the flags passed in via the ``OPTIONS``
 285 argument.  The only nvcc flag added automatically is the bitness flag as
 286 specified by ``CUDA_64_BIT_DEVICE_CODE``.  Note that this is a function
 287 instead of a macro.
 288
 289 .. code-block:: cmake
 290
 291   cuda_select_nvcc_arch_flags(<out_variable> [<target_CUDA_architecture> ...])
 292
 293 Selects GPU arch flags for nvcc based on ``target_CUDA_architecture``.
 294
 295 Values for ``target_CUDA_architecture``:
 296
 297 * ``Auto``: detects local machine GPU compute arch at runtime.
 298 * ``Common`` and ``All``: cover common and entire subsets of architectures.
 299 * ``<name>``: one of ``Fermi``, ``Kepler``, ``Maxwell``, ``Kepler+Tegra``, ``Kepler+Tesla``, ``Maxwell+Tegra``, ``Pascal``.
 300 * ``<ver>``, ``<ver>(<ver>)``, ``<ver>+PTX``, where ``<ver>`` is one of
 301   ``2.0``, ``2.1``, ``3.0``, ``3.2``, ``3.5``, ``3.7``, ``5.0``, ``5.2``, ``5.3``, ``6.0``, ``6.2``.
 302
 303 Returns list of flags to be added to ``CUDA_NVCC_FLAGS`` in ``<out_variable>``.
 304 Additionally, sets ``<out_variable>_readable`` to the resulting numeric list.
 305
 306 Example::
 307
 308   cuda_select_nvcc_arch_flags(ARCH_FLAGS 3.0 3.5+PTX 5.2(5.0) Maxwell)
 309   list(APPEND CUDA_NVCC_FLAGS ${ARCH_FLAGS})
 310
 311 More info on CUDA architectures: https://en.wikipedia.org/wiki/CUDA.
 312 Note that this is a function instead of a macro.
 313
 314 .. code-block:: cmake
 315
 316   cuda_wrap_srcs(<cuda_target> <format> <generated_files> <file>...
 317                  [STATIC | SHARED | MODULE] [OPTIONS ...])
 318
 319 This is where all the magic happens.  ``cuda_add_executable()``,
 320 ``cuda_add_library()``, ``cuda_compile()``, and ``cuda_compile_ptx()`` all call this
 321 function under the hood.
 322
 323 Given the list of files ``<file>...`` this macro generates
 324 custom commands that generate either PTX or linkable objects (use ``PTX`` or
 325 ``OBJ`` for the ``<format>`` argument to switch).  Files that don't end with ``.cu``
 326 or have the ``HEADER_FILE_ONLY`` property are ignored.
 327
 328 The arguments passed in after ``OPTIONS`` are extra command line options to
 329 give to nvcc.  You can also specify per configuration options by
 330 specifying the name of the configuration followed by the options.  General
 331 options must precede configuration specific options.  Not all
 332 configurations need to be specified, only the ones provided will be used.
 333 For example:
 334
 335 .. code-block:: cmake
 336
 337   cuda_add_executable(...
 338     OPTIONS -DFLAG=2 "-DFLAG_OTHER=space in flag"
 339     DEBUG -g
 340     RELEASE --use_fast_math
 341     RELWITHDEBINFO --use_fast_math;-g
 342     MINSIZEREL --use_fast_math)
 343
 344 For certain configurations (namely VS generating object files with
 345 ``CUDA_ATTACH_VS_BUILD_RULE_TO_CUDA_FILE`` set to ``ON``), no generated file will
 346 be produced for the given cuda file.  This is because when you add the
 347 cuda file to Visual Studio it knows that this file produces an object file
 348 and will link in the resulting object file automatically.
 349
 350 This script will also generate a separate cmake script that is used at
 351 build time to invoke nvcc.  This is for several reasons:
 352
 353 * nvcc can return negative numbers as return values which confuses
 354   Visual Studio into thinking that the command succeeded.  The script now
 355   checks the error codes and produces errors when there was a problem.
 356
 357 * nvcc has been known to not delete incomplete results when it
 358   encounters problems.  This confuses build systems into thinking the
 359   target was generated when in fact an unusable file exists.  The script
 360   now deletes the output files if there was an error.
 361
 362 * By putting all the options that affect the build into a file and then
 363   make the build rule dependent on the file, the output files will be
 364   regenerated when the options change.
 365
 366 This script also looks at optional arguments ``STATIC``, ``SHARED``, or ``MODULE`` to
 367 determine when to target the object compilation for a shared library.
 368 :variable:`BUILD_SHARED_LIBS` is ignored in ``cuda_wrap_srcs()``, but it is respected in
 369 ``cuda_add_library()``.  On some systems special flags are added for building
 370 objects intended for shared libraries.  A preprocessor macro,
 371 ``<target_name>_EXPORTS`` is defined when a shared library compilation is
 372 detected.
 373
 374 Flags passed into add_definitions with ``-D`` or ``/D`` are passed along to nvcc.
 375
 376 Result Variables
 377 """"""""""""""""
 378
 379 The script defines the following variables:
 380
 381 ``CUDA_VERSION_MAJOR``
 382   The major version of cuda as reported by nvcc.
 383
 384 ``CUDA_VERSION_MINOR``
 385   The minor version.
 386
 387 ``CUDA_VERSION``, ``CUDA_VERSION_STRING``
 388   Full version in the ``X.Y`` format.
 389
 390 ``CUDA_HAS_FP16``
 391   .. versionadded:: 3.6
 392     Whether a short float (``float16``, ``fp16``) is supported.
 393
 394 ``CUDA_TOOLKIT_ROOT_DIR``
 395   Path to the CUDA Toolkit (defined if not set).
 396
 397 ``CUDA_SDK_ROOT_DIR``
 398   Path to the CUDA SDK.  Use this to find files in the SDK.  This script will
 399   not directly support finding specific libraries or headers, as that isn't
 400   supported by NVIDIA.  If you want to change libraries when the path changes
 401   see the ``FindCUDA.cmake`` script for an example of how to clear these
 402   variables.  There are also examples of how to use the ``CUDA_SDK_ROOT_DIR``
 403   to locate headers or libraries, if you so choose (at your own risk).
 404
 405 ``CUDA_INCLUDE_DIRS``
 406   Include directory for cuda headers.  Added automatically
 407   for ``cuda_add_executable()`` and ``cuda_add_library()``.
 408
 409 ``CUDA_LIBRARIES``
 410   Cuda RT library.
 411
 412 ``CUDA_CUFFT_LIBRARIES``
 413   Device or emulation library for the Cuda FFT implementation (alternative to
 414   ``cuda_add_cufft_to_target()`` macro)
 415
 416 ``CUDA_CUBLAS_LIBRARIES``
 417   Device or emulation library for the Cuda BLAS implementation (alternative to
 418   ``cuda_add_cublas_to_target()`` macro).
 419
 420 ``CUDA_cudart_static_LIBRARY``
 421   Statically linkable cuda runtime library.
 422   Only available for CUDA version 5.5+.
 423
 424 ``CUDA_cudadevrt_LIBRARY``
 425   .. versionadded:: 3.7
 426     Device runtime library.  Required for separable compilation.
 427
 428 ``CUDA_cupti_LIBRARY``
 429   CUDA Profiling Tools Interface library.
 430   Only available for CUDA version 4.0+.
 431
 432 ``CUDA_curand_LIBRARY``
 433   CUDA Random Number Generation library.
 434   Only available for CUDA version 3.2+.
 435
 436 ``CUDA_cusolver_LIBRARY``
 437   .. versionadded:: 3.2
 438     CUDA Direct Solver library.
 439     Only available for CUDA version 7.0+.
 440
 441 ``CUDA_cusparse_LIBRARY``
 442   CUDA Sparse Matrix library.
 443   Only available for CUDA version 3.2+.
 444
 445 ``CUDA_npp_LIBRARY``
 446   NVIDIA Performance Primitives lib.
 447   Only available for CUDA version 4.0+.
 448
 449 ``CUDA_nppc_LIBRARY``
 450   NVIDIA Performance Primitives lib (core).
 451   Only available for CUDA version 5.5+.
 452
 453 ``CUDA_nppi_LIBRARY``
 454   NVIDIA Performance Primitives lib (image processing).
 455   Only available for CUDA version 5.5 - 8.0.
 456
 457 ``CUDA_nppial_LIBRARY``
 458   NVIDIA Performance Primitives lib (image processing).
 459   Only available for CUDA version 9.0.
 460
 461 ``CUDA_nppicc_LIBRARY``
 462   NVIDIA Performance Primitives lib (image processing).
 463   Only available for CUDA version 9.0.
 464
 465 ``CUDA_nppicom_LIBRARY``
 466   NVIDIA Performance Primitives lib (image processing).
 467   Only available for CUDA version 9.0 - 10.2.
 468   Replaced by nvjpeg.
 469
 470 ``CUDA_nppidei_LIBRARY``
 471   NVIDIA Performance Primitives lib (image processing).
 472   Only available for CUDA version 9.0.
 473
 474 ``CUDA_nppif_LIBRARY``
 475   NVIDIA Performance Primitives lib (image processing).
 476   Only available for CUDA version 9.0.
 477
 478 ``CUDA_nppig_LIBRARY``
 479   NVIDIA Performance Primitives lib (image processing).
 480   Only available for CUDA version 9.0.
 481
 482 ``CUDA_nppim_LIBRARY``
 483   NVIDIA Performance Primitives lib (image processing).
 484   Only available for CUDA version 9.0.
 485
 486 ``CUDA_nppist_LIBRARY``
 487   NVIDIA Performance Primitives lib (image processing).
 488   Only available for CUDA version 9.0.
 489
 490 ``CUDA_nppisu_LIBRARY``
 491   NVIDIA Performance Primitives lib (image processing).
 492   Only available for CUDA version 9.0.
 493
 494 ``CUDA_nppitc_LIBRARY``
 495   NVIDIA Performance Primitives lib (image processing).
 496   Only available for CUDA version 9.0.
 497
 498 ``CUDA_npps_LIBRARY``
 499   NVIDIA Performance Primitives lib (signal processing).
 500   Only available for CUDA version 5.5+.
 501
 502 ``CUDA_nvcuvenc_LIBRARY``
 503   CUDA Video Encoder library.
 504   Only available for CUDA version 3.2+.
 505   Windows only.
 506
 507 ``CUDA_nvcuvid_LIBRARY``
 508   CUDA Video Decoder library.
 509   Only available for CUDA version 3.2+.
 510   Windows only.
 511
 512 ``CUDA_nvToolsExt_LIBRARY``
 513   .. versionadded:: 3.16
 514     NVIDA CUDA Tools Extension library.
 515     Available for CUDA version 5+.
 516
 517 ``CUDA_OpenCL_LIBRARY``
 518   .. versionadded:: 3.16
 519     NVIDA CUDA OpenCL library.
 520     Available for CUDA version 5+.
 521
 522 #]=======================================================================]
 523
 524 #   James Bigler, NVIDIA Corp (nvidia.com - jbigler)
 525 #   Abe Stephens, SCI Institute -- http://www.sci.utah.edu/~abe/FindCuda.html
 526 #
 527 #   Copyright (c) 2008 - 2009 NVIDIA Corporation.  All rights reserved.
 528 #
 529 #   Copyright (c) 2007-2009
 530 #   Scientific Computing and Imaging Institute, University of Utah
 531 #
 532 #   This code is licensed under the MIT License.  See the FindCUDA.cmake script
 533 #   for the text of the license.
 534
 535 # The MIT License
 536 #
 537 # License for the specific language governing rights and limitations under
 538 # Permission is hereby granted, free of charge, to any person obtaining a
 539 # copy of this software and associated documentation files (the "Software"),
 540 # to deal in the Software without restriction, including without limitation
 541 # the rights to use, copy, modify, merge, publish, distribute, sublicense,
 542 # and/or sell copies of the Software, and to permit persons to whom the
 543 # Software is furnished to do so, subject to the following conditions:
 544 #
 545 # The above copyright notice and this permission notice shall be included
 546 # in all copies or substantial portions of the Software.
 547 #
 548 # THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
 549 # OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 550 # FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
 551 # THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 552 # LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
 553 # FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
 554 # DEALINGS IN THE SOFTWARE.
 555 #
 556 ###############################################################################
 557
 558 # FindCUDA.cmake
 559
 560 # This macro helps us find the location of helper files we will need the full path to
 561 macro(CUDA_FIND_HELPER_FILE _name _extension)
 562   set(_full_name "${_name}.${_extension}")
 563   # CMAKE_CURRENT_LIST_FILE contains the full path to the file currently being
 564   # processed.  Using this variable, we can pull out the current path, and
 565   # provide a way to get access to the other files we need local to here.
 566   get_filename_component(CMAKE_CURRENT_LIST_DIR "${CMAKE_CURRENT_LIST_FILE}" PATH)
 567   set(CUDA_${_name} "${CMAKE_CURRENT_LIST_DIR}/FindCUDA/${_full_name}")
 568   if(NOT EXISTS "${CUDA_${_name}}")
 569     set(error_message "${_full_name} not found in ${CMAKE_CURRENT_LIST_DIR}/FindCUDA")
 570     if(CUDA_FIND_REQUIRED)
 571       message(FATAL_ERROR "${error_message}")
 572     else()
 573       if(NOT CUDA_FIND_QUIETLY)
 574         message(STATUS "${error_message}")
 575       endif()
 576     endif()
 577   endif()
 578   # Set this variable as internal, so the user isn't bugged with it.
 579   set(CUDA_${_name} ${CUDA_${_name}} CACHE INTERNAL "Location of ${_full_name}" FORCE)
 580 endmacro()
 581
 582 #####################################################################
 583 ## CUDA_INCLUDE_NVCC_DEPENDENCIES
 584 ##
 585
 586 # So we want to try and include the dependency file if it exists.  If
 587 # it doesn't exist then we need to create an empty one, so we can
 588 # include it.
 589
 590 # If it does exist, then we need to check to see if all the files it
 591 # depends on exist.  If they don't then we should clear the dependency
 592 # file and regenerate it later.  This covers the case where a header
 593 # file has disappeared or moved.
 594
 595 macro(CUDA_INCLUDE_NVCC_DEPENDENCIES dependency_file)
 596   set(CUDA_NVCC_DEPEND)
 597   set(CUDA_NVCC_DEPEND_REGENERATE FALSE)
 598
 599
 600   # Include the dependency file.  Create it first if it doesn't exist .  The
 601   # INCLUDE puts a dependency that will force CMake to rerun and bring in the
 602   # new info when it changes.  DO NOT REMOVE THIS (as I did and spent a few
 603   # hours figuring out why it didn't work.
 604   if(NOT EXISTS ${dependency_file})
 605     file(WRITE ${dependency_file} "#FindCUDA.cmake generated file.  Do not edit.\n")
 606   endif()
 607   # Always include this file to force CMake to run again next
 608   # invocation and rebuild the dependencies.
 609   #message("including dependency_file = ${dependency_file}")
 610   include(${dependency_file})
 611
 612   # Now we need to verify the existence of all the included files
 613   # here.  If they aren't there we need to just blank this variable and
 614   # make the file regenerate again.
 615 #   if(DEFINED CUDA_NVCC_DEPEND)
 616 #     message("CUDA_NVCC_DEPEND set")
 617 #   else()
 618 #     message("CUDA_NVCC_DEPEND NOT set")
 619 #   endif()
 620   if(CUDA_NVCC_DEPEND)
 621     #message("CUDA_NVCC_DEPEND found")
 622     foreach(f ${CUDA_NVCC_DEPEND})
 623       # message("searching for ${f}")
 624       if(NOT EXISTS ${f})
 625         #message("file ${f} not found")
 626         set(CUDA_NVCC_DEPEND_REGENERATE TRUE)
 627       endif()
 628     endforeach()
 629   else()
 630     #message("CUDA_NVCC_DEPEND false")
 631     # No dependencies, so regenerate the file.
 632     set(CUDA_NVCC_DEPEND_REGENERATE TRUE)
 633   endif()
 634
 635   #message("CUDA_NVCC_DEPEND_REGENERATE = ${CUDA_NVCC_DEPEND_REGENERATE}")
 636   # No incoming dependencies, so we need to generate them.  Make the
 637   # output depend on the dependency file itself, which should cause the
 638   # rule to re-run.
 639   if(CUDA_NVCC_DEPEND_REGENERATE)
 640     set(CUDA_NVCC_DEPEND ${dependency_file})
 641     #message("Generating an empty dependency_file: ${dependency_file}")
 642     file(WRITE ${dependency_file} "#FindCUDA.cmake generated file.  Do not edit.\n")
 643   endif()
 644
 645 endmacro()
 646
 647 ###############################################################################
 648 ###############################################################################
 649 # Setup variables' defaults
 650 ###############################################################################
 651 ###############################################################################
 652
 653 # Allow the user to specify if the device code is supposed to be 32 or 64 bit.
 654 if(CMAKE_SIZEOF_VOID_P EQUAL 8)
 655   set(CUDA_64_BIT_DEVICE_CODE_DEFAULT ON)
 656 else()
 657   set(CUDA_64_BIT_DEVICE_CODE_DEFAULT OFF)
 658 endif()
 659 option(CUDA_64_BIT_DEVICE_CODE "Compile device code in 64 bit mode" ${CUDA_64_BIT_DEVICE_CODE_DEFAULT})
 660
 661 # Attach the build rule to the source file in VS.  This option
 662 option(CUDA_ATTACH_VS_BUILD_RULE_TO_CUDA_FILE "Attach the build rule to the CUDA source file.  Enable only when the CUDA source file is added to at most one target." ON)
 663
 664 # Prints out extra information about the cuda file during compilation
 665 option(CUDA_BUILD_CUBIN "Generate and parse .cubin files in Device mode." OFF)
 666
 667 # Set whether we are using emulation or device mode.
 668 option(CUDA_BUILD_EMULATION "Build in Emulation mode" OFF)
 669
 670 # Where to put the generated output.
 671 set(CUDA_GENERATED_OUTPUT_DIR "" CACHE PATH "Directory to put all the output files.  If blank it will default to the CMAKE_CURRENT_BINARY_DIR")
 672
 673 # Parse HOST_COMPILATION mode.
 674 option(CUDA_HOST_COMPILATION_CPP "Generated file extension" ON)
 675
 676 # Extra user settable flags
 677 cmake_initialize_per_config_variable(CUDA_NVCC_FLAGS "Semi-colon delimit multiple arguments.")
 678
 679 if(DEFINED ENV{CUDAHOSTCXX})
 680   set(CUDA_HOST_COMPILER "$ENV{CUDAHOSTCXX}" CACHE FILEPATH "Host side compiler used by NVCC")
 681 elseif(CMAKE_GENERATOR MATCHES "Visual Studio")
 682   set(_CUDA_MSVC_HOST_COMPILER "$(VCInstallDir)Tools/MSVC/$(VCToolsVersion)/bin/Host$(Platform)/$(PlatformTarget)")
 683   if(MSVC_VERSION LESS 1910)
 684     set(_CUDA_MSVC_HOST_COMPILER "$(VCInstallDir)bin")
 685   endif()
 686
 687   set(CUDA_HOST_COMPILER "${_CUDA_MSVC_HOST_COMPILER}" CACHE FILEPATH "Host side compiler used by NVCC")
 688
 689 else()
 690   if(APPLE
 691       AND "${CMAKE_C_COMPILER_ID}" MATCHES "Clang"
 692       AND "${CMAKE_C_COMPILER}" MATCHES "/cc$")
 693     # Using cc which is symlink to clang may let NVCC think it is GCC and issue
 694     # unhandled -dumpspecs option to clang. Also in case neither
 695     # CMAKE_C_COMPILER is defined (project does not use C language) nor
 696     # CUDA_HOST_COMPILER is specified manually we should skip -ccbin and let
 697     # nvcc use its own default C compiler.
 698     # Only care about this on APPLE with clang to avoid
 699     # following symlinks to things like ccache
 700     if(DEFINED CMAKE_C_COMPILER AND NOT DEFINED CUDA_HOST_COMPILER)
 701       get_filename_component(c_compiler_realpath "${CMAKE_C_COMPILER}" REALPATH)
 702       # if the real path does not end up being clang then
 703       # go back to using CMAKE_C_COMPILER
 704       if(NOT "${c_compiler_realpath}" MATCHES "/clang$")
 705         set(c_compiler_realpath "${CMAKE_C_COMPILER}")
 706       endif()
 707     else()
 708       set(c_compiler_realpath "")
 709     endif()
 710     set(CUDA_HOST_COMPILER "${c_compiler_realpath}" CACHE FILEPATH "Host side compiler used by NVCC")
 711   elseif(MSVC AND "${CMAKE_C_COMPILER}" MATCHES "clcache|sccache")
 712     # NVCC does not think it will work if it is passed clcache.exe or sccache.exe
 713     # as the host compiler, which means that builds with CC=cl.exe won't work.
 714     # Best to just feed it whatever the actual cl.exe is as the host compiler.
 715     set(CUDA_HOST_COMPILER "cl.exe" CACHE FILEPATH "Host side compiler used by NVCC")
 716   else()
 717     set(CUDA_HOST_COMPILER "${CMAKE_C_COMPILER}"
 718       CACHE FILEPATH "Host side compiler used by NVCC")
 719   endif()
 720 endif()
 721
 722 # Propagate the host flags to the host compiler via -Xcompiler
 723 option(CUDA_PROPAGATE_HOST_FLAGS "Propagate C/CXX_FLAGS and friends to the host compiler via -Xcompile" ON)
 724
 725 # Enable CUDA_SEPARABLE_COMPILATION
 726 option(CUDA_SEPARABLE_COMPILATION "Compile CUDA objects with separable compilation enabled.  Requires CUDA 5.0+" OFF)
 727
 728 # Specifies whether the commands used when compiling the .cu file will be printed out.
 729 option(CUDA_VERBOSE_BUILD "Print out the commands run while compiling the CUDA source file.  With the Makefile generator this defaults to VERBOSE variable specified on the command line, but can be forced on with this option." OFF)
 730
 731 mark_as_advanced(
 732   CUDA_64_BIT_DEVICE_CODE
 733   CUDA_ATTACH_VS_BUILD_RULE_TO_CUDA_FILE
 734   CUDA_GENERATED_OUTPUT_DIR
 735   CUDA_HOST_COMPILATION_CPP
 736   CUDA_NVCC_FLAGS
 737   CUDA_PROPAGATE_HOST_FLAGS
 738   CUDA_BUILD_CUBIN
 739   CUDA_BUILD_EMULATION
 740   CUDA_VERBOSE_BUILD
 741   CUDA_SEPARABLE_COMPILATION
 742   )
 743
 744 # Single config generators like Makefiles or Ninja don't usually have
 745 # CMAKE_CONFIGURATION_TYPES defined (but note that it can be defined if set by
 746 # projects or developers). Even CMAKE_BUILD_TYPE might not be defined for
 747 # single config generators (and should not be defined for multi-config
 748 # generators). To ensure we get a complete superset of all possible
 749 # configurations, we combine CMAKE_CONFIGURATION_TYPES, CMAKE_BUILD_TYPE and
 750 # all of the standard configurations, then weed out duplicates with
 751 # list(REMOVE_DUPLICATES). Looping over the unique set then ensures we have
 752 # each configuration-specific set of nvcc flags defined and marked as advanced.
 753 set(CUDA_configuration_types ${CMAKE_CONFIGURATION_TYPES} ${CMAKE_BUILD_TYPE} Debug MinSizeRel Release RelWithDebInfo)
 754 list(REMOVE_DUPLICATES CUDA_configuration_types)
 755
 756 ###############################################################################
 757 ###############################################################################
 758 # Locate CUDA, Set Build Type, etc.
 759 ###############################################################################
 760 ###############################################################################
 761
 762 macro(cuda_unset_include_and_libraries)
 763   unset(CUDA_TOOLKIT_INCLUDE CACHE)
 764   unset(CUDA_CUDART_LIBRARY CACHE)
 765   unset(CUDA_CUDA_LIBRARY CACHE)
 766   # Make sure you run this before you unset CUDA_VERSION.
 767   if(CUDA_VERSION VERSION_EQUAL "3.0")
 768     # This only existed in the 3.0 version of the CUDA toolkit
 769     unset(CUDA_CUDARTEMU_LIBRARY CACHE)
 770   endif()
 771   unset(CUDA_cudart_static_LIBRARY CACHE)
 772   unset(CUDA_cudadevrt_LIBRARY CACHE)
 773   unset(CUDA_cublas_LIBRARY CACHE)
 774   unset(CUDA_cublas_device_LIBRARY CACHE)
 775   unset(CUDA_cublasemu_LIBRARY CACHE)
 776   unset(CUDA_cufft_LIBRARY CACHE)
 777   unset(CUDA_cufftemu_LIBRARY CACHE)
 778   unset(CUDA_cupti_LIBRARY CACHE)
 779   unset(CUDA_curand_LIBRARY CACHE)
 780   unset(CUDA_cusolver_LIBRARY CACHE)
 781   unset(CUDA_cusparse_LIBRARY CACHE)
 782   unset(CUDA_npp_LIBRARY CACHE)
 783   unset(CUDA_nppc_LIBRARY CACHE)
 784   unset(CUDA_nppi_LIBRARY CACHE)
 785   unset(CUDA_npps_LIBRARY CACHE)
 786   unset(CUDA_nvcuvenc_LIBRARY CACHE)
 787   unset(CUDA_nvcuvid_LIBRARY CACHE)
 788   unset(CUDA_nvToolsExt_LIBRARY CACHE)
 789   unset(CUDA_OpenCL_LIBRARY CACHE)
 790   unset(CUDA_GPU_DETECT_OUTPUT CACHE)
 791 endmacro()
 792
 793 # Check to see if the CUDA_TOOLKIT_ROOT_DIR and CUDA_SDK_ROOT_DIR have changed,
 794 # if they have then clear the cache variables, so that will be detected again.
 795 if(NOT "${CUDA_TOOLKIT_ROOT_DIR}" STREQUAL "${CUDA_TOOLKIT_ROOT_DIR_INTERNAL}")
 796   unset(CUDA_TOOLKIT_TARGET_DIR CACHE)
 797   unset(CUDA_NVCC_EXECUTABLE CACHE)
 798   cuda_unset_include_and_libraries()
 799   unset(CUDA_VERSION CACHE)
 800 endif()
 801
 802 if(NOT "${CUDA_TOOLKIT_TARGET_DIR}" STREQUAL "${CUDA_TOOLKIT_TARGET_DIR_INTERNAL}")
 803   cuda_unset_include_and_libraries()
 804 endif()
 805
 806 #
 807 #  End of unset()
 808 #
 809
 810 #
 811 #  Start looking for things
 812 #
 813
 814 # Search for the cuda distribution.
 815 if(NOT CUDA_TOOLKIT_ROOT_DIR AND NOT CMAKE_CROSSCOMPILING)
 816   # Search in the CUDA_BIN_PATH first.
 817   find_program(CUDA_TOOLKIT_ROOT_DIR_NVCC
 818     NAMES nvcc nvcc.exe
 819     PATHS
 820       ENV CUDA_TOOLKIT_ROOT
 821       ENV CUDA_PATH
 822       ENV CUDA_BIN_PATH
 823     PATH_SUFFIXES bin bin64
 824     DOC "Toolkit location."
 825     NO_DEFAULT_PATH
 826     )
 827
 828   # Now search default paths
 829   find_program(CUDA_TOOLKIT_ROOT_DIR_NVCC
 830     NAMES nvcc nvcc.exe
 831     PATHS /opt/cuda/bin
 832     PATH_SUFFIXES cuda/bin
 833     DOC "Toolkit location."
 834     )
 835
 836   if (CUDA_TOOLKIT_ROOT_DIR_NVCC)
 837     # Given that NVCC can be provided by multiple different sources (NVIDIA HPC SDK, CUDA Toolkit, distro)
 838     # each of which has a different layout, we need to extract the CUDA toolkit root from the compiler
 839     # itself, allowing us to support numerous different scattered toolkit layouts
 840     execute_process(COMMAND ${CUDA_TOOLKIT_ROOT_DIR_NVCC} "-v" "__cmake_determine_cuda"
 841       OUTPUT_VARIABLE _CUDA_NVCC_OUT ERROR_VARIABLE _CUDA_NVCC_OUT)
 842     if(_CUDA_NVCC_OUT MATCHES "\\#\\$ TOP=([^\r\n]*)")
 843       get_filename_component(CUDA_TOOLKIT_ROOT_DIR "${CMAKE_MATCH_1}" ABSOLUTE CACHE)
 844     else()
 845       get_filename_component(CUDA_TOOLKIT_ROOT_DIR "${CUDA_TOOLKIT_ROOT_DIR_NVCC}" DIRECTORY)
 846       get_filename_component(CUDA_TOOLKIT_ROOT_DIR "${CUDA_TOOLKIT_ROOT_DIR}" DIRECTORY CACHE)
 847     endif()
 848     unset(_CUDA_NVCC_OUT)
 849
 850     string(REGEX REPLACE "[/\\\\]?bin[64]*[/\\\\]?$" "" CUDA_TOOLKIT_ROOT_DIR ${CUDA_TOOLKIT_ROOT_DIR})
 851     # We need to force this back into the cache.
 852     set(CUDA_TOOLKIT_ROOT_DIR ${CUDA_TOOLKIT_ROOT_DIR} CACHE PATH "Toolkit location." FORCE)
 853     set(CUDA_TOOLKIT_TARGET_DIR ${CUDA_TOOLKIT_ROOT_DIR})
 854   endif()
 855   unset(CUDA_TOOLKIT_ROOT_DIR_NVCC CACHE)
 856
 857   if (NOT EXISTS ${CUDA_TOOLKIT_ROOT_DIR})
 858     if(CUDA_FIND_REQUIRED)
 859       message(FATAL_ERROR "Specify CUDA_TOOLKIT_ROOT_DIR")
 860     elseif(NOT CUDA_FIND_QUIETLY)
 861       message("CUDA_TOOLKIT_ROOT_DIR not found or specified")
 862     endif()
 863   endif ()
 864 endif ()
 865
 866 if(CMAKE_CROSSCOMPILING)
 867   SET (CUDA_TOOLKIT_ROOT $ENV{CUDA_TOOLKIT_ROOT})
 868   if(CMAKE_SYSTEM_PROCESSOR STREQUAL "armv7-a")
 869     # Support for NVPACK
 870     set (CUDA_TOOLKIT_TARGET_NAME "armv7-linux-androideabi")
 871   elseif(CMAKE_SYSTEM_PROCESSOR MATCHES "arm")
 872     # Support for arm cross compilation
 873     set(CUDA_TOOLKIT_TARGET_NAME "armv7-linux-gnueabihf")
 874   elseif(CMAKE_SYSTEM_PROCESSOR MATCHES "aarch64")
 875     # Support for aarch64 cross compilation
 876     if (ANDROID_ARCH_NAME STREQUAL "arm64")
 877       set(CUDA_TOOLKIT_TARGET_NAME "aarch64-linux-androideabi")
 878     elseif (CMAKE_SYSTEM_NAME STREQUAL "QNX")
 879       set(CUDA_TOOLKIT_TARGET_NAME "aarch64-qnx")
 880     else()
 881       set(CUDA_TOOLKIT_TARGET_NAME "aarch64-linux")
 882     endif (ANDROID_ARCH_NAME STREQUAL "arm64")
 883   endif()
 884
 885   if (EXISTS "${CUDA_TOOLKIT_ROOT}/targets/${CUDA_TOOLKIT_TARGET_NAME}")
 886     set(CUDA_TOOLKIT_TARGET_DIR "${CUDA_TOOLKIT_ROOT}/targets/${CUDA_TOOLKIT_TARGET_NAME}" CACHE PATH "CUDA Toolkit target location.")
 887     SET (CUDA_TOOLKIT_ROOT_DIR ${CUDA_TOOLKIT_ROOT})
 888     mark_as_advanced(CUDA_TOOLKIT_TARGET_DIR)
 889   endif()
 890
 891   # add known CUDA targetr root path to the set of directories we search for programs, libraries and headers
 892   set( CMAKE_FIND_ROOT_PATH "${CUDA_TOOLKIT_TARGET_DIR};${CMAKE_FIND_ROOT_PATH}")
 893   macro( cuda_find_host_program )
 894     if (COMMAND find_host_program)
 895       find_host_program( ${ARGN} )
 896     else()
 897       find_program( ${ARGN} )
 898     endif()
 899   endmacro()
 900 else()
 901   # for non-cross-compile, find_host_program == find_program and CUDA_TOOLKIT_TARGET_DIR == CUDA_TOOLKIT_ROOT_DIR
 902   macro( cuda_find_host_program )
 903     find_program( ${ARGN} )
 904   endmacro()
 905   SET (CUDA_TOOLKIT_TARGET_DIR ${CUDA_TOOLKIT_ROOT_DIR})
 906 endif()
 907
 908
 909 # CUDA_NVCC_EXECUTABLE
 910 if(DEFINED ENV{CUDA_NVCC_EXECUTABLE})
 911   set(CUDA_NVCC_EXECUTABLE "$ENV{CUDA_NVCC_EXECUTABLE}" CACHE FILEPATH "The CUDA compiler")
 912 else()
 913   cuda_find_host_program(CUDA_NVCC_EXECUTABLE
 914     NAMES nvcc
 915     PATHS "${CUDA_TOOLKIT_ROOT_DIR}"
 916     ENV CUDA_PATH
 917     ENV CUDA_BIN_PATH
 918     PATH_SUFFIXES bin bin64
 919     NO_DEFAULT_PATH
 920     )
 921   # Search default search paths, after we search our own set of paths.
 922   cuda_find_host_program(CUDA_NVCC_EXECUTABLE nvcc)
 923 endif()
 924 mark_as_advanced(CUDA_NVCC_EXECUTABLE)
 925
 926 if(CUDA_NVCC_EXECUTABLE AND NOT CUDA_VERSION)
 927   # Compute the version.
 928   execute_process (COMMAND ${CUDA_NVCC_EXECUTABLE} "--version" OUTPUT_VARIABLE NVCC_OUT)
 929   string(REGEX REPLACE ".*release ([0-9]+)\\.([0-9]+).*" "\\1" CUDA_VERSION_MAJOR "${NVCC_OUT}")
 930   string(REGEX REPLACE ".*release ([0-9]+)\\.([0-9]+).*" "\\2" CUDA_VERSION_MINOR "${NVCC_OUT}")
 931   set(CUDA_VERSION "${CUDA_VERSION_MAJOR}.${CUDA_VERSION_MINOR}" CACHE STRING "Version of CUDA as computed from nvcc.")
 932   mark_as_advanced(CUDA_VERSION)
 933 else()
 934   # Need to set these based off of the cached value
 935   string(REGEX REPLACE "([0-9]+)\\.([0-9]+).*" "\\1" CUDA_VERSION_MAJOR "${CUDA_VERSION}")
 936   string(REGEX REPLACE "([0-9]+)\\.([0-9]+).*" "\\2" CUDA_VERSION_MINOR "${CUDA_VERSION}")
 937 endif()
 938
 939
 940 # Always set this convenience variable
 941 set(CUDA_VERSION_STRING "${CUDA_VERSION}")
 942
 943 # CUDA_TOOLKIT_INCLUDE
 944 find_path(CUDA_TOOLKIT_INCLUDE
 945   device_functions.h # Header included in toolkit
 946   PATHS ${CUDA_TOOLKIT_TARGET_DIR}
 947   ENV CUDA_PATH
 948   ENV CUDA_INC_PATH
 949   PATH_SUFFIXES include
 950   NO_DEFAULT_PATH
 951   )
 952 # Search default search paths, after we search our own set of paths.
 953 find_path(CUDA_TOOLKIT_INCLUDE device_functions.h)
 954 mark_as_advanced(CUDA_TOOLKIT_INCLUDE)
 955
 956 if (CUDA_VERSION VERSION_GREATER "7.0" OR EXISTS "${CUDA_TOOLKIT_INCLUDE}/cuda_fp16.h")
 957   set(CUDA_HAS_FP16 TRUE)
 958 else()
 959   set(CUDA_HAS_FP16 FALSE)
 960 endif()
 961
 962 # Set the user list of include dir to nothing to initialize it.
 963 set (CUDA_NVCC_INCLUDE_DIRS_USER "")
 964 set (CUDA_INCLUDE_DIRS ${CUDA_TOOLKIT_INCLUDE})
 965
 966 macro(cuda_find_library_local_first_with_path_ext _var _names _doc _path_ext )
 967   if(CMAKE_SIZEOF_VOID_P EQUAL 8)
 968     # CUDA 3.2+ on Windows moved the library directories, so we need the new
 969     # and old paths.
 970     set(_cuda_64bit_lib_dir "${_path_ext}lib/x64" "${_path_ext}lib64" "${_path_ext}libx64" )
 971   endif()
 972   # CUDA 3.2+ on Windows moved the library directories, so we need to new
 973   # (lib/Win32) and the old path (lib).
 974   find_library(${_var}
 975     NAMES ${_names}
 976     PATHS "${CUDA_TOOLKIT_TARGET_DIR}"
 977     ENV CUDA_PATH
 978     ENV CUDA_LIB_PATH
 979     PATH_SUFFIXES ${_cuda_64bit_lib_dir} "${_path_ext}lib/Win32" "${_path_ext}lib" "${_path_ext}libWin32"
 980     DOC ${_doc}
 981     NO_DEFAULT_PATH
 982     )
 983   if (NOT CMAKE_CROSSCOMPILING)
 984     # Search default search paths, after we search our own set of paths.
 985     find_library(${_var}
 986       NAMES ${_names}
 987       PATHS "/usr/lib/nvidia-current"
 988       DOC ${_doc}
 989       )
 990   endif()
 991 endmacro()
 992
 993 macro(cuda_find_library_local_first _var _names _doc)
 994   cuda_find_library_local_first_with_path_ext( "${_var}" "${_names}" "${_doc}" "" )
 995 endmacro()
 996
 997 macro(find_library_local_first _var _names _doc )
 998   cuda_find_library_local_first( "${_var}" "${_names}" "${_doc}" "" )
 999 endmacro()
1000
1001
1002 # CUDA_LIBRARIES
1003 cuda_find_library_local_first(CUDA_CUDART_LIBRARY cudart "\"cudart\" library")
1004 if(CUDA_VERSION VERSION_EQUAL "3.0")
1005   # The cudartemu library only existed for the 3.0 version of CUDA.
1006   cuda_find_library_local_first(CUDA_CUDARTEMU_LIBRARY cudartemu "\"cudartemu\" library")
1007   mark_as_advanced(
1008     CUDA_CUDARTEMU_LIBRARY
1009     )
1010 endif()
1011
1012 if(NOT CUDA_VERSION VERSION_LESS "5.5")
1013   cuda_find_library_local_first(CUDA_cudart_static_LIBRARY cudart_static "static CUDA runtime library")
1014   mark_as_advanced(CUDA_cudart_static_LIBRARY)
1015 endif()
1016
1017
1018 if(CUDA_cudart_static_LIBRARY)
1019   # If static cudart available, use it by default, but provide a user-visible option to disable it.
1020   option(CUDA_USE_STATIC_CUDA_RUNTIME "Use the static version of the CUDA runtime library if available" ON)
1021 else()
1022   # If not available, silently disable the option.
1023   set(CUDA_USE_STATIC_CUDA_RUNTIME OFF CACHE INTERNAL "")
1024 endif()
1025
1026 if(CUDA_USE_STATIC_CUDA_RUNTIME)
1027   set(CUDA_CUDART_LIBRARY_VAR CUDA_cudart_static_LIBRARY)
1028 else()
1029   set(CUDA_CUDART_LIBRARY_VAR CUDA_CUDART_LIBRARY)
1030 endif()
1031
1032 if(NOT CUDA_VERSION VERSION_LESS "5.0")
1033   cuda_find_library_local_first(CUDA_cudadevrt_LIBRARY cudadevrt "\"cudadevrt\" library")
1034   mark_as_advanced(CUDA_cudadevrt_LIBRARY)
1035 endif()
1036
1037 if(CUDA_USE_STATIC_CUDA_RUNTIME)
1038   if(UNIX)
1039     # Check for the dependent libraries.
1040
1041     # Many of the FindXYZ CMake comes with makes use of try_compile with int main(){return 0;}
1042     # as the source file.  Unfortunately this causes a warning with -Wstrict-prototypes and
1043     # -Werror causes the try_compile to fail.  We will just temporarily disable other flags
1044     # when doing the find_package command here.
1045     set(_cuda_cmake_c_flags ${CMAKE_C_FLAGS})
1046     set(CMAKE_C_FLAGS "-fPIC")
1047     find_package(Threads REQUIRED)
1048     set(CMAKE_C_FLAGS ${_cuda_cmake_c_flags})
1049
1050     if(NOT APPLE AND NOT (CMAKE_SYSTEM_NAME STREQUAL "QNX"))
1051       #On Linux, you must link against librt when using the static cuda runtime.
1052       find_library(CUDA_rt_LIBRARY rt)
1053       if (NOT CUDA_rt_LIBRARY)
1054         message(WARNING "Expecting to find librt for libcudart_static, but didn't find it.")
1055       endif()
1056     endif()
1057   endif()
1058 endif()
1059
1060 # CUPTI library showed up in cuda toolkit 4.0
1061 if(NOT CUDA_VERSION VERSION_LESS "4.0")
1062   cuda_find_library_local_first_with_path_ext(CUDA_cupti_LIBRARY cupti "\"cupti\" library" "extras/CUPTI/")
1063   mark_as_advanced(CUDA_cupti_LIBRARY)
1064 endif()
1065
1066 # Set the CUDA_LIBRARIES variable.  This is the set of stuff to link against if you are
1067 # using the CUDA runtime.  For the dynamic version of the runtime, most of the
1068 # dependencies are brough in, but for the static version there are additional libraries
1069 # and linker commands needed.
1070 # Initialize to empty
1071 set(CUDA_LIBRARIES)
1072
1073 # If we are using emulation mode and we found the cudartemu library then use
1074 # that one instead of cudart.
1075 if(CUDA_BUILD_EMULATION AND CUDA_CUDARTEMU_LIBRARY)
1076   list(APPEND CUDA_LIBRARIES ${CUDA_CUDARTEMU_LIBRARY})
1077 elseif(CUDA_USE_STATIC_CUDA_RUNTIME AND CUDA_cudart_static_LIBRARY)
1078   list(APPEND CUDA_LIBRARIES ${CUDA_cudart_static_LIBRARY})
1079   if (TARGET Threads::Threads)
1080     list(APPEND CUDA_LIBRARIES Threads::Threads)
1081   endif()
1082   list(APPEND CUDA_LIBRARIES ${CMAKE_DL_LIBS})
1083   if (CUDA_rt_LIBRARY)
1084     list(APPEND CUDA_LIBRARIES ${CUDA_rt_LIBRARY})
1085   endif()
1086   if(APPLE)
1087     # We need to add the default path to the driver (libcuda.dylib) as an rpath, so that
1088     # the static cuda runtime can find it at runtime.
1089     list(APPEND CUDA_LIBRARIES -Wl,-rpath,/usr/local/cuda/lib)
1090   endif()
1091 else()
1092   list(APPEND CUDA_LIBRARIES ${CUDA_CUDART_LIBRARY})
1093 endif()
1094
1095 # 1.1 toolkit on linux doesn't appear to have a separate library on
1096 # some platforms.
1097 cuda_find_library_local_first(CUDA_CUDA_LIBRARY cuda "\"cuda\" library (older versions only).")
1098
1099 mark_as_advanced(
1100   CUDA_CUDA_LIBRARY
1101   CUDA_CUDART_LIBRARY
1102   )
1103
1104 #######################
1105 # Look for some of the toolkit helper libraries
1106 macro(FIND_CUDA_HELPER_LIBS _name)
1107   cuda_find_library_local_first(CUDA_${_name}_LIBRARY ${_name} "\"${_name}\" library")
1108   mark_as_advanced(CUDA_${_name}_LIBRARY)
1109 endmacro()
1110
1111 #######################
1112 # Disable emulation for v3.1 onward
1113 if(CUDA_VERSION VERSION_GREATER "3.0")
1114   if(CUDA_BUILD_EMULATION)
1115     message(FATAL_ERROR "CUDA_BUILD_EMULATION is not supported in version 3.1 and onwards.  You must disable it to proceed.  You have version ${CUDA_VERSION}.")
1116   endif()
1117 endif()
1118
1119 # Search for additional CUDA toolkit libraries.
1120 if(CUDA_VERSION VERSION_LESS "3.1")
1121   # Emulation libraries aren't available in version 3.1 onward.
1122   find_cuda_helper_libs(cufftemu)
1123   find_cuda_helper_libs(cublasemu)
1124 endif()
1125 find_cuda_helper_libs(cufft)
1126 find_cuda_helper_libs(cublas)
1127 if(NOT CUDA_VERSION VERSION_LESS "3.2")
1128   # cusparse showed up in version 3.2
1129   find_cuda_helper_libs(cusparse)
1130   find_cuda_helper_libs(curand)
1131   if (WIN32)
1132     find_cuda_helper_libs(nvcuvenc)
1133     find_cuda_helper_libs(nvcuvid)
1134   endif()
1135 endif()
1136 if(CUDA_VERSION VERSION_GREATER "5.0" AND CUDA_VERSION VERSION_LESS "9.2")
1137   # In CUDA 9.2 cublas_device was deprecated
1138   find_cuda_helper_libs(cublas_device)
1139 endif()
1140
1141 if(NOT CUDA_VERSION VERSION_LESS "5.0")
1142   find_cuda_helper_libs(nvToolsExt)
1143   find_cuda_helper_libs(OpenCL)
1144 endif()
1145
1146 if(NOT CUDA_VERSION VERSION_LESS "9.0")
1147   # In CUDA 9.0 NPP was nppi was removed
1148   find_cuda_helper_libs(nppc)
1149   find_cuda_helper_libs(nppial)
1150   find_cuda_helper_libs(nppicc)
1151   if(CUDA_VERSION VERSION_LESS "11.0")
1152     find_cuda_helper_libs(nppicom)
1153   endif()
1154   find_cuda_helper_libs(nppidei)
1155   find_cuda_helper_libs(nppif)
1156   find_cuda_helper_libs(nppig)
1157   find_cuda_helper_libs(nppim)
1158   find_cuda_helper_libs(nppist)
1159   find_cuda_helper_libs(nppisu)
1160   find_cuda_helper_libs(nppitc)
1161   find_cuda_helper_libs(npps)
1162   set(CUDA_npp_LIBRARY "${CUDA_nppc_LIBRARY};${CUDA_nppial_LIBRARY};${CUDA_nppicc_LIBRARY};${CUDA_nppicom_LIBRARY};${CUDA_nppidei_LIBRARY};${CUDA_nppif_LIBRARY};${CUDA_nppig_LIBRARY};${CUDA_nppim_LIBRARY};${CUDA_nppist_LIBRARY};${CUDA_nppisu_LIBRARY};${CUDA_nppitc_LIBRARY};${CUDA_npps_LIBRARY}")
1163 elseif(CUDA_VERSION VERSION_GREATER "5.0")
1164   # In CUDA 5.5 NPP was split into 3 separate libraries.
1165   find_cuda_helper_libs(nppc)
1166   find_cuda_helper_libs(nppi)
1167   find_cuda_helper_libs(npps)
1168   set(CUDA_npp_LIBRARY "${CUDA_nppc_LIBRARY};${CUDA_nppi_LIBRARY};${CUDA_npps_LIBRARY}")
1169 elseif(NOT CUDA_VERSION VERSION_LESS "4.0")
1170   find_cuda_helper_libs(npp)
1171 endif()
1172 if(NOT CUDA_VERSION VERSION_LESS "7.0")
1173   # cusolver showed up in version 7.0
1174   find_cuda_helper_libs(cusolver)
1175 endif()
1176
1177 if (CUDA_BUILD_EMULATION)
1178   set(CUDA_CUFFT_LIBRARIES ${CUDA_cufftemu_LIBRARY})
1179   set(CUDA_CUBLAS_LIBRARIES ${CUDA_cublasemu_LIBRARY})
1180 else()
1181   set(CUDA_CUFFT_LIBRARIES ${CUDA_cufft_LIBRARY})
1182   set(CUDA_CUBLAS_LIBRARIES ${CUDA_cublas_LIBRARY} ${CUDA_cublas_device_LIBRARY})
1183 endif()
1184
1185 ########################
1186 # Look for the SDK stuff.  As of CUDA 3.0 NVSDKCUDA_ROOT has been replaced with
1187 # NVSDKCOMPUTE_ROOT with the old CUDA C contents moved into the C subdirectory
1188 find_path(CUDA_SDK_ROOT_DIR common/inc/cutil.h
1189  HINTS
1190   "$ENV{NVSDKCOMPUTE_ROOT}/C"
1191   ENV NVSDKCUDA_ROOT
1192   "[HKEY_LOCAL_MACHINE\\SOFTWARE\\NVIDIA Corporation\\Installed Products\\NVIDIA SDK 10\\Compute;InstallDir]"
1193  PATHS
1194   "/Developer/GPU\ Computing/C"
1195   )
1196
1197 # Keep the CUDA_SDK_ROOT_DIR first in order to be able to override the
1198 # environment variables.
1199 set(CUDA_SDK_SEARCH_PATH
1200   "${CUDA_SDK_ROOT_DIR}"
1201   "${CUDA_TOOLKIT_ROOT_DIR}/local/NVSDK0.2"
1202   "${CUDA_TOOLKIT_ROOT_DIR}/NVSDK0.2"
1203   "${CUDA_TOOLKIT_ROOT_DIR}/NV_CUDA_SDK"
1204   "$ENV{HOME}/NVIDIA_CUDA_SDK"
1205   "$ENV{HOME}/NVIDIA_CUDA_SDK_MACOSX"
1206   "/Developer/CUDA"
1207   )
1208
1209 # Example of how to find an include file from the CUDA_SDK_ROOT_DIR
1210
1211 # find_path(CUDA_CUT_INCLUDE_DIR
1212 #   cutil.h
1213 #   PATHS ${CUDA_SDK_SEARCH_PATH}
1214 #   PATH_SUFFIXES "common/inc"
1215 #   DOC "Location of cutil.h"
1216 #   NO_DEFAULT_PATH
1217 #   )
1218 # # Now search system paths
1219 # find_path(CUDA_CUT_INCLUDE_DIR cutil.h DOC "Location of cutil.h")
1220
1221 # mark_as_advanced(CUDA_CUT_INCLUDE_DIR)
1222
1223
1224 # Example of how to find a library in the CUDA_SDK_ROOT_DIR
1225
1226 # # cutil library is called cutil64 for 64 bit builds on windows.  We don't want
1227 # # to get these confused, so we are setting the name based on the word size of
1228 # # the build.
1229
1230 # if(CMAKE_SIZEOF_VOID_P EQUAL 8)
1231 #   set(cuda_cutil_name cutil64)
1232 # else()
1233 #   set(cuda_cutil_name cutil32)
1234 # endif()
1235
1236 # find_library(CUDA_CUT_LIBRARY
1237 #   NAMES cutil ${cuda_cutil_name}
1238 #   PATHS ${CUDA_SDK_SEARCH_PATH}
1239 #   # The new version of the sdk shows up in common/lib, but the old one is in lib
1240 #   PATH_SUFFIXES "common/lib" "lib"
1241 #   DOC "Location of cutil library"
1242 #   NO_DEFAULT_PATH
1243 #   )
1244 # # Now search system paths
1245 # find_library(CUDA_CUT_LIBRARY NAMES cutil ${cuda_cutil_name} DOC "Location of cutil library")
1246 # mark_as_advanced(CUDA_CUT_LIBRARY)
1247 # set(CUDA_CUT_LIBRARIES ${CUDA_CUT_LIBRARY})
1248
1249
1250
1251 #############################
1252 # Check for required components
1253 set(CUDA_FOUND TRUE)
1254
1255 set(CUDA_TOOLKIT_ROOT_DIR_INTERNAL "${CUDA_TOOLKIT_ROOT_DIR}" CACHE INTERNAL
1256   "This is the value of the last time CUDA_TOOLKIT_ROOT_DIR was set successfully." FORCE)
1257 set(CUDA_TOOLKIT_TARGET_DIR_INTERNAL "${CUDA_TOOLKIT_TARGET_DIR}" CACHE INTERNAL
1258   "This is the value of the last time CUDA_TOOLKIT_TARGET_DIR was set successfully." FORCE)
1259 set(CUDA_SDK_ROOT_DIR_INTERNAL "${CUDA_SDK_ROOT_DIR}" CACHE INTERNAL
1260   "This is the value of the last time CUDA_SDK_ROOT_DIR was set successfully." FORCE)
1261
1262 include(${CMAKE_CURRENT_LIST_DIR}/FindPackageHandleStandardArgs.cmake)
1263
1264 find_package_handle_standard_args(CUDA
1265   REQUIRED_VARS
1266     CUDA_TOOLKIT_ROOT_DIR
1267     CUDA_NVCC_EXECUTABLE
1268     CUDA_INCLUDE_DIRS
1269     ${CUDA_CUDART_LIBRARY_VAR}
1270   VERSION_VAR
1271     CUDA_VERSION
1272   )
1273
1274
1275
1276 ###############################################################################
1277 ###############################################################################
1278 # Macros
1279 ###############################################################################
1280 ###############################################################################
1281
1282 ###############################################################################
1283 # Add include directories to pass to the nvcc command.
1284 macro(CUDA_INCLUDE_DIRECTORIES)
1285   foreach(dir ${ARGN})
1286     list(APPEND CUDA_NVCC_INCLUDE_DIRS_USER ${dir})
1287   endforeach()
1288 endmacro()
1289
1290
1291 ##############################################################################
1292 cuda_find_helper_file(parse_cubin cmake)
1293 cuda_find_helper_file(make2cmake cmake)
1294 cuda_find_helper_file(run_nvcc cmake)
1295 include("${CMAKE_CURRENT_LIST_DIR}/FindCUDA/select_compute_arch.cmake")
1296
1297 ##############################################################################
1298 # Separate the OPTIONS out from the sources
1299 #
1300 macro(CUDA_GET_SOURCES_AND_OPTIONS _sources _cmake_options _options)
1301   set( ${_sources} )
1302   set( ${_cmake_options} )
1303   set( ${_options} )
1304   set( _found_options FALSE )
1305   foreach(arg ${ARGN})
1306     if("x${arg}" STREQUAL "xOPTIONS")
1307       set( _found_options TRUE )
1308     elseif(
1309         "x${arg}" STREQUAL "xWIN32" OR
1310         "x${arg}" STREQUAL "xMACOSX_BUNDLE" OR
1311         "x${arg}" STREQUAL "xEXCLUDE_FROM_ALL" OR
1312         "x${arg}" STREQUAL "xSTATIC" OR
1313         "x${arg}" STREQUAL "xSHARED" OR
1314         "x${arg}" STREQUAL "xMODULE"
1315         )
1316       list(APPEND ${_cmake_options} ${arg})
1317     else()
1318       if ( _found_options )
1319         list(APPEND ${_options} ${arg})
1320       else()
1321         # Assume this is a file
1322         list(APPEND ${_sources} ${arg})
1323       endif()
1324     endif()
1325   endforeach()
1326 endmacro()
1327
1328 ##############################################################################
1329 # Parse the OPTIONS from ARGN and set the variables prefixed by _option_prefix
1330 #
1331 macro(CUDA_PARSE_NVCC_OPTIONS _option_prefix)
1332   set( _found_config )
1333   foreach(arg ${ARGN})
1334     # Determine if we are dealing with a perconfiguration flag
1335     foreach(config ${CUDA_configuration_types})
1336       string(TOUPPER ${config} config_upper)
1337       if (arg STREQUAL "${config_upper}")
1338         set( _found_config _${arg})
1339         # Set arg to nothing to keep it from being processed further
1340         set( arg )
1341       endif()
1342     endforeach()
1343
1344     if ( arg )
1345       list(APPEND ${_option_prefix}${_found_config} "${arg}")
1346     endif()
1347   endforeach()
1348 endmacro()
1349
1350 ##############################################################################
1351 # Helper to add the include directory for CUDA only once
1352 function(CUDA_ADD_CUDA_INCLUDE_ONCE)
1353   get_directory_property(_include_directories INCLUDE_DIRECTORIES)
1354   set(_add TRUE)
1355   if(_include_directories)
1356     foreach(dir ${_include_directories})
1357       if("${dir}" STREQUAL "${CUDA_INCLUDE_DIRS}")
1358         set(_add FALSE)
1359       endif()
1360     endforeach()
1361   endif()
1362   if(_add)
1363     include_directories(${CUDA_INCLUDE_DIRS})
1364   endif()
1365 endfunction()
1366
1367 function(CUDA_BUILD_SHARED_LIBRARY shared_flag)
1368   set(cmake_args ${ARGN})
1369   # If SHARED, MODULE, or STATIC aren't already in the list of arguments, then
1370   # add SHARED or STATIC based on the value of BUILD_SHARED_LIBS.
1371   list(FIND cmake_args SHARED _cuda_found_SHARED)
1372   list(FIND cmake_args MODULE _cuda_found_MODULE)
1373   list(FIND cmake_args STATIC _cuda_found_STATIC)
1374   if( _cuda_found_SHARED GREATER -1 OR
1375       _cuda_found_MODULE GREATER -1 OR
1376       _cuda_found_STATIC GREATER -1)
1377     set(_cuda_build_shared_libs)
1378   else()
1379     if (BUILD_SHARED_LIBS)
1380       set(_cuda_build_shared_libs SHARED)
1381     else()
1382       set(_cuda_build_shared_libs STATIC)
1383     endif()
1384   endif()
1385   set(${shared_flag} ${_cuda_build_shared_libs} PARENT_SCOPE)
1386 endfunction()
1387
1388 ##############################################################################
1389 # Helper to avoid clashes of files with the same basename but different paths.
1390 # This doesn't attempt to do exactly what CMake internals do, which is to only
1391 # add this path when there is a conflict, since by the time a second collision
1392 # in names is detected it's already too late to fix the first one.  For
1393 # consistency sake the relative path will be added to all files.
1394 function(CUDA_COMPUTE_BUILD_PATH path build_path)
1395   #message("CUDA_COMPUTE_BUILD_PATH([${path}] ${build_path})")
1396   # Only deal with CMake style paths from here on out
1397   file(TO_CMAKE_PATH "${path}" bpath)
1398   if (IS_ABSOLUTE "${bpath}")
1399     # Absolute paths are generally unnessary, especially if something like
1400     # file(GLOB_RECURSE) is used to pick up the files.
1401
1402     string(FIND "${bpath}" "${CMAKE_CURRENT_BINARY_DIR}" _binary_dir_pos)
1403     if (_binary_dir_pos EQUAL 0)
1404       file(RELATIVE_PATH bpath "${CMAKE_CURRENT_BINARY_DIR}" "${bpath}")
1405     else()
1406       file(RELATIVE_PATH bpath "${CMAKE_CURRENT_SOURCE_DIR}" "${bpath}")
1407     endif()
1408   endif()
1409
1410   # This recipe is from cmLocalGenerator::CreateSafeUniqueObjectFileName in the
1411   # CMake source.
1412
1413   # Remove leading /
1414   string(REGEX REPLACE "^[/]+" "" bpath "${bpath}")
1415   # Avoid absolute paths by removing ':'
1416   string(REPLACE ":" "_" bpath "${bpath}")
1417   # Avoid relative paths that go up the tree
1418   string(REPLACE "../" "__/" bpath "${bpath}")
1419   # Avoid spaces
1420   string(REPLACE " " "_" bpath "${bpath}")
1421
1422   # Strip off the filename.  I wait until here to do it, since removin the
1423   # basename can make a path that looked like path/../basename turn into
1424   # path/.. (notice the trailing slash).
1425   get_filename_component(bpath "${bpath}" PATH)
1426
1427   set(${build_path} "${bpath}" PARENT_SCOPE)
1428   #message("${build_path} = ${bpath}")
1429 endfunction()
1430
1431 ##############################################################################
1432 # This helper macro populates the following variables and setups up custom
1433 # commands and targets to invoke the nvcc compiler to generate C or PTX source
1434 # dependent upon the format parameter.  The compiler is invoked once with -M
1435 # to generate a dependency file and a second time with -cuda or -ptx to generate
1436 # a .cpp or .ptx file.
1437 # INPUT:
1438 #   cuda_target         - Target name
1439 #   format              - PTX, CUBIN, FATBIN or OBJ
1440 #   FILE1 .. FILEN      - The remaining arguments are the sources to be wrapped.
1441 #   OPTIONS             - Extra options to NVCC
1442 # OUTPUT:
1443 #   generated_files     - List of generated files
1444 ##############################################################################
1445 ##############################################################################
1446
1447 macro(CUDA_WRAP_SRCS cuda_target format generated_files)
1448
1449   # Put optional arguments in list.
1450   set(_argn_list "${ARGN}")
1451   # If one of the given optional arguments is "PHONY", make a note of it, then
1452   # remove it from the list.
1453   list(FIND _argn_list "PHONY" _phony_idx)
1454   if("${_phony_idx}" GREATER "-1")
1455     set(_target_is_phony true)
1456     list(REMOVE_AT _argn_list ${_phony_idx})
1457   else()
1458     set(_target_is_phony false)
1459   endif()
1460
1461   # If CMake doesn't support separable compilation, complain
1462   if(CUDA_SEPARABLE_COMPILATION AND CMAKE_VERSION VERSION_LESS "2.8.10.1")
1463     message(SEND_ERROR "CUDA_SEPARABLE_COMPILATION isn't supported for CMake versions less than 2.8.10.1")
1464   endif()
1465
1466   # Set up all the command line flags here, so that they can be overridden on a per target basis.
1467
1468   set(nvcc_flags "")
1469
1470   # Emulation if the card isn't present.
1471   if (CUDA_BUILD_EMULATION)
1472     # Emulation.
1473     set(nvcc_flags ${nvcc_flags} --device-emulation -D_DEVICEEMU -g)
1474   else()
1475     # Device mode.  No flags necessary.
1476   endif()
1477
1478   if(CUDA_HOST_COMPILATION_CPP)
1479     set(CUDA_C_OR_CXX CXX)
1480   else()
1481     if(CUDA_VERSION VERSION_LESS "3.0")
1482       set(nvcc_flags ${nvcc_flags} --host-compilation C)
1483     else()
1484       message(WARNING "--host-compilation flag is deprecated in CUDA version >= 3.0.  Removing --host-compilation C flag" )
1485     endif()
1486     set(CUDA_C_OR_CXX C)
1487   endif()
1488
1489   set(generated_extension ${CMAKE_${CUDA_C_OR_CXX}_OUTPUT_EXTENSION})
1490
1491   if(CUDA_64_BIT_DEVICE_CODE)
1492     set(nvcc_flags ${nvcc_flags} -m64)
1493   else()
1494     set(nvcc_flags ${nvcc_flags} -m32)
1495   endif()
1496
1497   if(CUDA_TARGET_CPU_ARCH)
1498     set(nvcc_flags ${nvcc_flags} "--target-cpu-architecture=${CUDA_TARGET_CPU_ARCH}")
1499   endif()
1500
1501   # This needs to be passed in at this stage, because VS needs to fill out the
1502   # various macros from within VS.  Note that CCBIN is only used if
1503   # -ccbin or --compiler-bindir isn't used and CUDA_HOST_COMPILER matches
1504   # _CUDA_MSVC_HOST_COMPILER
1505   if(CMAKE_GENERATOR MATCHES "Visual Studio")
1506     set(ccbin_flags -D "\"CCBIN:PATH=${_CUDA_MSVC_HOST_COMPILER}\"" )
1507   else()
1508     set(ccbin_flags)
1509   endif()
1510
1511   # Figure out which configure we will use and pass that in as an argument to
1512   # the script.  We need to defer the decision until compilation time, because
1513   # for VS projects we won't know if we are making a debug or release build
1514   # until build time.
1515   if(CMAKE_GENERATOR MATCHES "Visual Studio")
1516     set( CUDA_build_configuration "$(ConfigurationName)" )
1517   else()
1518     set( CUDA_build_configuration "${CMAKE_BUILD_TYPE}")
1519   endif()
1520
1521   # Initialize our list of includes with the user ones followed by the CUDA system ones.
1522   set(CUDA_NVCC_INCLUDE_DIRS ${CUDA_NVCC_INCLUDE_DIRS_USER} "${CUDA_INCLUDE_DIRS}")
1523   if(_target_is_phony)
1524     # If the passed in target name isn't a real target (i.e., this is from a call to one of the
1525     # cuda_compile_* functions), need to query directory properties to get include directories
1526     # and compile definitions.
1527     get_directory_property(_dir_include_dirs INCLUDE_DIRECTORIES)
1528     get_directory_property(_dir_compile_defs COMPILE_DEFINITIONS)
1529
1530     list(APPEND CUDA_NVCC_INCLUDE_DIRS "${_dir_include_dirs}")
1531     set(CUDA_NVCC_COMPILE_DEFINITIONS "${_dir_compile_defs}")
1532   else()
1533     # Append the include directories for this target via generator expression, which is
1534     # expanded by the FILE(GENERATE) call below.  This generator expression captures all
1535     # include dirs set by the user, whether via directory properties or target properties
1536     list(APPEND CUDA_NVCC_INCLUDE_DIRS "$<TARGET_PROPERTY:${cuda_target},INCLUDE_DIRECTORIES>")
1537
1538     # Do the same thing with compile definitions
1539     set(CUDA_NVCC_COMPILE_DEFINITIONS "$<TARGET_PROPERTY:${cuda_target},COMPILE_DEFINITIONS>")
1540   endif()
1541
1542
1543   # Reset these variables
1544   set(CUDA_WRAP_OPTION_NVCC_FLAGS)
1545   foreach(config ${CUDA_configuration_types})
1546     string(TOUPPER ${config} config_upper)
1547     set(CUDA_WRAP_OPTION_NVCC_FLAGS_${config_upper})
1548   endforeach()
1549
1550   CUDA_GET_SOURCES_AND_OPTIONS(_cuda_wrap_sources _cuda_wrap_cmake_options _cuda_wrap_options ${_argn_list})
1551   CUDA_PARSE_NVCC_OPTIONS(CUDA_WRAP_OPTION_NVCC_FLAGS ${_cuda_wrap_options})
1552
1553   # Figure out if we are building a shared library.  BUILD_SHARED_LIBS is
1554   # respected in CUDA_ADD_LIBRARY.
1555   set(_cuda_build_shared_libs FALSE)
1556   # SHARED, MODULE
1557   list(FIND _cuda_wrap_cmake_options SHARED _cuda_found_SHARED)
1558   list(FIND _cuda_wrap_cmake_options MODULE _cuda_found_MODULE)
1559   if(_cuda_found_SHARED GREATER -1 OR _cuda_found_MODULE GREATER -1)
1560     set(_cuda_build_shared_libs TRUE)
1561   endif()
1562   # STATIC
1563   list(FIND _cuda_wrap_cmake_options STATIC _cuda_found_STATIC)
1564   if(_cuda_found_STATIC GREATER -1)
1565     set(_cuda_build_shared_libs FALSE)
1566   endif()
1567
1568   # CUDA_HOST_FLAGS
1569   if(_cuda_build_shared_libs)
1570     # If we are setting up code for a shared library, then we need to add extra flags for
1571     # compiling objects for shared libraries.
1572     set(CUDA_HOST_SHARED_FLAGS ${CMAKE_SHARED_LIBRARY_${CUDA_C_OR_CXX}_FLAGS})
1573   else()
1574     set(CUDA_HOST_SHARED_FLAGS)
1575   endif()
1576   # Only add the CMAKE_{C,CXX}_FLAGS if we are propagating host flags.  We
1577   # always need to set the SHARED_FLAGS, though.
1578   if(CUDA_PROPAGATE_HOST_FLAGS)
1579     set(_cuda_host_flags "set(CMAKE_HOST_FLAGS ${CMAKE_${CUDA_C_OR_CXX}_FLAGS} ${CUDA_HOST_SHARED_FLAGS})")
1580   else()
1581     set(_cuda_host_flags "set(CMAKE_HOST_FLAGS ${CUDA_HOST_SHARED_FLAGS})")
1582   endif()
1583
1584   set(_cuda_nvcc_flags_config "# Build specific configuration flags")
1585   # Loop over all the configuration types to generate appropriate flags for run_nvcc.cmake
1586   foreach(config ${CUDA_configuration_types})
1587     string(TOUPPER ${config} config_upper)
1588     # CMAKE_FLAGS are strings and not lists.  By not putting quotes around CMAKE_FLAGS
1589     # we convert the strings to lists (like we want).
1590
1591     if(CUDA_PROPAGATE_HOST_FLAGS)
1592       # nvcc chokes on -g3 in versions previous to 3.0, so replace it with -g
1593       set(_cuda_fix_g3 FALSE)
1594
1595       if(CMAKE_COMPILER_IS_GNUCC)
1596         if (CUDA_VERSION VERSION_LESS  "3.0" OR
1597             CUDA_VERSION VERSION_EQUAL "4.1" OR
1598             CUDA_VERSION VERSION_EQUAL "4.2"
1599             )
1600           set(_cuda_fix_g3 TRUE)
1601         endif()
1602       endif()
1603       if(_cuda_fix_g3)
1604         string(REPLACE "-g3" "-g" _cuda_C_FLAGS "${CMAKE_${CUDA_C_OR_CXX}_FLAGS_${config_upper}}")
1605       else()
1606         set(_cuda_C_FLAGS "${CMAKE_${CUDA_C_OR_CXX}_FLAGS_${config_upper}}")
1607       endif()
1608
1609       string(APPEND _cuda_host_flags "\nset(CMAKE_HOST_FLAGS_${config_upper} ${_cuda_C_FLAGS})")
1610     endif()
1611
1612     # Note that if we ever want CUDA_NVCC_FLAGS_<CONFIG> to be string (instead of a list
1613     # like it is currently), we can remove the quotes around the
1614     # ${CUDA_NVCC_FLAGS_${config_upper}} variable like the CMAKE_HOST_FLAGS_<CONFIG> variable.
1615     string(APPEND _cuda_nvcc_flags_config "\nset(CUDA_NVCC_FLAGS_${config_upper} ${CUDA_NVCC_FLAGS_${config_upper}} ;; ${CUDA_WRAP_OPTION_NVCC_FLAGS_${config_upper}})")
1616   endforeach()
1617
1618   # Process the C++11 flag.  If the host sets the flag, we need to add it to nvcc and
1619   # remove it from the host. This is because -Xcompile -std=c++ will choke nvcc (it uses
1620   # the C preprocessor).  In order to get this to work correctly, we need to use nvcc's
1621   # specific c++11 flag.
1622   if( "${_cuda_host_flags}" MATCHES "-std=c\\+\\+11")
1623     # Add the c++11 flag to nvcc if it isn't already present.  Note that we only look at
1624     # the main flag instead of the configuration specific flags.
1625     if( NOT "${CUDA_NVCC_FLAGS}" MATCHES "-std=c\\+\\+11" )
1626       list(APPEND nvcc_flags --std c++11)
1627     endif()
1628     string(REGEX REPLACE "[-]+std=c\\+\\+11" "" _cuda_host_flags "${_cuda_host_flags}")
1629   endif()
1630
1631   if(_cuda_build_shared_libs)
1632     list(APPEND nvcc_flags "-D${cuda_target}_EXPORTS")
1633   endif()
1634
1635   # Reset the output variable
1636   set(_cuda_wrap_generated_files "")
1637
1638   # Iterate over the macro arguments and create custom
1639   # commands for all the .cu files.
1640   foreach(file ${_argn_list})
1641     # Ignore any file marked as a HEADER_FILE_ONLY
1642     get_source_file_property(_is_header ${file} HEADER_FILE_ONLY)
1643     # Allow per source file overrides of the format.  Also allows compiling non-.cu files.
1644     get_source_file_property(_cuda_source_format ${file} CUDA_SOURCE_PROPERTY_FORMAT)
1645     if((${file} MATCHES "\\.cu$" OR _cuda_source_format) AND NOT _is_header)
1646
1647       if(NOT _cuda_source_format)
1648         set(_cuda_source_format ${format})
1649       endif()
1650       # If file isn't a .cu file, we need to tell nvcc to treat it as such.
1651       if(NOT ${file} MATCHES "\\.cu$")
1652         set(cuda_language_flag -x=cu)
1653       else()
1654         set(cuda_language_flag)
1655       endif()
1656
1657       if( ${_cuda_source_format} MATCHES "OBJ")
1658         set( cuda_compile_to_external_module OFF )
1659       else()
1660         set( cuda_compile_to_external_module ON )
1661         if( ${_cuda_source_format} MATCHES "PTX" )
1662           set( cuda_compile_to_external_module_type "ptx" )
1663         elseif( ${_cuda_source_format} MATCHES "CUBIN")
1664           set( cuda_compile_to_external_module_type "cubin" )
1665         elseif( ${_cuda_source_format} MATCHES "FATBIN")
1666           set( cuda_compile_to_external_module_type "fatbin" )
1667         else()
1668           message( FATAL_ERROR "Invalid format flag passed to CUDA_WRAP_SRCS or set with CUDA_SOURCE_PROPERTY_FORMAT file property for file '${file}': '${_cuda_source_format}'.  Use OBJ, PTX, CUBIN or FATBIN.")
1669         endif()
1670       endif()
1671
1672       if(cuda_compile_to_external_module)
1673         # Don't use any of the host compilation flags for PTX targets.
1674         set(CUDA_HOST_FLAGS)
1675         set(CUDA_NVCC_FLAGS_CONFIG)
1676       else()
1677         set(CUDA_HOST_FLAGS ${_cuda_host_flags})
1678         set(CUDA_NVCC_FLAGS_CONFIG ${_cuda_nvcc_flags_config})
1679       endif()
1680
1681       # Determine output directory
1682       cuda_compute_build_path("${file}" cuda_build_path)
1683       set(cuda_compile_intermediate_directory "${CMAKE_CURRENT_BINARY_DIR}/CMakeFiles/${cuda_target}.dir/${cuda_build_path}")
1684       if(CUDA_GENERATED_OUTPUT_DIR)
1685         set(cuda_compile_output_dir "${CUDA_GENERATED_OUTPUT_DIR}")
1686       else()
1687         if ( cuda_compile_to_external_module )
1688           set(cuda_compile_output_dir "${CMAKE_CURRENT_BINARY_DIR}")
1689         else()
1690           set(cuda_compile_output_dir "${cuda_compile_intermediate_directory}")
1691         endif()
1692       endif()
1693
1694       # Add a custom target to generate a c or ptx file. ######################
1695
1696       get_filename_component( basename ${file} NAME )
1697       if( cuda_compile_to_external_module )
1698         set(generated_file_path "${cuda_compile_output_dir}")
1699         set(generated_file_basename "${cuda_target}_generated_${basename}.${cuda_compile_to_external_module_type}")
1700         set(format_flag "-${cuda_compile_to_external_module_type}")
1701         file(MAKE_DIRECTORY "${cuda_compile_output_dir}")
1702       else()
1703         set(generated_file_path "${cuda_compile_output_dir}/${CMAKE_CFG_INTDIR}")
1704         set(generated_file_basename "${cuda_target}_generated_${basename}${generated_extension}")
1705         if(CUDA_SEPARABLE_COMPILATION)
1706           set(format_flag "-dc")
1707         else()
1708           set(format_flag "-c")
1709         endif()
1710       endif()
1711
1712       # Set all of our file names.  Make sure that whatever filenames that have
1713       # generated_file_path in them get passed in through as a command line
1714       # argument, so that the ${CMAKE_CFG_INTDIR} gets expanded at run time
1715       # instead of configure time.
1716       set(generated_file "${generated_file_path}/${generated_file_basename}")
1717       set(cmake_dependency_file "${cuda_compile_intermediate_directory}/${generated_file_basename}.depend")
1718       set(NVCC_generated_dependency_file "${cuda_compile_intermediate_directory}/${generated_file_basename}.NVCC-depend")
1719       set(generated_cubin_file "${generated_file_path}/${generated_file_basename}.cubin.txt")
1720       set(custom_target_script_pregen "${cuda_compile_intermediate_directory}/${generated_file_basename}.cmake.pre-gen")
1721       set(custom_target_script "${cuda_compile_intermediate_directory}/${generated_file_basename}$<$<BOOL:$<CONFIG>>:.$<CONFIG>>.cmake")
1722
1723       # Setup properties for obj files:
1724       if( NOT cuda_compile_to_external_module )
1725         set_source_files_properties("${generated_file}"
1726           PROPERTIES
1727           EXTERNAL_OBJECT true # This is an object file not to be compiled, but only be linked.
1728           )
1729       endif()
1730
1731       # Don't add CMAKE_CURRENT_SOURCE_DIR if the path is already an absolute path.
1732       get_filename_component(file_path "${file}" PATH)
1733       if(IS_ABSOLUTE "${file_path}")
1734         set(source_file "${file}")
1735       else()
1736         set(source_file "${CMAKE_CURRENT_SOURCE_DIR}/${file}")
1737       endif()
1738
1739       if( NOT cuda_compile_to_external_module AND CUDA_SEPARABLE_COMPILATION)
1740         list(APPEND ${cuda_target}_SEPARABLE_COMPILATION_OBJECTS "${generated_file}")
1741       endif()
1742
1743       # Bring in the dependencies.  Creates a variable CUDA_NVCC_DEPEND #######
1744       cuda_include_nvcc_dependencies(${cmake_dependency_file})
1745
1746       # Convenience string for output #########################################
1747       if(CUDA_BUILD_EMULATION)
1748         set(cuda_build_type "Emulation")
1749       else()
1750         set(cuda_build_type "Device")
1751       endif()
1752
1753       # Build the NVCC made dependency file ###################################
1754       set(build_cubin OFF)
1755       if ( NOT CUDA_BUILD_EMULATION AND CUDA_BUILD_CUBIN )
1756          if ( NOT cuda_compile_to_external_module )
1757            set ( build_cubin ON )
1758          endif()
1759       endif()
1760
1761       # Configure the build script
1762       configure_file("${CUDA_run_nvcc}" "${custom_target_script_pregen}" @ONLY)
1763       file(GENERATE
1764         OUTPUT "${custom_target_script}"
1765         INPUT "${custom_target_script_pregen}"
1766         )
1767
1768       # So if a user specifies the same cuda file as input more than once, you
1769       # can have bad things happen with dependencies.  Here we check an option
1770       # to see if this is the behavior they want.
1771       if(CUDA_ATTACH_VS_BUILD_RULE_TO_CUDA_FILE)
1772         set(main_dep MAIN_DEPENDENCY ${source_file})
1773       else()
1774         set(main_dep DEPENDS ${source_file})
1775       endif()
1776
1777       if(CUDA_VERBOSE_BUILD)
1778         set(verbose_output ON)
1779       elseif(CMAKE_GENERATOR MATCHES "Makefiles")
1780         set(verbose_output "$(VERBOSE)")
1781       else()
1782         set(verbose_output OFF)
1783       endif()
1784
1785       # Create up the comment string
1786       file(RELATIVE_PATH generated_file_relative_path "${CMAKE_BINARY_DIR}" "${generated_file}")
1787       if(cuda_compile_to_external_module)
1788         set(cuda_build_comment_string "Building NVCC ${cuda_compile_to_external_module_type} file ${generated_file_relative_path}")
1789       else()
1790         set(cuda_build_comment_string "Building NVCC (${cuda_build_type}) object ${generated_file_relative_path}")
1791       endif()
1792
1793       set(_verbatim VERBATIM)
1794       if(ccbin_flags MATCHES "\\$\\(VCInstallDir\\)")
1795         set(_verbatim "")
1796       endif()
1797
1798       # Build the generated file and dependency file ##########################
1799       add_custom_command(
1800         OUTPUT ${generated_file}
1801         # These output files depend on the source_file and the contents of cmake_dependency_file
1802         ${main_dep}
1803         DEPENDS ${CUDA_NVCC_DEPEND}
1804         DEPENDS ${custom_target_script}
1805         # Make sure the output directory exists before trying to write to it.
1806         COMMAND ${CMAKE_COMMAND} -E make_directory "${generated_file_path}"
1807         COMMAND ${CMAKE_COMMAND} ARGS
1808           -D verbose:BOOL=${verbose_output}
1809           ${ccbin_flags}
1810           -D build_configuration:STRING=${CUDA_build_configuration}
1811           -D "generated_file:STRING=${generated_file}"
1812           -D "generated_cubin_file:STRING=${generated_cubin_file}"
1813           -P "${custom_target_script}"
1814         WORKING_DIRECTORY "${cuda_compile_intermediate_directory}"
1815         COMMENT "${cuda_build_comment_string}"
1816         ${_verbatim}
1817         )
1818
1819       # Make sure the build system knows the file is generated.
1820       set_source_files_properties(${generated_file} PROPERTIES GENERATED TRUE)
1821
1822       list(APPEND _cuda_wrap_generated_files ${generated_file})
1823
1824       # Add the other files that we want cmake to clean on a cleanup ##########
1825       list(APPEND CUDA_ADDITIONAL_CLEAN_FILES "${cmake_dependency_file}")
1826       list(REMOVE_DUPLICATES CUDA_ADDITIONAL_CLEAN_FILES)
1827       set(CUDA_ADDITIONAL_CLEAN_FILES ${CUDA_ADDITIONAL_CLEAN_FILES} CACHE INTERNAL "List of intermediate files that are part of the cuda dependency scanning.")
1828
1829     endif()
1830   endforeach()
1831
1832   # Set the return parameter
1833   set(${generated_files} ${_cuda_wrap_generated_files})
1834 endmacro()
1835
1836 function(_cuda_get_important_host_flags important_flags flag_string)
1837   if(CMAKE_GENERATOR MATCHES "Visual Studio")
1838     string(REGEX MATCHALL "/M[DT][d]?" flags "${flag_string}")
1839     list(APPEND ${important_flags} ${flags})
1840   else()
1841     string(REGEX MATCHALL "-fPIC" flags "${flag_string}")
1842     list(APPEND ${important_flags} ${flags})
1843   endif()
1844   set(${important_flags} ${${important_flags}} PARENT_SCOPE)
1845 endfunction()
1846
1847 ###############################################################################
1848 ###############################################################################
1849 # Separable Compilation Link
1850 ###############################################################################
1851 ###############################################################################
1852
1853 # Compute the filename to be used by CUDA_LINK_SEPARABLE_COMPILATION_OBJECTS
1854 function(CUDA_COMPUTE_SEPARABLE_COMPILATION_OBJECT_FILE_NAME output_file_var cuda_target object_files)
1855   if (object_files)
1856     set(generated_extension ${CMAKE_${CUDA_C_OR_CXX}_OUTPUT_EXTENSION})
1857     set(output_file "${CMAKE_CURRENT_BINARY_DIR}/CMakeFiles/${cuda_target}.dir/${CMAKE_CFG_INTDIR}/${cuda_target}_intermediate_link${generated_extension}")
1858   else()
1859     set(output_file)
1860   endif()
1861
1862   set(${output_file_var} "${output_file}" PARENT_SCOPE)
1863 endfunction()
1864
1865 # Setup the build rule for the separable compilation intermediate link file.
1866 function(CUDA_LINK_SEPARABLE_COMPILATION_OBJECTS output_file cuda_target options object_files)
1867   if (object_files)
1868
1869     set_source_files_properties("${output_file}"
1870       PROPERTIES
1871       EXTERNAL_OBJECT TRUE # This is an object file not to be compiled, but only
1872                            # be linked.
1873       GENERATED TRUE       # This file is generated during the build
1874       )
1875
1876     # For now we are ignoring all the configuration specific flags.
1877     set(nvcc_flags)
1878     CUDA_PARSE_NVCC_OPTIONS(nvcc_flags ${options})
1879     if(CUDA_64_BIT_DEVICE_CODE)
1880       list(APPEND nvcc_flags -m64)
1881     else()
1882       list(APPEND nvcc_flags -m32)
1883     endif()
1884     # If -ccbin, --compiler-bindir has been specified, don't do anything.  Otherwise add it here.
1885     list( FIND nvcc_flags "-ccbin" ccbin_found0 )
1886     list( FIND nvcc_flags "--compiler-bindir" ccbin_found1 )
1887     if( ccbin_found0 LESS 0 AND ccbin_found1 LESS 0 AND CUDA_HOST_COMPILER )
1888       # Match VERBATIM check below.
1889       if(CUDA_HOST_COMPILER MATCHES "\\$\\(VCInstallDir\\)")
1890         list(APPEND nvcc_flags -ccbin "\"${CUDA_HOST_COMPILER}\"")
1891       else()
1892         list(APPEND nvcc_flags -ccbin "${CUDA_HOST_COMPILER}")
1893       endif()
1894     endif()
1895
1896     # Create a list of flags specified by CUDA_NVCC_FLAGS_${CONFIG} and CMAKE_${CUDA_C_OR_CXX}_FLAGS*
1897     set(config_specific_flags)
1898     set(flags)
1899     foreach(config ${CUDA_configuration_types})
1900       string(TOUPPER ${config} config_upper)
1901       # Add config specific flags
1902       foreach(f ${CUDA_NVCC_FLAGS_${config_upper}})
1903         list(APPEND config_specific_flags $<$<CONFIG:${config}>:${f}>)
1904       endforeach()
1905       set(important_host_flags)
1906       _cuda_get_important_host_flags(important_host_flags "${CMAKE_${CUDA_C_OR_CXX}_FLAGS_${config_upper}}")
1907       foreach(f ${important_host_flags})
1908         list(APPEND flags $<$<CONFIG:${config}>:-Xcompiler> $<$<CONFIG:${config}>:${f}>)
1909       endforeach()
1910     endforeach()
1911     # Add CMAKE_${CUDA_C_OR_CXX}_FLAGS
1912     set(important_host_flags)
1913     _cuda_get_important_host_flags(important_host_flags "${CMAKE_${CUDA_C_OR_CXX}_FLAGS}")
1914     foreach(f ${important_host_flags})
1915       list(APPEND flags -Xcompiler ${f})
1916     endforeach()
1917
1918     # Add our general CUDA_NVCC_FLAGS with the configuration specifig flags
1919     set(nvcc_flags ${CUDA_NVCC_FLAGS} ${config_specific_flags} ${nvcc_flags})
1920
1921     file(RELATIVE_PATH output_file_relative_path "${CMAKE_BINARY_DIR}" "${output_file}")
1922
1923     # Some generators don't handle the multiple levels of custom command
1924     # dependencies correctly (obj1 depends on file1, obj2 depends on obj1), so
1925     # we work around that issue by compiling the intermediate link object as a
1926     # pre-link custom command in that situation.
1927     set(do_obj_build_rule TRUE)
1928     if (MSVC_VERSION GREATER 1599 AND MSVC_VERSION LESS 1800)
1929       # VS 2010 and 2012 have this problem.
1930       set(do_obj_build_rule FALSE)
1931     endif()
1932
1933     set(_verbatim VERBATIM)
1934     if(nvcc_flags MATCHES "\\$\\(VCInstallDir\\)")
1935       set(_verbatim "")
1936     endif()
1937
1938     if (do_obj_build_rule)
1939       add_custom_command(
1940         OUTPUT ${output_file}
1941         DEPENDS ${object_files}
1942         COMMAND ${CUDA_NVCC_EXECUTABLE} ${nvcc_flags} -dlink ${object_files} -o ${output_file}
1943         ${flags}
1944         COMMENT "Building NVCC intermediate link file ${output_file_relative_path}"
1945         COMMAND_EXPAND_LISTS
1946         ${_verbatim}
1947         )
1948     else()
1949       get_filename_component(output_file_dir "${output_file}" DIRECTORY)
1950       add_custom_command(
1951         TARGET ${cuda_target}
1952         PRE_LINK
1953         COMMAND ${CMAKE_COMMAND} -E echo "Building NVCC intermediate link file ${output_file_relative_path}"
1954         COMMAND ${CMAKE_COMMAND} -E make_directory "${output_file_dir}"
1955         COMMAND ${CUDA_NVCC_EXECUTABLE} ${nvcc_flags} ${flags} -dlink ${object_files} -o "${output_file}"
1956         COMMAND_EXPAND_LISTS
1957         ${_verbatim}
1958         )
1959     endif()
1960  endif()
1961 endfunction()
1962
1963 ###############################################################################
1964 ###############################################################################
1965 # ADD LIBRARY
1966 ###############################################################################
1967 ###############################################################################
1968 macro(CUDA_ADD_LIBRARY cuda_target)
1969
1970   CUDA_ADD_CUDA_INCLUDE_ONCE()
1971
1972   # Separate the sources from the options
1973   CUDA_GET_SOURCES_AND_OPTIONS(_sources _cmake_options _options ${ARGN})
1974   CUDA_BUILD_SHARED_LIBRARY(_cuda_shared_flag ${ARGN})
1975   # Create custom commands and targets for each file.
1976   CUDA_WRAP_SRCS( ${cuda_target} OBJ _generated_files ${_sources}
1977     ${_cmake_options} ${_cuda_shared_flag}
1978     OPTIONS ${_options} )
1979
1980   # Compute the file name of the intermedate link file used for separable
1981   # compilation.
1982   CUDA_COMPUTE_SEPARABLE_COMPILATION_OBJECT_FILE_NAME(link_file ${cuda_target} "${${cuda_target}_SEPARABLE_COMPILATION_OBJECTS}")
1983
1984   # Add the library.
1985   add_library(${cuda_target} ${_cmake_options}
1986     ${_generated_files}
1987     ${_sources}
1988     ${link_file}
1989     )
1990
1991   # Add a link phase for the separable compilation if it has been enabled.  If
1992   # it has been enabled then the ${cuda_target}_SEPARABLE_COMPILATION_OBJECTS
1993   # variable will have been defined.
1994   CUDA_LINK_SEPARABLE_COMPILATION_OBJECTS("${link_file}" ${cuda_target} "${_options}" "${${cuda_target}_SEPARABLE_COMPILATION_OBJECTS}")
1995
1996   target_link_libraries(${cuda_target} ${CUDA_LINK_LIBRARIES_KEYWORD}
1997     ${CUDA_LIBRARIES}
1998     )
1999
2000   if(CUDA_SEPARABLE_COMPILATION)
2001     target_link_libraries(${cuda_target} ${CUDA_LINK_LIBRARIES_KEYWORD}
2002       ${CUDA_cudadevrt_LIBRARY}
2003       )
2004   endif()
2005
2006   # We need to set the linker language based on what the expected generated file
2007   # would be. CUDA_C_OR_CXX is computed based on CUDA_HOST_COMPILATION_CPP.
2008   set_target_properties(${cuda_target}
2009     PROPERTIES
2010     LINKER_LANGUAGE ${CUDA_C_OR_CXX}
2011     )
2012
2013 endmacro()
2014
2015
2016 ###############################################################################
2017 ###############################################################################
2018 # ADD EXECUTABLE
2019 ###############################################################################
2020 ###############################################################################
2021 macro(CUDA_ADD_EXECUTABLE cuda_target)
2022
2023   CUDA_ADD_CUDA_INCLUDE_ONCE()
2024
2025   # Separate the sources from the options
2026   CUDA_GET_SOURCES_AND_OPTIONS(_sources _cmake_options _options ${ARGN})
2027   # Create custom commands and targets for each file.
2028   CUDA_WRAP_SRCS( ${cuda_target} OBJ _generated_files ${_sources} OPTIONS ${_options} )
2029
2030   # Compute the file name of the intermedate link file used for separable
2031   # compilation.
2032   CUDA_COMPUTE_SEPARABLE_COMPILATION_OBJECT_FILE_NAME(link_file ${cuda_target} "${${cuda_target}_SEPARABLE_COMPILATION_OBJECTS}")
2033
2034   # Add the library.
2035   add_executable(${cuda_target} ${_cmake_options}
2036     ${_generated_files}
2037     ${_sources}
2038     ${link_file}
2039     )
2040
2041   # Add a link phase for the separable compilation if it has been enabled.  If
2042   # it has been enabled then the ${cuda_target}_SEPARABLE_COMPILATION_OBJECTS
2043   # variable will have been defined.
2044   CUDA_LINK_SEPARABLE_COMPILATION_OBJECTS("${link_file}" ${cuda_target} "${_options}" "${${cuda_target}_SEPARABLE_COMPILATION_OBJECTS}")
2045
2046   target_link_libraries(${cuda_target} ${CUDA_LINK_LIBRARIES_KEYWORD}
2047     ${CUDA_LIBRARIES}
2048     )
2049
2050   # We need to set the linker language based on what the expected generated file
2051   # would be. CUDA_C_OR_CXX is computed based on CUDA_HOST_COMPILATION_CPP.
2052   set_target_properties(${cuda_target}
2053     PROPERTIES
2054     LINKER_LANGUAGE ${CUDA_C_OR_CXX}
2055     )
2056
2057 endmacro()
2058
2059
2060 ###############################################################################
2061 ###############################################################################
2062 # (Internal) helper for manually added cuda source files with specific targets
2063 ###############################################################################
2064 ###############################################################################
2065 macro(cuda_compile_base cuda_target format generated_files)
2066   # Update a counter in this directory, to keep phony target names unique.
2067   set(_cuda_target "${cuda_target}")
2068   get_property(_counter DIRECTORY PROPERTY _cuda_internal_phony_counter)
2069   if(_counter)
2070     math(EXPR _counter "${_counter} + 1")
2071   else()
2072     set(_counter 1)
2073   endif()
2074   string(APPEND _cuda_target "_${_counter}")
2075   set_property(DIRECTORY PROPERTY _cuda_internal_phony_counter ${_counter})
2076
2077   # Separate the sources from the options
2078   CUDA_GET_SOURCES_AND_OPTIONS(_sources _cmake_options _options ${ARGN})
2079
2080   # Create custom commands and targets for each file.
2081   CUDA_WRAP_SRCS( ${_cuda_target} ${format} _generated_files ${_sources}
2082                   ${_cmake_options} OPTIONS ${_options} PHONY)
2083
2084   set( ${generated_files} ${_generated_files})
2085
2086 endmacro()
2087
2088 ###############################################################################
2089 ###############################################################################
2090 # CUDA COMPILE
2091 ###############################################################################
2092 ###############################################################################
2093 macro(CUDA_COMPILE generated_files)
2094   cuda_compile_base(cuda_compile OBJ ${generated_files} ${ARGN})
2095 endmacro()
2096
2097 ###############################################################################
2098 ###############################################################################
2099 # CUDA COMPILE PTX
2100 ###############################################################################
2101 ###############################################################################
2102 macro(CUDA_COMPILE_PTX generated_files)
2103   cuda_compile_base(cuda_compile_ptx PTX ${generated_files} ${ARGN})
2104 endmacro()
2105
2106 ###############################################################################
2107 ###############################################################################
2108 # CUDA COMPILE FATBIN
2109 ###############################################################################
2110 ###############################################################################
2111 macro(CUDA_COMPILE_FATBIN generated_files)
2112   cuda_compile_base(cuda_compile_fatbin FATBIN ${generated_files} ${ARGN})
2113 endmacro()
2114
2115 ###############################################################################
2116 ###############################################################################
2117 # CUDA COMPILE CUBIN
2118 ###############################################################################
2119 ###############################################################################
2120 macro(CUDA_COMPILE_CUBIN generated_files)
2121   cuda_compile_base(cuda_compile_cubin CUBIN ${generated_files} ${ARGN})
2122 endmacro()
2123
2124
2125 ###############################################################################
2126 ###############################################################################
2127 # CUDA ADD CUFFT TO TARGET
2128 ###############################################################################
2129 ###############################################################################
2130 macro(CUDA_ADD_CUFFT_TO_TARGET target)
2131   if (CUDA_BUILD_EMULATION)
2132     target_link_libraries(${target} ${CUDA_LINK_LIBRARIES_KEYWORD} ${CUDA_cufftemu_LIBRARY})
2133   else()
2134     target_link_libraries(${target} ${CUDA_LINK_LIBRARIES_KEYWORD} ${CUDA_cufft_LIBRARY})
2135   endif()
2136 endmacro()
2137
2138 ###############################################################################
2139 ###############################################################################
2140 # CUDA ADD CUBLAS TO TARGET
2141 ###############################################################################
2142 ###############################################################################
2143 macro(CUDA_ADD_CUBLAS_TO_TARGET target)
2144   if (CUDA_BUILD_EMULATION)
2145     target_link_libraries(${target} ${CUDA_LINK_LIBRARIES_KEYWORD} ${CUDA_cublasemu_LIBRARY})
2146   else()
2147     target_link_libraries(${target} ${CUDA_LINK_LIBRARIES_KEYWORD} ${CUDA_cublas_LIBRARY} ${CUDA_cublas_device_LIBRARY})
2148   endif()
2149 endmacro()
2150
2151 ###############################################################################
2152 ###############################################################################
2153 # CUDA BUILD CLEAN TARGET
2154 ###############################################################################
2155 ###############################################################################
2156 macro(CUDA_BUILD_CLEAN_TARGET)
2157   # Call this after you add all your CUDA targets, and you will get a
2158   # convenience target.  You should also make clean after running this target
2159   # to get the build system to generate all the code again.
2160
2161   set(cuda_clean_target_name clean_cuda_depends)
2162   if (CMAKE_GENERATOR MATCHES "Visual Studio")
2163     string(TOUPPER ${cuda_clean_target_name} cuda_clean_target_name)
2164   endif()
2165   add_custom_target(${cuda_clean_target_name}
2166     COMMAND ${CMAKE_COMMAND} -E rm -f ${CUDA_ADDITIONAL_CLEAN_FILES})
2167
2168   # Clear out the variable, so the next time we configure it will be empty.
2169   # This is useful so that the files won't persist in the list after targets
2170   # have been removed.
2171   set(CUDA_ADDITIONAL_CLEAN_FILES "" CACHE INTERNAL "List of intermediate files that are part of the cuda dependency scanning.")
2172 endmacro()