From eed7c8dec14a37660ed0bf74cac3bfd0221c1f5b Mon Sep 17 00:00:00 2001 From: Alexander Neundorf Date: Tue, 29 May 2007 11:36:07 -0400 Subject: ENH: always provide CMAKE_SYSTEM_XXX() and MAKE_HOST_SYSTEM_XXX() variables, so when cross compiling the build host platform can be tested Alex --- Modules/CMakeDetermineSystem.cmake | 137 +++++++++++++++----------- Modules/CMakeSystem.cmake.in | 7 ++ Modules/CMakeSystemWithToolchainFile.cmake.in | 6 ++ Tests/CMakeTests/ToolchainTest.cmake.in | 54 ++++++++++ 4 files changed, 145 insertions(+), 59 deletions(-) diff --git a/Modules/CMakeDetermineSystem.cmake b/Modules/CMakeDetermineSystem.cmake index e47ea15..1da8cb4 100644 --- a/Modules/CMakeDetermineSystem.cmake +++ b/Modules/CMakeDetermineSystem.cmake @@ -27,6 +27,43 @@ # MacOSX Darwin +# find out on which system cmake runs +IF(UNIX) + FIND_PROGRAM(CMAKE_UNAME uname /bin /usr/bin /usr/local/bin ) + IF(CMAKE_UNAME) + EXEC_PROGRAM(uname ARGS -s OUTPUT_VARIABLE CMAKE_HOST_SYSTEM_NAME) + EXEC_PROGRAM(uname ARGS -r OUTPUT_VARIABLE CMAKE_HOST_SYSTEM_VERSION) + IF(CMAKE_HOST_SYSTEM_NAME MATCHES "Linux") + EXEC_PROGRAM(uname ARGS -m OUTPUT_VARIABLE CMAKE_HOST_SYSTEM_PROCESSOR + RETURN_VALUE val) + ELSE(CMAKE_HOST_SYSTEM_NAME MATCHES "Linux") + EXEC_PROGRAM(uname ARGS -p OUTPUT_VARIABLE CMAKE_HOST_SYSTEM_PROCESSOR + RETURN_VALUE val) + IF("${val}" GREATER 0) + EXEC_PROGRAM(uname ARGS -m OUTPUT_VARIABLE CMAKE_HOST_SYSTEM_PROCESSOR + RETURN_VALUE val) + ENDIF("${val}" GREATER 0) + ENDIF(CMAKE_HOST_SYSTEM_NAME MATCHES "Linux") + # check the return of the last uname -m or -p + IF("${val}" GREATER 0) + SET(CMAKE_HOST_SYSTEM_PROCESSOR "unknown") + ENDIF("${val}" GREATER 0) + SET(CMAKE_UNAME ${CMAKE_UNAME} CACHE INTERNAL "uname command") + # processor may have double quote in the name, and that needs to be removed + STRING(REGEX REPLACE "\"" "" CMAKE_HOST_SYSTEM_PROCESSOR "${CMAKE_HOST_SYSTEM_PROCESSOR}") + STRING(REGEX REPLACE "/" "_" CMAKE_HOST_SYSTEM_PROCESSOR "${CMAKE_HOST_SYSTEM_PROCESSOR}") + ENDIF(CMAKE_UNAME) +ELSE(UNIX) + IF(WIN32) + SET (CMAKE_HOST_SYSTEM_NAME "Windows") + SET (CMAKE_HOST_SYSTEM_PROCESSOR "$ENV{PROCESSOR_ARCHITECTURE}") + ENDIF(WIN32) +ENDIF(UNIX) + +# if a toolchain file is used, the user wants to cross compile. +# in this case read the toolchain file and keep the CMAKE_HOST_SYSTEM_* +# variables around so they can be used in CMakeLists.txt. +# In all other cases, the host and target platform are the same. IF(CMAKE_TOOLCHAIN_FILE) # at first try to load it as path relative to the directory from which cmake has been run INCLUDE("${CMAKE_BINARY_DIR}/${CMAKE_TOOLCHAIN_FILE}" OPTIONAL RESULT_VARIABLE _INCLUDED_TOOLCHAIN_FILE) @@ -44,72 +81,52 @@ IF(CMAKE_TOOLCHAIN_FILE) IF(NOT DEFINED CMAKE_CROSSCOMPILING) SET(CMAKE_CROSSCOMPILING TRUE) ENDIF(NOT DEFINED CMAKE_CROSSCOMPILING) + +ELSE(CMAKE_TOOLCHAIN_FILE) + + SET(CMAKE_SYSTEM_NAME "${CMAKE_HOST_SYSTEM_NAME}") + SET(CMAKE_SYSTEM_VERSION "${CMAKE_HOST_SYSTEM_VERSION}") + SET(CMAKE_SYSTEM_PROCESSOR "${CMAKE_HOST_SYSTEM_PROCESSOR}") + SET(CMAKE_CROSSCOMPILING FALSE) + ENDIF(CMAKE_TOOLCHAIN_FILE) -IF(NOT CMAKE_SYSTEM_NAME) - IF(UNIX) - FIND_PROGRAM(CMAKE_UNAME uname /bin /usr/bin /usr/local/bin ) - IF(CMAKE_UNAME) - EXEC_PROGRAM(uname ARGS -s OUTPUT_VARIABLE CMAKE_SYSTEM_NAME) - EXEC_PROGRAM(uname ARGS -r OUTPUT_VARIABLE CMAKE_SYSTEM_VERSION) - IF(CMAKE_SYSTEM_NAME MATCHES "Linux") - EXEC_PROGRAM(uname ARGS -m OUTPUT_VARIABLE CMAKE_SYSTEM_PROCESSOR - RETURN_VALUE val) - ELSE(CMAKE_SYSTEM_NAME MATCHES "Linux") - EXEC_PROGRAM(uname ARGS -p OUTPUT_VARIABLE CMAKE_SYSTEM_PROCESSOR - RETURN_VALUE val) - IF("${val}" GREATER 0) - EXEC_PROGRAM(uname ARGS -m OUTPUT_VARIABLE CMAKE_SYSTEM_PROCESSOR - RETURN_VALUE val) - ENDIF("${val}" GREATER 0) - ENDIF(CMAKE_SYSTEM_NAME MATCHES "Linux") - # check the return of the last uname -m or -p - IF("${val}" GREATER 0) - SET(CMAKE_SYSTEM_PROCESSOR "unknown") - ENDIF("${val}" GREATER 0) - SET(CMAKE_UNAME ${CMAKE_UNAME} CACHE INTERNAL "uname command") - # processor may have double quote in the name, and that needs to be removed - STRING(REGEX REPLACE "\"" "" CMAKE_SYSTEM_PROCESSOR "${CMAKE_SYSTEM_PROCESSOR}") - STRING(REGEX REPLACE "/" "_" CMAKE_SYSTEM_PROCESSOR "${CMAKE_SYSTEM_PROCESSOR}") - ENDIF(CMAKE_UNAME) - ELSE(UNIX) - IF(WIN32) - SET (CMAKE_SYSTEM_NAME "Windows") - SET (CMAKE_SYSTEM_PROCESSOR "$ENV{PROCESSOR_ARCHITECTURE}") - ENDIF(WIN32) - ENDIF(UNIX) -ENDIF(NOT CMAKE_SYSTEM_NAME) - - -IF(NOT CMAKE_SYSTEM_NAME) - SET(CMAKE_SYSTEM_NAME "UnknownOS") -ENDIF(NOT CMAKE_SYSTEM_NAME) - -# fix for BSD/OS , remove the / -IF(CMAKE_SYSTEM_NAME MATCHES BSD.OS) - SET(CMAKE_SYSTEM_NAME BSDOS) -ENDIF(CMAKE_SYSTEM_NAME MATCHES BSD.OS) - -# fix for CYGWIN which has windows version in it -IF(CMAKE_SYSTEM_NAME MATCHES CYGWIN) - SET(CMAKE_SYSTEM_NAME CYGWIN) -ENDIF(CMAKE_SYSTEM_NAME MATCHES CYGWIN) - -# set CMAKE_SYSTEM to the CMAKE_SYSTEM_NAME -SET(CMAKE_SYSTEM ${CMAKE_SYSTEM_NAME}) -# if there is a CMAKE_SYSTEM_VERSION then add a -${CMAKE_SYSTEM_VERSION} -IF(CMAKE_SYSTEM_VERSION) - SET(CMAKE_SYSTEM ${CMAKE_SYSTEM}-${CMAKE_SYSTEM_VERSION}) -ENDIF(CMAKE_SYSTEM_VERSION) - - -FILE(APPEND ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeOutput.log - "The system is: ${CMAKE_SYSTEM_NAME} - ${CMAKE_SYSTEM_VERSION} - ${CMAKE_SYSTEM_PROCESSOR}\n") +MACRO(ADJUST_CMAKE_SYSTEM_VARIABLES _PREFIX) + IF(NOT ${_PREFIX}_NAME) + SET(${_PREFIX}_NAME "UnknownOS") + ENDIF(NOT ${_PREFIX}_NAME) + + # fix for BSD/OS , remove the / + IF(${_PREFIX}_NAME MATCHES BSD.OS) + SET(${_PREFIX}_NAME BSDOS) + ENDIF(${_PREFIX}_NAME MATCHES BSD.OS) + + # fix for CYGWIN which has windows version in it + IF(${_PREFIX}_NAME MATCHES CYGWIN) + SET(${_PREFIX}_NAME CYGWIN) + ENDIF(${_PREFIX}_NAME MATCHES CYGWIN) + + # set CMAKE_SYSTEM to the CMAKE_SYSTEM_NAME + SET(${_PREFIX} ${${_PREFIX}_NAME}) + # if there is a CMAKE_SYSTEM_VERSION then add a -${CMAKE_SYSTEM_VERSION} + IF(${_PREFIX}_VERSION) + SET(${_PREFIX} ${${_PREFIX}}-${${_PREFIX}_VERSION}) + ENDIF(${_PREFIX}_VERSION) + +ENDMACRO(ADJUST_CMAKE_SYSTEM_VARIABLES _PREFIX) + +ADJUST_CMAKE_SYSTEM_VARIABLES(CMAKE_SYSTEM) +ADJUST_CMAKE_SYSTEM_VARIABLES(CMAKE_HOST_SYSTEM) # if a toolchain file is used use configure_file() to copy it into the # build tree, because this way e.g. ${CMAKE_SOURCE_DIR} will be replaced # with its full path, and so it will also work when used in try_compile() IF (CMAKE_TOOLCHAIN_FILE) + FILE(APPEND ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeOutput.log + "The target system is: ${CMAKE_SYSTEM_NAME} - ${CMAKE_SYSTEM_VERSION} - ${CMAKE_SYSTEM_PROCESSOR}\n") + FILE(APPEND ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeOutput.log + "The host system is: ${CMAKE_HOST_SYSTEM_NAME} - ${CMAKE_HOST_SYSTEM_VERSION} - ${CMAKE_HOST_SYSTEM_PROCESSOR}\n") + SET(_OWN_DIR ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}) CONFIGURE_FILE(${CMAKE_TOOLCHAIN_FILE} ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeToolchainFile.cmake) @@ -119,6 +136,8 @@ IF (CMAKE_TOOLCHAIN_FILE) IMMEDIATE @ONLY) ELSE (CMAKE_TOOLCHAIN_FILE) + FILE(APPEND ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeOutput.log + "The system is: ${CMAKE_SYSTEM_NAME} - ${CMAKE_SYSTEM_VERSION} - ${CMAKE_SYSTEM_PROCESSOR}\n") # configure variables set in this file for fast reload, the template file is defined at the top of this file CONFIGURE_FILE(${CMAKE_ROOT}/Modules/CMakeSystem.cmake.in diff --git a/Modules/CMakeSystem.cmake.in b/Modules/CMakeSystem.cmake.in index 785f197..e6c4f9e 100644 --- a/Modules/CMakeSystem.cmake.in +++ b/Modules/CMakeSystem.cmake.in @@ -3,4 +3,11 @@ SET(CMAKE_SYSTEM_NAME "@CMAKE_SYSTEM_NAME@") SET(CMAKE_SYSTEM_VERSION "@CMAKE_SYSTEM_VERSION@") SET(CMAKE_SYSTEM_PROCESSOR "@CMAKE_SYSTEM_PROCESSOR@") +SET(CMAKE_HOST_SYSTEM "@CMAKE_HOST_SYSTEM@") +SET(CMAKE_HOST_SYSTEM_NAME "@CMAKE_HOST_SYSTEM_NAME@") +SET(CMAKE_HOST_SYSTEM_VERSION "@CMAKE_HOST_SYSTEM_VERSION@") +SET(CMAKE_HOST_SYSTEM_PROCESSOR "@CMAKE_HOST_SYSTEM_PROCESSOR@") + +SET(CMAKE_CROSSCOMPILING "@CMAKE_CROSSCOMPILING@") + SET(CMAKE_SYSTEM_LOADED 1) diff --git a/Modules/CMakeSystemWithToolchainFile.cmake.in b/Modules/CMakeSystemWithToolchainFile.cmake.in index e308956..cfaa037 100644 --- a/Modules/CMakeSystemWithToolchainFile.cmake.in +++ b/Modules/CMakeSystemWithToolchainFile.cmake.in @@ -8,4 +8,10 @@ IF(CMAKE_SYSTEM_VERSION) SET(CMAKE_SYSTEM ${CMAKE_SYSTEM}-${CMAKE_SYSTEM_VERSION}) ENDIF(CMAKE_SYSTEM_VERSION) +SET(CMAKE_HOST_SYSTEM "@CMAKE_HOST_SYSTEM@") +SET(CMAKE_HOST_SYSTEM_NAME "@CMAKE_HOST_SYSTEM_NAME@") +SET(CMAKE_HOST_SYSTEM_VERSION "@CMAKE_HOST_SYSTEM_VERSION@") +SET(CMAKE_HOST_SYSTEM_PROCESSOR "@CMAKE_HOST_SYSTEM_PROCESSOR@") +SET(CMAKE_CROSSCOMPILING "@CMAKE_CROSSCOMPILING@") + SET(CMAKE_SYSTEM_LOADED 1) diff --git a/Tests/CMakeTests/ToolchainTest.cmake.in b/Tests/CMakeTests/ToolchainTest.cmake.in index 7d59118..577894b 100644 --- a/Tests/CMakeTests/ToolchainTest.cmake.in +++ b/Tests/CMakeTests/ToolchainTest.cmake.in @@ -15,6 +15,45 @@ 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(NOT "${CMAKE_SYSTEM_NAME}" STREQUAL "${CMAKE_HOST_SYSTEM_NAME}") + +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(NOT "${CMAKE_SYSTEM}" STREQUAL "${CMAKE_HOST_SYSTEM}") + +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(NOT "${CMAKE_SYSTEM_VERSION}" STREQUAL "${CMAKE_HOST_SYSTEM_VERSION}") + +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(NOT "${CMAKE_SYSTEM_PROCESSOR}" STREQUAL "${CMAKE_HOST_SYSTEM_PROCESSOR}") + +# 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 @@ -42,6 +81,21 @@ if(NOT "${_INCLUDED_TOOLCHAIN_FILE}" STREQUAL "${MY_SOURCE_DIR}/DummyToolchain.c message(FATAL_ERROR "wrong toolchain file loaded: \"${_INCLUDED_TOOLCHAIN_FILE}\", expected: \"${MY_SOURCE_DIR}/DummyToolchain.cmake\"") endif(NOT "${_INCLUDED_TOOLCHAIN_FILE}" STREQUAL "${MY_SOURCE_DIR}/DummyToolchain.cmake") + +# 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(NOT "${CMAKE_HOST_SYSTEM_NAME}" STREQUAL "${NATIVE_SYSTEM_NAME}") +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(NOT "${CMAKE_HOST_SYSTEM}" STREQUAL "${NATIVE_SYSTEM}") +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(NOT "${CMAKE_HOST_SYSTEM_VERSION}" STREQUAL "${NATIVE_SYSTEM_VERSION}") +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(NOT "${CMAKE_HOST_SYSTEM_PROCESSOR}" STREQUAL "${NATIVE_SYSTEM_PROCESSOR}") + ############################################################# # check the results from DetermineCCompiler -- cgit v0.12