.. warning::
- This is experimental and based on "Visual Studio 2022 Preview 3.1".
+ This is experimental and based on "Visual Studio 2022 Preview 4".
As of this version of CMake, VS 2022 has not been released.
Project Types
Toolset Selection
^^^^^^^^^^^^^^^^^
-The ``v143`` toolset that comes with VS 17 2022 Preview 3.1 is selected by
+The ``v143`` toolset that comes with VS 17 2022 Preview 4 is selected by
default. The :variable:`CMAKE_GENERATOR_TOOLSET` option may be set, perhaps
via the :manual:`cmake(1)` ``-T`` option, to specify another toolset.
The oneAPI 2021.2 Fortran compiler defines the proper identification
macro and so is identified as ``IntelLLVM`` by all CMake 3.20 versions.
-3.20.3, 3.20.4, 3.20.5
-----------------------
+3.20.3, 3.20.4, 3.20.5, 3.20.6
+------------------------------
These versions made no changes to documented features or interfaces.
Some implementation updates were made to support ecosystem changes
----------
* The :generator:`Visual Studio 17 2022` generator was added. This is
- experimental and based on "Visual Studio 2022 Preview 3.1" because this
+ experimental and based on "Visual Studio 2022 Preview 4" because this
version of VS has not been released.
* The :ref:`Makefile Generators` and the :generator:`Ninja` generator
* The :generator:`Visual Studio 17 2022` generator is now based on
"Visual Studio 2022 Preview 3.1". Previously it was based on "Preview 2".
+
+3.21.3
+------
+
+* The :generator:`Visual Studio 17 2022` generator is now based on
+ "Visual Studio 2022 Preview 4". Previously it was based on "Preview 3.1".
+
+* The AMD ROCm Platform ``hipcc`` compiler was identifed by CMake 3.21.0
+ through 3.21.2 as a distinct compiler with id ``ROCMClang``. This has
+ been removed because it caused regressions. Instead:
+
+ * ``hipcc`` may no longer be used as a ``HIP`` compiler because it
+ interferes with flags CMake needs to pass to Clang. Use Clang directly.
+
+ * ``hipcc`` may once again be used as a ``CXX`` compiler, and is treated as
+ whatever compiler it selects underneath, as CMake 3.20 and below did.
Default value for :prop_tgt:`HIP_ARCHITECTURES` property of targets.
-This is initialized to the default architecture chosen by the compiler.
+This is initialized to the architectures reported by ``rocm_agent_enumerator``,
+if available, and otherwise to the default chosen by the compiler.
This variable is used to initialize the :prop_tgt:`HIP_ARCHITECTURES` property
on all targets. See the target property for additional information.
OpenWatcom = Open Watcom (openwatcom.org)
PGI = The Portland Group (pgroup.com)
PathScale = PathScale (pathscale.com)
- ROCMClang = ROCm Toolkit Clang-based Compiler (rocmdocs.amd.com)
SDCC = Small Device C Compiler (sdcc.sourceforge.net)
SunPro = Oracle Solaris Studio (oracle.com)
TI = Texas Instruments (ti.com)
AppleClang
ARMClang
)
- if(NOT __skip_rocmclang)
- list(APPEND ordered_compilers ROCMClang)
- endif()
list(APPEND ordered_compilers
Clang
GNU
endif()
# Look for directories containing compilers of reference languages.
- set(_${lang}_COMPILER_HINTS)
+ set(_${lang}_COMPILER_HINTS "${CMAKE_${lang}_COMPILER_HINTS}")
foreach(l ${_languages})
if(CMAKE_${l}_COMPILER AND IS_ABSOLUTE "${CMAKE_${l}_COMPILER}")
get_filename_component(_hint "${CMAKE_${l}_COMPILER}" PATH)
endif()
endif()
- # When invoked with HIPCC we need to extract the path to the underlying
- # clang compiler when possible. This fixes the following issues:
- # env variables can change how hipcc behaves
- # allows us to properly find the binutils bundled with hip
- if(CMAKE_${lang}_COMPILER_ID STREQUAL "ROCMClang"
- AND CMAKE_${lang}_COMPILER MATCHES ".*hipcc")
- get_filename_component(_hipcc_dir "${CMAKE_${lang}_COMPILER}" DIRECTORY)
- execute_process(
- COMMAND "${_hipcc_dir}/hipconfig"
- --hipclangpath
- OUTPUT_VARIABLE output
- RESULT_VARIABLE result
- )
- if(result EQUAL 0 AND EXISTS "${output}")
- if(lang STREQUAL "C")
- set_property(CACHE CMAKE_${lang}_COMPILER PROPERTY VALUE "${output}/clang")
- set(CMAKE_${lang}_COMPILER "${output}/clang" PARENT_SCOPE)
- else()
- set_property(CACHE CMAKE_${lang}_COMPILER PROPERTY VALUE "${output}/clang++")
- set(CMAKE_${lang}_COMPILER "${output}/clang++" PARENT_SCOPE)
- endif()
- endif()
- if(lang STREQUAL "HIP")
- execute_process(
- COMMAND "${_hipcc_dir}/hipconfig"
- --rocmpath
- OUTPUT_VARIABLE output
- RESULT_VARIABLE result
- )
- if(result EQUAL 0)
- set(_CMAKE_HIP_COMPILER_ROCM_ROOT "${output}" PARENT_SCOPE)
- endif()
- endif()
- endif()
-
if (COMPILER_QNXNTO AND CMAKE_${lang}_COMPILER_ID STREQUAL "GNU")
execute_process(
COMMAND "${CMAKE_${lang}_COMPILER}"
# prefer the environment variable HIPCXX
if(NOT $ENV{HIPCXX} STREQUAL "")
+ if("$ENV{HIPCXX}" MATCHES "hipcc")
+ message(FATAL_ERROR
+ "The HIPCXX environment variable is set to the hipcc wrapper:\n"
+ " $ENV{HIPCXX}\n"
+ "This is not supported. Use Clang directly, or let CMake pick a default."
+ )
+ endif()
get_filename_component(CMAKE_HIP_COMPILER_INIT $ENV{HIPCXX} PROGRAM PROGRAM_ARGS CMAKE_HIP_FLAGS_ENV_INIT)
if(CMAKE_HIP_FLAGS_ENV_INIT)
set(CMAKE_HIP_COMPILER_ARG1 "${CMAKE_HIP_FLAGS_ENV_INIT}" CACHE STRING "Arguments to CXX compiler")
# finally list compilers to try
if(NOT CMAKE_HIP_COMPILER_INIT)
- set(CMAKE_HIP_COMPILER_LIST hipcc clang++)
+ set(CMAKE_HIP_COMPILER_LIST clang++)
+
+ # Look for the Clang coming with ROCm to support HIP.
+ execute_process(COMMAND hipconfig --hipclangpath
+ OUTPUT_VARIABLE _CMAKE_HIPCONFIG_CLANGPATH
+ RESULT_VARIABLE _CMAKE_HIPCONFIG_RESULT
+ )
+ if(_CMAKE_HIPCONFIG_RESULT EQUAL 0 AND EXISTS "${_CMAKE_HIPCONFIG_CLANGPATH}")
+ set(CMAKE_HIP_COMPILER_HINTS "${_CMAKE_HIPCONFIG_CLANGPATH}")
+ endif()
endif()
_cmake_find_compiler(HIP)
+elseif(CMAKE_HIP_COMPILER MATCHES "hipcc")
+ message(FATAL_ERROR
+ "CMAKE_HIP_COMPILER is set to the hipcc wrapper:\n"
+ " ${CMAKE_HIP_COMPILER}\n"
+ "This is not supported. Use Clang directly, or let CMake pick a default."
+ )
else()
_cmake_find_compiler_path(HIP)
endif()
CMAKE_DETERMINE_COMPILER_ID(HIP HIPFLAGS CMakeHIPCompilerId.hip)
_cmake_find_compiler_sysroot(HIP)
+endif()
+if(NOT CMAKE_HIP_COMPILER_ROCM_ROOT AND CMAKE_HIP_COMPILER_ID STREQUAL "Clang")
+ execute_process(COMMAND "${CMAKE_HIP_COMPILER}" -v -print-targets
+ OUTPUT_STRIP_TRAILING_WHITESPACE
+ RESULT_VARIABLE _CMAKE_HIP_COMPILER_RESULT
+ OUTPUT_VARIABLE _CMAKE_HIP_COMPILER_STDOUT
+ ERROR_VARIABLE _CMAKE_HIP_COMPILER_STDERR
+ )
+
+ if(_CMAKE_HIP_COMPILER_RESULT EQUAL 0 AND _CMAKE_HIP_COMPILER_STDERR MATCHES "Found HIP installation: *([^,]*)[,\n]")
+ set(CMAKE_HIP_COMPILER_ROCM_ROOT "${CMAKE_MATCH_1}")
+ endif()
+endif()
+if(NOT CMAKE_HIP_COMPILER_ROCM_ROOT)
+ execute_process(
+ COMMAND hipconfig --rocmpath
+ OUTPUT_VARIABLE _CMAKE_HIPCONFIG_ROCMPATH
+ RESULT_VARIABLE _CMAKE_HIPCONFIG_RESULT
+ )
+ if(_CMAKE_HIPCONFIG_RESULT EQUAL 0 AND EXISTS "${_CMAKE_HIPCONFIG_ROCMPATH}")
+ set(CMAKE_HIP_COMPILER_ROCM_ROOT "${_CMAKE_HIPCONFIG_ROCMPATH}")
+ endif()
+endif()
+if(NOT CMAKE_HIP_COMPILER_ROCM_ROOT)
+ message(FATAL_ERROR "Failed to find ROCm root directory.")
+endif()
+if(NOT EXISTS "${CMAKE_HIP_COMPILER_ROCM_ROOT}/lib/cmake/hip-lang/hip-lang-config.cmake")
+ message(FATAL_ERROR
+ "The ROCm root directory:\n"
+ " ${CMAKE_HIP_COMPILER_ROCM_ROOT}\n"
+ "does not contain the HIP runtime CMake package, expected at:\n"
+ " ${CMAKE_HIP_COMPILER_ROCM_ROOT}/lib/cmake/hip-lang/hip-lang-config.cmake\n"
+ )
endif()
if (NOT _CMAKE_TOOLCHAIN_LOCATION)
endif()
if(NOT DEFINED CMAKE_HIP_ARCHITECTURES)
- # Analyze output from hipcc to get the current GPU architecture.
- if(CMAKE_HIP_COMPILER_PRODUCED_OUTPUT MATCHES " -target-cpu ([a-z0-9]+) ")
+ # Use 'rocm_agent_enumerator' to get the current GPU architecture.
+ set(_CMAKE_HIP_ARCHITECTURES)
+ find_program(_CMAKE_HIP_ROCM_AGENT_ENUMERATOR
+ NAMES rocm_agent_enumerator
+ HINTS "${CMAKE_HIP_COMPILER_ROCM_ROOT}/bin"
+ NO_CACHE)
+ if(_CMAKE_HIP_ROCM_AGENT_ENUMERATOR)
+ execute_process(COMMAND "${_CMAKE_HIP_ROCM_AGENT_ENUMERATOR}" -t GPU
+ RESULT_VARIABLE _CMAKE_ROCM_AGENT_ENUMERATOR_RESULT
+ OUTPUT_VARIABLE _CMAKE_ROCM_AGENT_ENUMERATOR_STDOUT
+ ERROR_VARIABLE _CMAKE_ROCM_AGENT_ENUMERATOR_STDERR
+ )
+ if(_CMAKE_ROCM_AGENT_ENUMERATOR_RESULT EQUAL 0)
+ separate_arguments(_hip_archs NATIVE_COMMAND "${_CMAKE_ROCM_AGENT_ENUMERATOR_STDOUT}")
+ foreach(_hip_arch ${_hip_archs})
+ if(_hip_arch STREQUAL "gfx000")
+ continue()
+ endif()
+ string(FIND ${_hip_arch} ":" pos)
+ if(NOT pos STREQUAL "-1")
+ string(SUBSTRING ${_hip_arch} 0 ${pos} _hip_arch)
+ endif()
+ list(APPEND _CMAKE_HIP_ARCHITECTURES "${_hip_arch}")
+ endforeach()
+ endif()
+ unset(_CMAKE_ROCM_AGENT_ENUMERATOR_RESULT)
+ unset(_CMAKE_ROCM_AGENT_ENUMERATOR_STDOUT)
+ unset(_CMAKE_ROCM_AGENT_ENUMERATOR_STDERR)
+ endif()
+ unset(_CMAKE_HIP_ROCM_AGENT_ENUMERATOR)
+ if(_CMAKE_HIP_ARCHITECTURES)
+ set(CMAKE_HIP_ARCHITECTURES "${_CMAKE_HIP_ARCHITECTURES}" CACHE STRING "HIP architectures")
+ elseif(CMAKE_HIP_COMPILER_PRODUCED_OUTPUT MATCHES " -target-cpu ([a-z0-9]+) ")
set(CMAKE_HIP_ARCHITECTURES "${CMAKE_MATCH_1}" CACHE STRING "HIP architectures")
else()
- message(FATAL_ERROR "Failed to find a working HIP architecture.")
+ message(FATAL_ERROR "Failed to find a default HIP architecture.")
endif()
+ unset(_CMAKE_HIP_ARCHITECTURES)
endif()
# configure variables set in this file for fast reload later on
# on UNIX, cygwin and mingw
+cmake_policy(PUSH)
+cmake_policy(SET CMP0057 NEW) # if IN_LIST
+
# Resolve full path of CMAKE_TOOL from user-defined name and SEARCH_PATH.
function(__resolve_tool_path CMAKE_TOOL SEARCH_PATH DOCSTRING)
set(CMAKE_IAR_LINKER "${CMAKE_LINKER}" CACHE FILEPATH "The IAR ILINK linker")
mark_as_advanced(CMAKE_IAR_LINKER CMAKE_IAR_AR)
endif()
+
+cmake_policy(POP)
set(CMAKE_HIP_SIMULATE_VERSION "@CMAKE_HIP_SIMULATE_VERSION@")
@SET_MSVC_HIP_ARCHITECTURE_ID@
@_SET_CMAKE_HIP_COMPILER_SYSROOT@
+set(CMAKE_HIP_COMPILER_ROCM_ROOT "@CMAKE_HIP_COMPILER_ROCM_ROOT@")
set(CMAKE_HIP_COMPILER_ENV_VAR "HIPCXX")
set(CMAKE_HIP_INFORMATION_LOADED 1)
# Load the file and find the relevant HIP runtime.
-# This file will only exist after all compiler detection has finished
-include(${CMAKE_PLATFORM_INFO_DIR}/CMakeHIPRuntime.cmake OPTIONAL)
-if(COMMAND _CMAKE_FIND_HIP_RUNTIME)
- _CMAKE_FIND_HIP_RUNTIME()
+if(NOT DEFINED _CMAKE_HIP_DEVICE_RUNTIME_TARGET)
+ set(hip-lang_DIR "${CMAKE_HIP_COMPILER_ROCM_ROOT}/lib/cmake/hip-lang")
+ find_package(hip-lang CONFIG QUIET NO_DEFAULT_PATH)
+endif()
+if(DEFINED _CMAKE_HIP_DEVICE_RUNTIME_TARGET)
+ list(APPEND CMAKE_HIP_RUNTIME_LIBRARIES_STATIC ${_CMAKE_HIP_DEVICE_RUNTIME_TARGET})
+ list(APPEND CMAKE_HIP_RUNTIME_LIBRARIES_SHARED ${_CMAKE_HIP_DEVICE_RUNTIME_TARGET})
endif()
+++ /dev/null
-# Distributed under the OSI-approved BSD 3-Clause License. See accompanying
-# file Copyright.txt or https://cmake.org/licensing for details.
-
-
-function(_CMAKE_FIND_HIP_RUNTIME )
- # Determined when hipcc is the HIP compiler
- set(_CMAKE_HIP_COMPILER_ROCM_ROOT "@_CMAKE_HIP_COMPILER_ROCM_ROOT@")
-
- # Forward facing value that can be provided by the user
- set(CMAKE_HIP_COMPILER_TOOLKIT_ROOT @CMAKE_HIP_COMPILER_TOOLKIT_ROOT@)
-
- if(NOT DEFINED _CMAKE_HIP_DEVICE_RUNTIME_TARGET)
- set(message_on_found TRUE)
- endif()
-
- set(explicit_search_only FALSE)
- set(rocm_root_dirs )
- if(DEFINED CMAKE_HIP_COMPILER_TOOLKIT_ROOT)
- set(rocm_root_dirs "${CMAKE_HIP_COMPILER_TOOLKIT_ROOT}")
- set(explicit_search_only TRUE)
- set(error_message_location "the variable CMAKE_HIP_COMPILER_TOOLKIT_ROOT [\"${CMAKE_HIP_COMPILER_TOOLKIT_ROOT}\"]")
- elseif(DEFINED ENV{CMAKE_HIP_COMPILER_TOOLKIT_ROOT})
- set(rocm_root_dirs "$ENV{CMAKE_HIP_COMPILER_TOOLKIT_ROOT}")
- set(explicit_search_only TRUE)
- set(error_message_location "CMAKE_HIP_COMPILER_TOOLKIT_ROOT")
- set(error_message_location "the environment variable CMAKE_HIP_COMPILER_TOOLKIT_ROOT [\"$ENV{CMAKE_HIP_COMPILER_TOOLKIT_ROOT}\"]")
- elseif(DEFINED _CMAKE_HIP_COMPILER_ROCM_ROOT)
- set(rocm_root_dirs "${_CMAKE_HIP_COMPILER_ROCM_ROOT}")
- set(explicit_search_only TRUE)
- set(error_message_location "the associated hipconfig --rocmpath [\"${_CMAKE_HIP_COMPILER_ROCM_ROOT}\"]")
- endif()
-
- # Guess on where rocm is installed
- if(NOT rocm_root_dirs AND (UNIX AND NOT APPLE))
- set(platform_base "/opt/rocm-")
-
- # Finad all default rocm installations
- file(GLOB possible_paths "${platform_base}*")
-
- set(versions)
- foreach(p ${possible_paths})
- # Extract version number from end of string
- string(REGEX MATCH "[0-9]+\\.[0-9]+\\.[0-9]+$" p_version ${p})
- if(IS_DIRECTORY ${p} AND p_version)
- list(APPEND versions ${p_version})
- endif()
- endforeach()
-
- # Sort numerically in descending order, so we try the newest versions first.
- list(SORT versions COMPARE NATURAL ORDER DESCENDING)
-
- # With a descending list of versions, populate possible paths to search.
- set(rocm_root_dirs "/opt/rocm")
- foreach(v IN LISTS versions)
- list(APPEND rocm_root_dirs "${platform_base}${v}")
- endforeach()
- endif()
-
- set(search_rel_path "/lib/cmake/hip-lang/")
- list(TRANSFORM rocm_root_dirs APPEND "${search_rel_path}")
-
- find_package(hip-lang
- CONFIG
- PATHS ${rocm_root_dirs}
- QUIET
- NO_DEFAULT_PATH
- )
- if(NOT DEFINED _CMAKE_HIP_DEVICE_RUNTIME_TARGET AND NOT explicit_search_only)
- find_package(hip-lang CONFIG QUIET)
- endif()
-
- if(DEFINED _CMAKE_HIP_DEVICE_RUNTIME_TARGET)
- set(CMAKE_HIP_RUNTIME_LIBRARIES_STATIC
- ${CMAKE_HIP_RUNTIME_LIBRARIES_STATIC}
- ${_CMAKE_HIP_DEVICE_RUNTIME_TARGET} PARENT_SCOPE)
- set(CMAKE_HIP_RUNTIME_LIBRARIES_SHARED
- ${CMAKE_HIP_RUNTIME_LIBRARIES_SHARED}
- ${_CMAKE_HIP_DEVICE_RUNTIME_TARGET} PARENT_SCOPE)
- endif()
-
- if(DEFINED _CMAKE_HIP_DEVICE_RUNTIME_TARGET AND message_on_found)
- message(STATUS "Found HIP runtime: ${hip-lang_DIR}")
- elseif(NOT DEFINED _CMAKE_HIP_DEVICE_RUNTIME_TARGET)
- if(explicit_search_only)
- set(error_message "Failed to find the HIP runtime, Could not find hip-lang-config.cmake at the following location(s):\n")
- foreach(p IN LISTS rocm_root_dirs)
- string(APPEND error_message "\t${p}\n")
- endforeach()
- string(APPEND "which are computed from the location specified by ${error_message_location}. \
- Please specify CMAKE_HIP_COMPILER_TOOLKIT_ROOT to the location of")
- message(FATAL_ERROR "${error_message}")
- else()
- message(FATAL_ERROR
- "Failed to find the HIP runtime, Could not find hip-lang-config.cmake.\
- Try setting CMAKE_HIP_COMPILER_TOOLKIT_ROOT")
- endif()
- endif()
-
-endfunction()
include(${CMAKE_ROOT}/Modules/CMakeDetermineCompileFeatures.cmake)
CMAKE_DETERMINE_COMPILE_FEATURES(HIP)
-
-# Setup the following:
-# Configure the new template file CMakeHipRuntime.cmake to
-# - ${CMAKE_PLATFORM_INFO_DIR}/
-# This file will do the actual find_package query. We than have
-# CMakeHIPInformation.cmake include `CMakeHipRuntime`
-# So it is included once system information has been finished
-#
-configure_file(
- ${CMAKE_ROOT}/Modules/CMakeHIPRuntime.cmake.in
- ${CMAKE_PLATFORM_INFO_DIR}/CMakeHIPRuntime.cmake
- @ONLY
-)
-
# Re-configure to save learned information.
configure_file(
${CMAKE_ROOT}/Modules/CMakeHIPCompiler.cmake.in
set(CMAKE_TRY_COMPILE_TARGET_TYPE ${__CMAKE_SAVED_TRY_COMPILE_TARGET_TYPE})
unset(__CMAKE_SAVED_TRY_COMPILE_TARGET_TYPE)
unset(__CMAKE_HIP_COMPILER_OUTPUT)
-
-# Load the file and find the relevant HIP runtime.
-# This file will only exist after all compiler detection has finished
-include(${CMAKE_PLATFORM_INFO_DIR}/CMakeHIPRuntime.cmake)
-if(COMMAND _CMAKE_FIND_HIP_RUNTIME)
- _CMAKE_FIND_HIP_RUNTIME()
-endif()
set(CMAKE_HIP_RUNTIME_LIBRARY_LINK_OPTIONS_STATIC "")
set(CMAKE_HIP_RUNTIME_LIBRARY_LINK_OPTIONS_SHARED "")
-# Populated by CMakeHIPRuntime.cmake
+# Populated by CMakeHIPInformation.cmake
set(CMAKE_HIP_RUNTIME_LIBRARIES_STATIC "")
set(CMAKE_HIP_RUNTIME_LIBRARIES_SHARED "")
+++ /dev/null
-include(Compiler/ROCMClang)
-__compiler_rocmclang(ASM)
+++ /dev/null
-include(Compiler/ROCMClang)
-__compiler_rocmclang(C)
-
-set(_rocm_clang_ver "${CMAKE_C_COMPILER_VERSION_INTERNAL}")
-set(CMAKE_C_COMPILER_VERSION "${CMAKE_C_COMPILER_VERSION_INTERNAL}")
-include(Compiler/Clang-C)
-set(CMAKE_C_COMPILER_VERSION "${_rocm_clang_ver}")
+++ /dev/null
-include(Compiler/ROCMClang)
-__compiler_rocmclang(CXX)
-
-set(_rocm_clang_ver "${CMAKE_CXX_COMPILER_VERSION_INTERNAL}")
-set(CMAKE_CXX_COMPILER_VERSION "${CMAKE_CXX_COMPILER_VERSION_INTERNAL}")
-include(Compiler/Clang-CXX)
-set(CMAKE_CXX_COMPILER_VERSION "${_rocm_clang_ver}")
+++ /dev/null
-
-set(_compiler_id_pp_test "defined(__clang__) && __has_include(<hip/hip_version.h>)")
-
-set(_compiler_id_version_compute "
-# if defined(__clang__) && __has_include(<hip/hip_version.h>)
-# include <hip/hip_version.h>
-# define @PREFIX@COMPILER_VERSION_MAJOR @MACRO_DEC@(HIP_VERSION_MAJOR)
-# define @PREFIX@COMPILER_VERSION_MINOR @MACRO_DEC@(HIP_VERSION_MINOR)
-# define @PREFIX@COMPILER_VERSION_PATCH @MACRO_DEC@(HIP_VERSION_PATCH)
-# endif")
-
-set(_compiler_id_simulate "
-# if defined(_MSC_VER)
-# define @PREFIX@SIMULATE_ID \"MSVC\"
-# elif defined(__clang__)
-# define @PREFIX@SIMULATE_ID \"Clang\"
-# elif defined(__GNUC__)
-# define @PREFIX@SIMULATE_ID \"GNU\"
-# endif")
+++ /dev/null
-include(Compiler/Clang-FindBinUtils)
+++ /dev/null
-include(Compiler/ROCMClang)
-__compiler_rocmclang(HIP)
-
-set(_CMAKE_COMPILE_AS_HIP_FLAG "-x hip")
-set(_CMAKE_HIP_RDC_FLAG "-fgpu-rdc")
-
-if(NOT "x${CMAKE_${lang}_SIMULATE_ID}" STREQUAL "xMSVC")
- set(CMAKE_HIP_COMPILE_OPTIONS_VISIBILITY_INLINES_HIDDEN "-fvisibility-inlines-hidden")
- string(APPEND CMAKE_HIP_FLAGS_DEBUG_INIT " -O")
-endif()
-
-if(CMAKE_HIP_SIMULATE_ID STREQUAL "GNU")
- set(CMAKE_HIP_LINKER_WRAPPER_FLAG "-Wl,")
- set(CMAKE_HIP_LINKER_WRAPPER_FLAG_SEP ",")
-elseif(CMAKE_HIP_SIMULATE_ID STREQUAL "Clang")
- set(CMAKE_HIP_LINKER_WRAPPER_FLAG "-Xlinker" " ")
- set(CMAKE_HIP_LINKER_WRAPPER_FLAG_SEP)
-endif()
-
-if(NOT CMAKE_HIP_COMPILER_VERSION VERSION_LESS 1.0)
- set(CMAKE_HIP98_STANDARD_COMPILE_OPTION "-std=c++98")
- set(CMAKE_HIP98_EXTENSION_COMPILE_OPTION "-std=gnu++98")
- set(CMAKE_HIP98_STANDARD__HAS_FULL_SUPPORT ON)
-
- set(CMAKE_HIP11_STANDARD_COMPILE_OPTION "-std=c++11")
- set(CMAKE_HIP11_EXTENSION_COMPILE_OPTION "-std=gnu++11")
- set(CMAKE_HIP11_STANDARD__HAS_FULL_SUPPORT ON)
-
- set(CMAKE_HIP14_STANDARD_COMPILE_OPTION "-std=c++14")
- set(CMAKE_HIP14_EXTENSION_COMPILE_OPTION "-std=gnu++14")
- set(CMAKE_HIP14_STANDARD__HAS_FULL_SUPPORT ON)
-
- set(CMAKE_HIP17_STANDARD_COMPILE_OPTION "-std=c++17")
- set(CMAKE_HIP17_EXTENSION_COMPILE_OPTION "-std=gnu++17")
- set(CMAKE_HIP17_STANDARD__HAS_FULL_SUPPORT ON)
-
- set(CMAKE_HIP20_STANDARD_COMPILE_OPTION "-std=c++20")
- set(CMAKE_HIP20_EXTENSION_COMPILE_OPTION "-std=gnu++20")
-endif()
-
-set(CMAKE_HIP_RUNTIME_LIBRARY_DEFAULT "SHARED")
-set(CMAKE_HIP_RUNTIME_LIBRARY_LINK_OPTIONS_STATIC "")
-set(CMAKE_HIP_RUNTIME_LIBRARY_LINK_OPTIONS_SHARED "")
-
-# Populated by CMakeHIPRuntime.cmake
-set(CMAKE_HIP_RUNTIME_LIBRARIES_STATIC "")
-set(CMAKE_HIP_RUNTIME_LIBRARIES_SHARED "")
-
-__compiler_check_default_language_standard(HIP 3.5 11)
+++ /dev/null
-include(Compiler/ROCMClang)
-__compiler_rocmclang(OBJC)
-
-set(_rocm_clang_ver "${CMAKE_OBJC_COMPILER_VERSION_INTERNAL}")
-set(CMAKE_OBJC_COMPILER_VERSION "${CMAKE_OBJC_COMPILER_VERSION_INTERNAL}")
-include(Compiler/Clang-OBJC)
-set(CMAKE_OBJC_COMPILER_VERSION "${_rocm_clang_ver}")
+++ /dev/null
-include(Compiler/ROCMClang)
-__compiler_rocmclang(OBJCXX)
-
-set(_rocm_clang_ver "${CMAKE_OBJCXX_COMPILER_VERSION_INTERNAL}")
-set(CMAKE_OBJCXX_COMPILER_VERSION "${CMAKE_OBJCXX_COMPILER_VERSION_INTERNAL}")
-include(Compiler/Clang-OBJCXX)
-set(CMAKE_OBJCXX_COMPILER_VERSION "${_rocm_clang_ver}")
+++ /dev/null
-# Distributed under the OSI-approved BSD 3-Clause License. See accompanying
-# file Copyright.txt or https://cmake.org/licensing for details.
-
-
-# This module is shared by multiple languages; use include blocker.
-include_guard()
-
-include(Compiler/CMakeCommonCompilerMacros)
-
-macro(__compiler_rocmclang lang)
-
- set(CMAKE_${lang}_VERBOSE_FLAG "-v")
-
- if(NOT "x${CMAKE_${lang}_SIMULATE_ID}" STREQUAL "xMSVC")
- # Feature flags.
- set(CMAKE_${lang}_COMPILE_OPTIONS_PIC "-fPIC")
- set(CMAKE_${lang}_COMPILE_OPTIONS_PIE "-fPIE")
- set(CMAKE_HIP_COMPILE_OPTIONS_VISIBILITY -fvisibility=)
-
- string(APPEND CMAKE_HIP_FLAGS_INIT " ")
- string(APPEND CMAKE_HIP_FLAGS_DEBUG_INIT " -g")
- string(APPEND CMAKE_HIP_FLAGS_RELEASE_INIT " -O3 -DNDEBUG")
- string(APPEND CMAKE_HIP_FLAGS_MINSIZEREL_INIT " -Os -DNDEBUG")
- string(APPEND CMAKE_HIP_FLAGS_RELWITHDEBINFO_INIT " -O2 -g -DNDEBUG")
- endif()
-
- set(CMAKE_SHARED_LIBRARY_CREATE_HIP_FLAGS -shared)
- set(CMAKE_INCLUDE_SYSTEM_FLAG_HIP "-isystem ")
-
- set(CMAKE_${lang}_USE_RESPONSE_FILE_FOR_INCLUDES 1)
- set(CMAKE_${lang}_USE_RESPONSE_FILE_FOR_LIBRARIES 1)
- set(CMAKE_${lang}_USE_RESPONSE_FILE_FOR_OBJECTS 1)
- set(CMAKE_${lang}_RESPONSE_FILE_FLAG "@")
- set(CMAKE_${lang}_RESPONSE_FILE_LINK_FLAG "@")
-endmacro()
set(_Boost_TIMER_DEPENDENCIES chrono)
set(_Boost_WAVE_DEPENDENCIES filesystem serialization thread chrono date_time atomic)
set(_Boost_WSERIALIZATION_DEPENDENCIES serialization)
- else()
+ elseif(Boost_VERSION_STRING VERSION_LESS 1.77.0)
set(_Boost_CONTRACT_DEPENDENCIES thread chrono date_time)
set(_Boost_COROUTINE_DEPENDENCIES context)
set(_Boost_FIBER_DEPENDENCIES context)
set(_Boost_TIMER_DEPENDENCIES chrono)
set(_Boost_WAVE_DEPENDENCIES filesystem serialization thread chrono date_time atomic)
set(_Boost_WSERIALIZATION_DEPENDENCIES serialization)
- if(Boost_VERSION_STRING VERSION_GREATER_EQUAL 1.77.0 AND NOT Boost_NO_WARN_NEW_VERSIONS)
+ else()
+ set(_Boost_CONTRACT_DEPENDENCIES thread chrono)
+ set(_Boost_COROUTINE_DEPENDENCIES context)
+ set(_Boost_FIBER_DEPENDENCIES context)
+ set(_Boost_IOSTREAMS_DEPENDENCIES regex)
+ set(_Boost_JSON_DEPENDENCIES container)
+ set(_Boost_LOG_DEPENDENCIES date_time log_setup filesystem thread regex chrono atomic)
+ set(_Boost_MATH_DEPENDENCIES math_c99 math_c99f math_c99l math_tr1 math_tr1f math_tr1l)
+ set(_Boost_MPI_DEPENDENCIES serialization)
+ set(_Boost_MPI_PYTHON_DEPENDENCIES python${component_python_version} mpi serialization)
+ set(_Boost_NUMPY_DEPENDENCIES python${component_python_version})
+ set(_Boost_THREAD_DEPENDENCIES chrono atomic)
+ set(_Boost_TIMER_DEPENDENCIES chrono)
+ set(_Boost_WAVE_DEPENDENCIES filesystem serialization thread chrono atomic)
+ set(_Boost_WSERIALIZATION_DEPENDENCIES serialization)
+ if(Boost_VERSION_STRING VERSION_GREATER_EQUAL 1.78.0 AND NOT Boost_NO_WARN_NEW_VERSIONS)
message(WARNING "New Boost version may have incorrect or missing dependencies and imported targets")
endif()
endif()
# _Boost_COMPONENT_HEADERS. See the instructions at the top of
# _Boost_COMPONENT_DEPENDENCIES.
set(_Boost_KNOWN_VERSIONS ${Boost_ADDITIONAL_VERSIONS}
- "1.76.0" "1.76" "1.75.0" "1.75" "1.74.0" "1.74"
+ "1.77.0" "1.77" "1.76.0" "1.76" "1.75.0" "1.75" "1.74.0" "1.74"
"1.73.0" "1.73" "1.72.0" "1.72" "1.71.0" "1.71" "1.70.0" "1.70" "1.69.0" "1.69"
"1.68.0" "1.68" "1.67.0" "1.67" "1.66.0" "1.66" "1.65.1" "1.65.0" "1.65"
"1.64.0" "1.64" "1.63.0" "1.63" "1.62.0" "1.62" "1.61.0" "1.61" "1.60.0" "1.60"
${_pff_CMAKE_FRAMEWORK_PATH}
~/Library/Frameworks
/usr/local/Frameworks
+ /opt/homebrew/Frameworks
${CMAKE_SYSTEM_FRAMEWORK_PATH})
list (REMOVE_DUPLICATES _pff_frameworks)
foreach (_pff_implementation IN LISTS _${_PYTHON_PREFIX}_FIND_IMPLEMENTATIONS)
set(_MSVC_IDE_VERSION "")
if(MSVC_VERSION GREATER_EQUAL 2000)
message(WARNING "MSVC ${MSVC_VERSION} not yet supported.")
- elseif(MSVC_TOOLSET_VERSION GREATER_EQUAL 143)
+ elseif(MSVC_TOOLSET_VERSION GREATER_EQUAL 144)
message(WARNING "MSVC toolset v${MSVC_TOOLSET_VERSION} not yet supported.")
+ elseif(MSVC_TOOLSET_VERSION EQUAL 143)
+ set(MSVC_REDIST_NAME VC142)
+ set(_MSVC_DLL_VERSION 140)
+ set(_MSVC_IDE_VERSION 17)
elseif(MSVC_TOOLSET_VERSION EQUAL 142)
set(MSVC_REDIST_NAME VC142)
set(_MSVC_DLL_VERSION 140)
if(NOT vs VERSION_LESS 15)
set(_vs_redist_paths "")
# The toolset and its redistributables may come with any VS version 15 or newer.
- set(_MSVC_IDE_VERSIONS 16 15)
+ set(_MSVC_IDE_VERSIONS 17 16 15)
foreach(_vs_ver ${_MSVC_IDE_VERSIONS})
set(_vs_glob_redist_paths "")
cmake_host_system_information(RESULT _vs_dir QUERY VS_${_vs_ver}_DIR) # undocumented query
set(CMAKE_FIND_ROOT_PATH_MODE_PACKAGE ONLY)
endif()
- # Don't search paths in PATH environment variable.
- if(NOT DEFINED CMAKE_FIND_USE_SYSTEM_ENVIRONMENT_PATH)
- set(CMAKE_FIND_USE_SYSTEM_ENVIRONMENT_PATH OFF)
- endif()
-
# Allows CMake to find headers in the architecture-specific include directories.
set(CMAKE_LIBRARY_ARCHITECTURE "${CMAKE_ANDROID_ARCH_TRIPLE}")
message(FATAL_ERROR "MSVC compiler version not detected properly: ${_compiler_version}")
endif()
- if(MSVC_VERSION GREATER_EQUAL 1920)
+ if(MSVC_VERSION GREATER_EQUAL 1930)
+ # VS 2022 or greater
+ set(MSVC_TOOLSET_VERSION 143)
+ elseif(MSVC_VERSION GREATER_EQUAL 1920)
# VS 2019 or greater
set(MSVC_TOOLSET_VERSION 142)
elseif(MSVC_VERSION GREATER_EQUAL 1910)
)
endif()
-set(__skip_rocmclang TRUE)
include(${CMAKE_CURRENT_LIST_DIR}/CMakeCompilerIdDetection.cmake)
function(_load_compiler_variables CompilerId lang)
# CMake version number components.
set(CMake_VERSION_MAJOR 3)
set(CMake_VERSION_MINOR 21)
-set(CMake_VERSION_PATCH 2)
+set(CMake_VERSION_PATCH 3)
#set(CMake_VERSION_RC 0)
set(CMake_VERSION_IS_DIRTY 0)
if(NOT CMake_VERSION_NO_GIT)
# If this source was exported by 'git archive', use its commit info.
- set(git_info [==[31c5700d43 CMake 3.21.2]==])
+ set(git_info [==[7612abd52f CMake 3.21.3]==])
# Otherwise, try to identify the current development source version.
if(NOT git_info MATCHES "^([0-9a-f][0-9a-f][0-9a-f][0-9a-f][0-9a-f][0-9a-f]?[0-9a-f]?)[0-9a-f]* "
(mf->GetSafeDefinition("CMAKE_CXX_COMPILER_ID") == "GNU") ||
(mf->GetSafeDefinition("CMAKE_C_COMPILER_ID") == "Clang") ||
(mf->GetSafeDefinition("CMAKE_CXX_COMPILER_ID") == "Clang") ||
+ (mf->GetSafeDefinition("CMAKE_C_COMPILER_ID") == "ARMClang") ||
+ (mf->GetSafeDefinition("CMAKE_CXX_COMPILER_ID") == "ARMClang") ||
(mf->GetSafeDefinition("CMAKE_C_COMPILER_ID") == "QCC") ||
(mf->GetSafeDefinition("CMAKE_CXX_COMPILER_ID") == "QCC")))) {
this->UsingGCCOnWindows = true;
}
if (this->Managed) {
+ if (this->LocalGenerator->GetVersion() >=
+ cmGlobalVisualStudioGenerator::VS17) {
+ e1.Element("ManagedAssembly", "true");
+ }
std::string outputType;
switch (this->GeneratorTarget->GetType()) {
case cmStateEnums::OBJECT_LIBRARY:
# endif
#endif
+#if defined(_WIN32) && !defined(_WIN32_WINNT)
+# define _WIN32_WINNT _WIN32_WINNT_VISTA
+#endif
+
#include "kwsysPrivate.h"
#include KWSYS_HEADER(RegularExpression.hxx)
#include KWSYS_HEADER(SystemTools.hxx)
PRIVATE
--offload-arch=gfx900
-DFLAG_COMPILE_LANG_$<COMPILE_LANGUAGE>
- $<$<HIP_COMPILER_ID:ROCMClang>:-DFLAG_LANG_IS_HIP=$<COMPILE_LANGUAGE:HIP>> # Host-only defines are possible only on NVCC.
+ $<$<HIP_COMPILER_ID:Clang>:-DFLAG_LANG_IS_HIP=$<COMPILE_LANGUAGE:HIP>> # Host-only defines are possible only on NVCC.
)
target_compile_definitions(HIPOnlyWithDefs
set(TARGET_LIBRARIES ${SYSLIBS})
add_executable(${PROJECT_NAME} ${TARGET_SRC} ${TARGET_H} ${TARGET_RESX})
+if(NOT CMAKE_GENERATOR MATCHES "Visual Studio 1[0-6]")
+ # VS 17 2022 and above require a global mark on managed assemblies.
+ # CMake adds this automatically when using COMMON_LANGUAGE_RUNTIME,
+ # but this test covers direct use of /clr.
+ set_property(TARGET ${PROJECT_NAME} PROPERTY VS_GLOBAL_ManagedAssembly "true")
+endif()
# Note: The property VS_GLOBAL_KEYWORD must be set.
set_property(TARGET ${PROJECT_NAME} PROPERTY VS_GLOBAL_KEYWORD "ManagedCProj")
projects / platform / upstream / cmake.git / commitdiff