Update upstream source from tag 'upstream/3.21.3'

Update to upstream version '3.21.3'
with Debian dir 09df7c6912
ci/unstable
Timo Röhling 3 years ago
commit 13afa71e65

@ -7,7 +7,7 @@ Generates Visual Studio 17 (VS 2022) project files.
.. 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
@ -51,7 +51,7 @@ name (architecture). For example:
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.

@ -363,8 +363,8 @@ Changes made since CMake 3.20.0 include the following.
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

@ -27,7 +27,7 @@ Generators
----------
* 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
@ -313,3 +313,19 @@ Changes made since CMake 3.21.0 include the following.
* 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.

@ -5,7 +5,8 @@ CMAKE_HIP_ARCHITECTURES
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.

@ -34,7 +34,6 @@ include:
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)

@ -82,9 +82,6 @@ function(compiler_id_detection outvar lang)
AppleClang
ARMClang
)
if(NOT __skip_rocmclang)
list(APPEND ordered_compilers ROCMClang)
endif()
list(APPEND ordered_compilers
Clang
GNU

@ -32,7 +32,7 @@ macro(_cmake_find_compiler lang)
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)

@ -150,41 +150,6 @@ function(CMAKE_DETERMINE_COMPILER_ID lang flagvar src)
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}"

@ -15,6 +15,13 @@ if(NOT CMAKE_HIP_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")
@ -26,10 +33,25 @@ if(NOT CMAKE_HIP_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()
@ -52,7 +74,40 @@ if(NOT CMAKE_HIP_COMPILER_ID_RUN)
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)
@ -85,12 +140,44 @@ if(MSVC_HIP_ARCHITECTURE_ID)
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

@ -20,6 +20,9 @@
# 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)
@ -240,3 +243,5 @@ if("x${CMAKE_${_CMAKE_PROCESSING_LANGUAGE}_COMPILER_ID}" MATCHES "^xIAR$")
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)

@ -16,6 +16,7 @@ set(CMAKE_HIP_COMPILER_FRONTEND_VARIANT "@CMAKE_HIP_COMPILER_FRONTEND_VARIANT@")
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")

@ -132,8 +132,11 @@ endif()
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()

@ -1,99 +0,0 @@
# 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()

@ -81,20 +81,6 @@ unset(__CMAKE_HIP_FLAGS)
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
@ -113,10 +99,3 @@ endif()
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()

@ -15,6 +15,6 @@ 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
# Populated by CMakeHIPInformation.cmake
set(CMAKE_HIP_RUNTIME_LIBRARIES_STATIC "")
set(CMAKE_HIP_RUNTIME_LIBRARIES_SHARED "")

@ -1,2 +0,0 @@
include(Compiler/ROCMClang)
__compiler_rocmclang(ASM)

@ -1,7 +0,0 @@
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}")

@ -1,7 +0,0 @@
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}")

@ -1,19 +0,0 @@
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")

@ -1 +0,0 @@
include(Compiler/Clang-FindBinUtils)

@ -1,49 +0,0 @@
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)

@ -1,7 +0,0 @@
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}")

@ -1,7 +0,0 @@
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}")

@ -1,35 +0,0 @@
# 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()

@ -1335,7 +1335,7 @@ function(_Boost_COMPONENT_DEPENDENCIES component _ret)
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)
@ -1350,7 +1350,22 @@ function(_Boost_COMPONENT_DEPENDENCIES component _ret)
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()
@ -1623,7 +1638,7 @@ else()
# _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"

@ -98,6 +98,7 @@ macro (_PYTHON_FIND_FRAMEWORKS)
${_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)

@ -222,8 +222,12 @@ if(MSVC)
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)
@ -264,7 +268,7 @@ if(MSVC)
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

@ -56,11 +56,6 @@ if(CMAKE_ANDROID_NDK_TOOLCHAIN_UNIFIED)
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}")

@ -67,7 +67,10 @@ if(NOT MSVC_VERSION)
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)

@ -384,7 +384,6 @@ elseif(_WCDH_policy STREQUAL "")
)
endif()
set(__skip_rocmclang TRUE)
include(${CMAKE_CURRENT_LIST_DIR}/CMakeCompilerIdDetection.cmake)
function(_load_compiler_variables CompilerId lang)

@ -1,7 +1,7 @@
# 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)
@ -21,7 +21,7 @@ endif()
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]* "

@ -952,6 +952,8 @@ void cmGlobalNinjaGenerator::EnableLanguage(
(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;

@ -581,6 +581,10 @@ void cmVisualStudio10TargetGenerator::Generate()
}
if (this->Managed) {
if (this->LocalGenerator->GetVersion() >=
cmGlobalVisualStudioGenerator::VS17) {
e1.Element("ManagedAssembly", "true");
}
std::string outputType;
switch (this->GeneratorTarget->GetType()) {
case cmStateEnums::OBJECT_LIBRARY:

@ -14,6 +14,10 @@
# 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)

@ -19,7 +19,7 @@ target_compile_options(HIPOnlyWithDefs
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

@ -33,6 +33,12 @@ set(TARGET_RESX
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")

Loading…
Cancel
Save