From c9b726c314c9c399975fbea3c673852310ee45e6 Mon Sep 17 00:00:00 2001 From: Brad King Date: Thu, 17 Dec 2009 15:14:47 -0500 Subject: [PATCH] New CheckTypeSize for OS X Universal Binaries We re-implement this module to support architecture-dependent type sizes. In the mixed-size case we generate C preprocessor code to select the detected type size for each architecture. --- Modules/CheckTypeSize.c.in | 37 +++++ Modules/CheckTypeSize.cmake | 246 +++++++++++++++++++----------- Modules/CheckTypeSizeC.c.in | 48 ------ Modules/CheckTypeSizeMap.cmake.in | 1 + 4 files changed, 198 insertions(+), 134 deletions(-) create mode 100644 Modules/CheckTypeSize.c.in delete mode 100644 Modules/CheckTypeSizeC.c.in create mode 100644 Modules/CheckTypeSizeMap.cmake.in diff --git a/Modules/CheckTypeSize.c.in b/Modules/CheckTypeSize.c.in new file mode 100644 index 000000000..b6c368801 --- /dev/null +++ b/Modules/CheckTypeSize.c.in @@ -0,0 +1,37 @@ +@headers@ + +#undef KEY +#if defined(__i386) +# define KEY '_','_','i','3','8','6' +#elif defined(__x86_64) +# define KEY '_','_','x','8','6','_','6','4' +#elif defined(__ppc__) +# define KEY '_','_','p','p','c','_','_' +#elif defined(__ppc64__) +# define KEY '_','_','p','p','c','6','4','_','_' +#endif + +#define SIZE (sizeof(@type@)) +char info_size[] = {'I', 'N', 'F', 'O', ':', 's','i','z','e','[', + ('0' + ((SIZE / 10000)%10)), + ('0' + ((SIZE / 1000)%10)), + ('0' + ((SIZE / 100)%10)), + ('0' + ((SIZE / 10)%10)), + ('0' + (SIZE % 10)), + ']', +#ifdef KEY + ' ','k','e','y','[', KEY, ']', +#endif + '\0'}; + +#ifdef __CLASSIC_C__ +int main(argc, argv) int argc; char *argv[]; +#else +int main(int argc, char *argv[]) +#endif +{ + int require = 0; + require += info_size[argc]; + (void)argv; + return require; +} diff --git a/Modules/CheckTypeSize.cmake b/Modules/CheckTypeSize.cmake index 3701467dc..6f4b43760 100644 --- a/Modules/CheckTypeSize.cmake +++ b/Modules/CheckTypeSize.cmake @@ -1,16 +1,29 @@ # - Check sizeof a type # CHECK_TYPE_SIZE(TYPE VARIABLE [BUILTIN_TYPES_ONLY]) -# Check if the type exists and determine size of type. if the type -# exists, the size will be stored to the variable. This also -# calls check_include_file for sys/types.h stdint.h -# and stddef.h, setting HAVE_SYS_TYPES_H, HAVE_STDINT_H, -# and HAVE_STDDEF_H. This is because many types are stored -# in these include files. -# VARIABLE - variable to store size if the type exists. -# HAVE_${VARIABLE} - does the variable exists or not -# BUILTIN_TYPES_ONLY - The third argument is optional and if -# it is set to the string BUILTIN_TYPES_ONLY -# this macro will not check for any header files. +# Check if the type exists and determine its size. +# On return, "HAVE_${VARIABLE}" holds the existence of the type, +# and "${VARIABLE}" holds one of the following: +# = type has non-zero size +# "0" = type has arch-dependent size (see below) +# "" = type does not exist +# Furthermore, the variable "${VARIABLE}_CODE" holds C preprocessor +# code to define the macro "${VARIABLE}" to the size of the type, or +# leave the macro undefined if the type does not exist. +# +# The variable "${VARIABLE}" may be "0" when CMAKE_OSX_ARCHITECTURES +# has multiple architectures for building OS X universal binaries. +# This indicates that the type size varies across architectures. +# In this case "${VARIABLE}_CODE" contains C preprocessor tests +# mapping from each architecture macro to the corresponding type size. +# The list of architecture macros is stored in "${VARIABLE}_KEYS", and +# the value for each key is stored in "${VARIABLE}-${KEY}". +# +# If the BUILTIN_TYPES_ONLY option is not given, the macro checks for +# headers , , and , and saves results +# in HAVE_SYS_TYPES_H, HAVE_STDINT_H, and HAVE_STDDEF_H. The type +# size check automatically includes the available headers, thus +# supporting checks of types defined in the headers. +# # The following variables may be set before calling this macro to # modify the way the check is run: # @@ -18,9 +31,7 @@ # CMAKE_REQUIRED_DEFINITIONS = list of macros to define (-DFOO=bar) # CMAKE_REQUIRED_INCLUDES = list of include directories # CMAKE_REQUIRED_LIBRARIES = list of libraries to link - -# These variables are referenced in CheckTypeSizeC.c so we have -# to check for them. +# CMAKE_EXTRA_INCLUDE_FILES = list of extra headers to include #============================================================================= # Copyright 2002-2009 Kitware, Inc. @@ -37,81 +48,144 @@ include(CheckIncludeFile) -MACRO(CHECK_TYPE_SIZE TYPE VARIABLE) - IF(NOT "${ARGV2}" STREQUAL "BUILTIN_TYPES_ONLY") +cmake_policy(PUSH) +cmake_minimum_required(VERSION 2.6 FATAL_ERROR) + +get_filename_component(__check_type_size_dir "${CMAKE_CURRENT_LIST_FILE}" PATH) + +#----------------------------------------------------------------------------- +# Helper function. DO NOT CALL DIRECTLY. +function(__check_type_size_impl type var map builtin) + message(STATUS "Check size of ${type}") + + # Include header files. + set(headers) + if(builtin) + if(HAVE_SYS_TYPES_H) + set(headers "${headers}#include \n") + endif() + if(HAVE_STDINT_H) + set(headers "${headers}#include \n") + endif() + if(HAVE_STDDEF_H) + set(headers "${headers}#include \n") + endif() + endif() + foreach(h ${CMAKE_EXTRA_INCLUDE_FILES}) + set(headers "${headers}#include \"${h}\"\n") + endforeach() + + # Perform the check. + set(src ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CheckTypeSize/${var}.c) + set(bin ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CheckTypeSize/${var}.bin) + configure_file(${__check_type_size_dir}/CheckTypeSize.c.in ${src} @ONLY) + try_compile(HAVE_${var} ${CMAKE_BINARY_DIR} ${src} + COMPILE_DEFINITIONS ${CMAKE_REQUIRED_DEFINITIONS} + CMAKE_FLAGS + "-DCOMPILE_DEFINITIONS:STRING=${CMAKE_REQUIRED_FLAGS}" + "-DINCLUDE_DIRECTORIES:STRING=${CMAKE_REQUIRED_INCLUDES}" + "-DLINK_LIBRARIES:STRING=${CMAKE_REQUIRED_LIBRARIES}" + OUTPUT_VARIABLE output + COPY_FILE ${bin} + ) + + if(HAVE_${var}) + # The check compiled. Load information from the binary. + file(STRINGS ${bin} strings LIMIT_COUNT 10 REGEX "INFO:size") + + # Parse the information strings. + set(regex_size ".*INFO:size\\[0*([^]]*)\\].*") + set(regex_key " key\\[([^]]*)\\]") + set(keys) + set(code) + set(mismatch) + set(first 1) + foreach(info ${strings}) + if("${info}" MATCHES "${regex_size}") + # Get the type size. + string(REGEX REPLACE "${regex_size}" "\\1" size "${info}") + if(first) + set(${var} ${size}) + elseif(NOT "${size}" STREQUAL "${${var}}") + set(mismatch 1) + endif() + set(first 0) + + # Get the architecture map key. + string(REGEX MATCH "${regex_key}" key "${info}") + string(REGEX REPLACE "${regex_key}" "\\1" key "${key}") + if(key) + set(code "${code}\nset(${var}-${key} \"${size}\")") + list(APPEND keys ${key}) + endif() + endif() + endforeach() + + # Update the architecture-to-size map. + if(mismatch AND keys) + configure_file(${__check_type_size_dir}/CheckTypeSizeMap.cmake.in ${map} @ONLY) + set(${var} 0) + else() + file(REMOVE ${map}) + endif() + + if(mismatch AND NOT keys) + message(SEND_ERROR "CHECK_TYPE_SIZE found different results, consider setting CMAKE_OSX_ARCHITECTURES or CMAKE_TRY_COMPILE_OSX_ARCHITECTURES to one or no architecture !") + endif() + + message(STATUS "Check size of ${type} - done") + file(APPEND ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeOutput.log + "Determining size of ${type} passed with the following output:\n${output}\n\n") + set(${var} "${${var}}" CACHE INTERNAL "CHECK_TYPE_SIZE: sizeof(${type})") + else(HAVE_${var}) + # The check failed to compile. + message(STATUS "Check size of ${type} - failed") + file(READ ${src} content) + file(APPEND ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeError.log + "Determining size of ${type} failed with the following output:\n${output}\n${src}:\n${content}\n\n") + set(${var} "" CACHE INTERNAL "CHECK_TYPE_SIZE: ${type} unknown") + file(REMOVE ${map}) + endif(HAVE_${var}) +endfunction() + +#----------------------------------------------------------------------------- +macro(CHECK_TYPE_SIZE TYPE VARIABLE) + # Optionally check for standard headers. + if("${ARGV2}" STREQUAL "BUILTIN_TYPES_ONLY") + set(_builtin 0) + else() + set(_builtin 1) check_include_file(sys/types.h HAVE_SYS_TYPES_H) check_include_file(stdint.h HAVE_STDINT_H) check_include_file(stddef.h HAVE_STDDEF_H) - ENDIF(NOT "${ARGV2}" STREQUAL "BUILTIN_TYPES_ONLY") - - IF("HAVE_${VARIABLE}" MATCHES "^HAVE_${VARIABLE}$") - MESSAGE(STATUS "Check size of ${TYPE}") - SET(CHECK_TYPE_SIZE_TYPE "${TYPE}") - SET(MACRO_CHECK_TYPE_SIZE_FLAGS - "${CMAKE_REQUIRED_FLAGS}") - FOREACH(def HAVE_SYS_TYPES_H HAVE_STDINT_H HAVE_STDDEF_H) - IF("${def}") - SET(MACRO_CHECK_TYPE_SIZE_FLAGS - "${MACRO_CHECK_TYPE_SIZE_FLAGS} -D${def}") - ENDIF("${def}") - ENDFOREACH(def) - SET(CHECK_TYPE_SIZE_PREINCLUDE) - SET(CHECK_TYPE_SIZE_PREMAIN) - SET(CHECK_TYPE_SIZE_ADD_LIBRARIES) - SET(CHECK_TYPE_SIZE_ADD_INCLUDES) + endif() - FOREACH(def ${CMAKE_EXTRA_INCLUDE_FILES}) - SET(CHECK_TYPE_SIZE_PREMAIN "${CHECK_TYPE_SIZE_PREMAIN}#include \"${def}\"\n") - ENDFOREACH(def) - IF(CMAKE_REQUIRED_LIBRARIES) - SET(CHECK_TYPE_SIZE_ADD_LIBRARIES - "-DLINK_LIBRARIES:STRING=${CMAKE_REQUIRED_LIBRARIES}") - ENDIF(CMAKE_REQUIRED_LIBRARIES) - IF(CMAKE_REQUIRED_INCLUDES) - SET(CHECK_TYPE_SIZE_ADD_INCLUDES - "-DINCLUDE_DIRECTORIES:STRING=${CMAKE_REQUIRED_INCLUDES}") - ENDIF(CMAKE_REQUIRED_INCLUDES) + # Compute or load the size or size map. + set(${VARIABLE}_KEYS) + set(_map_file ${CMAKE_BINARY_DIR}/${CMAKE_FILES_DIRECTORY}/CheckTypeSize/${VARIABLE}.cmake) + if(NOT DEFINED HAVE_${VARIABLE}) + __check_type_size_impl(${TYPE} ${VARIABLE} ${_map_file} ${_builtin}) + endif() + include(${_map_file} OPTIONAL) + set(_map_file) + set(_builtin) - CONFIGURE_FILE("${CMAKE_ROOT}/Modules/CheckTypeSizeC.c.in" - "${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeTmp/CheckTypeSizeC.c" IMMEDIATE @ONLY) - FILE(READ "${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeTmp/CheckTypeSizeC.c" - CHECK_TYPE_SIZE_FILE_CONTENT) - TRY_COMPILE(HAVE_${VARIABLE} - ${CMAKE_BINARY_DIR} - "${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeTmp/CheckTypeSizeC.c" - COMPILE_DEFINITIONS ${CMAKE_REQUIRED_DEFINITIONS} - CMAKE_FLAGS -DCOMPILE_DEFINITIONS:STRING=${MACRO_CHECK_TYPE_SIZE_FLAGS} - "${CHECK_TYPE_SIZE_ADD_LIBRARIES}" - "${CHECK_TYPE_SIZE_ADD_INCLUDES}" - OUTPUT_VARIABLE OUTPUT - COPY_FILE "${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CheckTypeSize.bin" ) + # Create preprocessor code. + if(${VARIABLE}_KEYS) + set(${VARIABLE}_CODE) + set(_if if) + foreach(key ${${VARIABLE}_KEYS}) + set(${VARIABLE}_CODE "${${VARIABLE}_CODE}#${_if} defined(${key})\n# define ${VARIABLE} ${${VARIABLE}-${key}}\n") + set(_if elif) + endforeach() + set(${VARIABLE}_CODE "${${VARIABLE}_CODE}#else\n# error ${VARIABLE} unknown\n#endif") + set(_if) + elseif(${VARIABLE}) + set(${VARIABLE}_CODE "#define ${VARIABLE} ${${VARIABLE}}") + else() + set(${VARIABLE}_CODE "/* #undef ${VARIABLE} */") + endif() +endmacro() - IF(HAVE_${VARIABLE}) - FILE(STRINGS "${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CheckTypeSize.bin" - CMAKE_CHECKTYPESIZE_STRINGS LIMIT_COUNT 2 REGEX "INFO:sizeof") - - SET(CMAKE_CHECKTYPESIZE_FIRST_RESULT "FIRST_LOOP") - FOREACH(info ${CMAKE_CHECKTYPESIZE_STRINGS}) - IF("${info}" MATCHES ".*INFO:sizeof\\[0*([^]]*)\\].*") - STRING(REGEX REPLACE ".*INFO:sizeof\\[0*([^]]*)\\].*" "\\1" ${VARIABLE} "${info}") - ENDIF("${info}" MATCHES ".*INFO:sizeof\\[0*([^]]*)\\].*") - IF("${CMAKE_CHECKTYPESIZE_FIRST_RESULT}" STREQUAL "FIRST_LOOP") - SET(CMAKE_CHECKTYPESIZE_FIRST_RESULT "${${VARIABLE}}") - ENDIF("${CMAKE_CHECKTYPESIZE_FIRST_RESULT}" STREQUAL "FIRST_LOOP") - IF(NOT "${CMAKE_CHECKTYPESIZE_FIRST_RESULT}" STREQUAL "${${VARIABLE}}") - MESSAGE(SEND_ERROR "CHECK_TYPE_SIZE found different results, consider setting CMAKE_OSX_ARCHITECTURES or CMAKE_TRY_COMPILE_OSX_ARCHITECTURES to one or no architecture !") - ENDIF(NOT "${CMAKE_CHECKTYPESIZE_FIRST_RESULT}" STREQUAL "${${VARIABLE}}") - - ENDFOREACH(info ${CMAKE_CHECKTYPESIZE_STRINGS}) - MESSAGE(STATUS "Check size of ${TYPE} - done") - FILE(APPEND ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeOutput.log - "Determining size of ${TYPE} passed with the following output:\n${OUTPUT}\n\n") - ELSE(HAVE_${VARIABLE}) - MESSAGE(STATUS "Check size of ${TYPE} - failed") - FILE(APPEND ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeError.log - "Determining size of ${TYPE} failed with the following output:\n${OUTPUT}\nCheckTypeSizeC.c:\n${CHECK_TYPE_SIZE_FILE_CONTENT}\n\n") - SET(${VARIABLE}) - ENDIF(HAVE_${VARIABLE}) - SET(${VARIABLE} "${${VARIABLE}}" CACHE INTERNAL "Result of CHECK_TYPE_SIZE" FORCE) - ENDIF("HAVE_${VARIABLE}" MATCHES "^HAVE_${VARIABLE}$") -ENDMACRO(CHECK_TYPE_SIZE) +#----------------------------------------------------------------------------- +cmake_policy(POP) diff --git a/Modules/CheckTypeSizeC.c.in b/Modules/CheckTypeSizeC.c.in deleted file mode 100644 index 8bcf1a0cc..000000000 --- a/Modules/CheckTypeSizeC.c.in +++ /dev/null @@ -1,48 +0,0 @@ -#cmakedefine CHECK_TYPE_SIZE_TYPE @CHECK_TYPE_SIZE_TYPE@ -#ifdef CHECK_TYPE_SIZE_TYPE - -@CHECK_TYPE_SIZE_PREINCLUDE@ -#ifdef HAVE_SYS_TYPES_H -# include -#endif /* HAVE_SYS_TYPES_H */ - -#ifdef HAVE_STDINT_H -# include -#endif /* HAVE_STDINT_H */ - -#ifdef HAVE_STDDEF_H -# include -#endif /* HAVE_STDDEF_H */ - -@CHECK_TYPE_SIZE_PREMAIN@ - -#ifdef __CLASSIC_C__ -# define const -#endif - -#define SIZE (sizeof(@CHECK_TYPE_SIZE_TYPE@)) -const char info_sizeof[] = {'I', 'N', 'F', 'O', ':', 's','i','z','e','o','f','[', - ('0' + ((SIZE / 10000)%10)), - ('0' + ((SIZE / 1000)%10)), - ('0' + ((SIZE / 100)%10)), - ('0' + ((SIZE / 10)%10)), - ('0' + (SIZE % 10)), - ']','\0'}; - -#ifdef __CLASSIC_C__ -int main(argc, argv) int argc; char *argv[]; -#else -int main(int argc, char *argv[]) -#endif -{ - int require = 0; - require += info_sizeof[argc]; - (void)argv; - return require; -} - -#else /* CHECK_TYPE_SIZE_TYPE */ - -# error "CHECK_TYPE_SIZE_TYPE has to specify the type" - -#endif /* CHECK_TYPE_SIZE_TYPE */ diff --git a/Modules/CheckTypeSizeMap.cmake.in b/Modules/CheckTypeSizeMap.cmake.in new file mode 100644 index 000000000..1e73cfff1 --- /dev/null +++ b/Modules/CheckTypeSizeMap.cmake.in @@ -0,0 +1 @@ +set(@var@_KEYS "@keys@")@code@