cpp
/
cmakemodules
1
0
Fork 0
Code Issues 0 Pull Requests 0 Releases 0 Wiki Activity
Browse Source

cotire 1.6.7

master
Sascha Kratky 9 years ago
parent
9d91facfdd
commit
880b748f37
6 changed files with 345 additions and 69 deletions
Split View
Diff Options
Show Stats Download Patch File Download Diff File
  1. +138
    -64
      CMake/cotire.cmake
  2. +11
    -0
      HISTORY.md
  3. +61
    -3
      MANUAL.md
  4. +37
    -0
      Patches/clang-3.5.src.patch
  5. +96
    -0
      Patches/llvm-3.5.src.patch
  6. +2
    -2
      README.md

+ 138
- 64
CMake/cotire.cmake View File

@@ -44,8 +44,15 @@ if (NOT CMAKE_SCRIPT_MODE_FILE)
cmake_policy(POP)
endif()

if (NOT CMAKE_VERSION VERSION_LESS "3.1.0")
# include TARGET_OBJECTS expressions in a target's SOURCES property
cmake_policy(SET CMP0051 NEW)
# only interpret if() arguments as variables or keywords when unquoted
cmake_policy(SET CMP0054 NEW)
endif()

set (COTIRE_CMAKE_MODULE_FILE "${CMAKE_CURRENT_LIST_FILE}")
set (COTIRE_CMAKE_MODULE_VERSION "1.6.6")
set (COTIRE_CMAKE_MODULE_VERSION "1.6.7")

include(CMakeParseArguments)
include(ProcessorCount)
@@ -85,6 +92,22 @@ function (cotire_determine_compiler_version _language _versionPrefix)
endif()
endfunction()

function (cotire_get_configuration_types _configsVar)
set (_configs "")
if (CMAKE_CONFIGURATION_TYPES)
list (APPEND _configs ${CMAKE_CONFIGURATION_TYPES})
endif()
if (CMAKE_BUILD_TYPE)
list (APPEND _configs "${CMAKE_BUILD_TYPE}")
endif()
if (_configs)
list (REMOVE_DUPLICATES _configs)
set (${_configsVar} ${_configs} PARENT_SCOPE)
else()
set (${_configsVar} "None" PARENT_SCOPE)
endif()
endfunction()

