1# Distributed under the OSI-approved BSD 3-Clause License. See accompanying 2# file Copyright.txt or https://cmake.org/licensing for details. 3 4macro(__determine_compiler_id_test testflags_var userflags_var) 5 separate_arguments(testflags UNIX_COMMAND "${${testflags_var}}") 6 CMAKE_DETERMINE_COMPILER_ID_BUILD("${lang}" "${testflags}" "${${userflags_var}}" "${src}") 7 CMAKE_DETERMINE_COMPILER_ID_MATCH_VENDOR("${lang}" "${COMPILER_${lang}_PRODUCED_OUTPUT}") 8 9 if(NOT CMAKE_${lang}_COMPILER_ID) 10 foreach(file ${COMPILER_${lang}_PRODUCED_FILES}) 11 CMAKE_DETERMINE_COMPILER_ID_CHECK("${lang}" "${CMAKE_${lang}_COMPILER_ID_DIR}/${file}" "${src}") 12 endforeach() 13 endif() 14endmacro() 15 16# Function to compile a source file to identify the compiler. This is 17# used internally by CMake and should not be included by user code. 18# If successful, sets CMAKE_<lang>_COMPILER_ID and CMAKE_<lang>_PLATFORM_ID 19 20function(CMAKE_DETERMINE_COMPILER_ID lang flagvar src) 21 # Make sure the compiler arguments are clean. 22 string(STRIP "${CMAKE_${lang}_COMPILER_ARG1}" CMAKE_${lang}_COMPILER_ID_ARG1) 23 string(REGEX REPLACE " +" ";" CMAKE_${lang}_COMPILER_ID_ARG1 "${CMAKE_${lang}_COMPILER_ID_ARG1}") 24 25 # Make sure user-specified compiler flags are used. 26 if(CMAKE_${lang}_FLAGS) 27 set(CMAKE_${lang}_COMPILER_ID_FLAGS ${CMAKE_${lang}_FLAGS}) 28 elseif(DEFINED ENV{${flagvar}}) 29 set(CMAKE_${lang}_COMPILER_ID_FLAGS $ENV{${flagvar}}) 30 else(CMAKE_${lang}_FLAGS_INIT) 31 set(CMAKE_${lang}_COMPILER_ID_FLAGS ${CMAKE_${lang}_FLAGS_INIT}) 32 endif() 33 string(REPLACE " " ";" CMAKE_${lang}_COMPILER_ID_FLAGS_LIST "${CMAKE_${lang}_COMPILER_ID_FLAGS}") 34 35 # Compute the directory in which to run the test. 36 set(CMAKE_${lang}_COMPILER_ID_DIR ${CMAKE_PLATFORM_INFO_DIR}/CompilerId${lang}) 37 38 # If we REQUIRE_SUCCESS, i.e. TEST_FLAGS_FIRST has the correct flags, we still need to 39 # try two combinations: with COMPILER_ID_FLAGS (from user) and without (see issue #21869). 40 if(CMAKE_${lang}_COMPILER_ID_REQUIRE_SUCCESS) 41 # If there COMPILER_ID_FLAGS is empty we can error for the first invocation. 42 if("${CMAKE_${lang}_COMPILER_ID_FLAGS_LIST}" STREQUAL "") 43 set(__compiler_id_require_success TRUE) 44 endif() 45 46 foreach(userflags "${CMAKE_${lang}_COMPILER_ID_FLAGS_LIST}" "") 47 set(testflags "${CMAKE_${lang}_COMPILER_ID_TEST_FLAGS_FIRST}") 48 __determine_compiler_id_test(testflags userflags) 49 if(CMAKE_${lang}_COMPILER_ID) 50 break() 51 endif() 52 set(__compiler_id_require_success TRUE) 53 endforeach() 54 else() 55 # Try building with no extra flags and then try each set 56 # of helper flags. Stop when the compiler is identified. 57 foreach(userflags "${CMAKE_${lang}_COMPILER_ID_FLAGS_LIST}" "") 58 foreach(testflags ${CMAKE_${lang}_COMPILER_ID_TEST_FLAGS_FIRST} "" ${CMAKE_${lang}_COMPILER_ID_TEST_FLAGS}) 59 __determine_compiler_id_test(testflags userflags) 60 if(CMAKE_${lang}_COMPILER_ID) 61 break() 62 endif() 63 endforeach() 64 if(CMAKE_${lang}_COMPILER_ID) 65 break() 66 endif() 67 endforeach() 68 endif() 69 70 # Check if compiler id detection gave us the compiler tool. 71 if(CMAKE_${lang}_COMPILER_ID_TOOL) 72 set(CMAKE_${lang}_COMPILER "${CMAKE_${lang}_COMPILER_ID_TOOL}") 73 set(CMAKE_${lang}_COMPILER "${CMAKE_${lang}_COMPILER_ID_TOOL}" PARENT_SCOPE) 74 elseif(NOT CMAKE_${lang}_COMPILER) 75 set(CMAKE_${lang}_COMPILER "CMAKE_${lang}_COMPILER-NOTFOUND" PARENT_SCOPE) 76 endif() 77 78 # If the compiler is still unknown, try to query its vendor. 79 if(CMAKE_${lang}_COMPILER AND NOT CMAKE_${lang}_COMPILER_ID) 80 foreach(userflags "${CMAKE_${lang}_COMPILER_ID_FLAGS_LIST}" "") 81 CMAKE_DETERMINE_COMPILER_ID_VENDOR(${lang} "${userflags}") 82 endforeach() 83 endif() 84 85 # If the compiler is still unknown, fallback to GHS 86 if(NOT CMAKE_${lang}_COMPILER_ID AND "${CMAKE_GENERATOR}" MATCHES "Green Hills MULTI") 87 set(CMAKE_${lang}_COMPILER_ID GHS) 88 file(APPEND ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeOutput.log 89 "The ${lang} compiler identification is falling back to GHS.\n\n") 90 endif() 91 92 # CUDA < 7.5 is missing version macros 93 if(lang STREQUAL "CUDA" 94 AND CMAKE_${lang}_COMPILER_ID STREQUAL "NVIDIA" 95 AND NOT CMAKE_${lang}_COMPILER_VERSION) 96 execute_process( 97 COMMAND "${CMAKE_${lang}_COMPILER}" 98 --version 99 OUTPUT_VARIABLE output ERROR_VARIABLE output 100 RESULT_VARIABLE result 101 TIMEOUT 10 102 ) 103 if(output MATCHES [=[ V([0-9]+)\.([0-9]+)\.([0-9]+)]=]) 104 set(CMAKE_${lang}_COMPILER_VERSION "${CMAKE_MATCH_1}.${CMAKE_MATCH_2}.${CMAKE_MATCH_3}") 105 endif() 106 endif() 107 108 # For Swift we need to explicitly query the version. 109 if(lang STREQUAL "Swift" 110 AND CMAKE_${lang}_COMPILER 111 AND NOT CMAKE_${lang}_COMPILER_VERSION) 112 execute_process( 113 COMMAND "${CMAKE_${lang}_COMPILER}" 114 -version 115 OUTPUT_VARIABLE output ERROR_VARIABLE output 116 RESULT_VARIABLE result 117 TIMEOUT 10 118 ) 119 file(APPEND ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeOutput.log 120 "Running the ${lang} compiler: \"${CMAKE_${lang}_COMPILER}\" -version\n" 121 "${output}\n" 122 ) 123 124 if(output MATCHES [[Swift version ([0-9]+\.[0-9]+(\.[0-9]+)?)]]) 125 set(CMAKE_${lang}_COMPILER_VERSION "${CMAKE_MATCH_1}") 126 if(NOT CMAKE_${lang}_COMPILER_ID) 127 set(CMAKE_Swift_COMPILER_ID "Apple") 128 endif() 129 endif() 130 endif() 131 132 # For ISPC we need to explicitly query the version. 133 if(lang STREQUAL "ISPC" 134 AND CMAKE_${lang}_COMPILER 135 AND NOT CMAKE_${lang}_COMPILER_VERSION) 136 execute_process( 137 COMMAND "${CMAKE_${lang}_COMPILER}" 138 --version 139 OUTPUT_VARIABLE output ERROR_VARIABLE output 140 RESULT_VARIABLE result 141 TIMEOUT 10 142 ) 143 file(APPEND ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeOutput.log 144 "Running the ${lang} compiler: \"${CMAKE_${lang}_COMPILER}\" -version\n" 145 "${output}\n" 146 ) 147 148 if(output MATCHES [[ISPC\), ([0-9]+\.[0-9]+(\.[0-9]+)?)]]) 149 set(CMAKE_${lang}_COMPILER_VERSION "${CMAKE_MATCH_1}") 150 endif() 151 endif() 152 153 if (COMPILER_QNXNTO AND CMAKE_${lang}_COMPILER_ID STREQUAL "GNU") 154 execute_process( 155 COMMAND "${CMAKE_${lang}_COMPILER}" 156 -V 157 OUTPUT_VARIABLE output ERROR_VARIABLE output 158 RESULT_VARIABLE result 159 TIMEOUT 10 160 ) 161 if (output MATCHES "targets available") 162 set(CMAKE_${lang}_COMPILER_ID QCC) 163 # http://community.qnx.com/sf/discussion/do/listPosts/projects.community/discussion.qnx_momentics_community_support.topc3555?_pagenum=2 164 # The qcc driver does not itself have a version. 165 endif() 166 endif() 167 168 # The Fujitsu compiler does not always convey version information through 169 # preprocessor symbols so we extract through command line info 170 if (CMAKE_${lang}_COMPILER_ID STREQUAL "Fujitsu") 171 if(NOT CMAKE_${lang}_COMPILER_VERSION) 172 execute_process( 173 COMMAND "${CMAKE_${lang}_COMPILER}" -V 174 OUTPUT_VARIABLE output 175 ERROR_VARIABLE output 176 RESULT_VARIABLE result 177 TIMEOUT 10 178 ) 179 if (result EQUAL 0) 180 if (output MATCHES [[Fujitsu [^ ]* Compiler ([0-9]+\.[0-9]+\.[0-9]+)]]) 181 set(CMAKE_${lang}_COMPILER_VERSION "${CMAKE_MATCH_1}") 182 endif() 183 endif() 184 endif() 185 endif() 186 187 # if the format is unknown after all files have been checked, put "Unknown" in the cache 188 if(NOT CMAKE_EXECUTABLE_FORMAT) 189 set(CMAKE_EXECUTABLE_FORMAT "Unknown" CACHE INTERNAL "Executable file format") 190 endif() 191 192 if((CMAKE_GENERATOR MATCHES "^Ninja" 193 OR ((NOT DEFINED CMAKE_DEPENDS_USE_COMPILER OR CMAKE_DEPENDS_USE_COMPILER) 194 AND CMAKE_GENERATOR MATCHES "Makefiles|WMake")) 195 AND MSVC_${lang}_ARCHITECTURE_ID) 196 foreach(userflags "${CMAKE_${lang}_COMPILER_ID_FLAGS_LIST}" "") 197 CMAKE_DETERMINE_MSVC_SHOWINCLUDES_PREFIX(${lang} "${userflags}") 198 endforeach() 199 else() 200 set(CMAKE_${lang}_CL_SHOWINCLUDES_PREFIX "") 201 endif() 202 203 set(_variant "") 204 if("x${CMAKE_${lang}_COMPILER_ID}" STREQUAL "xClang" 205 OR "x${CMAKE_${lang}_COMPILER_ID}" STREQUAL "xIntelLLVM") 206 if("x${CMAKE_${lang}_SIMULATE_ID}" STREQUAL "xMSVC") 207 if(CMAKE_GENERATOR MATCHES "Visual Studio") 208 set(CMAKE_${lang}_COMPILER_FRONTEND_VARIANT "MSVC") 209 else() 210 # Test whether an MSVC-like command-line option works. 211 execute_process(COMMAND "${CMAKE_${lang}_COMPILER}" -? 212 RESULT_VARIABLE _clang_result 213 OUTPUT_VARIABLE _clang_stdout 214 ERROR_VARIABLE _clang_stderr) 215 if(_clang_result EQUAL 0) 216 set(CMAKE_${lang}_COMPILER_FRONTEND_VARIANT "MSVC") 217 else() 218 set(CMAKE_${lang}_COMPILER_FRONTEND_VARIANT "GNU") 219 endif() 220 endif() 221 set(_variant " with ${CMAKE_${lang}_COMPILER_FRONTEND_VARIANT}-like command-line") 222 else() 223 set(CMAKE_${lang}_COMPILER_FRONTEND_VARIANT "GNU") 224 endif() 225 elseif("x${CMAKE_${lang}_COMPILER_ID}" STREQUAL "xFujitsuClang") 226 set(CMAKE_${lang}_COMPILER_FRONTEND_VARIANT "GNU") 227 else() 228 set(CMAKE_${lang}_COMPILER_FRONTEND_VARIANT "") 229 endif() 230 231 # Display the final identification result. 232 if(CMAKE_${lang}_COMPILER_ID) 233 if(CMAKE_${lang}_COMPILER_VERSION) 234 set(_version " ${CMAKE_${lang}_COMPILER_VERSION}") 235 else() 236 set(_version "") 237 endif() 238 if(CMAKE_${lang}_COMPILER_ARCHITECTURE_ID AND "x${CMAKE_${lang}_COMPILER_ID}" STREQUAL "xIAR") 239 set(_archid " ${CMAKE_${lang}_COMPILER_ARCHITECTURE_ID}") 240 else() 241 set(_archid "") 242 endif() 243 message(STATUS "The ${lang} compiler identification is " 244 "${CMAKE_${lang}_COMPILER_ID}${_archid}${_version}${_variant}") 245 unset(_archid) 246 unset(_version) 247 unset(_variant) 248 else() 249 message(STATUS "The ${lang} compiler identification is unknown") 250 endif() 251 252 if(lang STREQUAL "Fortran" AND CMAKE_${lang}_COMPILER_ID STREQUAL "XL") 253 set(CMAKE_${lang}_XL_CPP "${CMAKE_${lang}_COMPILER_ID_CPP}" PARENT_SCOPE) 254 endif() 255 256 set(CMAKE_${lang}_COMPILER_ID "${CMAKE_${lang}_COMPILER_ID}" PARENT_SCOPE) 257 set(CMAKE_${lang}_PLATFORM_ID "${CMAKE_${lang}_PLATFORM_ID}" PARENT_SCOPE) 258 set(CMAKE_${lang}_COMPILER_ARCHITECTURE_ID "${CMAKE_${lang}_COMPILER_ARCHITECTURE_ID}" PARENT_SCOPE) 259 set(MSVC_${lang}_ARCHITECTURE_ID "${MSVC_${lang}_ARCHITECTURE_ID}" 260 PARENT_SCOPE) 261 set(CMAKE_${lang}_XCODE_ARCHS "${CMAKE_${lang}_XCODE_ARCHS}" PARENT_SCOPE) 262 set(CMAKE_${lang}_CL_SHOWINCLUDES_PREFIX "${CMAKE_${lang}_CL_SHOWINCLUDES_PREFIX}" PARENT_SCOPE) 263 set(CMAKE_${lang}_COMPILER_FRONTEND_VARIANT "${CMAKE_${lang}_COMPILER_FRONTEND_VARIANT}" PARENT_SCOPE) 264 set(CMAKE_${lang}_COMPILER_VERSION "${CMAKE_${lang}_COMPILER_VERSION}" PARENT_SCOPE) 265 set(CMAKE_${lang}_COMPILER_VERSION_INTERNAL "${CMAKE_${lang}_COMPILER_VERSION_INTERNAL}" PARENT_SCOPE) 266 set(CMAKE_${lang}_COMPILER_WRAPPER "${CMAKE_${lang}_COMPILER_WRAPPER}" PARENT_SCOPE) 267 set(CMAKE_${lang}_SIMULATE_ID "${CMAKE_${lang}_SIMULATE_ID}" PARENT_SCOPE) 268 set(CMAKE_${lang}_SIMULATE_VERSION "${CMAKE_${lang}_SIMULATE_VERSION}" PARENT_SCOPE) 269 set(CMAKE_${lang}_STANDARD_COMPUTED_DEFAULT "${CMAKE_${lang}_STANDARD_COMPUTED_DEFAULT}" PARENT_SCOPE) 270 set(CMAKE_${lang}_EXTENSIONS_COMPUTED_DEFAULT "${CMAKE_${lang}_EXTENSIONS_COMPUTED_DEFAULT}" PARENT_SCOPE) 271 set(CMAKE_${lang}_COMPILER_PRODUCED_OUTPUT "${COMPILER_${lang}_PRODUCED_OUTPUT}" PARENT_SCOPE) 272 set(CMAKE_${lang}_COMPILER_PRODUCED_FILES "${COMPILER_${lang}_PRODUCED_FILES}" PARENT_SCOPE) 273endfunction() 274 275include(CMakeCompilerIdDetection) 276 277#----------------------------------------------------------------------------- 278# Function to write the compiler id source file. 279function(CMAKE_DETERMINE_COMPILER_ID_WRITE lang src) 280 find_file(src_in ${src}.in PATHS ${CMAKE_ROOT}/Modules ${CMAKE_MODULE_PATH} NO_DEFAULT_PATH NO_CMAKE_FIND_ROOT_PATH) 281 file(READ ${src_in} ID_CONTENT_IN) 282 283 compiler_id_detection(CMAKE_${lang}_COMPILER_ID_CONTENT ${lang} 284 ID_STRING 285 VERSION_STRINGS 286 PLATFORM_DEFAULT_COMPILER 287 ) 288 289 unset(src_in CACHE) 290 string(CONFIGURE "${ID_CONTENT_IN}" ID_CONTENT_OUT @ONLY) 291 file(WRITE ${CMAKE_${lang}_COMPILER_ID_DIR}/${src} "${ID_CONTENT_OUT}") 292endfunction() 293 294#----------------------------------------------------------------------------- 295# Function to build the compiler id source file and look for output 296# files. 297function(CMAKE_DETERMINE_COMPILER_ID_BUILD lang testflags userflags src) 298 # Create a clean working directory. 299 file(REMOVE_RECURSE ${CMAKE_${lang}_COMPILER_ID_DIR}) 300 file(MAKE_DIRECTORY ${CMAKE_${lang}_COMPILER_ID_DIR}) 301 file(MAKE_DIRECTORY ${CMAKE_${lang}_COMPILER_ID_DIR}/tmp) 302 CMAKE_DETERMINE_COMPILER_ID_WRITE("${lang}" "${src}") 303 304 # Construct a description of this test case. 305 set(COMPILER_DESCRIPTION 306 "Compiler: ${CMAKE_${lang}_COMPILER} ${CMAKE_${lang}_COMPILER_ID_ARG1} 307Build flags: ${userflags} 308Id flags: ${testflags} ${CMAKE_${lang}_COMPILER_ID_FLAGS_ALWAYS} 309") 310 311 # Compile the compiler identification source. 312 if("${CMAKE_GENERATOR}" MATCHES "Visual Studio ([0-9]+)") 313 set(vs_version ${CMAKE_MATCH_1}) 314 set(id_platform ${CMAKE_VS_PLATFORM_NAME}) 315 set(id_lang "${lang}") 316 set(id_PostBuildEvent_Command "") 317 if(CMAKE_VS_PLATFORM_TOOLSET MATCHES "^[Ll][Ll][Vv][Mm](_v[0-9]+(_xp)?)?$") 318 set(id_cl_var "ClangClExecutable") 319 elseif(CMAKE_VS_PLATFORM_TOOLSET MATCHES "^[Cc][Ll][Aa][Nn][Gg]([Cc][Ll]$|_[0-9])") 320 set(id_cl "$(CLToolExe)") 321 elseif(CMAKE_VS_PLATFORM_TOOLSET MATCHES "v[0-9]+_clang_.*") 322 set(id_cl clang.exe) 323 # Executable names have been chosen according documentation 324 # URL: (https://software.intel.com/content/www/us/en/develop/documentation/get-started-with-dpcpp-compiler/top.html#top_GUID-A9B4C91D-97AC-450D-9742-9D895BC8AEE1) 325 elseif(CMAKE_VS_PLATFORM_TOOLSET MATCHES "Intel") 326 if(CMAKE_VS_PLATFORM_TOOLSET MATCHES "DPC\\+\\+ Compiler") 327 set(id_cl dpcpp.exe) 328 elseif(CMAKE_VS_PLATFORM_TOOLSET MATCHES "C\\+\\+ Compiler 2021") 329 set(id_cl icx.exe) 330 elseif(CMAKE_VS_PLATFORM_TOOLSET MATCHES "C\\+\\+ Compiler") 331 set(id_cl icl.exe) 332 endif() 333 else() 334 set(id_cl cl.exe) 335 endif() 336 if(CMAKE_VS_PLATFORM_NAME STREQUAL "Tegra-Android") 337 set(v NsightTegra) 338 set(ext vcxproj) 339 if(lang STREQUAL CXX) 340 set(id_gcc g++) 341 set(id_clang clang++) 342 else() 343 set(id_gcc gcc) 344 set(id_clang clang) 345 endif() 346 elseif(lang STREQUAL Fortran) 347 set(v Intel) 348 set(ext vfproj) 349 set(id_cl ifort.exe) 350 elseif(lang STREQUAL CSharp) 351 set(v 10) 352 set(ext csproj) 353 set(id_cl csc.exe) 354 elseif(NOT "${vs_version}" VERSION_LESS 10) 355 set(v 10) 356 set(ext vcxproj) 357 else() 358 set(id_version ${vs_version}.00) 359 set(v 7) 360 set(ext vcproj) 361 endif() 362 if(CMAKE_VS_PLATFORM_TOOLSET) 363 if(CMAKE_VS_PLATFORM_NAME STREQUAL "Tegra-Android") 364 set(id_toolset "<NdkToolchainVersion>${CMAKE_VS_PLATFORM_TOOLSET}</NdkToolchainVersion>") 365 else() 366 set(id_toolset "<PlatformToolset>${CMAKE_VS_PLATFORM_TOOLSET}</PlatformToolset>") 367 if(CMAKE_VS_PLATFORM_TOOLSET_VERSION) 368 set(id_sep "\\") 369 if(CMAKE_VS_PLATFORM_TOOLSET_VERSION VERSION_GREATER_EQUAL "14.20") 370 if(EXISTS "${CMAKE_GENERATOR_INSTANCE}/VC/Auxiliary/Build.${CMAKE_VS_PLATFORM_TOOLSET_VERSION}/Microsoft.VCToolsVersion.${CMAKE_VS_PLATFORM_TOOLSET_VERSION}.props") 371 set(id_sep ".") 372 endif() 373 endif() 374 set(id_toolset_version_props "<Import Project=\"${CMAKE_GENERATOR_INSTANCE}\\VC\\Auxiliary\\Build${id_sep}${CMAKE_VS_PLATFORM_TOOLSET_VERSION}\\Microsoft.VCToolsVersion.${CMAKE_VS_PLATFORM_TOOLSET_VERSION}.props\" />") 375 unset(id_sep) 376 endif() 377 endif() 378 else() 379 set(id_toolset "") 380 set(id_toolset_version_props "") 381 endif() 382 if(CMAKE_VS_PLATFORM_TOOLSET_HOST_ARCHITECTURE) 383 set(id_PreferredToolArchitecture "<PreferredToolArchitecture>${CMAKE_VS_PLATFORM_TOOLSET_HOST_ARCHITECTURE}</PreferredToolArchitecture>") 384 else() 385 set(id_PreferredToolArchitecture "") 386 endif() 387 if(CMAKE_SYSTEM_NAME STREQUAL "WindowsPhone") 388 set(id_keyword "Win32Proj") 389 set(id_system "<ApplicationType>Windows Phone</ApplicationType>") 390 elseif(CMAKE_SYSTEM_NAME STREQUAL "WindowsStore") 391 set(id_keyword "Win32Proj") 392 set(id_system "<ApplicationType>Windows Store</ApplicationType>") 393 elseif(CMAKE_SYSTEM_NAME STREQUAL "Android") 394 set(id_keyword "Android") 395 set(id_system "<ApplicationType>Android</ApplicationType>") 396 else() 397 set(id_keyword "Win32Proj") 398 set(id_system "") 399 endif() 400 if(id_keyword STREQUAL "Android") 401 if(CMAKE_GENERATOR MATCHES "Visual Studio 14") 402 set(id_system_version "<ApplicationTypeRevision>2.0</ApplicationTypeRevision>") 403 elseif(CMAKE_GENERATOR MATCHES "Visual Studio 1[56]") 404 set(id_system_version "<ApplicationTypeRevision>3.0</ApplicationTypeRevision>") 405 else() 406 set(id_system_version "") 407 endif() 408 elseif(id_system AND CMAKE_SYSTEM_VERSION MATCHES "^([0-9]+\\.[0-9]+)") 409 set(id_system_version "<ApplicationTypeRevision>${CMAKE_MATCH_1}</ApplicationTypeRevision>") 410 else() 411 set(id_system_version "") 412 endif() 413 if(id_keyword STREQUAL "Android") 414 set(id_config_type "DynamicLibrary") 415 else() 416 set(id_config_type "Application") 417 endif() 418 if(CMAKE_VS_WINDOWS_TARGET_PLATFORM_VERSION) 419 set(id_WindowsTargetPlatformVersion "<WindowsTargetPlatformVersion>${CMAKE_VS_WINDOWS_TARGET_PLATFORM_VERSION}</WindowsTargetPlatformVersion>") 420 endif() 421 if(CMAKE_VS_PLATFORM_TOOLSET_VCTARGETS_CUSTOM_DIR) 422 set(id_ToolsetVCTargetsDir "<VCTargetsPath>${CMAKE_VS_PLATFORM_TOOLSET_VCTARGETS_CUSTOM_DIR}</VCTargetsPath>") 423 endif() 424 if(CMAKE_VS_TARGET_FRAMEWORK_VERSION) 425 set(id_TargetFrameworkVersion "<TargetFrameworkVersion>${CMAKE_VS_TARGET_FRAMEWORK_VERSION}</TargetFrameworkVersion>") 426 endif() 427 if(CMAKE_VS_TARGET_FRAMEWORK_IDENTIFIER) 428 set(id_TargetFrameworkIdentifier "<TargetFrameworkIdentifier>${CMAKE_VS_TARGET_FRAMEWORK_IDENTIFIER}</TargetFrameworkIdentifier>") 429 endif() 430 if(CMAKE_VS_TARGET_FRAMEWORK_TARGETS_VERSION) 431 set(id_TargetFrameworkTargetsVersion "<TargetFrameworkTargetsVersion>${CMAKE_VS_TARGET_FRAMEWORK_TARGETS_VERSION}</TargetFrameworkTargetsVersion>") 432 endif() 433 set(id_CustomGlobals "") 434 foreach(pair IN LISTS CMAKE_VS_GLOBALS) 435 if("${pair}" MATCHES "([^=]+)=(.*)$") 436 string(APPEND id_CustomGlobals "<${CMAKE_MATCH_1}>${CMAKE_MATCH_2}</${CMAKE_MATCH_1}>\n ") 437 endif() 438 endforeach() 439 if(id_keyword STREQUAL "Android") 440 set(id_WindowsSDKDesktopARMSupport "") 441 elseif(id_platform STREQUAL "ARM64") 442 set(id_WindowsSDKDesktopARMSupport "<WindowsSDKDesktopARM64Support>true</WindowsSDKDesktopARM64Support>") 443 elseif(id_platform STREQUAL "ARM") 444 set(id_WindowsSDKDesktopARMSupport "<WindowsSDKDesktopARMSupport>true</WindowsSDKDesktopARMSupport>") 445 else() 446 set(id_WindowsSDKDesktopARMSupport "") 447 endif() 448 if(CMAKE_VS_WINCE_VERSION) 449 set(id_entrypoint "mainACRTStartup") 450 if("${vs_version}" VERSION_LESS 9) 451 set(id_subsystem 9) 452 else() 453 set(id_subsystem 8) 454 endif() 455 else() 456 set(id_subsystem 1) 457 endif() 458 set(id_dir ${CMAKE_${lang}_COMPILER_ID_DIR}) 459 set(id_src "${src}") 460 set(id_compile "ClCompile") 461 if(id_cl_var) 462 set(id_PostBuildEvent_Command "echo CMAKE_${lang}_COMPILER=$(${id_cl_var})") 463 else() 464 set(id_PostBuildEvent_Command "for %%i in (${id_cl}) do %40echo CMAKE_${lang}_COMPILER=%%~$PATH:i") 465 endif() 466 set(id_Import_props "") 467 set(id_Import_targets "") 468 set(id_ItemDefinitionGroup_entry "") 469 set(id_Link_AdditionalDependencies "") 470 if(lang STREQUAL CUDA) 471 if(NOT CMAKE_VS_PLATFORM_TOOLSET_CUDA) 472 message(FATAL_ERROR "No CUDA toolset found.") 473 endif() 474 set(cuda_tools "CUDA ${CMAKE_VS_PLATFORM_TOOLSET_CUDA}") 475 set(id_compile "CudaCompile") 476 if(CMAKE_VS_PLATFORM_NAME STREQUAL x64) 477 set(cuda_target "<TargetMachinePlatform>64</TargetMachinePlatform>") 478 endif() 479 foreach(arch ${CMAKE_CUDA_ARCHITECTURES}) 480 string(REGEX MATCH "[0-9]+" arch_name "${arch}") 481 string(APPEND cuda_codegen "compute_${arch_name},sm_${arch_name};") 482 endforeach() 483 set(id_ItemDefinitionGroup_entry "<CudaCompile>${cuda_target}<AdditionalOptions>%(AdditionalOptions)-v</AdditionalOptions><CodeGeneration>${cuda_codegen}</CodeGeneration></CudaCompile>") 484 set(id_PostBuildEvent_Command [[echo CMAKE_CUDA_COMPILER=$(CudaToolkitBinDir)\nvcc.exe]]) 485 if(CMAKE_VS_PLATFORM_TOOLSET_CUDA_CUSTOM_DIR) 486 # check for legacy cuda custom toolkit folder structure 487 if(EXISTS ${CMAKE_VS_PLATFORM_TOOLSET_CUDA_CUSTOM_DIR}nvcc) 488 set(id_CudaToolkitCustomDir "<CudaToolkitCustomDir>${CMAKE_VS_PLATFORM_TOOLSET_CUDA_CUSTOM_DIR}nvcc</CudaToolkitCustomDir>") 489 else() 490 set(id_CudaToolkitCustomDir "<CudaToolkitCustomDir>${CMAKE_VS_PLATFORM_TOOLSET_CUDA_CUSTOM_DIR}</CudaToolkitCustomDir>") 491 endif() 492 if(EXISTS ${CMAKE_VS_PLATFORM_TOOLSET_CUDA_CUSTOM_DIR}CUDAVisualStudioIntegration) 493 string(CONCAT id_Import_props "<Import Project=\"${CMAKE_VS_PLATFORM_TOOLSET_CUDA_CUSTOM_DIR}CUDAVisualStudioIntegration\\extras\\visual_studio_integration\\MSBuildExtensions\\${cuda_tools}.props\" />") 494 string(CONCAT id_Import_targets "<Import Project=\"${CMAKE_VS_PLATFORM_TOOLSET_CUDA_CUSTOM_DIR}CUDAVisualStudioIntegration\\extras\\visual_studio_integration\\MSBuildExtensions\\${cuda_tools}.targets\" />") 495 else() 496 string(CONCAT id_Import_props "<Import Project=\"${CMAKE_VS_PLATFORM_TOOLSET_CUDA_CUSTOM_DIR}\\extras\\visual_studio_integration\\MSBuildExtensions\\${cuda_tools}.props\" />") 497 string(CONCAT id_Import_targets "<Import Project=\"${CMAKE_VS_PLATFORM_TOOLSET_CUDA_CUSTOM_DIR}\\extras\\visual_studio_integration\\MSBuildExtensions\\${cuda_tools}.targets\" />") 498 endif() 499 else() 500 string(CONCAT id_Import_props [[<Import Project="$(VCTargetsPath)\BuildCustomizations\]] "${cuda_tools}" [[.props" />]]) 501 string(CONCAT id_Import_targets [[<Import Project="$(VCTargetsPath)\BuildCustomizations\]] "${cuda_tools}" [[.targets" />]]) 502 endif() 503 if(CMAKE_CUDA_FLAGS MATCHES "(^| )-cudart +shared( |$)") 504 set(id_Link_AdditionalDependencies "<AdditionalDependencies>cudart.lib</AdditionalDependencies>") 505 else() 506 set(id_Link_AdditionalDependencies "<AdditionalDependencies>cudart_static.lib</AdditionalDependencies>") 507 endif() 508 endif() 509 configure_file(${CMAKE_ROOT}/Modules/CompilerId/VS-${v}.${ext}.in 510 ${id_dir}/CompilerId${lang}.${ext} @ONLY) 511 if(CMAKE_VS_MSBUILD_COMMAND AND NOT lang STREQUAL "Fortran") 512 set(command "${CMAKE_VS_MSBUILD_COMMAND}" "CompilerId${lang}.${ext}" 513 "/p:Configuration=Debug" "/p:Platform=${id_platform}" "/p:VisualStudioVersion=${vs_version}.0" 514 ) 515 elseif(CMAKE_VS_DEVENV_COMMAND) 516 set(command "${CMAKE_VS_DEVENV_COMMAND}" "CompilerId${lang}.${ext}" "/build" "Debug") 517 else() 518 set(command "") 519 endif() 520 if(command) 521 execute_process( 522 COMMAND ${command} 523 WORKING_DIRECTORY ${CMAKE_${lang}_COMPILER_ID_DIR} 524 OUTPUT_VARIABLE CMAKE_${lang}_COMPILER_ID_OUTPUT 525 ERROR_VARIABLE CMAKE_${lang}_COMPILER_ID_OUTPUT 526 RESULT_VARIABLE CMAKE_${lang}_COMPILER_ID_RESULT 527 ) 528 else() 529 set(CMAKE_${lang}_COMPILER_ID_RESULT 1) 530 set(CMAKE_${lang}_COMPILER_ID_OUTPUT "VS environment not known to support ${lang}") 531 endif() 532 # Match the compiler location line printed out. 533 if("${CMAKE_${lang}_COMPILER_ID_OUTPUT}" MATCHES "CMAKE_${lang}_COMPILER=([^%\r\n]+)[\r\n]") 534 # Strip VS diagnostic output from the end of the line. 535 string(REGEX REPLACE " \\(TaskId:[0-9]*\\)$" "" _comp "${CMAKE_MATCH_1}") 536 if(EXISTS "${_comp}") 537 file(TO_CMAKE_PATH "${_comp}" _comp) 538 set(CMAKE_${lang}_COMPILER_ID_TOOL "${_comp}" PARENT_SCOPE) 539 endif() 540 endif() 541 elseif("${CMAKE_GENERATOR}" MATCHES "Xcode") 542 set(id_lang "${lang}") 543 set(id_type ${CMAKE_${lang}_COMPILER_XCODE_TYPE}) 544 set(id_dir ${CMAKE_${lang}_COMPILER_ID_DIR}) 545 set(id_src "${src}") 546 if(CMAKE_XCODE_PLATFORM_TOOLSET) 547 set(id_toolset "GCC_VERSION = ${CMAKE_XCODE_PLATFORM_TOOLSET};") 548 else() 549 set(id_toolset "") 550 endif() 551 set(id_lang_version "") 552 if("x${lang}" STREQUAL "xSwift") 553 if(CMAKE_Swift_LANGUAGE_VERSION) 554 set(id_lang_version "SWIFT_VERSION = ${CMAKE_Swift_LANGUAGE_VERSION};") 555 elseif(XCODE_VERSION VERSION_GREATER_EQUAL 10.2) 556 set(id_lang_version "SWIFT_VERSION = 4.0;") 557 elseif(XCODE_VERSION VERSION_GREATER_EQUAL 8.3) 558 set(id_lang_version "SWIFT_VERSION = 3.0;") 559 else() 560 set(id_lang_version "SWIFT_VERSION = 2.3;") 561 endif() 562 elseif("x${lang}" STREQUAL "xC" OR "x${lang}" STREQUAL "xOBJC") 563 if(CMAKE_${lang}_COMPILER_ID_FLAGS MATCHES "(^| )(-std=[^ ]+)( |$)") 564 set(id_lang_version "OTHER_CFLAGS = \"${CMAKE_MATCH_2}\";") 565 endif() 566 elseif("x${lang}" STREQUAL "xCXX" OR "x${lang}" STREQUAL "xOBJCXX") 567 if(CMAKE_${lang}_COMPILER_ID_FLAGS MATCHES "(^| )(-std=[^ ]+)( |$)") 568 set(id_lang_version "OTHER_CPLUSPLUSFLAGS = \"${CMAKE_MATCH_2}\";") 569 endif() 570 endif() 571 if(CMAKE_OSX_DEPLOYMENT_TARGET) 572 set(id_deployment_target 573 "MACOSX_DEPLOYMENT_TARGET = \"${CMAKE_OSX_DEPLOYMENT_TARGET}\";") 574 else() 575 set(id_deployment_target "") 576 endif() 577 set(id_product_type "com.apple.product-type.tool") 578 if(CMAKE_OSX_SYSROOT) 579 set(id_sdkroot "SDKROOT = \"${CMAKE_OSX_SYSROOT}\";") 580 if(CMAKE_OSX_SYSROOT MATCHES "(^|/)[Ii][Pp][Hh][Oo][Nn][Ee]" OR 581 CMAKE_OSX_SYSROOT MATCHES "(^|/)[Aa][Pp][Pp][Ll][Ee][Tt][Vv]") 582 set(id_product_type "com.apple.product-type.bundle.unit-test") 583 elseif(CMAKE_OSX_SYSROOT MATCHES "(^|/)[Ww][Aa][Tt][Cc][Hh]") 584 set(id_product_type "com.apple.product-type.framework") 585 endif() 586 else() 587 set(id_sdkroot "") 588 endif() 589 set(id_clang_cxx_library "") 590 set(stdlib_regex "(^| )(-stdlib=)([^ ]+)( |$)") 591 string(REGEX MATCHALL "${stdlib_regex}" all_stdlib_matches "${CMAKE_CXX_FLAGS}") 592 if(all_stdlib_matches) 593 list(GET all_stdlib_matches "-1" last_stdlib_match) 594 if(last_stdlib_match MATCHES "${stdlib_regex}") 595 set(id_clang_cxx_library "CLANG_CXX_LIBRARY = \"${CMAKE_MATCH_3}\";") 596 endif() 597 endif() 598 if(CMAKE_SYSTEM_NAME STREQUAL "Darwin" AND CMAKE_OSX_SYSROOT MATCHES "^$|[Mm][Aa][Cc][Oo][Ss]") 599 # When targeting macOS, use only the host architecture. 600 if (_CMAKE_APPLE_ARCHS_DEFAULT) 601 set(id_archs "ARCHS = \"${_CMAKE_APPLE_ARCHS_DEFAULT}\";") 602 set(id_arch_active "ONLY_ACTIVE_ARCH = NO;") 603 else() 604 set(id_archs [[ARCHS = "$(NATIVE_ARCH_ACTUAL)";]]) 605 set(id_arch_active "ONLY_ACTIVE_ARCH = YES;") 606 endif() 607 else() 608 set(id_archs "") 609 set(id_arch_active "ONLY_ACTIVE_ARCH = YES;") 610 endif() 611 configure_file(${CMAKE_ROOT}/Modules/CompilerId/Xcode-3.pbxproj.in 612 ${id_dir}/CompilerId${lang}.xcodeproj/project.pbxproj @ONLY) 613 unset(_ENV_MACOSX_DEPLOYMENT_TARGET) 614 if(DEFINED ENV{MACOSX_DEPLOYMENT_TARGET}) 615 set(_ENV_MACOSX_DEPLOYMENT_TARGET "$ENV{MACOSX_DEPLOYMENT_TARGET}") 616 set(ENV{MACOSX_DEPLOYMENT_TARGET} "") 617 endif() 618 execute_process(COMMAND xcodebuild 619 WORKING_DIRECTORY ${CMAKE_${lang}_COMPILER_ID_DIR} 620 OUTPUT_VARIABLE CMAKE_${lang}_COMPILER_ID_OUTPUT 621 ERROR_VARIABLE CMAKE_${lang}_COMPILER_ID_OUTPUT 622 RESULT_VARIABLE CMAKE_${lang}_COMPILER_ID_RESULT 623 ) 624 if(DEFINED _ENV_MACOSX_DEPLOYMENT_TARGET) 625 set(ENV{MACOSX_DEPLOYMENT_TARGET} "${_ENV_MACOSX_DEPLOYMENT_TARGET}") 626 endif() 627 628 if(DEFINED CMAKE_${lang}_COMPILER_ID_TOOL_MATCH_REGEX) 629 if("${CMAKE_${lang}_COMPILER_ID_OUTPUT}" MATCHES "${CMAKE_${lang}_COMPILER_ID_TOOL_MATCH_REGEX}") 630 set(_comp "${CMAKE_MATCH_${CMAKE_${lang}_COMPILER_ID_TOOL_MATCH_INDEX}}") 631 if(EXISTS "${_comp}") 632 set(CMAKE_${lang}_COMPILER_ID_TOOL "${_comp}" PARENT_SCOPE) 633 endif() 634 endif() 635 endif() 636 if("${CMAKE_${lang}_COMPILER_ID_OUTPUT}" MATCHES "ARCHS=([^%\r\n]+)[\r\n]") 637 set(CMAKE_${lang}_XCODE_ARCHS "${CMAKE_MATCH_1}") 638 separate_arguments(CMAKE_${lang}_XCODE_ARCHS) 639 set(CMAKE_${lang}_XCODE_ARCHS "${CMAKE_${lang}_XCODE_ARCHS}" PARENT_SCOPE) 640 endif() 641 elseif("${CMAKE_GENERATOR}" MATCHES "Green Hills MULTI") 642 set(id_dir ${CMAKE_${lang}_COMPILER_ID_DIR}) 643 set(id_src "${src}") 644 if (GHS_PRIMARY_TARGET) 645 set(ghs_primary_target "${GHS_PRIMARY_TARGET}") 646 else() 647 set(ghs_primary_target "${CMAKE_GENERATOR_PLATFORM}_${GHS_TARGET_PLATFORM}.tgt") 648 endif() 649 if ("${GHS_TARGET_PLATFORM}" MATCHES "integrity") 650 set(bsp_name "macro GHS_BSP=${GHS_BSP_NAME}") 651 set(os_dir "macro GHS_OS=${GHS_OS_DIR}") 652 endif() 653 set(command "${CMAKE_MAKE_PROGRAM}" "-commands" "-top" "GHS_default.gpj") 654 configure_file(${CMAKE_ROOT}/Modules/CompilerId/GHS_default.gpj.in 655 ${id_dir}/GHS_default.gpj @ONLY) 656 configure_file(${CMAKE_ROOT}/Modules/CompilerId/GHS_lib.gpj.in 657 ${id_dir}/GHS_lib.gpj @ONLY) 658 execute_process(COMMAND ${command} 659 WORKING_DIRECTORY ${id_dir} 660 OUTPUT_VARIABLE CMAKE_${lang}_COMPILER_ID_OUTPUT 661 ERROR_VARIABLE CMAKE_${lang}_COMPILER_ID_OUTPUT 662 RESULT_VARIABLE CMAKE_${lang}_COMPILER_ID_RESULT 663 ) 664 # Match the compiler location line printed out. 665 set(ghs_toolpath "${CMAKE_MAKE_PROGRAM}") 666 if(CMAKE_HOST_UNIX) 667 string(REPLACE "/gbuild" "/" ghs_toolpath ${ghs_toolpath}) 668 else() 669 string(REPLACE "/gbuild.exe" "/" ghs_toolpath ${ghs_toolpath}) 670 string(REPLACE / "\\\\" ghs_toolpath ${ghs_toolpath}) 671 endif() 672 if("${CMAKE_${lang}_COMPILER_ID_OUTPUT}" MATCHES "(${ghs_toolpath}[^ ]*)") 673 if(CMAKE_HOST_UNIX) 674 set(_comp "${CMAKE_MATCH_1}") 675 else() 676 set(_comp "${CMAKE_MATCH_1}.exe") 677 endif() 678 if(EXISTS "${_comp}") 679 file(TO_CMAKE_PATH "${_comp}" _comp) 680 set(CMAKE_${lang}_COMPILER_ID_TOOL "${_comp}" PARENT_SCOPE) 681 endif() 682 endif() 683 else() 684 execute_process( 685 COMMAND "${CMAKE_${lang}_COMPILER}" 686 ${CMAKE_${lang}_COMPILER_ID_ARG1} 687 ${userflags} 688 ${testflags} 689 ${CMAKE_${lang}_COMPILER_ID_FLAGS_ALWAYS} 690 "${src}" 691 WORKING_DIRECTORY ${CMAKE_${lang}_COMPILER_ID_DIR} 692 OUTPUT_VARIABLE CMAKE_${lang}_COMPILER_ID_OUTPUT 693 ERROR_VARIABLE CMAKE_${lang}_COMPILER_ID_OUTPUT 694 RESULT_VARIABLE CMAKE_${lang}_COMPILER_ID_RESULT 695 ) 696 if("${CMAKE_${lang}_COMPILER_ID_OUTPUT}" MATCHES "exec: [^\n]*\\((/[^,\n]*/cpp),CMakeFortranCompilerId.F") 697 set(_cpp "${CMAKE_MATCH_1}") 698 if(EXISTS "${_cpp}") 699 set(CMAKE_${lang}_COMPILER_ID_CPP "${_cpp}" PARENT_SCOPE) 700 endif() 701 endif() 702 endif() 703 704 # Check the result of compilation. 705 if(CMAKE_${lang}_COMPILER_ID_RESULT 706 # Intel Fortran warns and ignores preprocessor lines without /fpp 707 OR CMAKE_${lang}_COMPILER_ID_OUTPUT MATCHES "warning #5117: Bad # preprocessor line" 708 ) 709 # Compilation failed. 710 set(MSG 711 "Compiling the ${lang} compiler identification source file \"${src}\" failed. 712${COMPILER_DESCRIPTION} 713The output was: 714${CMAKE_${lang}_COMPILER_ID_RESULT} 715${CMAKE_${lang}_COMPILER_ID_OUTPUT} 716 717") 718 # Log the output unless we recognize it as a known-bad case. 719 if(NOT CMAKE_${lang}_COMPILER_ID_OUTPUT MATCHES "warning #5117: Bad # preprocessor line") 720 file(APPEND ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeError.log "${MSG}") 721 endif() 722 723 # Some languages may know the correct/desired set of flags and want to fail right away if they don't work. 724 # This is currently only used by CUDA. 725 if(__compiler_id_require_success) 726 message(FATAL_ERROR "${MSG}") 727 endif() 728 729 # No output files should be inspected. 730 set(COMPILER_${lang}_PRODUCED_FILES) 731 set(COMPILER_${lang}_PRODUCED_OUTPUT) 732 else() 733 # Compilation succeeded. 734 file(APPEND ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeOutput.log 735 "Compiling the ${lang} compiler identification source file \"${src}\" succeeded. 736${COMPILER_DESCRIPTION} 737The output was: 738${CMAKE_${lang}_COMPILER_ID_RESULT} 739${CMAKE_${lang}_COMPILER_ID_OUTPUT} 740 741") 742 743 # Find the executable produced by the compiler, try all files in the 744 # binary dir. 745 string(REGEX REPLACE "([][])" "[\\1]" _glob_id_dir "${CMAKE_${lang}_COMPILER_ID_DIR}") 746 file(GLOB files 747 RELATIVE ${CMAKE_${lang}_COMPILER_ID_DIR} 748 749 # normal case 750 ${_glob_id_dir}/* 751 752 # com.apple.package-type.bundle.unit-test 753 ${_glob_id_dir}/*.xctest/* 754 755 # com.apple.product-type.framework 756 ${_glob_id_dir}/*.framework/* 757 ) 758 list(REMOVE_ITEM files "${src}") 759 set(COMPILER_${lang}_PRODUCED_FILES "") 760 foreach(file ${files}) 761 if(NOT IS_DIRECTORY ${CMAKE_${lang}_COMPILER_ID_DIR}/${file}) 762 list(APPEND COMPILER_${lang}_PRODUCED_FILES ${file}) 763 file(APPEND ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeOutput.log 764 "Compilation of the ${lang} compiler identification source \"" 765 "${src}\" produced \"${file}\"\n\n") 766 endif() 767 endforeach() 768 769 if(NOT COMPILER_${lang}_PRODUCED_FILES) 770 # No executable was found. 771 file(APPEND ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeError.log 772 "Compilation of the ${lang} compiler identification source \"" 773 "${src}\" did not produce an executable in \"" 774 "${CMAKE_${lang}_COMPILER_ID_DIR}\".\n\n") 775 endif() 776 777 set(COMPILER_${lang}_PRODUCED_OUTPUT "${CMAKE_${lang}_COMPILER_ID_OUTPUT}") 778 endif() 779 780 # Return the files produced by the compilation. 781 set(COMPILER_${lang}_PRODUCED_FILES "${COMPILER_${lang}_PRODUCED_FILES}" PARENT_SCOPE) 782 set(COMPILER_${lang}_PRODUCED_OUTPUT "${COMPILER_${lang}_PRODUCED_OUTPUT}" PARENT_SCOPE) 783 784endfunction() 785 786#----------------------------------------------------------------------------- 787# Function to extract the compiler id from compiler output. 788function(CMAKE_DETERMINE_COMPILER_ID_MATCH_VENDOR lang output) 789 foreach(vendor ${CMAKE_${lang}_COMPILER_ID_MATCH_VENDORS}) 790 if(output MATCHES "${CMAKE_${lang}_COMPILER_ID_MATCH_VENDOR_REGEX_${vendor}}") 791 set(CMAKE_${lang}_COMPILER_ID "${vendor}") 792 endif() 793 endforeach() 794 set(CMAKE_${lang}_COMPILER_ID "${CMAKE_${lang}_COMPILER_ID}" PARENT_SCOPE) 795endfunction() 796 797#----------------------------------------------------------------------------- 798# Function to extract the compiler id from an executable. 799function(CMAKE_DETERMINE_COMPILER_ID_CHECK lang file) 800 # Look for a compiler id if not yet known. 801 if(NOT CMAKE_${lang}_COMPILER_ID) 802 # Read the compiler identification string from the executable file. 803 set(COMPILER_ID) 804 set(COMPILER_VERSION) 805 set(COMPILER_VERSION_MAJOR 0) 806 set(COMPILER_VERSION_MINOR 0) 807 set(COMPILER_VERSION_PATCH 0) 808 set(COMPILER_VERSION_TWEAK 0) 809 set(COMPILER_VERSION_INTERNAL "") 810 set(HAVE_COMPILER_VERSION_MAJOR 0) 811 set(HAVE_COMPILER_VERSION_MINOR 0) 812 set(HAVE_COMPILER_VERSION_PATCH 0) 813 set(HAVE_COMPILER_VERSION_TWEAK 0) 814 set(COMPILER_WRAPPER) 815 set(DIGIT_VALUE_1 1) 816 set(DIGIT_VALUE_2 10) 817 set(DIGIT_VALUE_3 100) 818 set(DIGIT_VALUE_4 1000) 819 set(DIGIT_VALUE_5 10000) 820 set(DIGIT_VALUE_6 100000) 821 set(DIGIT_VALUE_7 1000000) 822 set(DIGIT_VALUE_8 10000000) 823 set(PLATFORM_ID) 824 set(ARCHITECTURE_ID) 825 set(SIMULATE_ID) 826 set(SIMULATE_VERSION) 827 foreach(encoding "" "ENCODING;UTF-16LE" "ENCODING;UTF-16BE") 828 file(STRINGS "${file}" CMAKE_${lang}_COMPILER_ID_STRINGS 829 LIMIT_COUNT 38 ${encoding} 830 REGEX ".?I.?N.?F.?O.?:.?[A-Za-z0-9_]+\\[[^]]*\\]") 831 if(NOT CMAKE_${lang}_COMPILER_ID_STRINGS STREQUAL "") 832 break() 833 endif() 834 endforeach() 835 836 # With the IAR Compiler, some strings are found twice, first time as incomplete 837 # list like "?<Constant "INFO:compiler[IAR]">". Remove the incomplete copies. 838 list(FILTER CMAKE_${lang}_COMPILER_ID_STRINGS EXCLUDE REGEX "\\?<Constant \\\"") 839 840 # The IAR-AVR compiler uses a binary format that places a '6' 841 # character (0x34) before each character in the string. Strip 842 # out these characters without removing any legitimate characters. 843 if(CMAKE_${lang}_COMPILER_ID_STRINGS MATCHES "(.)I.N.F.O.:.") 844 string(REGEX REPLACE "${CMAKE_MATCH_1}([^;])" "\\1" 845 CMAKE_${lang}_COMPILER_ID_STRINGS "${CMAKE_${lang}_COMPILER_ID_STRINGS}") 846 endif() 847 848 # Remove arbitrary text that may appear before or after each INFO string. 849 string(REGEX MATCHALL "INFO:[A-Za-z0-9_]+\\[([^]\"]*)\\]" 850 CMAKE_${lang}_COMPILER_ID_STRINGS "${CMAKE_${lang}_COMPILER_ID_STRINGS}") 851 852 # In C# binaries, some strings are found more than once. 853 list(REMOVE_DUPLICATES CMAKE_${lang}_COMPILER_ID_STRINGS) 854 855 set(COMPILER_ID_TWICE) 856 foreach(info ${CMAKE_${lang}_COMPILER_ID_STRINGS}) 857 if("${info}" MATCHES "INFO:compiler\\[([^]\"]*)\\]") 858 if(COMPILER_ID) 859 set(COMPILER_ID_TWICE 1) 860 endif() 861 set(COMPILER_ID "${CMAKE_MATCH_1}") 862 endif() 863 if("${info}" MATCHES "INFO:platform\\[([^]\"]*)\\]") 864 set(PLATFORM_ID "${CMAKE_MATCH_1}") 865 endif() 866 if("${info}" MATCHES "INFO:arch\\[([^]\"]*)\\]") 867 set(ARCHITECTURE_ID "${CMAKE_MATCH_1}") 868 endif() 869 if("${info}" MATCHES "INFO:compiler_version\\[([^]\"]*)\\]") 870 string(REGEX REPLACE "^0+([0-9]+)" "\\1" COMPILER_VERSION "${CMAKE_MATCH_1}") 871 string(REGEX REPLACE "\\.0+([0-9])" ".\\1" COMPILER_VERSION "${COMPILER_VERSION}") 872 endif() 873 if("${info}" MATCHES "INFO:compiler_version_internal\\[([^]\"]*)\\]") 874 set(COMPILER_VERSION_INTERNAL "${CMAKE_MATCH_1}") 875 string(REGEX REPLACE "^0+([0-9]+)" "\\1" COMPILER_VERSION_INTERNAL "${COMPILER_VERSION_INTERNAL}") 876 string(REGEX REPLACE "\\.0+([0-9]+)" ".\\1" COMPILER_VERSION_INTERNAL "${COMPILER_VERSION_INTERNAL}") 877 string(STRIP "${COMPILER_VERSION_INTERNAL}" COMPILER_VERSION_INTERNAL) 878 endif() 879 foreach(comp MAJOR MINOR PATCH TWEAK) 880 foreach(digit 1 2 3 4 5 6 7 8 9) 881 if("${info}" MATCHES "INFO:compiler_version_${comp}_digit_${digit}\\[([0-9])\\]") 882 set(value ${CMAKE_MATCH_1}) 883 math(EXPR COMPILER_VERSION_${comp} "${COMPILER_VERSION_${comp}} + ${value} * ${DIGIT_VALUE_${digit}}") 884 set(HAVE_COMPILER_VERSION_${comp} 1) 885 endif() 886 endforeach() 887 endforeach() 888 if("${info}" MATCHES "INFO:compiler_wrapper\\[([^]\"]*)\\]") 889 set(COMPILER_WRAPPER "${CMAKE_MATCH_1}") 890 endif() 891 if("${info}" MATCHES "INFO:simulate\\[([^]\"]*)\\]") 892 set(SIMULATE_ID "${CMAKE_MATCH_1}") 893 endif() 894 if("${info}" MATCHES "INFO:simulate_version\\[([^]\"]*)\\]") 895 string(REGEX REPLACE "^0+([0-9])" "\\1" SIMULATE_VERSION "${CMAKE_MATCH_1}") 896 string(REGEX REPLACE "\\.0+([0-9])" ".\\1" SIMULATE_VERSION "${SIMULATE_VERSION}") 897 endif() 898 if("${info}" MATCHES "INFO:qnxnto\\[\\]") 899 set(COMPILER_QNXNTO 1) 900 endif() 901 if("${info}" MATCHES "INFO:standard_default\\[([^]\"]*)\\]") 902 set(CMAKE_${lang}_STANDARD_COMPUTED_DEFAULT "${CMAKE_MATCH_1}") 903 endif() 904 if("${info}" MATCHES "INFO:extensions_default\\[([^]\"]*)\\]") 905 set(CMAKE_${lang}_EXTENSIONS_COMPUTED_DEFAULT "${CMAKE_MATCH_1}") 906 endif() 907 endforeach() 908 909 # Construct compiler version from components if needed. 910 if(NOT DEFINED COMPILER_VERSION AND HAVE_COMPILER_VERSION_MAJOR) 911 set(COMPILER_VERSION "${COMPILER_VERSION_MAJOR}") 912 if(HAVE_COMPILER_VERSION_MINOR) 913 string(APPEND COMPILER_VERSION ".${COMPILER_VERSION_MINOR}") 914 if(HAVE_COMPILER_VERSION_PATCH) 915 string(APPEND COMPILER_VERSION ".${COMPILER_VERSION_PATCH}") 916 if(HAVE_COMPILER_VERSION_TWEAK) 917 string(APPEND COMPILER_VERSION ".${COMPILER_VERSION_TWEAK}") 918 endif() 919 endif() 920 endif() 921 endif() 922 923 # Detect the exact architecture from the PE header. 924 if(WIN32) 925 # The offset to the PE signature is stored at 0x3c. 926 file(READ ${file} peoffsethex LIMIT 1 OFFSET 60 HEX) 927 if(NOT peoffsethex STREQUAL "") 928 string(SUBSTRING "${peoffsethex}" 0 1 peoffsethex1) 929 string(SUBSTRING "${peoffsethex}" 1 1 peoffsethex2) 930 set(peoffsetexpression "${peoffsethex1} * 16 + ${peoffsethex2}") 931 string(REPLACE "a" "10" peoffsetexpression "${peoffsetexpression}") 932 string(REPLACE "b" "11" peoffsetexpression "${peoffsetexpression}") 933 string(REPLACE "c" "12" peoffsetexpression "${peoffsetexpression}") 934 string(REPLACE "d" "13" peoffsetexpression "${peoffsetexpression}") 935 string(REPLACE "e" "14" peoffsetexpression "${peoffsetexpression}") 936 string(REPLACE "f" "15" peoffsetexpression "${peoffsetexpression}") 937 math(EXPR peoffset "${peoffsetexpression}") 938 939 file(READ ${file} peheader LIMIT 6 OFFSET ${peoffset} HEX) 940 if(peheader STREQUAL "50450000a201") 941 set(ARCHITECTURE_ID "SH3") 942 elseif(peheader STREQUAL "50450000a301") 943 set(ARCHITECTURE_ID "SH3DSP") 944 elseif(peheader STREQUAL "50450000a601") 945 set(ARCHITECTURE_ID "SH4") 946 elseif(peheader STREQUAL "50450000a801") 947 set(ARCHITECTURE_ID "SH5") 948 endif() 949 endif() 950 endif() 951 952 # Check if a valid compiler and platform were found. 953 if(COMPILER_ID AND NOT COMPILER_ID_TWICE) 954 set(CMAKE_${lang}_COMPILER_ID "${COMPILER_ID}") 955 set(CMAKE_${lang}_PLATFORM_ID "${PLATFORM_ID}") 956 set(CMAKE_${lang}_COMPILER_ARCHITECTURE_ID "${ARCHITECTURE_ID}") 957 set(MSVC_${lang}_ARCHITECTURE_ID "${ARCHITECTURE_ID}") 958 set(CMAKE_${lang}_COMPILER_VERSION "${COMPILER_VERSION}") 959 set(CMAKE_${lang}_COMPILER_VERSION_INTERNAL "${COMPILER_VERSION_INTERNAL}") 960 set(CMAKE_${lang}_SIMULATE_ID "${SIMULATE_ID}") 961 set(CMAKE_${lang}_SIMULATE_VERSION "${SIMULATE_VERSION}") 962 endif() 963 964 # Check the compiler identification string. 965 if(CMAKE_${lang}_COMPILER_ID) 966 # The compiler identification was found. 967 file(APPEND ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeOutput.log 968 "The ${lang} compiler identification is ${CMAKE_${lang}_COMPILER_ID}, found in \"" 969 "${file}\"\n\n") 970 else() 971 # The compiler identification could not be found. 972 file(APPEND ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeError.log 973 "The ${lang} compiler identification could not be found in \"" 974 "${file}\"\n\n") 975 endif() 976 endif() 977 978 # try to figure out the executable format: ELF, COFF, Mach-O 979 if(NOT CMAKE_EXECUTABLE_FORMAT) 980 file(READ ${file} CMAKE_EXECUTABLE_MAGIC LIMIT 4 HEX) 981 982 # ELF files start with 0x7f"ELF" 983 if("${CMAKE_EXECUTABLE_MAGIC}" STREQUAL "7f454c46") 984 set(CMAKE_EXECUTABLE_FORMAT "ELF" CACHE INTERNAL "Executable file format") 985 endif() 986 987# # COFF (.exe) files start with "MZ" 988# if("${CMAKE_EXECUTABLE_MAGIC}" MATCHES "4d5a....") 989# set(CMAKE_EXECUTABLE_FORMAT "COFF" CACHE INTERNAL "Executable file format") 990# endif() 991# 992 # Mach-O files start with MH_MAGIC or MH_CIGAM 993 if("${CMAKE_EXECUTABLE_MAGIC}" MATCHES "feedface|cefaedfe|feedfacf|cffaedfe") 994 set(CMAKE_EXECUTABLE_FORMAT "MACHO" CACHE INTERNAL "Executable file format") 995 endif() 996 997 # XCOFF files start with 0x01 followed by 0xDF (32-bit) or 0xF7 (64-bit). 998 if("${CMAKE_EXECUTABLE_MAGIC}" MATCHES "^01(df|f7)") 999 set(CMAKE_EXECUTABLE_FORMAT "XCOFF" CACHE INTERNAL "Executable file format") 1000 endif() 1001 1002 endif() 1003 # Return the information extracted. 1004 set(CMAKE_${lang}_COMPILER_ID "${CMAKE_${lang}_COMPILER_ID}" PARENT_SCOPE) 1005 set(CMAKE_${lang}_PLATFORM_ID "${CMAKE_${lang}_PLATFORM_ID}" PARENT_SCOPE) 1006 set(CMAKE_${lang}_COMPILER_ARCHITECTURE_ID "${CMAKE_${lang}_COMPILER_ARCHITECTURE_ID}" PARENT_SCOPE) 1007 set(MSVC_${lang}_ARCHITECTURE_ID "${MSVC_${lang}_ARCHITECTURE_ID}" 1008 PARENT_SCOPE) 1009 set(CMAKE_${lang}_COMPILER_VERSION "${CMAKE_${lang}_COMPILER_VERSION}" PARENT_SCOPE) 1010 set(CMAKE_${lang}_COMPILER_VERSION_INTERNAL "${CMAKE_${lang}_COMPILER_VERSION_INTERNAL}" PARENT_SCOPE) 1011 set(CMAKE_${lang}_COMPILER_WRAPPER "${COMPILER_WRAPPER}" PARENT_SCOPE) 1012 set(CMAKE_${lang}_SIMULATE_ID "${CMAKE_${lang}_SIMULATE_ID}" PARENT_SCOPE) 1013 set(CMAKE_${lang}_SIMULATE_VERSION "${CMAKE_${lang}_SIMULATE_VERSION}" PARENT_SCOPE) 1014 set(COMPILER_QNXNTO "${COMPILER_QNXNTO}" PARENT_SCOPE) 1015 set(CMAKE_${lang}_STANDARD_COMPUTED_DEFAULT "${CMAKE_${lang}_STANDARD_COMPUTED_DEFAULT}" PARENT_SCOPE) 1016 set(CMAKE_${lang}_EXTENSIONS_COMPUTED_DEFAULT "${CMAKE_${lang}_EXTENSIONS_COMPUTED_DEFAULT}" PARENT_SCOPE) 1017endfunction() 1018 1019#----------------------------------------------------------------------------- 1020# Function to query the compiler vendor. 1021# This uses a table with entries of the form 1022# list(APPEND CMAKE_${lang}_COMPILER_ID_VENDORS ${vendor}) 1023# set(CMAKE_${lang}_COMPILER_ID_VENDOR_FLAGS_${vendor} -some-vendor-flag) 1024# set(CMAKE_${lang}_COMPILER_ID_VENDOR_REGEX_${vendor} "Some Vendor Output") 1025# We try running the compiler with the flag for each vendor and 1026# matching its regular expression in the output. 1027function(CMAKE_DETERMINE_COMPILER_ID_VENDOR lang userflags) 1028 1029 if(NOT CMAKE_${lang}_COMPILER_ID_DIR) 1030 # We get here when this function is called not from within CMAKE_DETERMINE_COMPILER_ID() 1031 # This is done e.g. for detecting the compiler ID for assemblers. 1032 # Compute the directory in which to run the test and Create a clean working directory. 1033 set(CMAKE_${lang}_COMPILER_ID_DIR ${CMAKE_PLATFORM_INFO_DIR}/CompilerId${lang}) 1034 file(REMOVE_RECURSE ${CMAKE_${lang}_COMPILER_ID_DIR}) 1035 file(MAKE_DIRECTORY ${CMAKE_${lang}_COMPILER_ID_DIR}) 1036 endif() 1037 1038 # Save the current LC_ALL, LC_MESSAGES, and LANG environment variables 1039 # and set them to "C" so we get the expected output to match. 1040 set(_orig_lc_all $ENV{LC_ALL}) 1041 set(_orig_lc_messages $ENV{LC_MESSAGES}) 1042 set(_orig_lang $ENV{LANG}) 1043 set(ENV{LC_ALL} C) 1044 set(ENV{LC_MESSAGES} C) 1045 set(ENV{LANG} C) 1046 1047 foreach(vendor ${CMAKE_${lang}_COMPILER_ID_VENDORS}) 1048 set(flags ${CMAKE_${lang}_COMPILER_ID_VENDOR_FLAGS_${vendor}}) 1049 set(regex ${CMAKE_${lang}_COMPILER_ID_VENDOR_REGEX_${vendor}}) 1050 execute_process( 1051 COMMAND "${CMAKE_${lang}_COMPILER}" 1052 ${CMAKE_${lang}_COMPILER_ID_ARG1} 1053 ${userflags} 1054 ${flags} 1055 WORKING_DIRECTORY ${CMAKE_${lang}_COMPILER_ID_DIR} 1056 OUTPUT_VARIABLE output ERROR_VARIABLE output 1057 RESULT_VARIABLE result 1058 TIMEOUT 10 1059 ) 1060 1061 if("${output}" MATCHES "${regex}") 1062 file(APPEND ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeOutput.log 1063 "Checking whether the ${lang} compiler is ${vendor} using \"${flags}\" " 1064 "matched \"${regex}\":\n${output}") 1065 set(CMAKE_${lang}_COMPILER_ID "${vendor}" PARENT_SCOPE) 1066 set(CMAKE_${lang}_COMPILER_ID_OUTPUT "${output}" PARENT_SCOPE) 1067 set(CMAKE_${lang}_COMPILER_ID_VENDOR_MATCH "${CMAKE_MATCH_1}" PARENT_SCOPE) 1068 break() 1069 else() 1070 if("${result}" MATCHES "timeout") 1071 file(APPEND ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeError.log 1072 "Checking whether the ${lang} compiler is ${vendor} using \"${flags}\" " 1073 "terminated after 10 s due to timeout.") 1074 else() 1075 file(APPEND ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeError.log 1076 "Checking whether the ${lang} compiler is ${vendor} using \"${flags}\" " 1077 "did not match \"${regex}\":\n${output}") 1078 endif() 1079 endif() 1080 endforeach() 1081 1082 # Restore original LC_ALL, LC_MESSAGES, and LANG 1083 set(ENV{LC_ALL} ${_orig_lc_all}) 1084 set(ENV{LC_MESSAGES} ${_orig_lc_messages}) 1085 set(ENV{LANG} ${_orig_lang}) 1086endfunction() 1087 1088function(CMAKE_DETERMINE_MSVC_SHOWINCLUDES_PREFIX lang userflags) 1089 # Run this MSVC-compatible compiler to detect what the /showIncludes 1090 # option displays. We can use a C source even with the C++ compiler 1091 # because MSVC-compatible compilers handle both and show the same output. 1092 set(showdir ${CMAKE_BINARY_DIR}/CMakeFiles/ShowIncludes) 1093 file(WRITE ${showdir}/foo.h "\n") 1094 file(WRITE ${showdir}/main.c "#include \"foo.h\" \nint main(){}\n") 1095 execute_process( 1096 COMMAND "${CMAKE_${lang}_COMPILER}" 1097 ${CMAKE_${lang}_COMPILER_ID_ARG1} 1098 ${userflags} 1099 /nologo /showIncludes /c main.c 1100 WORKING_DIRECTORY ${showdir} 1101 OUTPUT_VARIABLE out 1102 ERROR_VARIABLE err 1103 RESULT_VARIABLE res 1104 ENCODING AUTO # cl prints in current code page 1105 ) 1106 if(res EQUAL 0 AND "${out}" MATCHES "(^|\n)([^:\n]*:[^:\n]*:[ \t]*)") 1107 set(CMAKE_${lang}_CL_SHOWINCLUDES_PREFIX "${CMAKE_MATCH_2}" PARENT_SCOPE) 1108 else() 1109 set(CMAKE_${lang}_CL_SHOWINCLUDES_PREFIX "" PARENT_SCOPE) 1110 endif() 1111endfunction() 1112