kolan
/
CMake
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity
CMake/Modules/Platform/Windows-MSVC.cmake

313 lines
13 KiB
CMake
Raw Normal View History

Simplify CMake per-source license notices Per-source copyright/license notice headers that spell out copyright holder names and years are hard to maintain and often out-of-date or plain wrong. Precise contributor information is already maintained automatically by the version control tool. Ultimately it is the receiver of a file who is responsible for determining its licensing status, and per-source notices are merely a convenience. Therefore it is simpler and more accurate for each source to have a generic notice of the license name and references to more detailed information on copyright holders and full license terms. Our `Copyright.txt` file now contains a list of Contributors whose names appeared source-level copyright notices. It also references version control history for more precise information. Therefore we no longer need to spell out the list of Contributors in each source file notice. Replace CMake per-source copyright/license notice headers with a short description of the license and links to `Copyright.txt` and online information available from "https://cmake.org/licensing". The online URL also handles cases of modules being copied out of our source into other projects, so we can drop our notices about replacing links with full license text. Run the `Utilities/Scripts/filter-notices.bash` script to perform the majority of the replacements mechanically. Manually fix up shebang lines and trailing newlines in a few files. Manually update the notices in a few files that the script does not handle.
2016-09-27 22:01:08 +03:00
# Distributed under the OSI-approved BSD 3-Clause License. See accompanying
# file Copyright.txt or https://cmake.org/licensing for details.
Complete rework of makefile generators expect trouble
2002-11-08 23:46:08 +03:00
Modernize MSVC compiler information files Remove the old-style "Windows-cl.cmake" and its helper "cl.cmake". Load the information through new-style "Platform/Windows-MSVC-<lang>.cmake" files. Factor information common to C and CXX into a helper file "Platform/Windows-MSVC.cmake" loaded from the per-language files.
2012-08-23 20:00:55 +04:00
# This module is shared by multiple languages; use include blocker.
if(__WINDOWS_MSVC)
return()
endif()
set(__WINDOWS_MSVC 1)
set(CMAKE_LIBRARY_PATH_FLAG "-LIBPATH:")
set(CMAKE_LINK_LIBRARY_FLAG "")
set(MSVC 1)
Fix spelling and typos (non-binary)
2012-11-07 20:13:09 +04:00
# hack: if a new cmake (which uses CMAKE_LINKER) runs on an old build tree
Modernize MSVC compiler information files Remove the old-style "Windows-cl.cmake" and its helper "cl.cmake". Load the information through new-style "Platform/Windows-MSVC-<lang>.cmake" files. Factor information common to C and CXX into a helper file "Platform/Windows-MSVC.cmake" loaded from the per-language files.
2012-08-23 20:00:55 +04:00
# (where link was hardcoded) and where CMAKE_LINKER isn't in the cache
# and still cmake didn't fail in CMakeFindBinUtils.cmake (because it isn't rerun)
# hardcode CMAKE_LINKER here to link, so it behaves as it did before, Alex
if(NOT DEFINED CMAKE_LINKER)
set(CMAKE_LINKER link)
endif()
if(CMAKE_VERBOSE_MAKEFILE)
set(CMAKE_CL_NOLOGO)
else()
set(CMAKE_CL_NOLOGO "/nologo")
endif()
MSVC: Use STREQUAL to check for WindowsCE In the Platform/Windows-MSVC module it is not necessary to use MATCHES because we are comparing against an exact string.
2014-07-28 22:12:39 +04:00
if(CMAKE_SYSTEM_NAME STREQUAL "WindowsCE")
MSVC: Fix linking of DLLs on WinCE (#15013) On WinCE we must link both shared libraries and executables with the /subsystem:windowsce flag. Teach Platform/Windows-MSVC to pass it to the linker in both cases. Suggested-by: Gunnar Roth <gunnar.roth@gmx.de>
2014-07-10 23:06:19 +04:00
set(CMAKE_CREATE_WIN32_EXE "/entry:WinMainCRTStartup")
set(CMAKE_CREATE_CONSOLE_EXE "/entry:mainACRTStartup")
set(_PLATFORM_LINK_FLAGS " /subsystem:windowsce")
Add WindowsCE platform information files This enables CMake to create Makefiles targeting Windows CE devices. CMake needs to be run within a cross compile command prompt and requires a toolchain file which sets CMAKE_SYSTEM_NAME to "WindowsCE" and optionally CMAKE_SYSTEM_VERSION.
2012-09-05 12:08:58 +04:00
else()
set(CMAKE_CREATE_WIN32_EXE "/subsystem:windows")
set(CMAKE_CREATE_CONSOLE_EXE "/subsystem:console")
MSVC: Fix linking of DLLs on WinCE (#15013) On WinCE we must link both shared libraries and executables with the /subsystem:windowsce flag. Teach Platform/Windows-MSVC to pass it to the linker in both cases. Suggested-by: Gunnar Roth <gunnar.roth@gmx.de>
2014-07-10 23:06:19 +04:00
set(_PLATFORM_LINK_FLAGS "")
Add WindowsCE platform information files This enables CMake to create Makefiles targeting Windows CE devices. CMake needs to be run within a cross compile command prompt and requires a toolchain file which sets CMAKE_SYSTEM_NAME to "WindowsCE" and optionally CMAKE_SYSTEM_VERSION.
2012-09-05 12:08:58 +04:00
endif()
BUG: fix for main in a library on windows with nmake
2003-08-07 22:10:16 +04:00
Windows: Optionally generate DLL module definition files automatically Create target property WINDOWS_EXPORT_ALL_SYMBOLS to automatically generate a module definition file from MS-compatible .obj files and give it to the linker in order to export all symbols from the .dll part of a SHARED library.
2015-06-19 23:12:43 +03:00
set(CMAKE_SUPPORT_WINDOWS_EXPORT_ALL_SYMBOLS 1)
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:47:32 +04:00
if(NOT CMAKE_NO_BUILD_TYPE AND CMAKE_GENERATOR MATCHES "Visual Studio")
set (CMAKE_NO_BUILD_TYPE 1)
Remove CMake-language block-end command arguments Ancient versions of CMake required else(), endif(), and similar block termination commands to have arguments matching the command starting the block. This is no longer the preferred style. Run the following shell code: for c in else endif endforeach endfunction endmacro endwhile; do echo 's/\b'"$c"'\(\s*\)(.\+)/'"$c"'\1()/' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | egrep -z -v 'Tests/CMakeTests/While-Endwhile-' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:50:14 +04:00
endif()
ENH: stuff to keep compiler tests from re-running all the time
2005-01-20 20:30:03 +03:00
VS: Simplify MSVC version reporting Teach Windows-cl.cmake to use CMAKE_(C|CXX)_COMPILER_VERSION to set the "MSVC##" and MSVC_VERSION variables. It no longer needs the IDE generator to dictate the version or to detect the version by running the command-line tool for NMake and Ninja generators. Drop configuration of CMakeCPlatform.cmake and CMakeCXXPlatform.cmake from Windows-cl.cmake.in because all the results it saved are now cheap to compute every time.
2012-08-23 19:20:48 +04:00
if("${CMAKE_GENERATOR}" MATCHES "Visual Studio")
set(MSVC_IDE 1)
VS: Fix MSVC_IDE definition recently broken by refactoring In commit 485a940e (VS: Simplify MSVC version reporting, 2012-08-23) we accidentally flipped the 0/1 values of MSVC_IDE. Flip them back and teach the CheckCompilerRelatedVariables test to check the variable.
2012-08-31 00:08:16 +04:00
else()
set(MSVC_IDE 0)
VS: Simplify MSVC version reporting Teach Windows-cl.cmake to use CMAKE_(C|CXX)_COMPILER_VERSION to set the "MSVC##" and MSVC_VERSION variables. It no longer needs the IDE generator to dictate the version or to detect the version by running the command-line tool for NMake and Ninja generators. Drop configuration of CMakeCPlatform.cmake and CMakeCXXPlatform.cmake from Windows-cl.cmake.in because all the results it saved are now cheap to compute every time.
2012-08-23 19:20:48 +04:00
endif()
if(NOT MSVC_VERSION)
Clang: Support Windows variants for GNU and MSVC (#13035, #14458) Teach the compiler identification preprocessor tests to report when Clang simulates MSVC, and what version. If not MSVC, assume GNU. Teach compiler information modules Clang-(C|CXX) to recognize when Clang simulates MSVC and skip loading the GNU information. Teach the Windows-MSVC platform information to recognize when it is loaded as the simulated compiler and use that version information instead of the real compiler's (different) version scheme. Add platform modules Windows-Clang-(C|CXX) and support module Windows-Clang to load either Windows-MSVC or Windows-GNU and wrap the corresponding information macros.
2013-10-04 18:13:08 +04:00
if(CMAKE_C_SIMULATE_VERSION)
set(_compiler_version ${CMAKE_C_SIMULATE_VERSION})
elseif(CMAKE_CXX_SIMULATE_VERSION)
set(_compiler_version ${CMAKE_CXX_SIMULATE_VERSION})
Intel: When simulating MSVC, re-use Windows-MSVC (#14476) Teach CMake(C|CXX|Fortran)CompilerId* to report the MSVC version simulated by the Intel compiler, if any. Refactor the Windows-Intel platform information helper module to load Windows-MSVC instead of duplicating the information. Teach Windows-MSVC to understand when it is loaded as the simulated Fortran compiler (its preprocessor is simulated).
2013-10-11 21:54:50 +04:00
elseif(CMAKE_Fortran_SIMULATE_VERSION)
set(_compiler_version ${CMAKE_Fortran_SIMULATE_VERSION})
Clang: Support Windows variants for GNU and MSVC (#13035, #14458) Teach the compiler identification preprocessor tests to report when Clang simulates MSVC, and what version. If not MSVC, assume GNU. Teach compiler information modules Clang-(C|CXX) to recognize when Clang simulates MSVC and skip loading the GNU information. Teach the Windows-MSVC platform information to recognize when it is loaded as the simulated compiler and use that version information instead of the real compiler's (different) version scheme. Add platform modules Windows-Clang-(C|CXX) and support module Windows-Clang to load either Windows-MSVC or Windows-GNU and wrap the corresponding information macros.
2013-10-04 18:13:08 +04:00
elseif(CMAKE_C_COMPILER_VERSION)
VS: Simplify MSVC version reporting Teach Windows-cl.cmake to use CMAKE_(C|CXX)_COMPILER_VERSION to set the "MSVC##" and MSVC_VERSION variables. It no longer needs the IDE generator to dictate the version or to detect the version by running the command-line tool for NMake and Ninja generators. Drop configuration of CMakeCPlatform.cmake and CMakeCXXPlatform.cmake from Windows-cl.cmake.in because all the results it saved are now cheap to compute every time.
2012-08-23 19:20:48 +04:00
set(_compiler_version ${CMAKE_C_COMPILER_VERSION})
else()
set(_compiler_version ${CMAKE_CXX_COMPILER_VERSION})
endif()
if("${_compiler_version}" MATCHES "^([0-9]+)\\.([0-9]+)")
math(EXPR MSVC_VERSION "${CMAKE_MATCH_1}*100 + ${CMAKE_MATCH_2}")
else()
message(FATAL_ERROR "MSVC compiler version not detected properly: ${_compiler_version}")
endif()
set(MSVC10)
set(MSVC11)
VS12: Add Visual Studio 12 generator (#14251) Copy cmGlobalVisualStudio11Generator to cmGlobalVisualStudio12Generator and update version numbers accordingly. Add the VS12 enumeration value. Add module CMakeVS12FindMake to find MSBuild. Look for MSBuild in its now-dedicated Windows Registry entry. Teach the platform module Windows-MSVC to set MSVC12 and document the variable. Teach module InstallRequiredSystemLibraries to look for the VS 12 runtime libraries. Teach tests CheckCompilerRelatedVariables, Preprocess, VSExternalInclude, and RunCMake.GeneratorToolset to treat VS 12 as they do VS 10 and 11. Inspired-by: Minmin Gong <minmin.gong@gmail.com>
2013-06-29 00:12:08 +04:00
set(MSVC12)
VS14: Add Visual Studio 14 generator (#14982) Call the generator "Visual Studio 14" without any year because this version of VS does not provide a year in the product name. Copy cmGlobalVisualStudio12Generator to cmGlobalVisualStudio14Generator and update version numbers accordingly. Add the VS14 enumeration value. Teach the platform module Windows-MSVC to set MSVC14 and document the variable. Teach module InstallRequiredSystemLibraries to look for the VS 14 runtime libraries. Teach tests CheckCompilerRelatedVariables, VSExternalInclude, and RunCMake.GeneratorToolset to treat VS 14 as they do VS 10, 11, and 12. Co-Author: Pawel Stopinski <diokhan@go2.pl>
2014-06-24 23:39:11 +04:00
set(MSVC14)
VS: Simplify MSVC version reporting Teach Windows-cl.cmake to use CMAKE_(C|CXX)_COMPILER_VERSION to set the "MSVC##" and MSVC_VERSION variables. It no longer needs the IDE generator to dictate the version or to detect the version by running the command-line tool for NMake and Ninja generators. Drop configuration of CMakeCPlatform.cmake and CMakeCXXPlatform.cmake from Windows-cl.cmake.in because all the results it saved are now cheap to compute every time.
2012-08-23 19:20:48 +04:00
set(MSVC60)
set(MSVC70)
set(MSVC71)
set(MSVC80)
set(MSVC90)
set(CMAKE_COMPILER_2005)
set(CMAKE_COMPILER_SUPPORTS_PDBTYPE)
VS14: Add Visual Studio 14 generator (#14982) Call the generator "Visual Studio 14" without any year because this version of VS does not provide a year in the product name. Copy cmGlobalVisualStudio12Generator to cmGlobalVisualStudio14Generator and update version numbers accordingly. Add the VS14 enumeration value. Teach the platform module Windows-MSVC to set MSVC14 and document the variable. Teach module InstallRequiredSystemLibraries to look for the VS 14 runtime libraries. Teach tests CheckCompilerRelatedVariables, VSExternalInclude, and RunCMake.GeneratorToolset to treat VS 14 as they do VS 10, 11, and 12. Co-Author: Pawel Stopinski <diokhan@go2.pl>
2014-06-24 23:39:11 +04:00
if(NOT "${_compiler_version}" VERSION_LESS 19)
set(MSVC14 1)
elseif(NOT "${_compiler_version}" VERSION_LESS 18)
VS12: Add Visual Studio 12 generator (#14251) Copy cmGlobalVisualStudio11Generator to cmGlobalVisualStudio12Generator and update version numbers accordingly. Add the VS12 enumeration value. Add module CMakeVS12FindMake to find MSBuild. Look for MSBuild in its now-dedicated Windows Registry entry. Teach the platform module Windows-MSVC to set MSVC12 and document the variable. Teach module InstallRequiredSystemLibraries to look for the VS 12 runtime libraries. Teach tests CheckCompilerRelatedVariables, Preprocess, VSExternalInclude, and RunCMake.GeneratorToolset to treat VS 12 as they do VS 10 and 11. Inspired-by: Minmin Gong <minmin.gong@gmail.com>
2013-06-29 00:12:08 +04:00
set(MSVC12 1)
elseif(NOT "${_compiler_version}" VERSION_LESS 17)
VS: Simplify MSVC version reporting Teach Windows-cl.cmake to use CMAKE_(C|CXX)_COMPILER_VERSION to set the "MSVC##" and MSVC_VERSION variables. It no longer needs the IDE generator to dictate the version or to detect the version by running the command-line tool for NMake and Ninja generators. Drop configuration of CMakeCPlatform.cmake and CMakeCXXPlatform.cmake from Windows-cl.cmake.in because all the results it saved are now cheap to compute every time.
2012-08-23 19:20:48 +04:00
set(MSVC11 1)
elseif(NOT "${_compiler_version}" VERSION_LESS 16)
set(MSVC10 1)
elseif(NOT "${_compiler_version}" VERSION_LESS 15)
set(MSVC90 1)
elseif(NOT "${_compiler_version}" VERSION_LESS 14)
set(MSVC80 1)
set(CMAKE_COMPILER_2005 1)
elseif(NOT "${_compiler_version}" VERSION_LESS 13.10)
set(MSVC71 1)
elseif(NOT "${_compiler_version}" VERSION_LESS 13)
set(MSVC70 1)
else()
set(MSVC60 1)
set(CMAKE_COMPILER_SUPPORTS_PDBTYPE 1)
Remove CMake-language block-end command arguments Ancient versions of CMake required else(), endif(), and similar block termination commands to have arguments matching the command starting the block. This is no longer the preferred style. Run the following shell code: for c in else endif endforeach endfunction endmacro endwhile; do echo 's/\b'"$c"'\(\s*\)(.\+)/'"$c"'\1()/' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | egrep -z -v 'Tests/CMakeTests/While-Endwhile-' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:50:14 +04:00
endif()
endif()
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:47:32 +04:00
MSVC: Fix CMAKE_CL_64 in CXX-only projects (#13896) When CXX is enabled without C then MSVC_CXX_ARCHITECTURE_ID is set instead but not MSVC_C_ARCHITECTURE_ID. Test both.
2013-02-08 00:04:06 +04:00
if(MSVC_C_ARCHITECTURE_ID MATCHES 64 OR MSVC_CXX_ARCHITECTURE_ID MATCHES 64)
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:47:32 +04:00
set(CMAKE_CL_64 1)
Remove CMake-language block-end command arguments Ancient versions of CMake required else(), endif(), and similar block termination commands to have arguments matching the command starting the block. This is no longer the preferred style. Run the following shell code: for c in else endif endforeach endfunction endmacro endwhile; do echo 's/\b'"$c"'\(\s*\)(.\+)/'"$c"'\1()/' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | egrep -z -v 'Tests/CMakeTests/While-Endwhile-' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:50:14 +04:00
else()
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:47:32 +04:00
set(CMAKE_CL_64 0)
Remove CMake-language block-end command arguments Ancient versions of CMake required else(), endif(), and similar block termination commands to have arguments matching the command starting the block. This is no longer the preferred style. Run the following shell code: for c in else endif endforeach endfunction endmacro endwhile; do echo 's/\b'"$c"'\(\s*\)(.\+)/'"$c"'\1()/' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | egrep -z -v 'Tests/CMakeTests/While-Endwhile-' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:50:14 +04:00
endif()
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:47:32 +04:00
if(CMAKE_FORCE_WIN64 OR CMAKE_FORCE_IA64)
set(CMAKE_CL_64 1)
Remove CMake-language block-end command arguments Ancient versions of CMake required else(), endif(), and similar block termination commands to have arguments matching the command starting the block. This is no longer the preferred style. Run the following shell code: for c in else endif endforeach endfunction endmacro endwhile; do echo 's/\b'"$c"'\(\s*\)(.\+)/'"$c"'\1()/' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | egrep -z -v 'Tests/CMakeTests/While-Endwhile-' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:50:14 +04:00
endif()
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:47:32 +04:00
if("${MSVC_VERSION}" GREATER 1599)
set(MSVC_INCREMENTAL_DEFAULT ON)
endif()
ENH: unify EnableLanguage across all generators
2002-12-05 21:44:11 +03:00
ENH: add support for VCExpress 2005
2004-07-05 20:16:33 +04:00
# default to Debug builds
Modernize MSVC compiler information files Remove the old-style "Windows-cl.cmake" and its helper "cl.cmake". Load the information through new-style "Platform/Windows-MSVC-<lang>.cmake" files. Factor information common to C and CXX into a helper file "Platform/Windows-MSVC.cmake" loaded from the per-language files.
2012-08-23 20:00:55 +04:00
set(CMAKE_BUILD_TYPE_INIT Debug)
MSVC: Distinguish among ARM architectures more precisely (#14552) Detect the exact ARM architecture instead of just "ARM". Treat "ARM" as an architecture family that includes THUMB (ARMV4I and ARMV5I).
2015-02-13 18:11:38 +03:00
# Compute an architecture family from the architecture id.
foreach(lang C CXX)
set(_MSVC_${lang}_ARCHITECTURE_FAMILY "${MSVC_${lang}_ARCHITECTURE_ID}")
if(_MSVC_${lang}_ARCHITECTURE_FAMILY MATCHES "^ARM")
set(_MSVC_${lang}_ARCHITECTURE_FAMILY "ARM")
elseif(_MSVC_${lang}_ARCHITECTURE_FAMILY MATCHES "^SH")
set(_MSVC_${lang}_ARCHITECTURE_FAMILY "SHx")
endif()
endforeach()
Set WINCE to 1 when building for WindowsCE Introduce a new variable WINCE to make the WindowsCE system more easy to use in if statements.
2013-02-02 02:23:09 +04:00
if(WINCE)
MSVC: Fix WinCE arch family preprocessor symbol (#14436) In commit bd827f98 (Use COFF file header header for architecture detection, 2013-08-05) the MSVC_<lang>_ARCHITECTURE_ID value computed by CMakeDetermineCompilerId.cmake changed for WinCE architectures to be the exact architecture read from the PE header. Fix platform preprocessor definitions in Modules/Platform/Windows-MSVC.cmake to correspond to the architecture family (ARM or SHx) instead of the specific architecture.
2013-09-25 07:20:22 +04:00
foreach(lang C CXX)
string(TOUPPER "${_MSVC_${lang}_ARCHITECTURE_FAMILY}" _MSVC_${lang}_ARCHITECTURE_FAMILY_UPPER)
endforeach()
Add WindowsCE platform information files This enables CMake to create Makefiles targeting Windows CE devices. CMake needs to be run within a cross compile command prompt and requires a toolchain file which sets CMAKE_SYSTEM_NAME to "WindowsCE" and optionally CMAKE_SYSTEM_VERSION.
2012-09-05 12:08:58 +04:00
if("${CMAKE_SYSTEM_VERSION}" MATCHES "^([0-9]+)\\.([0-9]+)")
math(EXPR _CE_VERSION "${CMAKE_MATCH_1}*100 + ${CMAKE_MATCH_2}")
elseif("${CMAKE_SYSTEM_VERSION}" STREQUAL "")
set(_CE_VERSION "500")
else()
message(FATAL_ERROR "Invalid Windows CE version: ${CMAKE_SYSTEM_VERSION}")
endif()
MSVC: Define /DWINCE when building for WinCE platforms (#14552)
2015-02-13 18:10:26 +03:00
set(_PLATFORM_DEFINES "/D_WIN32_WCE=0x${_CE_VERSION} /DUNDER_CE /DWINCE")
MSVC: Fix WinCE arch family preprocessor symbol (#14436) In commit bd827f98 (Use COFF file header header for architecture detection, 2013-08-05) the MSVC_<lang>_ARCHITECTURE_ID value computed by CMakeDetermineCompilerId.cmake changed for WinCE architectures to be the exact architecture read from the PE header. Fix platform preprocessor definitions in Modules/Platform/Windows-MSVC.cmake to correspond to the architecture family (ARM or SHx) instead of the specific architecture.
2013-09-25 07:20:22 +04:00
set(_PLATFORM_DEFINES_C " /D${_MSVC_C_ARCHITECTURE_FAMILY} /D_${_MSVC_C_ARCHITECTURE_FAMILY_UPPER}_")
set(_PLATFORM_DEFINES_CXX " /D${_MSVC_CXX_ARCHITECTURE_FAMILY} /D_${_MSVC_CXX_ARCHITECTURE_FAMILY_UPPER}_")
Add WindowsCE platform information files This enables CMake to create Makefiles targeting Windows CE devices. CMake needs to be run within a cross compile command prompt and requires a toolchain file which sets CMAKE_SYSTEM_NAME to "WindowsCE" and optionally CMAKE_SYSTEM_VERSION.
2012-09-05 12:08:58 +04:00
set(_RTC1 "")
MSVC: Compile with arch-specific flags on ARM platforms (#14552) Define the exact ARM architecture name as a preprocessor symbol. Compile with /QRarch4T or /QRarch5T on ARMV4I or ARMV5I.
2015-02-13 18:14:34 +03:00
set(_FLAGS_C "")
Modernize MSVC compiler information files Remove the old-style "Windows-cl.cmake" and its helper "cl.cmake". Load the information through new-style "Platform/Windows-MSVC-<lang>.cmake" files. Factor information common to C and CXX into a helper file "Platform/Windows-MSVC.cmake" loaded from the per-language files.
2012-08-23 20:00:55 +04:00
set(_FLAGS_CXX " /GR /EHsc")
MSVC: Compile with arch-specific flags on ARM platforms (#14552) Define the exact ARM architecture name as a preprocessor symbol. Compile with /QRarch4T or /QRarch5T on ARMV4I or ARMV5I.
2015-02-13 18:14:34 +03:00
foreach(lang C CXX)
if(_MSVC_${lang}_ARCHITECTURE_FAMILY STREQUAL "ARM")
set(_PLATFORM_DEFINES_${lang} "${_PLATFORM_DEFINES_${lang}} /D${MSVC_${lang}_ARCHITECTURE_ID}")
if(MSVC_${lang}_ARCHITECTURE_ID MATCHES "^ARMV([45])I$")
set(_FLAGS_${lang} "${_FLAGS_${lang}} /QRarch${CMAKE_MATCH_1}T")
endif()
endif()
endforeach()
Add support for new Windows CE compiler The new compiler versions do not need corelibc.lib as a default link library and a architecture detection workaround.
2013-08-04 22:11:30 +04:00
set(CMAKE_C_STANDARD_LIBRARIES_INIT "coredll.lib ole32.lib oleaut32.lib uuid.lib commctrl.lib")
MSVC: Set all CMAKE_*_LINKER_FLAGS_INIT directly Avoid copying CMAKE_EXE_LINKER_FLAGS_INIT to the others.
2016-07-13 22:05:32 +03:00
foreach(t EXE SHARED MODULE)
string(APPEND CMAKE_${t}_LINKER_FLAGS_INIT " /NODEFAULTLIB:libc.lib /NODEFAULTLIB:oldnames.lib")
endforeach()
Add support for new Windows CE compiler The new compiler versions do not need corelibc.lib as a default link library and a architecture detection workaround.
2013-08-04 22:11:30 +04:00
MSVC: Fix version test for linking corelibc on Windows CE (#14420) In commit 8fcf0ab0 (Add support for new Windows CE compiler, 2013-08-04) we made corelibc conditional on the MSVC version, but the version value was incorrect. Update it to use corelibc for VS 2008 and below.
2013-09-23 21:38:13 +04:00
if (MSVC_VERSION LESS 1600)
Use string(APPEND) in Modules Automate with: find Modules -type f -print0 | xargs -0 perl -i -0pe \ 's/set\(([a-zA-Z0-9_]+)(\s+)"\$\{\1\}([^"])/string(APPEND \1\2"\3/g'
2016-07-28 01:41:13 +03:00
string(APPEND CMAKE_C_STANDARD_LIBRARIES_INIT " corelibc.lib")
Add support for new Windows CE compiler The new compiler versions do not need corelibc.lib as a default link library and a architecture detection workaround.
2013-08-04 22:11:30 +04:00
endif ()
MSVC: Add default WindowsPhone and WindowsStore compile flags Also set the list of standard libraries to empty.
2014-07-28 22:56:13 +04:00
elseif(WINDOWS_PHONE OR WINDOWS_STORE)
MSVC: Define 'WIN32' for Windows Store and Windows Phone This was accidentally left out of commit c72f0887 (MSVC: Add default WindowsPhone and WindowsStore compile flags, 2014-07-28).
2014-08-27 02:44:12 +04:00
set(_PLATFORM_DEFINES "/DWIN32")
MSVC: Add default WindowsPhone and WindowsStore compile flags Also set the list of standard libraries to empty.
2014-07-28 22:56:13 +04:00
set(_FLAGS_C " /DUNICODE /D_UNICODE")
set(_FLAGS_CXX " /DUNICODE /D_UNICODE /GR /EHsc")
MSVC: Add system libs for WindowsStore on VS 2015 Use WindowsApp.lib for a Universal Application Platform project.
2015-10-02 21:34:55 +03:00
if(WINDOWS_STORE AND MSVC_VERSION GREATER 1899)
set(CMAKE_C_STANDARD_LIBRARIES_INIT "WindowsApp.lib")
elseif(WINDOWS_PHONE)
MSVC: Add system libs for WindowsPhone and WindowsStore Use the libraries that are added by default by the VS 2013 IDE for Windows Phone and Windows Store projects.
2014-07-31 21:08:53 +04:00
set(CMAKE_C_STANDARD_LIBRARIES_INIT "WindowsPhoneCore.lib RuntimeObject.lib PhoneAppModelHost.lib")
MSVC: Distinguish among ARM architectures more precisely (#14552) Detect the exact ARM architecture instead of just "ARM". Treat "ARM" as an architecture family that includes THUMB (ARMV4I and ARMV5I).
2015-02-13 18:11:38 +03:00
elseif(_MSVC_C_ARCHITECTURE_FAMILY STREQUAL "ARM" OR _MSVC_CXX_ARCHITECTURE_FAMILY STREQUAL "ARM")
MSVC: Select default standard libraries for ARM platform For Windows ARM targets, only kernel32.lib and user32.lib are standard.
2014-08-05 23:02:49 +04:00
set(CMAKE_C_STANDARD_LIBRARIES_INIT "kernel32.lib user32.lib")
MSVC: Add system libs for WindowsPhone and WindowsStore Use the libraries that are added by default by the VS 2013 IDE for Windows Phone and Windows Store projects.
2014-07-31 21:08:53 +04:00
else()
set(CMAKE_C_STANDARD_LIBRARIES_INIT "kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib")
endif()
Remove CMake-language block-end command arguments Ancient versions of CMake required else(), endif(), and similar block termination commands to have arguments matching the command starting the block. This is no longer the preferred style. Run the following shell code: for c in else endif endforeach endfunction endmacro endwhile; do echo 's/\b'"$c"'\(\s*\)(.\+)/'"$c"'\1()/' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | egrep -z -v 'Tests/CMakeTests/While-Endwhile-' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:50:14 +04:00
else()
Add WindowsCE platform information files This enables CMake to create Makefiles targeting Windows CE devices. CMake needs to be run within a cross compile command prompt and requires a toolchain file which sets CMAKE_SYSTEM_NAME to "WindowsCE" and optionally CMAKE_SYSTEM_VERSION.
2012-09-05 12:08:58 +04:00
set(_PLATFORM_DEFINES "/DWIN32")
MSVC: Distinguish among ARM architectures more precisely (#14552) Detect the exact ARM architecture instead of just "ARM". Treat "ARM" as an architecture family that includes THUMB (ARMV4I and ARMV5I).
2015-02-13 18:11:38 +03:00
if(_MSVC_C_ARCHITECTURE_FAMILY STREQUAL "ARM" OR _MSVC_CXX_ARCHITECTURE_FAMILY STREQUAL "ARM")
MSVC: Select default standard libraries for ARM platform For Windows ARM targets, only kernel32.lib and user32.lib are standard.
2014-08-05 23:02:49 +04:00
set(CMAKE_C_STANDARD_LIBRARIES_INIT "kernel32.lib user32.lib")
elseif(MSVC_VERSION GREATER 1310)
VS: Recognize VS/LLVM toolset names as Clang Update the toolset name matching added by commit v3.6.0-rc1~279^2~10 (VS: in Clang/C2 toolset, setup correct compiler settings, 2016-02-18) to match VS/LLVM toolset names too.
2016-09-28 09:46:00 +03:00
if(CMAKE_VS_PLATFORM_TOOLSET MATCHES "(v[0-9]+_clang_.*|LLVM-vs[0-9]+.*)")
VS: in Clang/C2 toolset, setup correct compiler settings
2016-02-18 03:06:52 +03:00
# Clang/C2 in MSVC14 Update 1 seems to not support -fsantinize (yet?)
# set(_RTC1 "-fsantinize=memory,safe-stack")
set(_FLAGS_CXX " -frtti -fexceptions")
else()
set(_RTC1 "/RTC1")
set(_FLAGS_CXX " /GR /EHsc")
endif()
Add WindowsCE platform information files This enables CMake to create Makefiles targeting Windows CE devices. CMake needs to be run within a cross compile command prompt and requires a toolchain file which sets CMAKE_SYSTEM_NAME to "WindowsCE" and optionally CMAKE_SYSTEM_VERSION.
2012-09-05 12:08:58 +04:00
set(CMAKE_C_STANDARD_LIBRARIES_INIT "kernel32.lib user32.lib gdi32.lib winspool.lib shell32.lib ole32.lib oleaut32.lib uuid.lib comdlg32.lib advapi32.lib")
else()
set(_RTC1 "/GZ")
set(_FLAGS_CXX " /GR /GX")
set(CMAKE_C_STANDARD_LIBRARIES_INIT "kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib")
endif()
MSVC: Drop default use of /Zm1000 for VS >= 7.1 From the option documentation of VS >= 7.1: "In earlier versions of Visual C++, the compiler used several discrete heaps, and each had a finite limit. Currently, the compiler dynamically grows the heaps as necessary up to a total heap size limit, and requires a fixed-size buffer only to construct precompiled headers. Consequently, the /Zm compiler option is rarely necessary." http://msdn.microsoft.com/en-us/library/bdscwf1c.aspx Suggested-by: Adam Moss <adam@broadcom.com>
2012-11-16 21:52:59 +04:00
if(MSVC_VERSION LESS 1310)
set(_FLAGS_C " /Zm1000${_FLAGS_C}")
set(_FLAGS_CXX " /Zm1000${_FLAGS_CXX}")
endif()
Remove CMake-language block-end command arguments Ancient versions of CMake required else(), endif(), and similar block termination commands to have arguments matching the command starting the block. This is no longer the preferred style. Run the following shell code: for c in else endif endforeach endfunction endmacro endwhile; do echo 's/\b'"$c"'\(\s*\)(.\+)/'"$c"'\1()/' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | egrep -z -v 'Tests/CMakeTests/While-Endwhile-' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:50:14 +04:00
endif()
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:47:32 +04:00
set(CMAKE_CXX_STANDARD_LIBRARIES_INIT "${CMAKE_C_STANDARD_LIBRARIES_INIT}")
ENH: add support for VCExpress 2005
2004-07-05 20:16:33 +04:00
ENH: fix up several problems with new stuff
2002-11-12 02:10:30 +03:00
# executable linker flags
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:47:32 +04:00
set (CMAKE_LINK_DEF_FILE_FLAG "/DEF:")
CMake: Remove "/STACK:10000000" from default linker flags (#12437) Modern apps that use multiple threads do NOT want 10 Megabytes of RAM per thread being used for each thread's stack... Just leave off the /STACK: argument, and let the compiler use a reasonable default value for the stack size. If existing single-threaded apps require the /STACK: argument because they do need a very large stack size, they can add the flag in their own CMakeLists files.
2012-11-23 20:41:58 +04:00
# set the machine type
Intel: When simulating MSVC, re-use Windows-MSVC (#14476) Teach CMake(C|CXX|Fortran)CompilerId* to report the MSVC version simulated by the Intel compiler, if any. Refactor the Windows-Intel platform information helper module to load Windows-MSVC instead of duplicating the information. Teach Windows-MSVC to understand when it is loaded as the simulated Fortran compiler (its preprocessor is simulated).
2013-10-11 21:54:50 +04:00
if(MSVC_C_ARCHITECTURE_ID)
MSVC: Distinguish among ARM architectures more precisely (#14552) Detect the exact ARM architecture instead of just "ARM". Treat "ARM" as an architecture family that includes THUMB (ARMV4I and ARMV5I).
2015-02-13 18:11:38 +03:00
if(MSVC_C_ARCHITECTURE_ID MATCHES "^ARMV.I")
set(_MACHINE_ARCH_FLAG "/machine:THUMB")
elseif(_MSVC_C_ARCHITECTURE_FAMILY STREQUAL "ARM")
set(_MACHINE_ARCH_FLAG "/machine:ARM")
else()
set(_MACHINE_ARCH_FLAG "/machine:${MSVC_C_ARCHITECTURE_ID}")
endif()
Intel: When simulating MSVC, re-use Windows-MSVC (#14476) Teach CMake(C|CXX|Fortran)CompilerId* to report the MSVC version simulated by the Intel compiler, if any. Refactor the Windows-Intel platform information helper module to load Windows-MSVC instead of duplicating the information. Teach Windows-MSVC to understand when it is loaded as the simulated Fortran compiler (its preprocessor is simulated).
2013-10-11 21:54:50 +04:00
elseif(MSVC_CXX_ARCHITECTURE_ID)
MSVC: Distinguish among ARM architectures more precisely (#14552) Detect the exact ARM architecture instead of just "ARM". Treat "ARM" as an architecture family that includes THUMB (ARMV4I and ARMV5I).
2015-02-13 18:11:38 +03:00
if(MSVC_CXX_ARCHITECTURE_ID MATCHES "^ARMV.I")
set(_MACHINE_ARCH_FLAG "/machine:THUMB")
elseif(_MSVC_CXX_ARCHITECTURE_FAMILY STREQUAL "ARM")
set(_MACHINE_ARCH_FLAG "/machine:ARM")
else()
set(_MACHINE_ARCH_FLAG "/machine:${MSVC_CXX_ARCHITECTURE_ID}")
endif()
Intel: When simulating MSVC, re-use Windows-MSVC (#14476) Teach CMake(C|CXX|Fortran)CompilerId* to report the MSVC version simulated by the Intel compiler, if any. Refactor the Windows-Intel platform information helper module to load Windows-MSVC instead of duplicating the information. Teach Windows-MSVC to understand when it is loaded as the simulated Fortran compiler (its preprocessor is simulated).
2013-10-11 21:54:50 +04:00
elseif(MSVC_Fortran_ARCHITECTURE_ID)
set(_MACHINE_ARCH_FLAG "/machine:${MSVC_Fortran_ARCHITECTURE_ID}")
Remove CMake-language block-end command arguments Ancient versions of CMake required else(), endif(), and similar block termination commands to have arguments matching the command starting the block. This is no longer the preferred style. Run the following shell code: for c in else endif endforeach endfunction endmacro endwhile; do echo 's/\b'"$c"'\(\s*\)(.\+)/'"$c"'\1()/' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | egrep -z -v 'Tests/CMakeTests/While-Endwhile-' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:50:14 +04:00
endif()
BUG: fix for bug 3550, for release builds do not build incremental
2006-07-26 19:15:28 +04:00
Fix Windows-cl.cmake so that at most one MSVC** variable is defined. The expectation of users of the MSVC60, MSVC70, MSVC71, MSVC80, MSVC90 and the new MSVC10 variables is that at most one of them will be set for any given build tree. This change enforces that expectation for build trees using Makefile generators. It also fixes the one mismatch in that expectation to be found in the Visual Studio generator world: previously, the VS 7.1 generator would set *both* MSVC70 and MSVC71; now, it only sets MSVC71. With these changes, user expectations are now met, and the recently introduced CheckCompilerRelatedVariables test should pass everywhere.
2010-05-04 05:29:08 +04:00
# add /debug and /INCREMENTAL:YES to DEBUG and RELWITHDEBINFO also add pdbtype
BUG: fix for bug 3550, for release builds do not build incremental
2006-07-26 19:15:28 +04:00
# on versions that support it
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:47:32 +04:00
set( MSVC_INCREMENTAL_YES_FLAG "")
MSVC: Disable incremental linking for WindowsPhone and WindowsStore Do not add a "/INCREMENTAL" flag when using the toolchains for these systems.
2014-07-28 22:50:57 +04:00
if(NOT WINDOWS_PHONE AND NOT WINDOWS_STORE)
if(NOT MSVC_INCREMENTAL_DEFAULT)
set( MSVC_INCREMENTAL_YES_FLAG "/INCREMENTAL:YES")
else()
set( MSVC_INCREMENTAL_YES_FLAG "/INCREMENTAL" )
endif()
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:47:32 +04:00
endif()
MSVC: Set all CMAKE_*_LINKER_FLAGS_INIT directly Avoid copying CMAKE_EXE_LINKER_FLAGS_INIT to the others.
2016-07-13 22:05:32 +03:00
foreach(t EXE SHARED MODULE)
string(APPEND CMAKE_${t}_LINKER_FLAGS_INIT " ${_MACHINE_ARCH_FLAG}")
if (CMAKE_COMPILER_SUPPORTS_PDBTYPE)
Honor CMAKE_*_LINKER_FLAGS[_<CONFIG>]_INIT set in toolchain files Document these variables. Change our convention for setting these variables from: set(CMAKE_EXE_LINKER_FLAGS_INIT "...") to string(APPEND CMAKE_EXE_LINKER_FLAGS_INIT " ...") so that any value previously set by a toolchain file will be used.
2016-07-13 22:06:23 +03:00
string(APPEND CMAKE_${t}_LINKER_FLAGS_DEBUG_INIT " /debug /pdbtype:sept ${MSVC_INCREMENTAL_YES_FLAG}")
string(APPEND CMAKE_${t}_LINKER_FLAGS_RELWITHDEBINFO_INIT " /debug /pdbtype:sept ${MSVC_INCREMENTAL_YES_FLAG}")
MSVC: Set all CMAKE_*_LINKER_FLAGS_INIT directly Avoid copying CMAKE_EXE_LINKER_FLAGS_INIT to the others.
2016-07-13 22:05:32 +03:00
else ()
Honor CMAKE_*_LINKER_FLAGS[_<CONFIG>]_INIT set in toolchain files Document these variables. Change our convention for setting these variables from: set(CMAKE_EXE_LINKER_FLAGS_INIT "...") to string(APPEND CMAKE_EXE_LINKER_FLAGS_INIT " ...") so that any value previously set by a toolchain file will be used.
2016-07-13 22:06:23 +03:00
string(APPEND CMAKE_${t}_LINKER_FLAGS_DEBUG_INIT " /debug ${MSVC_INCREMENTAL_YES_FLAG}")
string(APPEND CMAKE_${t}_LINKER_FLAGS_RELWITHDEBINFO_INIT " /debug ${MSVC_INCREMENTAL_YES_FLAG}")
MSVC: Set all CMAKE_*_LINKER_FLAGS_INIT directly Avoid copying CMAKE_EXE_LINKER_FLAGS_INIT to the others.
2016-07-13 22:05:32 +03:00
endif ()
# for release and minsize release default to no incremental linking
Honor CMAKE_*_LINKER_FLAGS[_<CONFIG>]_INIT set in toolchain files Document these variables. Change our convention for setting these variables from: set(CMAKE_EXE_LINKER_FLAGS_INIT "...") to string(APPEND CMAKE_EXE_LINKER_FLAGS_INIT " ...") so that any value previously set by a toolchain file will be used.
2016-07-13 22:06:23 +03:00
string(APPEND CMAKE_${t}_LINKER_FLAGS_MINSIZEREL_INIT " /INCREMENTAL:NO")
string(APPEND CMAKE_${t}_LINKER_FLAGS_RELEASE_INIT " /INCREMENTAL:NO")
MSVC: Set all CMAKE_*_LINKER_FLAGS_INIT directly Avoid copying CMAKE_EXE_LINKER_FLAGS_INIT to the others.
2016-07-13 22:05:32 +03:00
endforeach()
added test for whether pdbtype should be used for nmake
2003-08-05 17:55:20 +04:00
MSVC: Set all CMAKE_*_LINKER_FLAGS_INIT directly Avoid copying CMAKE_EXE_LINKER_FLAGS_INIT to the others.
2016-07-13 22:05:32 +03:00
string(APPEND CMAKE_STATIC_LINKER_FLAGS_INIT " ${_MACHINE_ARCH_FLAG}")
unset(_MACHINE_ARCH_FLAG)
Modernize MSVC compiler information files Remove the old-style "Windows-cl.cmake" and its helper "cl.cmake". Load the information through new-style "Platform/Windows-MSVC-<lang>.cmake" files. Factor information common to C and CXX into a helper file "Platform/Windows-MSVC.cmake" loaded from the per-language files.
2012-08-23 20:00:55 +04:00
macro(__windows_compiler_msvc lang)
Clang: Support Windows variants for GNU and MSVC (#13035, #14458) Teach the compiler identification preprocessor tests to report when Clang simulates MSVC, and what version. If not MSVC, assume GNU. Teach compiler information modules Clang-(C|CXX) to recognize when Clang simulates MSVC and skip loading the GNU information. Teach the Windows-MSVC platform information to recognize when it is loaded as the simulated compiler and use that version information instead of the real compiler's (different) version scheme. Add platform modules Windows-Clang-(C|CXX) and support module Windows-Clang to load either Windows-MSVC or Windows-GNU and wrap the corresponding information macros.
2013-10-04 18:13:08 +04:00
if(NOT MSVC_VERSION LESS 1400)
Modernize MSVC compiler information files Remove the old-style "Windows-cl.cmake" and its helper "cl.cmake". Load the information through new-style "Platform/Windows-MSVC-<lang>.cmake" files. Factor information common to C and CXX into a helper file "Platform/Windows-MSVC.cmake" loaded from the per-language files.
2012-08-23 20:00:55 +04:00
# for 2005 make sure the manifest is put in the dll with mt
Add support for *.manifest source files with MSVC tools Classify .manifest sources separately, add dependencies on them, and pass them to the MS manifest tool to merge with linker-generated manifest files. Inspired-by: Gilles Khouzam <gillesk@microsoft.com>
2015-09-16 17:24:16 +03:00
set(_CMAKE_VS_LINK_DLL "<CMAKE_COMMAND> -E vs_link_dll --intdir=<OBJECT_DIR> --manifests <MANIFESTS> -- ")
set(_CMAKE_VS_LINK_EXE "<CMAKE_COMMAND> -E vs_link_exe --intdir=<OBJECT_DIR> --manifests <MANIFESTS> -- ")
Modernize MSVC compiler information files Remove the old-style "Windows-cl.cmake" and its helper "cl.cmake". Load the information through new-style "Platform/Windows-MSVC-<lang>.cmake" files. Factor information common to C and CXX into a helper file "Platform/Windows-MSVC.cmake" loaded from the per-language files.
2012-08-23 20:00:55 +04:00
endif()
set(CMAKE_${lang}_CREATE_SHARED_LIBRARY
MSVC: Fix linking of DLLs on WinCE (#15013) On WinCE we must link both shared libraries and executables with the /subsystem:windowsce flag. Teach Platform/Windows-MSVC to pass it to the linker in both cases. Suggested-by: Gunnar Roth <gunnar.roth@gmx.de>
2014-07-10 23:06:19 +04:00
"${_CMAKE_VS_LINK_DLL}<CMAKE_LINKER> ${CMAKE_CL_NOLOGO} <OBJECTS> ${CMAKE_START_TEMP_FILE} /out:<TARGET> /implib:<TARGET_IMPLIB> /pdb:<TARGET_PDB> /dll /version:<TARGET_VERSION_MAJOR>.<TARGET_VERSION_MINOR>${_PLATFORM_LINK_FLAGS} <LINK_FLAGS> <LINK_LIBRARIES> ${CMAKE_END_TEMP_FILE}")
Modernize MSVC compiler information files Remove the old-style "Windows-cl.cmake" and its helper "cl.cmake". Load the information through new-style "Platform/Windows-MSVC-<lang>.cmake" files. Factor information common to C and CXX into a helper file "Platform/Windows-MSVC.cmake" loaded from the per-language files.
2012-08-23 20:00:55 +04:00
set(CMAKE_${lang}_CREATE_SHARED_MODULE ${CMAKE_${lang}_CREATE_SHARED_LIBRARY})
set(CMAKE_${lang}_CREATE_STATIC_LIBRARY "<CMAKE_LINKER> /lib ${CMAKE_CL_NOLOGO} <LINK_FLAGS> /out:<TARGET> <OBJECTS> ")
set(CMAKE_${lang}_COMPILE_OBJECT
Factor an <INCLUDES> placeholder out of <FLAGS> in rule variables Teach the Makefile and Ninja generators to substitute for an <INCLUDES> placeholder instead of putting -I in <FLAGS>. Update our values for CMAKE_<LANG>_COMPILE_OBJECT, CMAKE_<LANG>_CREATE_ASSEMBLY_SOURCE, and CMAKE_<LANG>_CREATE_PREPROCESSED_SOURCE to place <INCLUDES> just before <FLAGS>.
2015-07-13 17:35:04 +03:00
"<CMAKE_${lang}_COMPILER> ${CMAKE_START_TEMP_FILE} ${CMAKE_CL_NOLOGO}${_COMPILE_${lang}} <DEFINES> <INCLUDES> <FLAGS> /Fo<OBJECT> /Fd<TARGET_COMPILE_PDB>${_FS_${lang}} -c <SOURCE>${CMAKE_END_TEMP_FILE}")
Modernize MSVC compiler information files Remove the old-style "Windows-cl.cmake" and its helper "cl.cmake". Load the information through new-style "Platform/Windows-MSVC-<lang>.cmake" files. Factor information common to C and CXX into a helper file "Platform/Windows-MSVC.cmake" loaded from the per-language files.
2012-08-23 20:00:55 +04:00
set(CMAKE_${lang}_CREATE_PREPROCESSED_SOURCE
Factor an <INCLUDES> placeholder out of <FLAGS> in rule variables Teach the Makefile and Ninja generators to substitute for an <INCLUDES> placeholder instead of putting -I in <FLAGS>. Update our values for CMAKE_<LANG>_COMPILE_OBJECT, CMAKE_<LANG>_CREATE_ASSEMBLY_SOURCE, and CMAKE_<LANG>_CREATE_PREPROCESSED_SOURCE to place <INCLUDES> just before <FLAGS>.
2015-07-13 17:35:04 +03:00
"<CMAKE_${lang}_COMPILER> > <PREPROCESSED_SOURCE> ${CMAKE_START_TEMP_FILE} ${CMAKE_CL_NOLOGO}${_COMPILE_${lang}} <DEFINES> <INCLUDES> <FLAGS> -E <SOURCE>${CMAKE_END_TEMP_FILE}")
Modernize MSVC compiler information files Remove the old-style "Windows-cl.cmake" and its helper "cl.cmake". Load the information through new-style "Platform/Windows-MSVC-<lang>.cmake" files. Factor information common to C and CXX into a helper file "Platform/Windows-MSVC.cmake" loaded from the per-language files.
2012-08-23 20:00:55 +04:00
set(CMAKE_${lang}_CREATE_ASSEMBLY_SOURCE
Factor an <INCLUDES> placeholder out of <FLAGS> in rule variables Teach the Makefile and Ninja generators to substitute for an <INCLUDES> placeholder instead of putting -I in <FLAGS>. Update our values for CMAKE_<LANG>_COMPILE_OBJECT, CMAKE_<LANG>_CREATE_ASSEMBLY_SOURCE, and CMAKE_<LANG>_CREATE_PREPROCESSED_SOURCE to place <INCLUDES> just before <FLAGS>.
2015-07-13 17:35:04 +03:00
"<CMAKE_${lang}_COMPILER> ${CMAKE_START_TEMP_FILE} ${CMAKE_CL_NOLOGO}${_COMPILE_${lang}} <DEFINES> <INCLUDES> <FLAGS> /FoNUL /FAs /Fa<ASSEMBLY_SOURCE> /c <SOURCE>${CMAKE_END_TEMP_FILE}")
Modernize MSVC compiler information files Remove the old-style "Windows-cl.cmake" and its helper "cl.cmake". Load the information through new-style "Platform/Windows-MSVC-<lang>.cmake" files. Factor information common to C and CXX into a helper file "Platform/Windows-MSVC.cmake" loaded from the per-language files.
2012-08-23 20:00:55 +04:00
set(CMAKE_${lang}_USE_RESPONSE_FILE_FOR_OBJECTS 1)
set(CMAKE_${lang}_LINK_EXECUTABLE
MSVC: Fix linking of DLLs on WinCE (#15013) On WinCE we must link both shared libraries and executables with the /subsystem:windowsce flag. Teach Platform/Windows-MSVC to pass it to the linker in both cases. Suggested-by: Gunnar Roth <gunnar.roth@gmx.de>
2014-07-10 23:06:19 +04:00
"${_CMAKE_VS_LINK_EXE}<CMAKE_LINKER> ${CMAKE_CL_NOLOGO} <OBJECTS> ${CMAKE_START_TEMP_FILE} /out:<TARGET> /implib:<TARGET_IMPLIB> /pdb:<TARGET_PDB> /version:<TARGET_VERSION_MAJOR>.<TARGET_VERSION_MINOR>${_PLATFORM_LINK_FLAGS} <CMAKE_${lang}_LINK_FLAGS> <LINK_FLAGS> <LINK_LIBRARIES>${CMAKE_END_TEMP_FILE}")
Modernize MSVC compiler information files Remove the old-style "Windows-cl.cmake" and its helper "cl.cmake". Load the information through new-style "Platform/Windows-MSVC-<lang>.cmake" files. Factor information common to C and CXX into a helper file "Platform/Windows-MSVC.cmake" loaded from the per-language files.
2012-08-23 20:00:55 +04:00
Intel: Do not use MSVC-like flags for Fortran Teach `Modules/Platform/Windows-MSVC.cmake` not to use MSVC options for Fortran. We use the `__windows_compiler_msvc` for the Intel Fortran compiler on Windows for other settings, but we do not want the flags. Previously this worked only because the options were later overridden by `Modules/Platform/Windows-Intel*.cmake`, but it is cleaner to not set the options in the first place.
2016-07-05 18:43:31 +03:00
if("x${lang}" STREQUAL "xC" OR
"x${lang}" STREQUAL "xCXX")
VS: Recognize VS/LLVM toolset names as Clang Update the toolset name matching added by commit v3.6.0-rc1~279^2~10 (VS: in Clang/C2 toolset, setup correct compiler settings, 2016-02-18) to match VS/LLVM toolset names too.
2016-09-28 09:46:00 +03:00
if(CMAKE_VS_PLATFORM_TOOLSET MATCHES "(v[0-9]+_clang_.*|LLVM-vs[0-9]+.*)")
Intel: Do not use MSVC-like flags for Fortran Teach `Modules/Platform/Windows-MSVC.cmake` not to use MSVC options for Fortran. We use the `__windows_compiler_msvc` for the Intel Fortran compiler on Windows for other settings, but we do not want the flags. Previously this worked only because the options were later overridden by `Modules/Platform/Windows-Intel*.cmake`, but it is cleaner to not set the options in the first place.
2016-07-05 18:43:31 +03:00
# note: MSVC 14 2015 Update 1 sets -fno-ms-compatibility by default, but this does not allow one to compile many projects
# that include MS's own headers. CMake itself is affected project too.
Honor CMAKE_<LANG>_FLAGS[_<CONFIG>]_INIT set in toolchain files Document these variables. Change our convention for setting these variables from: set(CMAKE_C_FLAGS_INIT "...") to string(APPEND CMAKE_C_FLAGS_INIT " ...") so that any value previously set by a toolchain file will be used. Automate the conversion with: sed -i 's/set *(\(CMAKE_\(C\|CXX\|Fortran\|RC\|ASM\|${[^}]\+}\)_FLAGS\(_[^_]\+\)\?_INIT \+"\)/string(APPEND \1 /' \ Modules/Compiler/*.cmake Modules/Platform/*.cmake and follow up with some manual fixes (e.g. to cases that already meant to append). Also revert the automated changes to contexts that are not protected from running multiple times.
2016-07-05 20:35:13 +03:00
string(APPEND CMAKE_${lang}_FLAGS_INIT " ${_PLATFORM_DEFINES}${_PLATFORM_DEFINES_${lang}} -fms-extensions -fms-compatibility -D_WINDOWS -Wall${_FLAGS_${lang}}")
string(APPEND CMAKE_${lang}_FLAGS_DEBUG_INIT " -D_DEBUG /MDd -gline-tables-only -fno-inline -O0 ${_RTC1}")
string(APPEND CMAKE_${lang}_FLAGS_RELEASE_INIT " /MD -O2 -DNDEBUG")
string(APPEND CMAKE_${lang}_FLAGS_RELWITHDEBINFO_INIT " /MD -gline-tables-only -O2 -fno-inline -DNDEBUG")
string(APPEND CMAKE_${lang}_FLAGS_MINSIZEREL_INIT " /MD -DNDEBUG") # TODO: Add '-Os' once VS generator maps it properly for Clang
Intel: Do not use MSVC-like flags for Fortran Teach `Modules/Platform/Windows-MSVC.cmake` not to use MSVC options for Fortran. We use the `__windows_compiler_msvc` for the Intel Fortran compiler on Windows for other settings, but we do not want the flags. Previously this worked only because the options were later overridden by `Modules/Platform/Windows-Intel*.cmake`, but it is cleaner to not set the options in the first place.
2016-07-05 18:43:31 +03:00
else()
Honor CMAKE_<LANG>_FLAGS[_<CONFIG>]_INIT set in toolchain files Document these variables. Change our convention for setting these variables from: set(CMAKE_C_FLAGS_INIT "...") to string(APPEND CMAKE_C_FLAGS_INIT " ...") so that any value previously set by a toolchain file will be used. Automate the conversion with: sed -i 's/set *(\(CMAKE_\(C\|CXX\|Fortran\|RC\|ASM\|${[^}]\+}\)_FLAGS\(_[^_]\+\)\?_INIT \+"\)/string(APPEND \1 /' \ Modules/Compiler/*.cmake Modules/Platform/*.cmake and follow up with some manual fixes (e.g. to cases that already meant to append). Also revert the automated changes to contexts that are not protected from running multiple times.
2016-07-05 20:35:13 +03:00
string(APPEND CMAKE_${lang}_FLAGS_INIT " ${_PLATFORM_DEFINES}${_PLATFORM_DEFINES_${lang}} /D_WINDOWS /W3${_FLAGS_${lang}}")
string(APPEND CMAKE_${lang}_FLAGS_DEBUG_INIT " /D_DEBUG /MDd /Zi /Ob0 /Od ${_RTC1}")
string(APPEND CMAKE_${lang}_FLAGS_RELEASE_INIT " /MD /O2 /Ob2 /DNDEBUG")
string(APPEND CMAKE_${lang}_FLAGS_RELWITHDEBINFO_INIT " /MD /Zi /O2 /Ob1 /DNDEBUG")
string(APPEND CMAKE_${lang}_FLAGS_MINSIZEREL_INIT " /MD /O1 /Ob1 /DNDEBUG")
Intel: Do not use MSVC-like flags for Fortran Teach `Modules/Platform/Windows-MSVC.cmake` not to use MSVC options for Fortran. We use the `__windows_compiler_msvc` for the Intel Fortran compiler on Windows for other settings, but we do not want the flags. Previously this worked only because the options were later overridden by `Modules/Platform/Windows-Intel*.cmake`, but it is cleaner to not set the options in the first place.
2016-07-05 18:43:31 +03:00
endif()
VS: in Clang/C2 toolset, setup correct compiler settings
2016-02-18 03:06:52 +03:00
endif()
Genex: Implement generator expressions for target PDB files.
2014-07-25 00:18:21 +04:00
set(CMAKE_${lang}_LINKER_SUPPORTS_PDB ON)
Ninja: Refactor selection of 'deps = ' value for MS-compatible toolchains Set variables in the platform information modules to tell the Ninja generator what deps type to use instead of hard-coding conditions in the generator itself.
2015-10-20 20:52:12 +03:00
set(CMAKE_NINJA_DEPTYPE_${lang} msvc)
RC: Enable language after C, CXX, or Fortran is enabled (#15404) The RC language is special in that it is automatically enabled on Windows-based platforms when another primary language is enabled. Move enablement of RC from early in the enablement of the other language to late. This will allow it to use information detected as part of enabling C, CXX, or Fortran.
2015-02-25 19:15:51 +03:00
RC: Simplify selection of resource compiler based on C/C++ toolchain Revert the refactoring by commit v2.8.11~105^2~1 (Ninja: use MinGW generator code in EnableLanguage, 2013-03-09) and move the MinGW- specific logic back to the "MinGW Makefiles" generator. Instead teach the platform information modules for GNU and MSVC on Windows to set the preferred RC compiler just before enabling the RC language. This way we choose the RC compiler based on the C/C++ toolchain that is actually enabled.
2015-05-07 18:43:02 +03:00
if(NOT CMAKE_RC_COMPILER_INIT)
set(CMAKE_RC_COMPILER_INIT rc)
endif()
RC: Add platform-specific preprocessor definitions (#15404) In Platform/Windows-MSVC the C and CXX flags are initialized to contain preprocessor definitions describing the platform. On WinCE platforms this may not be just -DWIN32. This information may be important to RC sources too, so add such preprocessor definitions to the default RC flags. Suggested-by: Gunnar Roth <gunnar.roth@gmx.de>
2015-02-25 19:26:48 +03:00
if(NOT CMAKE_RC_FLAGS_INIT)
Honor CMAKE_<LANG>_FLAGS[_<CONFIG>]_INIT set in toolchain files Document these variables. Change our convention for setting these variables from: set(CMAKE_C_FLAGS_INIT "...") to string(APPEND CMAKE_C_FLAGS_INIT " ...") so that any value previously set by a toolchain file will be used. Automate the conversion with: sed -i 's/set *(\(CMAKE_\(C\|CXX\|Fortran\|RC\|ASM\|${[^}]\+}\)_FLAGS\(_[^_]\+\)\?_INIT \+"\)/string(APPEND \1 /' \ Modules/Compiler/*.cmake Modules/Platform/*.cmake and follow up with some manual fixes (e.g. to cases that already meant to append). Also revert the automated changes to contexts that are not protected from running multiple times.
2016-07-05 20:35:13 +03:00
string(APPEND CMAKE_RC_FLAGS_INIT " ${_PLATFORM_DEFINES} ${_PLATFORM_DEFINES_${lang}}")
RC: Add platform-specific preprocessor definitions (#15404) In Platform/Windows-MSVC the C and CXX flags are initialized to contain preprocessor definitions describing the platform. On WinCE platforms this may not be just -DWIN32. This information may be important to RC sources too, so add such preprocessor definitions to the default RC flags. Suggested-by: Gunnar Roth <gunnar.roth@gmx.de>
2015-02-25 19:26:48 +03:00
endif()
RC: Enable language after C, CXX, or Fortran is enabled (#15404) The RC language is special in that it is automatically enabled on Windows-based platforms when another primary language is enabled. Move enablement of RC from early in the enablement of the other language to late. This will allow it to use information detected as part of enabling C, CXX, or Fortran.
2015-02-25 19:15:51 +03:00
enable_language(RC)
Ninja: Refactor selection of 'deps = ' value for MS-compatible toolchains Set variables in the platform information modules to tell the Ninja generator what deps type to use instead of hard-coding conditions in the generator itself.
2015-10-20 20:52:12 +03:00
set(CMAKE_NINJA_CMCLDEPS_RC 1)
Modernize MSVC compiler information files Remove the old-style "Windows-cl.cmake" and its helper "cl.cmake". Load the information through new-style "Platform/Windows-MSVC-<lang>.cmake" files. Factor information common to C and CXX into a helper file "Platform/Windows-MSVC.cmake" loaded from the per-language files.
2012-08-23 20:00:55 +04:00
endmacro()