mirror of
https://github.com/reactos/CMake.git
synced 2024-12-02 00:26:18 +00:00
1b0c77a33d
I was previously appending to nvcc_flags inside the file loop. This caused the flag to be appended multiple times which freaks out nvcc. Now the flag is specifically handled per file.
291 lines
11 KiB
CMake
291 lines
11 KiB
CMake
# James Bigler, NVIDIA Corp (nvidia.com - jbigler)
|
|
#
|
|
# Copyright (c) 2008 - 2009 NVIDIA Corporation. All rights reserved.
|
|
#
|
|
# This code is licensed under the MIT License. See the FindCUDA.cmake script
|
|
# for the text of the license.
|
|
|
|
# The MIT License
|
|
#
|
|
# License for the specific language governing rights and limitations under
|
|
# Permission is hereby granted, free of charge, to any person obtaining a
|
|
# copy of this software and associated documentation files (the "Software"),
|
|
# to deal in the Software without restriction, including without limitation
|
|
# the rights to use, copy, modify, merge, publish, distribute, sublicense,
|
|
# and/or sell copies of the Software, and to permit persons to whom the
|
|
# Software is furnished to do so, subject to the following conditions:
|
|
#
|
|
# The above copyright notice and this permission notice shall be included
|
|
# in all copies or substantial portions of the Software.
|
|
#
|
|
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
|
|
# OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
|
# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
|
|
# THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
|
# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
|
|
# FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
|
|
# DEALINGS IN THE SOFTWARE.
|
|
|
|
|
|
##########################################################################
|
|
# This file runs the nvcc commands to produce the desired output file along with
|
|
# the dependency file needed by CMake to compute dependencies. In addition the
|
|
# file checks the output of each command and if the command fails it deletes the
|
|
# output files.
|
|
|
|
# Input variables
|
|
#
|
|
# verbose:BOOL=<> OFF: Be as quiet as possible (default)
|
|
# ON : Describe each step
|
|
#
|
|
# build_configuration:STRING=<> Typically one of Debug, MinSizeRel, Release, or
|
|
# RelWithDebInfo, but it should match one of the
|
|
# entries in CUDA_HOST_FLAGS. This is the build
|
|
# configuration used when compiling the code. If
|
|
# blank or unspecified Debug is assumed as this is
|
|
# what CMake does.
|
|
#
|
|
# generated_file:STRING=<> File to generate. This argument must be passed in.
|
|
#
|
|
# generated_cubin_file:STRING=<> File to generate. This argument must be passed
|
|
# in if build_cubin is true.
|
|
|
|
if(NOT generated_file)
|
|
message(FATAL_ERROR "You must specify generated_file on the command line")
|
|
endif()
|
|
|
|
# Set these up as variables to make reading the generated file easier
|
|
set(CMAKE_COMMAND "@CMAKE_COMMAND@") # path
|
|
set(source_file "@source_file@") # path
|
|
set(NVCC_generated_dependency_file "@NVCC_generated_dependency_file@") # path
|
|
set(cmake_dependency_file "@cmake_dependency_file@") # path
|
|
set(CUDA_make2cmake "@CUDA_make2cmake@") # path
|
|
set(CUDA_parse_cubin "@CUDA_parse_cubin@") # path
|
|
set(build_cubin @build_cubin@) # bool
|
|
set(CUDA_HOST_COMPILER "@CUDA_HOST_COMPILER@") # path
|
|
# We won't actually use these variables for now, but we need to set this, in
|
|
# order to force this file to be run again if it changes.
|
|
set(generated_file_path "@generated_file_path@") # path
|
|
set(generated_file_internal "@generated_file@") # path
|
|
set(generated_cubin_file_internal "@generated_cubin_file@") # path
|
|
|
|
set(CUDA_NVCC_EXECUTABLE "@CUDA_NVCC_EXECUTABLE@") # path
|
|
set(CUDA_NVCC_FLAGS @CUDA_NVCC_FLAGS@ ;; @CUDA_WRAP_OPTION_NVCC_FLAGS@) # list
|
|
@CUDA_NVCC_FLAGS_CONFIG@
|
|
set(nvcc_flags @nvcc_flags@) # list
|
|
set(CUDA_NVCC_INCLUDE_ARGS "@CUDA_NVCC_INCLUDE_ARGS@") # list (needs to be in quotes to handle spaces properly).
|
|
set(format_flag "@format_flag@") # string
|
|
set(cuda_language_flag @cuda_language_flag@) # list
|
|
|
|
if(build_cubin AND NOT generated_cubin_file)
|
|
message(FATAL_ERROR "You must specify generated_cubin_file on the command line")
|
|
endif()
|
|
|
|
# This is the list of host compilation flags. It C or CXX should already have
|
|
# been chosen by FindCUDA.cmake.
|
|
@CUDA_HOST_FLAGS@
|
|
|
|
# Take the compiler flags and package them up to be sent to the compiler via -Xcompiler
|
|
set(nvcc_host_compiler_flags "")
|
|
# If we weren't given a build_configuration, use Debug.
|
|
if(NOT build_configuration)
|
|
set(build_configuration Debug)
|
|
endif()
|
|
string(TOUPPER "${build_configuration}" build_configuration)
|
|
#message("CUDA_NVCC_HOST_COMPILER_FLAGS = ${CUDA_NVCC_HOST_COMPILER_FLAGS}")
|
|
foreach(flag ${CMAKE_HOST_FLAGS} ${CMAKE_HOST_FLAGS_${build_configuration}})
|
|
# Extra quotes are added around each flag to help nvcc parse out flags with spaces.
|
|
set(nvcc_host_compiler_flags "${nvcc_host_compiler_flags},\"${flag}\"")
|
|
endforeach()
|
|
if (nvcc_host_compiler_flags)
|
|
set(nvcc_host_compiler_flags "-Xcompiler" ${nvcc_host_compiler_flags})
|
|
endif()
|
|
#message("nvcc_host_compiler_flags = \"${nvcc_host_compiler_flags}\"")
|
|
# Add the build specific configuration flags
|
|
list(APPEND CUDA_NVCC_FLAGS ${CUDA_NVCC_FLAGS_${build_configuration}})
|
|
|
|
# Any -ccbin existing in CUDA_NVCC_FLAGS gets highest priority
|
|
list( FIND CUDA_NVCC_FLAGS "-ccbin" ccbin_found0 )
|
|
list( FIND CUDA_NVCC_FLAGS "--compiler-bindir" ccbin_found1 )
|
|
if( ccbin_found0 LESS 0 AND ccbin_found1 LESS 0 AND CUDA_HOST_COMPILER )
|
|
if (CUDA_HOST_COMPILER STREQUAL "$(VCInstallDir)bin" AND DEFINED CCBIN)
|
|
set(CCBIN -ccbin "${CCBIN}")
|
|
else()
|
|
set(CCBIN -ccbin "${CUDA_HOST_COMPILER}")
|
|
endif()
|
|
endif()
|
|
|
|
# cuda_execute_process - Executes a command with optional command echo and status message.
|
|
#
|
|
# status - Status message to print if verbose is true
|
|
# command - COMMAND argument from the usual execute_process argument structure
|
|
# ARGN - Remaining arguments are the command with arguments
|
|
#
|
|
# CUDA_result - return value from running the command
|
|
#
|
|
# Make this a macro instead of a function, so that things like RESULT_VARIABLE
|
|
# and other return variables are present after executing the process.
|
|
macro(cuda_execute_process status command)
|
|
set(_command ${command})
|
|
if(NOT "x${_command}" STREQUAL "xCOMMAND")
|
|
message(FATAL_ERROR "Malformed call to cuda_execute_process. Missing COMMAND as second argument. (command = ${command})")
|
|
endif()
|
|
if(verbose)
|
|
execute_process(COMMAND "${CMAKE_COMMAND}" -E echo -- ${status})
|
|
# Now we need to build up our command string. We are accounting for quotes
|
|
# and spaces, anything else is left up to the user to fix if they want to
|
|
# copy and paste a runnable command line.
|
|
set(cuda_execute_process_string)
|
|
foreach(arg ${ARGN})
|
|
# If there are quotes, excape them, so they come through.
|
|
string(REPLACE "\"" "\\\"" arg ${arg})
|
|
# Args with spaces need quotes around them to get them to be parsed as a single argument.
|
|
if(arg MATCHES " ")
|
|
list(APPEND cuda_execute_process_string "\"${arg}\"")
|
|
else()
|
|
list(APPEND cuda_execute_process_string ${arg})
|
|
endif()
|
|
endforeach()
|
|
# Echo the command
|
|
execute_process(COMMAND ${CMAKE_COMMAND} -E echo ${cuda_execute_process_string})
|
|
endif()
|
|
# Run the command
|
|
execute_process(COMMAND ${ARGN} RESULT_VARIABLE CUDA_result )
|
|
endmacro()
|
|
|
|
# Delete the target file
|
|
cuda_execute_process(
|
|
"Removing ${generated_file}"
|
|
COMMAND "${CMAKE_COMMAND}" -E remove "${generated_file}"
|
|
)
|
|
|
|
# For CUDA 2.3 and below, -G -M doesn't work, so remove the -G flag
|
|
# for dependency generation and hope for the best.
|
|
set(depends_CUDA_NVCC_FLAGS "${CUDA_NVCC_FLAGS}")
|
|
set(CUDA_VERSION @CUDA_VERSION@)
|
|
if(CUDA_VERSION VERSION_LESS "3.0")
|
|
cmake_policy(PUSH)
|
|
# CMake policy 0007 NEW states that empty list elements are not
|
|
# ignored. I'm just setting it to avoid the warning that's printed.
|
|
cmake_policy(SET CMP0007 NEW)
|
|
# Note that this will remove all occurances of -G.
|
|
list(REMOVE_ITEM depends_CUDA_NVCC_FLAGS "-G")
|
|
cmake_policy(POP)
|
|
endif()
|
|
|
|
# nvcc doesn't define __CUDACC__ for some reason when generating dependency files. This
|
|
# can cause incorrect dependencies when #including files based on this macro which is
|
|
# defined in the generating passes of nvcc invokation. We will go ahead and manually
|
|
# define this for now until a future version fixes this bug.
|
|
set(CUDACC_DEFINE -D__CUDACC__)
|
|
|
|
# Generate the dependency file
|
|
cuda_execute_process(
|
|
"Generating dependency file: ${NVCC_generated_dependency_file}"
|
|
COMMAND "${CUDA_NVCC_EXECUTABLE}"
|
|
-M
|
|
${CUDACC_DEFINE}
|
|
"${source_file}"
|
|
-o "${NVCC_generated_dependency_file}"
|
|
${CCBIN}
|
|
${nvcc_flags}
|
|
${nvcc_host_compiler_flags}
|
|
${depends_CUDA_NVCC_FLAGS}
|
|
-DNVCC
|
|
${CUDA_NVCC_INCLUDE_ARGS}
|
|
)
|
|
|
|
if(CUDA_result)
|
|
message(FATAL_ERROR "Error generating ${generated_file}")
|
|
endif()
|
|
|
|
# Generate the cmake readable dependency file to a temp file. Don't put the
|
|
# quotes just around the filenames for the input_file and output_file variables.
|
|
# CMake will pass the quotes through and not be able to find the file.
|
|
cuda_execute_process(
|
|
"Generating temporary cmake readable file: ${cmake_dependency_file}.tmp"
|
|
COMMAND "${CMAKE_COMMAND}"
|
|
-D "input_file:FILEPATH=${NVCC_generated_dependency_file}"
|
|
-D "output_file:FILEPATH=${cmake_dependency_file}.tmp"
|
|
-P "${CUDA_make2cmake}"
|
|
)
|
|
|
|
if(CUDA_result)
|
|
message(FATAL_ERROR "Error generating ${generated_file}")
|
|
endif()
|
|
|
|
# Copy the file if it is different
|
|
cuda_execute_process(
|
|
"Copy if different ${cmake_dependency_file}.tmp to ${cmake_dependency_file}"
|
|
COMMAND "${CMAKE_COMMAND}" -E copy_if_different "${cmake_dependency_file}.tmp" "${cmake_dependency_file}"
|
|
)
|
|
|
|
if(CUDA_result)
|
|
message(FATAL_ERROR "Error generating ${generated_file}")
|
|
endif()
|
|
|
|
# Delete the temporary file
|
|
cuda_execute_process(
|
|
"Removing ${cmake_dependency_file}.tmp and ${NVCC_generated_dependency_file}"
|
|
COMMAND "${CMAKE_COMMAND}" -E remove "${cmake_dependency_file}.tmp" "${NVCC_generated_dependency_file}"
|
|
)
|
|
|
|
if(CUDA_result)
|
|
message(FATAL_ERROR "Error generating ${generated_file}")
|
|
endif()
|
|
|
|
# Generate the code
|
|
cuda_execute_process(
|
|
"Generating ${generated_file}"
|
|
COMMAND "${CUDA_NVCC_EXECUTABLE}"
|
|
"${source_file}"
|
|
${cuda_language_flag}
|
|
${format_flag} -o "${generated_file}"
|
|
${CCBIN}
|
|
${nvcc_flags}
|
|
${nvcc_host_compiler_flags}
|
|
${CUDA_NVCC_FLAGS}
|
|
-DNVCC
|
|
${CUDA_NVCC_INCLUDE_ARGS}
|
|
)
|
|
|
|
if(CUDA_result)
|
|
# Since nvcc can sometimes leave half done files make sure that we delete the output file.
|
|
cuda_execute_process(
|
|
"Removing ${generated_file}"
|
|
COMMAND "${CMAKE_COMMAND}" -E remove "${generated_file}"
|
|
)
|
|
message(FATAL_ERROR "Error generating file ${generated_file}")
|
|
else()
|
|
if(verbose)
|
|
message("Generated ${generated_file} successfully.")
|
|
endif()
|
|
endif()
|
|
|
|
# Cubin resource report commands.
|
|
if( build_cubin )
|
|
# Run with -cubin to produce resource usage report.
|
|
cuda_execute_process(
|
|
"Generating ${generated_cubin_file}"
|
|
COMMAND "${CUDA_NVCC_EXECUTABLE}"
|
|
"${source_file}"
|
|
${CUDA_NVCC_FLAGS}
|
|
${nvcc_flags}
|
|
${CCBIN}
|
|
${nvcc_host_compiler_flags}
|
|
-DNVCC
|
|
-cubin
|
|
-o "${generated_cubin_file}"
|
|
${CUDA_NVCC_INCLUDE_ARGS}
|
|
)
|
|
|
|
# Execute the parser script.
|
|
cuda_execute_process(
|
|
"Executing the parser script"
|
|
COMMAND "${CMAKE_COMMAND}"
|
|
-D "input_file:STRING=${generated_cubin_file}"
|
|
-P "${CUDA_parse_cubin}"
|
|
)
|
|
|
|
endif()
|