function (cotire_get_source_file_extension _sourceFile _extVar)
# get_filename_component returns extension from first occurrence of . in file name
# this function computes the extension from last occurrence of . in file name
@@ -135,7 +158,15 @@ function (cotire_filter_language_source_files _language _sourceFilesVar _exclude
message (STATUS "${_language} ignore extensions: ${_ignoreExtensions}")
message (STATUS "${_language} exclude extensions: ${_excludeExtensions}")
endif()
foreach (_sourceFile ${ARGN})
if (CMAKE_VERSION VERSION_LESS "3.1.0")
set (_allSourceFiles ${ARGN})
else()
# as of CMake 3.1 target sources may contain generator expressions
# since we cannot obtain required property information about source files added
# through generator expressions at configure time, we filter them out
string (GENEX_STRIP "${ARGN}" _allSourceFiles)
endif()
foreach (_sourceFile ${_allSourceFiles})
get_source_file_property(_sourceIsHeaderOnly "${_sourceFile}" HEADER_FILE_ONLY)
get_source_file_property(_sourceIsExternal "${_sourceFile}" EXTERNAL_OBJECT)
get_source_file_property(_sourceIsSymbolic "${_sourceFile}" SYMBOLIC)
@@ -466,7 +497,6 @@ function (cotire_get_target_include_directories _config _language _targetSourceD
if (_targetDirs)
list (APPEND _systemIncludeDirs ${_targetDirs})
endif()

# interface include directories from linked library targets
cotire_get_target_link_libraries_for_usage_requirements(${_target} _linkLibraries)
foreach (_library ${_linkLibraries})
@@ -1124,7 +1154,7 @@ function (cotire_generate_unity_source _unityFile)
set(_options "")
set(_oneValueArgs LANGUAGE)
set(_multiValueArgs
DEPENDS SOURCES_COMPILE_DEFINITIONS
DEPENDS SOURCE_LOCATIONS SOURCES_COMPILE_DEFINITIONS
PRE_UNDEFS SOURCES_PRE_UNDEFS POST_UNDEFS SOURCES_POST_UNDEFS PROLOGUE EPILOGUE)
cmake_parse_arguments(_option "${_options}" "${_oneValueArgs}" "${_multiValueArgs}" ${ARGN})
if (_option_DEPENDS)
@@ -1158,6 +1188,7 @@ function (cotire_generate_unity_source _unityFile)
endif()
endif()
set (_compileUndefinitions "")
set (_index 0)
foreach (_sourceFile ${_sourceFiles})
cotire_get_source_compile_definitions(
"${_option_CONFIGURATION}" "${_option_LANGUAGE}" "${_sourceFile}" _compileDefinitions
@@ -1189,11 +1220,18 @@ function (cotire_generate_unity_source _unityFile)
list (INSERT _compileUndefinitions 0 "${_definition}")
endif()
endforeach()
get_filename_component(_sourceFile "${_sourceFile}" ABSOLUTE)
if (_option_SOURCE_LOCATIONS)
# use explicitly provided source file location
list (GET _option_SOURCE_LOCATIONS ${_index} _sourceFileLocation)
else()
# use absolute path as source file location
get_filename_component(_sourceFileLocation "${_sourceFile}" ABSOLUTE)
endif()
if (WIN32)
file (TO_NATIVE_PATH "${_sourceFile}" _sourceFile)
file (TO_NATIVE_PATH "${_sourceFileLocation}" _sourceFileLocation)
endif()
list (APPEND _contents "#include \"${_sourceFile}\"")
list (APPEND _contents "#include \"${_sourceFileLocation}\"")
math (EXPR _index "${_index} + 1")
endforeach()
if (_compileUndefinitions)
cotire_append_undefs(_contents ${_compileUndefinitions})
@@ -1655,21 +1693,15 @@ function (cotire_check_precompiled_header_support _language _targetSourceDir _ta
set (${_msgVar} "${_unsupportedCompiler}." PARENT_SCOPE)
endif()
if (CMAKE_${_language}_COMPILER MATCHES "ccache")
if (NOT "$ENV{CCACHE_SLOPPINESS}" MATCHES "time_macros")
if (NOT "$ENV{CCACHE_SLOPPINESS}" MATCHES "time_macros|pch_defines")
set (${_msgVar}
"ccache requires the environment variable CCACHE_SLOPPINESS to be set to time_macros."
"ccache requires the environment variable CCACHE_SLOPPINESS to be set to \"pch_defines,time_macros\"."
PARENT_SCOPE)
endif()
endif()
if (APPLE)
# PCH compilation not supported by GCC / Clang for multi-architecture builds (e.g., i386, x86_64)
if (CMAKE_CONFIGURATION_TYPES)
set (_configs ${CMAKE_CONFIGURATION_TYPES})
elseif (CMAKE_BUILD_TYPE)
set (_configs ${CMAKE_BUILD_TYPE})
else()
set (_configs "None")
endif()
cotire_get_configuration_types(_configs)
foreach (_config ${_configs})
set (_targetFlags "")
cotire_get_target_compile_flags("${_config}" "${_language}" "${_targetSourceDir}" "${_target}" _targetFlags)
@@ -1906,6 +1938,7 @@ endfunction()

function (cotire_generate_target_script _language _configurations _targetSourceDir _targetBinaryDir _target _targetScriptVar _targetConfigScriptVar)
set (COTIRE_TARGET_SOURCES ${ARGN})
cotire_get_source_file_property_values(COTIRE_TARGET_SOURCE_LOCATIONS LOCATION ${COTIRE_TARGET_SOURCES})
cotire_get_prefix_header_dependencies(${_language} ${_target} COTIRE_TARGET_PREFIX_DEPENDS ${COTIRE_TARGET_SOURCES})
cotire_get_unity_source_dependencies(${_language} ${_target} COTIRE_TARGET_UNITY_DEPENDS ${COTIRE_TARGET_SOURCES})
# set up variables to be configured
@@ -1940,7 +1973,7 @@ function (cotire_generate_target_script _language _configurations _targetSourceD
set (_contents "")
set (_contentsHasGeneratorExpressions FALSE)
foreach (_var IN LISTS _matchVars ITEMS
MSVC CMAKE_GENERATOR CMAKE_BUILD_TYPE CMAKE_CONFIGURATION_TYPES
XCODE MSVC CMAKE_GENERATOR CMAKE_BUILD_TYPE CMAKE_CONFIGURATION_TYPES
CMAKE_${_language}_COMPILER_ID CMAKE_${_language}_COMPILER CMAKE_${_language}_COMPILER_ARG1
CMAKE_${_language}_SOURCE_FILE_EXTENSIONS)
if (DEFINED ${_var})
@@ -2169,13 +2202,15 @@ function (cotire_setup_target_pch_usage _languages _targetSourceDir _target _who
# see cotire_setup_pch_file_inclusion
if (NOT CMAKE_${_language}_COMPILER_ID MATCHES "MSVC|Intel")
get_property(_prefixFile TARGET ${_target} PROPERTY COTIRE_${_language}_PREFIX_HEADER)
get_property(_pchFile TARGET ${_target} PROPERTY COTIRE_${_language}_PRECOMPILED_HEADER)
set (_flags "")
cotire_determine_compiler_version("${_language}" COTIRE_${_language}_COMPILER)
cotire_add_prefix_pch_inclusion_flags(
"${_language}" "${CMAKE_${_language}_COMPILER_ID}" "${COTIRE_${_language}_COMPILER_VERSION}"
"${_prefixFile}" "${_pchFile}" _flags)
set_property(TARGET ${_target} APPEND_STRING PROPERTY COMPILE_FLAGS " ${_flags} ")
if (_prefixFile)
set (_flags "")
cotire_determine_compiler_version("${_language}" COTIRE_${_language}_COMPILER)
get_property(_pchFile TARGET ${_target} PROPERTY COTIRE_${_language}_PRECOMPILED_HEADER)
cotire_add_prefix_pch_inclusion_flags(
"${_language}" "${CMAKE_${_language}_COMPILER_ID}" "${COTIRE_${_language}_COMPILER_VERSION}"
"${_prefixFile}" "${_pchFile}" _flags)
set_property(TARGET ${_target} APPEND_STRING PROPERTY COMPILE_FLAGS " ${_flags} ")
endif()
endif()
endif()
endif()
@@ -2187,13 +2222,19 @@ function (cotire_setup_unity_generation_commands _language _targetSourceDir _tar
foreach (_unityFile ${_unityFiles})
file (RELATIVE_PATH _unityFileRelPath "${CMAKE_BINARY_DIR}" "${_unityFile}")
set_property (SOURCE "${_unityFile}" PROPERTY GENERATED TRUE)
# set up compiled unity source dependencies
# set up compiled unity source dependencies via OBJECT_DEPENDS
# this ensures that missing source files are generated before the unity file is compiled
if (COTIRE_DEBUG AND _dependencySources)
message (STATUS "${_unityFile} OBJECT_DEPENDS ${_dependencySources}")
endif()
if (_dependencySources)
set_property (SOURCE "${_unityFile}" PROPERTY OBJECT_DEPENDS ${_dependencySources})
# the OBJECT_DEPENDS property requires a list of full paths
set (_objectDependsPaths "")
foreach (_sourceFile ${_dependencySources})
get_source_file_property(_sourceLocation "${_sourceFile}" LOCATION)
list (APPEND _objectDependsPaths "${_sourceLocation}")
endforeach()
set_property (SOURCE "${_unityFile}" PROPERTY OBJECT_DEPENDS ${_objectDependsPaths})
endif()
if (WIN32 AND CMAKE_${_language}_COMPILER_ID MATCHES "MSVC|Intel")
# unity file compilation results in potentially huge object file, thus use /bigobj by default unter MSVC and Windows Intel
@@ -2201,13 +2242,19 @@ function (cotire_setup_unity_generation_commands _language _targetSourceDir _tar
endif()
cotire_set_cmd_to_prologue(_unityCmd)
list (APPEND _unityCmd -P "${COTIRE_CMAKE_MODULE_FILE}" "unity" "${_targetConfigScript}" "${_unityFile}")
if (CMAKE_VERSION VERSION_LESS "3.1.0")
set (_unityCmdDepends "${_targetScript}")
else()
# CMake 3.1.0 supports generator expressions in arguments to DEPENDS
set (_unityCmdDepends "${_targetConfigScript}")
endif()
if (COTIRE_DEBUG)
message (STATUS "add_custom_command: OUTPUT ${_unityFile} COMMAND ${_unityCmd} DEPENDS ${_targetScript}")
message (STATUS "add_custom_command: OUTPUT ${_unityFile} COMMAND ${_unityCmd} DEPENDS ${_unityCmdDepends}")
endif()
add_custom_command(
OUTPUT "${_unityFile}"
COMMAND ${_unityCmd}
DEPENDS "${_targetScript}"
DEPENDS ${_unityCmdDepends}
COMMENT "Generating ${_language} unity source ${_unityFileRelPath}"
WORKING_DIRECTORY "${_targetSourceDir}" VERBATIM)
list (APPEND ${_cmdsVar} COMMAND ${_unityCmd})
@@ -2383,12 +2430,13 @@ function (cotire_make_target_message _target _languages _disableMsg _targetMsgVa
set (${_targetMsgVar} "${_targetMsg}" PARENT_SCOPE)
endfunction()

function (cotire_choose_target_languages _targetSourceDir _target _targetLanguagesVar)
function (cotire_choose_target_languages _targetSourceDir _target _targetLanguagesVar _wholeTargetVar)
set (_languages ${ARGN})
set (_allSourceFiles "")
set (_allExcludedSourceFiles "")
set (_allCotiredSourceFiles "")
set (_targetLanguages "")
set (_pchEligibleTargetLanguages "")
get_target_property(_targetType ${_target} TYPE)
get_target_property(_targetSourceFiles ${_target} SOURCES)
get_target_property(_targetUsePCH ${_target} COTIRE_ENABLE_PRECOMPILED_HEADER)
@@ -2418,6 +2466,10 @@ function (cotire_choose_target_languages _targetSourceDir _target _targetLanguag
if (_sourceFiles)
list (APPEND _allSourceFiles ${_sourceFiles})
endif()
list (LENGTH _sourceFiles _numberOfSources)
if (NOT _numberOfSources LESS ${COTIRE_MINIMUM_NUMBER_OF_TARGET_SOURCES})
list (APPEND _pchEligibleTargetLanguages ${_language})
endif()
if (_excludedSources)
list (APPEND _allExcludedSourceFiles ${_excludedSources})
endif()
@@ -2433,11 +2485,7 @@ function (cotire_choose_target_languages _targetSourceDir _target _targetLanguag
set (_targetAddSCU FALSE)
endif()
if (_targetUsePCH)
list (LENGTH _allSourceFiles _numberOfSources)
if (_numberOfSources LESS ${COTIRE_MINIMUM_NUMBER_OF_TARGET_SOURCES})
set (_disableMsg "Too few applicable sources.")
set (_targetUsePCH FALSE)
elseif (_allCotiredSourceFiles)
if (_allCotiredSourceFiles)
cotire_get_source_file_property_values(_cotireTargets COTIRE_TARGET ${_allCotiredSourceFiles})
list (REMOVE_DUPLICATES _cotireTargets)
string (REPLACE ";" ", " _cotireTargetsStr "${_cotireTargets}")
@@ -2446,6 +2494,9 @@ function (cotire_choose_target_languages _targetSourceDir _target _targetLanguag
set (_disableMsg "${_disableMsg} ${_cotireTargetsStr} to get a workable build system.")
set (_targetMsgLevel SEND_ERROR)
set (_targetUsePCH FALSE)
elseif (NOT _pchEligibleTargetLanguages)
set (_disableMsg "Too few applicable sources.")
set (_targetUsePCH FALSE)
elseif (XCODE AND _allExcludedSourceFiles)
# for Xcode, we cannot apply the precompiled header to individual sources, only to the whole target
set (_disableMsg "Exclusion of source files not supported for generator Xcode.")
@@ -2470,6 +2521,12 @@ function (cotire_choose_target_languages _targetSourceDir _target _targetLanguag
message (${_targetMsgLevel} "${_targetMsg}")
endif()
endif()
list (LENGTH _targetLanguages _numberOfLanguages)
if (_numberOfLanguages GREATER 1 OR _allExcludedSourceFiles)
set (${_wholeTargetVar} FALSE PARENT_SCOPE)
else()
set (${_wholeTargetVar} TRUE PARENT_SCOPE)
endif()
set (${_targetLanguagesVar} ${_targetLanguages} PARENT_SCOPE)
endfunction()

@@ -2497,7 +2554,7 @@ function (cotire_compute_unity_max_number_of_includes _target _maxIncludesVar)
set (${_maxIncludesVar} ${_maxIncludes} PARENT_SCOPE)
endfunction()

function (cotire_process_target_language _language _configurations _targetSourceDir _targetBinaryDir _target _wholeTargetVar _cmdsVar)
function (cotire_process_target_language _language _configurations _targetSourceDir _targetBinaryDir _target _wholeTarget _cmdsVar)
set (${_cmdsVar} "" PARENT_SCOPE)
get_target_property(_targetSourceFiles ${_target} SOURCES)
set (_sourceFiles "")
@@ -2507,7 +2564,6 @@ function (cotire_process_target_language _language _configurations _targetSource
if (NOT _sourceFiles AND NOT _cotiredSources)
return()
endif()
set (_wholeTarget ${${_wholeTargetVar}})
set (_cmds "")
# check for user provided unity source file list
get_property(_unitySourceFiles TARGET ${_target} PROPERTY COTIRE_${_language}_UNITY_SOURCE_INIT)
@@ -2534,22 +2590,24 @@ function (cotire_process_target_language _language _configurations _targetSource
cotire_setup_prefix_generation_from_unity_command(
${_language} ${_target} "${_targetSourceDir}" "${_targetConfigScript}" "${_prefixFile}" "${_unityFiles}" _cmds ${_unitySourceFiles})
endif()
get_target_property(_targetUsePCH ${_target} COTIRE_ENABLE_PRECOMPILED_HEADER)
# check if selected language has enough sources at all
list (LENGTH _sourceFiles _numberOfSources)
if (_numberOfSources LESS ${COTIRE_MINIMUM_NUMBER_OF_TARGET_SOURCES})
set (_targetUsePCH FALSE)
else()
get_target_property(_targetUsePCH ${_target} COTIRE_ENABLE_PRECOMPILED_HEADER)
endif()
if (_targetUsePCH)
cotire_make_pch_file_path(${_language} "${_targetSourceDir}" ${_target} _pchFile)
if (_pchFile)
cotire_setup_pch_file_compilation(
${_language} ${_target} "${_targetSourceDir}" "${_targetConfigScript}" "${_prefixFile}" "${_pchFile}" ${_sourceFiles})
if (_excludedSources)
set (_wholeTarget FALSE)
endif()
cotire_setup_pch_file_inclusion(
${_language} ${_target} ${_wholeTarget} "${_prefixFile}" "${_pchFile}" ${_sourceFiles})
endif()
elseif (_prefixHeaderFiles)
# user provided prefix header must be included
cotire_setup_prefix_file_inclusion(
${_language} ${_target} "${_prefixFile}" ${_sourceFiles})
# user provided prefix header must be included unconditionally
cotire_setup_prefix_file_inclusion(${_language} ${_target} "${_prefixFile}" ${_sourceFiles})
endif()
endif()
# mark target as cotired for language
@@ -2560,7 +2618,6 @@ function (cotire_process_target_language _language _configurations _targetSource
set_property(TARGET ${_target} PROPERTY COTIRE_${_language}_PRECOMPILED_HEADER "${_pchFile}")
endif()
endif()
set (${_wholeTargetVar} ${_wholeTarget} PARENT_SCOPE)
set (${_cmdsVar} ${_cmds} PARENT_SCOPE)
endfunction()

@@ -2777,13 +2834,7 @@ function (cotire_target _target)
get_property (_option_LANGUAGES GLOBAL PROPERTY ENABLED_LANGUAGES)
endif()
if (NOT _option_CONFIGURATIONS)
if (CMAKE_CONFIGURATION_TYPES)
set (_option_CONFIGURATIONS ${CMAKE_CONFIGURATION_TYPES})
elseif (CMAKE_BUILD_TYPE)
set (_option_CONFIGURATIONS "${CMAKE_BUILD_TYPE}")
else()
set (_option_CONFIGURATIONS "None")
endif()
cotire_get_configuration_types(_option_CONFIGURATIONS)
endif()
# trivial checks
get_target_property(_imported ${_target} IMPORTED)
@@ -2816,20 +2867,14 @@ function (cotire_target _target)
endif()
endif()
# choose languages that apply to the target
cotire_choose_target_languages("${_option_SOURCE_DIR}" "${_target}" _targetLanguages ${_option_LANGUAGES})
cotire_choose_target_languages("${_option_SOURCE_DIR}" "${_target}" _targetLanguages _wholeTarget ${_option_LANGUAGES})
if (NOT _targetLanguages)
return()
endif()
list (LENGTH _targetLanguages _numberOfLanguages)
if (_numberOfLanguages GREATER 1)
set (_wholeTarget FALSE)
else()
set (_wholeTarget TRUE)
endif()
set (_cmds "")
foreach (_language ${_targetLanguages})
cotire_process_target_language("${_language}" "${_option_CONFIGURATIONS}"
"${_option_SOURCE_DIR}" "${_option_BINARY_DIR}" ${_target} _wholeTarget _cmd)
"${_option_SOURCE_DIR}" "${_option_BINARY_DIR}" ${_target} ${_wholeTarget} _cmd)
if (_cmd)
list (APPEND _cmds ${_cmd})
endif()
@@ -2853,6 +2898,7 @@ function (cotire_map_libraries _strategy _mappedLibrariesVar)
set (_mappedLibraries "")
foreach (_library ${ARGN})
if (TARGET "${_library}" AND "${_strategy}" MATCHES "COPY_UNITY")
# use target's corresponding unity target, if available
get_target_property(_libraryUnityTargetName ${_library} COTIRE_UNITY_TARGET_NAME)
if (TARGET "${_libraryUnityTargetName}")
list (APPEND _mappedLibraries "${_libraryUnityTargetName}")
@@ -2878,9 +2924,16 @@ function (cotire_target_link_libraries _target)
if (CMAKE_VERSION VERSION_LESS "2.8.11")
message (WARNING "cotire: unity target link strategy ${_linkLibrariesStrategy} requires CMake 2.8.11 or later. Defaulting to NONE for ${_target}.")
else()
set (_unityLinkLibraries "")
get_target_property(_linkLibraries ${_target} LINK_LIBRARIES)
if (_linkLibraries)
list (APPEND _unityLinkLibraries ${_linkLibraries})
endif()
get_target_property(_interfaceLinkLibraries ${_target} INTERFACE_LINK_LIBRARIES)
cotire_map_libraries("${_linkLibrariesStrategy}" _unityLinkLibraries ${_linkLibraries} ${_interfaceLinkLibraries})
if (_interfaceLinkLibraries)
list (APPEND _unityLinkLibraries ${_interfaceLinkLibraries})
endif()
cotire_map_libraries("${_linkLibrariesStrategy}" _unityLinkLibraries ${_unityLinkLibraries})
if (COTIRE_DEBUG)
message (STATUS "unity target ${_unityTargetName} libraries: ${_unityLinkLibraries}")
endif()
@@ -3026,12 +3079,14 @@ if (CMAKE_SCRIPT_MODE_FILE)
list (FIND COTIRE_TARGET_CONFIGURATION_TYPES "${COTIRE_BUILD_TYPE}" _index)
if (_index GREATER -1)
set (_sources ${COTIRE_TARGET_SOURCES})
set (_sourceLocations ${COTIRE_TARGET_SOURCE_LOCATIONS})
set (_sourcesDefinitions ${COTIRE_TARGET_SOURCES_COMPILE_DEFINITIONS_${_upperConfig}})
else()
if (COTIRE_DEBUG)
message (STATUS "COTIRE_BUILD_TYPE=${COTIRE_BUILD_TYPE} not cotired (${COTIRE_TARGET_CONFIGURATION_TYPES})")
endif()
set (_sources "")
set (_sourceLocations "")
set (_sourcesDefinitions "")
endif()
set (_targetPreUndefs ${COTIRE_TARGET_PRE_UNDEFS})
@@ -3041,19 +3096,37 @@ if (CMAKE_SCRIPT_MODE_FILE)

if ("${COTIRE_ARGV1}" STREQUAL "unity")

if (XCODE)
# executing pre-build action under Xcode, check dependency on target script
set (_dependsOption DEPENDS "${COTIRE_ARGV2}")
else()
# executing custom command, no need to re-check for dependencies
set (_dependsOption "")
endif()

cotire_select_unity_source_files("${COTIRE_ARGV3}" _sources ${_sources})

cotire_generate_unity_source(
"${COTIRE_ARGV3}" ${_sources}
LANGUAGE "${COTIRE_TARGET_LANGUAGE}"
DEPENDS "${COTIRE_ARGV0}" "${COTIRE_ARGV2}"
SOURCE_LOCATIONS ${_sourceLocations}
SOURCES_COMPILE_DEFINITIONS ${_sourcesDefinitions}
PRE_UNDEFS ${_targetPreUndefs}
POST_UNDEFS ${_targetPostUndefs}
SOURCES_PRE_UNDEFS ${_sourcesPreUndefs}
SOURCES_POST_UNDEFS ${_sourcesPostUndefs})
SOURCES_POST_UNDEFS ${_sourcesPostUndefs}
${_dependsOption})

elseif ("${COTIRE_ARGV1}" STREQUAL "prefix")

if (XCODE)
# executing pre-build action under Xcode, check dependency on unity file and prefix dependencies
set (_dependsOption DEPENDS "${COTIRE_ARGV4}" ${COTIRE_TARGET_PREFIX_DEPENDS})
else()
# executing custom command, no need to re-check for dependencies
set (_dependsOption "")
endif()

set (_files "")
foreach (_index RANGE 4 ${COTIRE_ARGC})
if (COTIRE_ARGV${_index})
@@ -3068,7 +3141,6 @@ if (CMAKE_SCRIPT_MODE_FILE)
COMPILER_ID "${CMAKE_${COTIRE_TARGET_LANGUAGE}_COMPILER_ID}"
COMPILER_VERSION "${COTIRE_${COTIRE_TARGET_LANGUAGE}_COMPILER_VERSION}"
LANGUAGE "${COTIRE_TARGET_LANGUAGE}"
DEPENDS "${COTIRE_ARGV0}" "${COTIRE_ARGV4}" ${COTIRE_TARGET_PREFIX_DEPENDS}
IGNORE_PATH "${COTIRE_TARGET_IGNORE_PATH};${COTIRE_ADDITIONAL_PREFIX_HEADER_IGNORE_PATH}"
INCLUDE_PATH ${COTIRE_TARGET_INCLUDE_PATH}
IGNORE_EXTENSIONS "${CMAKE_${COTIRE_TARGET_LANGUAGE}_SOURCE_FILE_EXTENSIONS};${COTIRE_ADDITIONAL_PREFIX_HEADER_IGNORE_EXTENSIONS}"
@@ -3076,7 +3148,8 @@ if (CMAKE_SCRIPT_MODE_FILE)
INCLUDE_DIRECTORIES ${_includeDirs}
SYSTEM_INCLUDE_DIRECTORIES ${_systemIncludeDirs}
COMPILE_DEFINITIONS ${_compileDefinitions}
COMPILE_FLAGS ${_compileFlags})
COMPILE_FLAGS ${_compileFlags}
${_dependsOption})

elseif ("${COTIRE_ARGV1}" STREQUAL "precompile")

@@ -3113,6 +3186,7 @@ if (CMAKE_SCRIPT_MODE_FILE)
list (APPEND _files "${COTIRE_ARGV${_index}}")
endif()
endforeach()

if (COTIRE_TARGET_LANGUAGE)
cotire_generate_unity_source(${_files} LANGUAGE "${COTIRE_TARGET_LANGUAGE}")
else()


+ 11
- 0
HISTORY.md View File

@@ -1,3 +1,14 @@
## 1.6.7 (2014-12-21)

* fix CMake 3.1 compatibility issues.
* fix ccache 3.2 compatibility issues.
* handle `COTIRE_MINIMUM_NUMBER_OF_TARGET_SOURCES` correctly for mixed-language targets.
* correctly compute absolute paths of generated source files added to the unity source file.
* fix bug with checking unity source and prefix header dependencies under Xcode.
* fix bug with handling of unity source file dependencies.
* move code to determine build configurations to function of its own.
* documentation updates.

## 1.6.6 (2014-09-21)

* fix GCC issue with prefix header generation when source files are missing.


+ 61
- 3
MANUAL.md View File

@@ -313,6 +313,10 @@ If a unity build target should not be added by cotire, the target property
set_target_properties(example PROPERTIES COTIRE_ADD_UNITY_BUILD FALSE)
cotire(example)

The property `COTIRE_ADD_UNITY_BUILD` only affects the addition of the unity build target. Custom
build rules for the generation of the unity source file will always be set up, because the
unity source file is needed for the generation of the prefix header.

Both properties default to `TRUE`. If both are set to `FALSE`, cotire will only set up custom build
rules for the generation of the unity source and the prefix header.

@@ -543,12 +547,12 @@ enabled in the following way upon configuring the project:

$ export CC="/usr/local/bin/ccache /usr/bin/gcc"
$ export CXX="/usr/local/bin/ccache /usr/bin/g++"
$ export CCACHE_SLOPPINESS=time_macros
$ export CCACHE_SLOPPINESS=pch_defines,time_macros
$ cmake ..

Note that with ccache in order for precompiled headers to work properly, it is necessary to set
the environment variable `CCACHE_SLOPPINESS` to `time_macros`. Otherwise the build process may
abort with the following error message:
the environment variable `CCACHE_SLOPPINESS` to `pch_defines,time_macros`. Otherwise the build
process may abort with the following error message:

fatal error: file 'example_CXX_prefix.hxx' has been modified since the precompiled header
'example_CXX_prefix.hxx.gch' was built
@@ -613,6 +617,60 @@ Cotire is compatible with both Qt4 and Qt5 projects that use CMake as build syst
directory contains examples for the [Qt4][fsedit_qt4] and [Qt5][fsedit_qt5] based variants of the
*FSEditor* sample Qt application.

### installing files generated by unity targets

Cotire cannot set up a `install_unity` target that mimics the `install` target automatically,
because CMake does not provide the necessary information about the existing install rules
programmatically.

When using a Makefile generator, you can use the following workaround (thanks to peterhuene):

$ make all_unity
$ make install/fast

The `install/fast` does not trigger a build, but will use the binaries built by the `all_unity`
target.

For other generators, set up an `install_unity` target manually. First set up install rules for
all unity targets, that mimic the install rules for the original targets:

install(TARGETS example_unity RUNTIME DESTINATION "bin" OPTIONAL COMPONENT "unity")

This installs the `example` executable built by the unity target to the `bin` folder. The install
rules for unity targets must use a custom install component. Then add a global `install_unity`
target that performs the installation of all unity targets:

add_custom_target(install_unity
COMMAND ${CMAKE_COMMAND} -DCOMPONENT=unity -P cmake_install.cmake
COMMENT "Install the unity-built project..."
WORKING_DIRECTORY ${CMAKE_BINARY_DIR})
add_dependencies(unity_install example_unity)

The global `install_unity` target must depend on all unity targets that should be installed.

### customized inclusion of system headers

If a system header ends up in a pre-compiled header, it is not possible to customize the inclusion
of that header in a source file through preprocessor defines.

For example, under Windows one may want to include `Windows.h` with `NOMINMAX` defined to prevent
the definition of the `min` and `max` macros:

#define NOMINMAX
#include <Windows.h>

The dependency of `Windows.h` on the preprocessor define `NOMINMAX` will not be picked up by cotire
automatically upon adding `Windows.h` to the prefix header. To work around the problem, make the
dependency explicit by using `add_definitions` in the corresponding `CMakeLists.txt`:

if (WIN32)
# prevent definition of min and max macros through inclusion of Windows.h
add_definitions("-DNOMINMAX")
endif()

That way, the preprocessor define `NOMINMAX` will be picked up by cotire and applied to the
pre-compilation of the prefix header.

cotire usage restrictions
-------------------------



+ 37
- 0
Patches/clang-3.5.src.patch View File

@@ -0,0 +1,39 @@
diff -rupN --exclude=.DS_Store cfe-3.5.0.src/CMakeLists.txt cfe-3.5.0.src.cotire/CMakeLists.txt
--- cfe-3.5.0.src/CMakeLists.txt 2014-07-16 18:48:33.000000000 +0200
@@ -94,6 +94,8 @@ if( CMAKE_SOURCE_DIR STREQUAL CMAKE_CURR
include(AddLLVM)
include(TableGen)
include(HandleLLVMOptions)
+ include(cotire)
+ set_property(DIRECTORY PROPERTY COTIRE_UNITY_LINK_LIBRARIES_INIT "COPY_UNITY")
set(PACKAGE_VERSION "${LLVM_PACKAGE_VERSION}")
@@ -343,6 +345,12 @@ macro(add_clang_library name)
endif()
set_target_properties(${name} PROPERTIES FOLDER "Clang libraries")
+ if (COMMAND cotire)
+ if (NOT "${name}" MATCHES "libclang")
+ set_target_properties(${name} PROPERTIES COTIRE_UNITY_SOURCE_POST_UNDEFS "DEBUG_TYPE")
+ cotire(${name})
+ endif()
+ endif()
endmacro(add_clang_library)
macro(add_clang_executable name)
diff -rupN --exclude=.DS_Store cfe-3.5.0.src/tools/libclang/CMakeLists.txt cfe-3.5.0.src.cotire/tools/libclang/CMakeLists.txt
--- cfe-3.5.0.src/tools/libclang/CMakeLists.txt 2014-07-15 00:17:16.000000000 +0200
@@ -114,3 +114,10 @@ if(ENABLE_SHARED)
LINK_FLAGS ${LIBCLANG_LINK_FLAGS})
endif()
endif()
+
+if (COMMAND cotire)
+ cotire(libclang)
+ if (TARGET ${LIBCLANG_STATIC_TARGET_NAME})
+ cotire(${LIBCLANG_STATIC_TARGET_NAME})
+ endif()
+endif()

+ 96
- 0
Patches/llvm-3.5.src.patch View File

@@ -0,0 +1,99 @@
diff -rupN --exclude=.DS_Store --exclude='*.pyc' llvm-3.5.0.src/CMakeLists.txt llvm-3.5.0.src.cotire/CMakeLists.txt
--- llvm-3.5.0.src/CMakeLists.txt 2014-07-04 06:23:26.000000000 +0200
@@ -1,6 +1,6 @@
# See docs/CMake.html for instructions about how to build LLVM with CMake.
-cmake_minimum_required(VERSION 2.8.8)
+cmake_minimum_required(VERSION 2.8.12)
# FIXME: It may be removed when we use 2.8.12.
if(CMAKE_VERSION VERSION_LESS 2.8.12)
@@ -41,6 +41,8 @@ if ( LLVM_USE_FOLDERS )
endif()
include(VersionFromVCS)
+include(cotire)
+set_property(DIRECTORY PROPERTY COTIRE_UNITY_LINK_LIBRARIES_INIT "COPY_UNITY")
option(LLVM_APPEND_VC_REV
"Append the version control system revision id to LLVM version" OFF)
diff -rupN --exclude=.DS_Store --exclude='*.pyc' llvm-3.5.0.src/cmake/modules/AddLLVM.cmake llvm-3.5.0.src.cotire/cmake/modules/AddLLVM.cmake
--- llvm-3.5.0.src/cmake/modules/AddLLVM.cmake 2014-07-23 17:19:01.000000000 +0200
@@ -106,6 +106,10 @@ function(add_llvm_symbol_exports target_
set_property(TARGET ${target_name} APPEND_STRING PROPERTY
LINK_FLAGS " /DEF:${CMAKE_CURRENT_BINARY_DIR}/${native_export_file}")
endif()
+if (COMMAND cotire)
+ set_target_properties(${name} PROPERTIES COTIRE_UNITY_SOURCE_POST_UNDEFS "DEBUG_TYPE")
+ cotire(${name})
+endif()
endif()
add_custom_target(${target_name}_exports DEPENDS ${native_export_file})
@@ -394,6 +398,10 @@ macro(add_llvm_library name)
set_property(GLOBAL APPEND PROPERTY LLVM_EXPORTS ${name})
endif()
set_target_properties(${name} PROPERTIES FOLDER "Libraries")
+if (COMMAND cotire)
+ set_target_properties(${name} PROPERTIES COTIRE_UNITY_SOURCE_POST_UNDEFS "DEBUG_TYPE")
+ cotire(${name})
+endif()
endmacro(add_llvm_library name)
macro(add_llvm_loadable_module name)
@@ -422,6 +430,10 @@ macro(add_llvm_loadable_module name)
endif()
set_target_properties(${name} PROPERTIES FOLDER "Loadable modules")
+if (COMMAND cotire)
+ set_target_properties(${name} PROPERTIES COTIRE_UNITY_SOURCE_POST_UNDEFS "DEBUG_TYPE")
+ cotire(${name})
+endif()
endmacro(add_llvm_loadable_module name)
@@ -471,6 +483,10 @@ macro(add_llvm_tool name)
set_property(GLOBAL APPEND PROPERTY LLVM_EXPORTS ${name})
endif()
set_target_properties(${name} PROPERTIES FOLDER "Tools")
+if (COMMAND cotire)
+ set_target_properties(${name} PROPERTIES COTIRE_UNITY_SOURCE_POST_UNDEFS "DEBUG_TYPE")
+ cotire(${name})
+endif()
endmacro(add_llvm_tool name)
@@ -483,12 +499,20 @@ macro(add_llvm_example name)
install(TARGETS ${name} RUNTIME DESTINATION examples)
endif()
set_target_properties(${name} PROPERTIES FOLDER "Examples")
+if (COMMAND cotire)
+ set_target_properties(${name} PROPERTIES COTIRE_UNITY_SOURCE_POST_UNDEFS "DEBUG_TYPE")
+ cotire(${name})
+endif()
endmacro(add_llvm_example name)
macro(add_llvm_utility name)
add_llvm_executable(${name} ${ARGN})
set_target_properties(${name} PROPERTIES FOLDER "Utils")
+if (COMMAND cotire)
+ set_target_properties(${name} PROPERTIES COTIRE_UNITY_SOURCE_POST_UNDEFS "DEBUG_TYPE")
+ cotire(${name})
+endif()
endmacro(add_llvm_utility name)
diff -rupN --exclude=.DS_Store --exclude='*.pyc' llvm-3.5.0.src/lib/Support/CMakeLists.txt llvm-3.5.0.src.cotire/lib/Support/CMakeLists.txt
--- llvm-3.5.0.src/lib/Support/CMakeLists.txt 2014-07-17 22:05:29.000000000 +0200
@@ -1,3 +1,7 @@
+if (COMMAND cotire)
+ set_source_files_properties (IsInf.cpp IsNAN.cpp PROPERTIES COTIRE_EXCLUDED TRUE)
+endif()
+
add_llvm_library(LLVMSupport
APFloat.cpp
APInt.cpp

+ 2
- 2
README.md View File

@@ -31,9 +31,9 @@ requirements

* [CMake 2.8.6][cmk] or newer. The executable `cmake` should be on the system path.
* [Visual Studio C++][vslstd], [MinGW][mingw] or [Cygwin][cgwn] under Windows.
* [GCC][gcc] under Linux or OS X.
* [GCC][gcc] or [Clang][clang] under Linux or OS X.
* [Intel C++ compiler][intel] under Windows, Linux or OS X.
* [Xcode][xcdt] developer tools package under OS X. This includes [Clang][clang].
* [Xcode][xcdt] application or Xcode Command Line Tools under OS X.

installation
------------


Write Preview
Loading…
Cancel
Save