mirror of
https://github.com/reactos/CMake.git
synced 2024-12-13 22:58:41 +00:00
7195aca54f
At the top of a build tree we configure inside the CMakeFiles directory files such as "CMakeSystem.cmake" and "CMake<lang>Compiler.cmake" to save information detected about the system and compilers in use. The method of detection and the exact results store varies across CMake versions as things improve. This leads to problems when loading files configured by a different version of CMake. Previously we ignored such existing files only if the major.minor part of the CMake version component changed, and depended on the CMakeCache.txt to tell us the last version of CMake that wrote the files. This led to problems if the user deletes the CMakeCache.txt or we add required information to the files in a patch-level release of CMake (still a "feature point" release by modern CMake versioning convention). Ensure that we always have version-consistent platform information files by storing them in a subdirectory named with the CMake version. Every version of CMake will do its own system and compiler identification checks even when a build tree has already been configured by another version of CMake. Stored results will not clobber those from other versions of CMake which may be run again on the same tree in the future. Loaded results will match what the system and language modules expect. Rename the undocumented variable CMAKE_PLATFORM_ROOT_BIN to CMAKE_PLATFORM_INFO_DIR to clarify its purpose. The new variable points at the version-specific directory while the old variable did not.
140 lines
5.9 KiB
CMake
140 lines
5.9 KiB
CMake
############################################################
|
|
# some preparations so that the CMakeDetermineXXX.cmake files will work in scripted mode
|
|
|
|
# overwrite mark_as_advanced(), since this is used in CMakeDetermineCCompiler.cmake
|
|
# which will complain that it can"t be used in script mode
|
|
macro(MARK_AS_ADVANCED)
|
|
endmacro()
|
|
# set this to a place where we are allowed to write
|
|
set(CMAKE_PLATFORM_INFO_DIR "${CMAKE_CURRENT_BINARY_DIR}")
|
|
|
|
# don't run the compiler detection
|
|
set(CMAKE_C_COMPILER_ID_RUN 1)
|
|
set(CMAKE_CXX_COMPILER_ID_RUN 1)
|
|
|
|
set(MY_SOURCE_DIR "@CMAKE_CURRENT_SOURCE_DIR@")
|
|
|
|
# at first load CMakeDetermineSystem.cmake without toolchain file
|
|
set(CMAKE_TOOLCHAIN_FILE)
|
|
include(CMakeDetermineSystem)
|
|
|
|
# check that CMAKE_SYSTEM_XXX and CMAKE_HOST_SYSTEM_xxx are identical
|
|
if(NOT "${CMAKE_SYSTEM_NAME}" STREQUAL "${CMAKE_HOST_SYSTEM_NAME}")
|
|
message(FATAL_ERROR "CMAKE_SYSTEM_NAME and CMAKE_HOST_SYSTEM_NAME not identical: \"${CMAKE_SYSTEM_NAME}\" vs. \"${CMAKE_HOST_SYSTEM_NAME}\"")
|
|
endif()
|
|
|
|
if(NOT "${CMAKE_SYSTEM}" STREQUAL "${CMAKE_HOST_SYSTEM}")
|
|
message(FATAL_ERROR "CMAKE_SYSTEM and CMAKE_HOST_SYSTEM not identical: \"${CMAKE_SYSTEM}\" vs. \"${CMAKE_HOST_SYSTEM}\"")
|
|
endif()
|
|
|
|
if(NOT "${CMAKE_SYSTEM_VERSION}" STREQUAL "${CMAKE_HOST_SYSTEM_VERSION}")
|
|
message(FATAL_ERROR "CMAKE_SYSTEM_VERSION and CMAKE_HOST_SYSTEM_VERSION not identical: \"${CMAKE_SYSTEM_VERSION}\" vs. \"${CMAKE_HOST_SYSTEM_VERSION}\"")
|
|
endif()
|
|
|
|
if(NOT "${CMAKE_SYSTEM_PROCESSOR}" STREQUAL "${CMAKE_HOST_SYSTEM_PROCESSOR}")
|
|
message(FATAL_ERROR "CMAKE_SYSTEM_PROCESSOR and CMAKE_HOST_SYSTEM_PROCESSOR not identical: \"${CMAKE_SYSTEM_PROCESSOR}\" vs. \"${CMAKE_HOST_SYSTEM_PROCESSOR}\"")
|
|
endif()
|
|
|
|
# save the values so we can compare them to CMAKE_HOST_SYSTEM_XXX in the toolchain case
|
|
|
|
set(NATIVE_SYSTEM "${CMAKE_SYSTEM}")
|
|
set(NATIVE_SYSTEM_NAME "${CMAKE_SYSTEM_NAME}")
|
|
set(NATIVE_SYSTEM_VERSION "${CMAKE_SYSTEM_VERSION}")
|
|
set(NATIVE_SYSTEM_PROCESSOR "${CMAKE_SYSTEM_PROCESSOR}")
|
|
|
|
# reset them so they will be detected again now
|
|
set(CMAKE_SYSTEM)
|
|
set(CMAKE_SYSTEM_NAME)
|
|
set(CMAKE_SYSTEM_VERSION)
|
|
set(CMAKE_SYSTEM_PROCESSOR)
|
|
set(CMAKE_HOST_SYSTEM)
|
|
set(CMAKE_HOST_SYSTEM_NAME)
|
|
set(CMAKE_HOST_SYSTEM_VERSION)
|
|
set(CMAKE_HOST_SYSTEM_PROCESSOR)
|
|
|
|
|
|
############################################################
|
|
|
|
# now define a toolchain file and check that everything is
|
|
# detected correctly and nothing predefined is overwritten
|
|
|
|
set(CMAKE_TOOLCHAIN_FILE "${MY_SOURCE_DIR}/DummyToolchain.cmake")
|
|
|
|
include(CMakeDetermineSystem)
|
|
# make cmake think we are cross compiling for test to work
|
|
set(CMAKE_CROSSCOMPILING TRUE)
|
|
set(CMAKE_C_COMPILER_ID "GNU")
|
|
include(CMakeDetermineCCompiler)
|
|
include(CMakeDetermineCXXCompiler)
|
|
|
|
#############################################################
|
|
|
|
# check the results from DetermineSystem
|
|
|
|
if(NOT "${CMAKE_SYSTEM_NAME}" STREQUAL "Dumdidum")
|
|
message(FATAL_ERROR "CMAKE_SYSTEM_NAME overwritten: \"${CMAKE_SYSTEM_NAME}\", was: \"Dumdidum\"")
|
|
endif()
|
|
|
|
if(NOT "${CMAKE_SYSTEM}" STREQUAL "Dumdidum-1.0")
|
|
message(FATAL_ERROR "CMAKE_SYSTEM wrong: \"${CMAKE_SYSTEM}\", expected: \"Dumdidum-1.0\"")
|
|
endif()
|
|
set(fileOne "${_INCLUDED_TOOLCHAIN_FILE}")
|
|
set(fileTwo "${MY_SOURCE_DIR}/DummyToolchain.cmake")
|
|
if(WIN32)
|
|
string(TOLOWER "${fileOne}" fileOne)
|
|
string(TOLOWER "${fileTwo}" fileTwo)
|
|
endif()
|
|
|
|
if(NOT "${fileOne}" STREQUAL "${fileTwo}")
|
|
message(FATAL_ERROR "Wrong toolchain was loaded: \"${fileOne}\" expected \"${fileTwo}\"")
|
|
endif()
|
|
|
|
# check that CMAKE_HOST_SYSTEM_XXX and _SYSTEM_xxx detected above are identical
|
|
if(NOT "${CMAKE_HOST_SYSTEM_NAME}" STREQUAL "${NATIVE_SYSTEM_NAME}")
|
|
message(FATAL_ERROR "CMAKE_HOST_SYSTEM_NAME and NATIVE_SYSTEM_NAME not identical: \"${CMAKE_HOST_SYSTEM_NAME}\" vs. \"${NATIVE_SYSTEM_NAME}\"")
|
|
endif()
|
|
if(NOT "${CMAKE_HOST_SYSTEM}" STREQUAL "${NATIVE_SYSTEM}")
|
|
message(FATAL_ERROR "CMAKE_HOST_SYSTEM and NATIVE_SYSTEM not identical: \"${CMAKE_HOST_SYSTEM}\" vs. \"${NATIVE_SYSTEM}\"")
|
|
endif()
|
|
if(NOT "${CMAKE_HOST_SYSTEM_VERSION}" STREQUAL "${NATIVE_SYSTEM_VERSION}")
|
|
message(FATAL_ERROR "CMAKE_HOST_SYSTEM_VERSION and NATIVE_SYSTEM_VERSION not identical: \"${CMAKE_HOST_SYSTEM_VERSION}\" vs. \"${NATIVE_SYSTEM_VERSION}\"")
|
|
endif()
|
|
if(NOT "${CMAKE_HOST_SYSTEM_PROCESSOR}" STREQUAL "${NATIVE_SYSTEM_PROCESSOR}")
|
|
message(FATAL_ERROR "CMAKE_HOST_SYSTEM_PROCESSOR and NATIVE_SYSTEM_PROCESSOR not identical: \"${CMAKE_HOST_SYSTEM_PROCESSOR}\" vs. \"${NATIVE_SYSTEM_PROCESSOR}\"")
|
|
endif()
|
|
|
|
#############################################################
|
|
|
|
# check the results from DetermineCCompiler
|
|
|
|
if(NOT "${_CMAKE_TOOLCHAIN_PREFIX}" STREQUAL "arm-elf-")
|
|
message(FATAL_ERROR "wrong toolchain prefix detected: \"${_CMAKE_TOOLCHAIN_PREFIX}\", expected: \"arm-elf-\"")
|
|
endif()
|
|
|
|
if(NOT "${_CMAKE_USER_C_COMPILER_PATH}" STREQUAL "/opt/foo/bin")
|
|
message(FATAL_ERROR "wrong C compiler location detected: \"${_CMAKE_USER_C_COMPILER_PATH}\", expected: \"/opt/foo/bin\"")
|
|
endif()
|
|
|
|
if(NOT "${CMAKE_C_OUTPUT_EXTENSION}" STREQUAL ".foo")
|
|
message(FATAL_ERROR "C output extension overwritten: \"${CMAKE_C_OUTPUT_EXTENSION}\", was: \".foo\"")
|
|
endif()
|
|
|
|
#############################################################
|
|
|
|
# check the results from DetermineCXXCompiler
|
|
|
|
if(NOT "${_CMAKE_USER_CXX_COMPILER_PATH}" STREQUAL "/opt/bar/bin")
|
|
message(FATAL_ERROR "wrong CXX compiler location detected: \"${_CMAKE_USER_CXX_COMPILER_PATH}\", expected: \"/opt/bar/bin\"")
|
|
endif()
|
|
|
|
if(NOT "${CMAKE_CXX_OUTPUT_EXTENSION}" STREQUAL ".bar")
|
|
message(FATAL_ERROR "C output extension overwritten: \"${CMAKE_CXX_OUTPUT_EXTENSION}\", was: \".bar\"")
|
|
endif()
|
|
|
|
message(STATUS "CMAKE_SYSTEM: \"${CMAKE_SYSTEM}\"")
|
|
message(STATUS "_CMAKE_TOOLCHAIN_PREFIX: \"${_CMAKE_TOOLCHAIN_PREFIX}\"")
|
|
message(STATUS "_CMAKE_USER_C_COMPILER_PATH: \"${_CMAKE_USER_C_COMPILER_PATH}\"")
|
|
message(STATUS "_CMAKE_USER_CXX_COMPILER_PATH: \"${_CMAKE_USER_CXX_COMPILER_PATH}\"")
|
|
message(STATUS "CMAKE_C_OUTPUT_EXTENSION: \"${CMAKE_C_OUTPUT_EXTENSION}\"")
|
|
message(STATUS "CMAKE_CXX_OUTPUT_EXTENSION: \"${CMAKE_CXX_OUTPUT_EXTENSION}\"")
|