1# James Bigler, NVIDIA Corp (nvidia.com - jbigler) 2# 3# Copyright (c) 2008 - 2009 NVIDIA Corporation. All rights reserved. 4# 5# This code is licensed under the MIT License. See the FindCUDA.cmake script 6# for the text of the license. 7 8# The MIT License 9# 10# License for the specific language governing rights and limitations under 11# Permission is hereby granted, free of charge, to any person obtaining a 12# copy of this software and associated documentation files (the "Software"), 13# to deal in the Software without restriction, including without limitation 14# the rights to use, copy, modify, merge, publish, distribute, sublicense, 15# and/or sell copies of the Software, and to permit persons to whom the 16# Software is furnished to do so, subject to the following conditions: 17# 18# The above copyright notice and this permission notice shall be included 19# in all copies or substantial portions of the Software. 20# 21# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS 22# OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 23# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL 24# THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 25# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING 26# FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER 27# DEALINGS IN THE SOFTWARE. 28 29 30########################################################################## 31# This file runs the nvcc commands to produce the desired output file along with 32# the dependency file needed by CMake to compute dependencies. In addition the 33# file checks the output of each command and if the command fails it deletes the 34# output files. 35 36# Input variables 37# 38# verbose:BOOL=<> OFF: Be as quiet as possible (default) 39# ON : Describe each step 40# 41# build_configuration:STRING=<> Typically one of Debug, MinSizeRel, Release, or 42# RelWithDebInfo, but it should match one of the 43# entries in CUDA_HOST_FLAGS. This is the build 44# configuration used when compiling the code. If 45# blank or unspecified Debug is assumed as this is 46# what CMake does. 47# 48# generated_file:STRING=<> File to generate. This argument must be passed in. 49# 50# generated_cubin_file:STRING=<> File to generate. This argument must be passed 51# in if build_cubin is true. 52 53if(NOT generated_file) 54 message(FATAL_ERROR "You must specify generated_file on the command line") 55endif() 56 57# Set these up as variables to make reading the generated file easier 58set(CMAKE_COMMAND "@CMAKE_COMMAND@") 59set(source_file "@source_file@") 60set(NVCC_generated_dependency_file "@NVCC_generated_dependency_file@") 61set(cmake_dependency_file "@cmake_dependency_file@") 62set(CUDA_make2cmake "@CUDA_make2cmake@") 63set(CUDA_parse_cubin "@CUDA_parse_cubin@") 64set(build_cubin @build_cubin@) 65# We won't actually use these variables for now, but we need to set this, in 66# order to force this file to be run again if it changes. 67set(generated_file_path "@generated_file_path@") 68set(generated_file_internal "@generated_file@") 69set(generated_cubin_file_internal "@generated_cubin_file@") 70 71set(CUDA_NVCC_EXECUTABLE "@CUDA_NVCC_EXECUTABLE@") 72set(CUDA_NVCC_FLAGS "@CUDA_NVCC_FLAGS@;;@CUDA_WRAP_OPTION_NVCC_FLAGS@") 73@CUDA_NVCC_FLAGS_CONFIG@ 74set(nvcc_flags "@nvcc_flags@") 75set(CUDA_NVCC_INCLUDE_ARGS "@CUDA_NVCC_INCLUDE_ARGS@") 76set(format_flag "@format_flag@") 77 78if(build_cubin AND NOT generated_cubin_file) 79 message(FATAL_ERROR "You must specify generated_cubin_file on the command line") 80endif() 81 82# This is the list of host compilation flags. It C or CXX should already have 83# been chosen by FindCUDA.cmake. 84@CUDA_HOST_FLAGS@ 85 86# Take the compiler flags and package them up to be sent to the compiler via -Xcompiler 87set(nvcc_host_compiler_flags "") 88# If we weren't given a build_configuration, use Debug. 89if(NOT build_configuration) 90 set(build_configuration Debug) 91endif() 92string(TOUPPER "${build_configuration}" build_configuration) 93#message("CUDA_NVCC_HOST_COMPILER_FLAGS = ${CUDA_NVCC_HOST_COMPILER_FLAGS}") 94foreach(flag ${CMAKE_HOST_FLAGS} ${CMAKE_HOST_FLAGS_${build_configuration}}) 95 # Extra quotes are added around each flag to help nvcc parse out flags with spaces. 96 set(nvcc_host_compiler_flags "${nvcc_host_compiler_flags},\"${flag}\"") 97endforeach() 98if (nvcc_host_compiler_flags) 99 set(nvcc_host_compiler_flags "-Xcompiler" ${nvcc_host_compiler_flags}) 100endif() 101#message("nvcc_host_compiler_flags = \"${nvcc_host_compiler_flags}\"") 102# Add the build specific configuration flags 103list(APPEND CUDA_NVCC_FLAGS ${CUDA_NVCC_FLAGS_${build_configuration}}) 104 105if(DEFINED CCBIN) 106 set(CCBIN -ccbin "${CCBIN}") 107endif() 108 109# cuda_execute_process - Executes a command with optional command echo and status message. 110# 111# status - Status message to print if verbose is true 112# command - COMMAND argument from the usual execute_process argument structure 113# ARGN - Remaining arguments are the command with arguments 114# 115# CUDA_result - return value from running the command 116# 117# Make this a macro instead of a function, so that things like RESULT_VARIABLE 118# and other return variables are present after executing the process. 119macro(cuda_execute_process status command) 120 set(_command ${command}) 121 if(NOT _command STREQUAL "COMMAND") 122 message(FATAL_ERROR "Malformed call to cuda_execute_process. Missing COMMAND as second argument. (command = ${command})") 123 endif() 124 if(verbose) 125 execute_process(COMMAND "${CMAKE_COMMAND}" -E echo -- ${status}) 126 # Now we need to build up our command string. We are accounting for quotes 127 # and spaces, anything else is left up to the user to fix if they want to 128 # copy and paste a runnable command line. 129 set(cuda_execute_process_string) 130 foreach(arg ${ARGN}) 131 # If there are quotes, excape them, so they come through. 132 string(REPLACE "\"" "\\\"" arg ${arg}) 133 # Args with spaces need quotes around them to get them to be parsed as a single argument. 134 if(arg MATCHES " ") 135 list(APPEND cuda_execute_process_string "\"${arg}\"") 136 else() 137 list(APPEND cuda_execute_process_string ${arg}) 138 endif() 139 endforeach() 140 # Echo the command 141 execute_process(COMMAND ${CMAKE_COMMAND} -E echo ${cuda_execute_process_string}) 142 endif(verbose) 143 # Run the command 144 execute_process(COMMAND ${ARGN} RESULT_VARIABLE CUDA_result ) 145endmacro() 146 147# Delete the target file 148cuda_execute_process( 149 "Removing ${generated_file}" 150 COMMAND "${CMAKE_COMMAND}" -E remove "${generated_file}" 151 ) 152 153# For CUDA 2.3 and below, -G -M doesn't work, so remove the -G flag 154# for dependency generation and hope for the best. 155set(depends_CUDA_NVCC_FLAGS "${CUDA_NVCC_FLAGS}") 156set(CUDA_VERSION @CUDA_VERSION@) 157if(CUDA_VERSION VERSION_LESS "3.0") 158 cmake_policy(PUSH) 159 # CMake policy 0007 NEW states that empty list elements are not 160 # ignored. I'm just setting it to avoid the warning that's printed. 161 cmake_policy(SET CMP0007 NEW) 162 # Note that this will remove all occurances of -G. 163 list(REMOVE_ITEM depends_CUDA_NVCC_FLAGS "-G") 164 cmake_policy(POP) 165endif() 166 167# nvcc doesn't define __CUDACC__ for some reason when generating dependency files. This 168# can cause incorrect dependencies when #including files based on this macro which is 169# defined in the generating passes of nvcc invokation. We will go ahead and manually 170# define this for now until a future version fixes this bug. 171set(CUDACC_DEFINE -D__CUDACC__) 172 173# Generate the dependency file 174cuda_execute_process( 175 "Generating dependency file: ${NVCC_generated_dependency_file}" 176 COMMAND "${CUDA_NVCC_EXECUTABLE}" 177 -M 178 ${CUDACC_DEFINE} 179 "${source_file}" 180 -o "${NVCC_generated_dependency_file}" 181 ${CCBIN} 182 ${nvcc_flags} 183 ${nvcc_host_compiler_flags} 184 ${depends_CUDA_NVCC_FLAGS} 185 -DNVCC 186 ${CUDA_NVCC_INCLUDE_ARGS} 187 ) 188 189if(CUDA_result) 190 message(FATAL_ERROR "Error generating ${generated_file}") 191endif() 192 193# Generate the cmake readable dependency file to a temp file. Don't put the 194# quotes just around the filenames for the input_file and output_file variables. 195# CMake will pass the quotes through and not be able to find the file. 196cuda_execute_process( 197 "Generating temporary cmake readable file: ${cmake_dependency_file}.tmp" 198 COMMAND "${CMAKE_COMMAND}" 199 -D "input_file:FILEPATH=${NVCC_generated_dependency_file}" 200 -D "output_file:FILEPATH=${cmake_dependency_file}.tmp" 201 -P "${CUDA_make2cmake}" 202 ) 203 204if(CUDA_result) 205 message(FATAL_ERROR "Error generating ${generated_file}") 206endif() 207 208# Copy the file if it is different 209cuda_execute_process( 210 "Copy if different ${cmake_dependency_file}.tmp to ${cmake_dependency_file}" 211 COMMAND "${CMAKE_COMMAND}" -E copy_if_different "${cmake_dependency_file}.tmp" "${cmake_dependency_file}" 212 ) 213 214if(CUDA_result) 215 message(FATAL_ERROR "Error generating ${generated_file}") 216endif() 217 218# Delete the temporary file 219cuda_execute_process( 220 "Removing ${cmake_dependency_file}.tmp and ${NVCC_generated_dependency_file}" 221 COMMAND "${CMAKE_COMMAND}" -E remove "${cmake_dependency_file}.tmp" "${NVCC_generated_dependency_file}" 222 ) 223 224if(CUDA_result) 225 message(FATAL_ERROR "Error generating ${generated_file}") 226endif() 227 228# Generate the code 229cuda_execute_process( 230 "Generating ${generated_file}" 231 COMMAND "${CUDA_NVCC_EXECUTABLE}" 232 "${source_file}" 233 ${format_flag} -o "${generated_file}" 234 ${CCBIN} 235 ${nvcc_flags} 236 ${nvcc_host_compiler_flags} 237 ${CUDA_NVCC_FLAGS} 238 -DNVCC 239 ${CUDA_NVCC_INCLUDE_ARGS} 240 ) 241 242if(CUDA_result) 243 # Since nvcc can sometimes leave half done files make sure that we delete the output file. 244 cuda_execute_process( 245 "Removing ${generated_file}" 246 COMMAND "${CMAKE_COMMAND}" -E remove "${generated_file}" 247 ) 248 message(FATAL_ERROR "Error generating file ${generated_file}") 249else() 250 if(verbose) 251 message("Generated ${generated_file} successfully.") 252 endif() 253endif() 254 255# Cubin resource report commands. 256if( build_cubin ) 257 # Run with -cubin to produce resource usage report. 258 cuda_execute_process( 259 "Generating ${generated_cubin_file}" 260 COMMAND "${CUDA_NVCC_EXECUTABLE}" 261 "${source_file}" 262 ${CUDA_NVCC_FLAGS} 263 ${nvcc_flags} 264 ${CCBIN} 265 ${nvcc_host_compiler_flags} 266 -DNVCC 267 -cubin 268 -o "${generated_cubin_file}" 269 ${CUDA_NVCC_INCLUDE_ARGS} 270 ) 271 272 # Execute the parser script. 273 cuda_execute_process( 274 "Executing the parser script" 275 COMMAND "${CMAKE_COMMAND}" 276 -D "input_file:STRING=${generated_cubin_file}" 277 -P "${CUDA_parse_cubin}" 278 ) 279 280endif( build_cubin ) 281