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

191 lines
8.8 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.
Modernize GNU compiler info on Windows This moves GNU compiler info on Windows into new-style modules Platform/Windows-GNU-<lang>.cmake using language-independent helper module Platform/Windows-GNU.cmake to define macros consolidating the information.
2009-12-02 19:27:59 +03:00
# This module is shared by multiple languages; use include blocker.
if(__WINDOWS_GNU)
return()
endif()
set(__WINDOWS_GNU 1)
set(CMAKE_IMPORT_LIBRARY_PREFIX "lib")
set(CMAKE_SHARED_LIBRARY_PREFIX "lib")
set(CMAKE_SHARED_MODULE_PREFIX "lib")
set(CMAKE_STATIC_LIBRARY_PREFIX "lib")
set(CMAKE_EXECUTABLE_SUFFIX ".exe")
set(CMAKE_IMPORT_LIBRARY_SUFFIX ".dll.a")
set(CMAKE_SHARED_LIBRARY_SUFFIX ".dll")
set(CMAKE_SHARED_MODULE_SUFFIX ".dll")
set(CMAKE_STATIC_LIBRARY_SUFFIX ".a")
if(MSYS OR MINGW)
set(CMAKE_EXTRA_LINK_EXTENSIONS ".lib") # MinGW can also link to a MS .lib
endif()
if(MINGW)
set(CMAKE_FIND_LIBRARY_PREFIXES "lib" "")
Windows-GNU: Restore find_library treatment of '.dll' as linkable (#15409) Revert commit v3.3.0-rc1~435^2 (Windows-GNU: Do not tell find_library to treat '.dll' as linkable, 2015-02-18). MinGW tools support linking to '.dll' files directly and many non-CMake build systems still do not provide a separate '.dll.a' file.
2015-06-08 17:08:59 +03:00
set(CMAKE_FIND_LIBRARY_SUFFIXES ".dll" ".dll.a" ".a" ".lib")
Modernize GNU compiler info on Windows This moves GNU compiler info on Windows into new-style modules Platform/Windows-GNU-<lang>.cmake using language-independent helper module Platform/Windows-GNU.cmake to define macros consolidating the information.
2009-12-02 19:27:59 +03:00
set(CMAKE_C_STANDARD_LIBRARIES_INIT "-lkernel32 -luser32 -lgdi32 -lwinspool -lshell32 -lole32 -loleaut32 -luuid -lcomdlg32 -ladvapi32")
set(CMAKE_CXX_STANDARD_LIBRARIES_INIT "${CMAKE_C_STANDARD_LIBRARIES_INIT}")
endif()
set(CMAKE_DL_LIBS "")
set(CMAKE_LIBRARY_PATH_FLAG "-L")
set(CMAKE_LINK_LIBRARY_FLAG "-l")
Pass .def files directly to MinGW tools (#9997) Commit 6a61a8a5 (Honor module .def files with MinGW tools, 2011-02-21) set CMAKE_LINK_DEF_FILE_FLAG to "-Wl," to enable passing .def files to the linker on MinGW. However, older GNU tools in the MSYS shell do not know how to translate "-Wl,/c/..." to "c:/..." and complain that the file does not exist. Instead set the flag to just "" which tells CMake it can pass the file through the front-end with no special flag.
2011-02-23 18:56:32 +03:00
set(CMAKE_LINK_DEF_FILE_FLAG "") # Empty string: passing the file is enough
Modernize GNU compiler info on Windows This moves GNU compiler info on Windows into new-style modules Platform/Windows-GNU-<lang>.cmake using language-independent helper module Platform/Windows-GNU.cmake to define macros consolidating the information.
2009-12-02 19:27:59 +03:00
set(CMAKE_LINK_LIBRARY_SUFFIX "")
set(CMAKE_CREATE_WIN32_EXE "-mwindows")
set(CMAKE_GNULD_IMAGE_VERSION
"-Wl,--major-image-version,<TARGET_VERSION_MAJOR>,--minor-image-version,<TARGET_VERSION_MINOR>")
No response files with GNU ld <= 2.16 (#10913) Older GNU ld does not support the @FILE syntax for response files. Check the ld version on MinGW and MSYS before enabling the syntax.
2010-08-06 17:34:53 +04:00
# Check if GNU ld is too old to support @FILE syntax.
set(__WINDOWS_GNU_LD_RESPONSE 1)
execute_process(COMMAND ld -v OUTPUT_VARIABLE _help ERROR_VARIABLE _help)
if("${_help}" MATCHES "GNU ld .* 2\\.1[1-6]")
set(__WINDOWS_GNU_LD_RESPONSE 0)
endif()
Find mingw's windres also when Unix Makefiles are used
2012-08-27 18:54:21 +04:00
if(NOT CMAKE_GENERATOR_RC AND CMAKE_GENERATOR MATCHES "Unix Makefiles")
set(CMAKE_GENERATOR_RC windres)
endif()
Modernize GNU compiler info on Windows This moves GNU compiler info on Windows into new-style modules Platform/Windows-GNU-<lang>.cmake using language-independent helper module Platform/Windows-GNU.cmake to define macros consolidating the information.
2009-12-02 19:27:59 +03:00
macro(__windows_compiler_gnu lang)
if(MSYS OR MINGW)
# Create archiving rules to support large object file lists for static libraries.
Re-order 'ar' options 'cq' => 'qc' The documetnation of binutils: https://sourceware.org/binutils/docs/binutils/ar-cmdline.html suggests to use the parameters "q" and "c" in this order ("q" is operation, and "c" is the modifier). Suggested-by: Дилян Палаузов <dilyan.palauzov@aegee.org>
2015-09-09 18:08:20 +03:00
set(CMAKE_${lang}_ARCHIVE_CREATE "<CMAKE_AR> qc <TARGET> <LINK_FLAGS> <OBJECTS>")
Windows-GNU: Support duplicate object names in large archives (#14874) Since commit v2.6.0~388 (Added build rule variables CMAKE_<LANG>_ARCHIVE_..., 2008-01-29) we use separate "ar cr ..." and "ar r ..." steps to incrementally add a large list of object files to an archive. Since the "r" command replaces existing objects of the same name in an archive, if multiple objects have the same file name and appear in separate append steps then one overwrites the other. Instead, use "ar cq ..." and "ar q ..." to always append to the archive. We already remove the archive before creating it so this will not cause objects to be appended to existing archives on incremental rebuilds.
2014-04-14 21:58:03 +04:00
set(CMAKE_${lang}_ARCHIVE_APPEND "<CMAKE_AR> q <TARGET> <LINK_FLAGS> <OBJECTS>")
Modernize GNU compiler info on Windows This moves GNU compiler info on Windows into new-style modules Platform/Windows-GNU-<lang>.cmake using language-independent helper module Platform/Windows-GNU.cmake to define macros consolidating the information.
2009-12-02 19:27:59 +03:00
set(CMAKE_${lang}_ARCHIVE_FINISH "<CMAKE_RANLIB> <TARGET>")
# Initialize C link type selection flags. These flags are used when
# building a shared library, shared module, or executable that links
# to other libraries to select whether to use the static or shared
# versions of the libraries.
foreach(type SHARED_LIBRARY SHARED_MODULE EXE)
set(CMAKE_${type}_LINK_STATIC_${lang}_FLAGS "-Wl,-Bstatic")
set(CMAKE_${type}_LINK_DYNAMIC_${lang}_FLAGS "-Wl,-Bdynamic")
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
endforeach()
Modernize GNU compiler info on Windows This moves GNU compiler info on Windows into new-style modules Platform/Windows-GNU-<lang>.cmake using language-independent helper module Platform/Windows-GNU.cmake to define macros consolidating the information.
2009-12-02 19:27:59 +03:00
endif()
Add platform variables for position independent code flags Store in new platform variables CMAKE_${lang}_COMPILE_OPTIONS_PIC CMAKE_${lang}_COMPILE_OPTIONS_PIE flags for position independent code generation. In almost all cases, this means duplication of the CMAKE_SHARED_LIBRARY_${lang}_FLAGS for the _PIC case and using the assumed pie equivalent for the _PIE case. Note that the GNU compiler has supported -fPIE since 3.4 and that there is no -fPIC on GNU for Windows or Cygwin. There is a possibility that the _PIE variables are not correct. However, as there is no backwards compatibility to be concerned about (as the POSITION_INDEPENDENT_CODE property is not used anywhere yet), the current state suffices.
2012-05-05 23:11:35 +04:00
# No -fPIC on Windows
set(CMAKE_${lang}_COMPILE_OPTIONS_PIC "")
set(CMAKE_${lang}_COMPILE_OPTIONS_PIE "")
set(CMAKE_SHARED_LIBRARY_${lang}_FLAGS "")
No response files with GNU ld <= 2.16 (#10913) Older GNU ld does not support the @FILE syntax for response files. Check the ld version on MinGW and MSYS before enabling the syntax.
2010-08-06 17:34:53 +04:00
set(CMAKE_${lang}_USE_RESPONSE_FILE_FOR_OBJECTS ${__WINDOWS_GNU_LD_RESPONSE})
Windows: Use response files to specify link libraries for GNU tools Work around the command-line-length limit by using an @linklibs.rsp response file to pass the flags for link libraries. This allows very long lists of libraries to be used in addition to the existing support for passing object files via response file. Suggested-by: Peter Keuschnigg <peter.keuschnigg@pmu.ac.at>
2014-03-04 22:25:42 +04:00
set(CMAKE_${lang}_USE_RESPONSE_FILE_FOR_LIBRARIES ${__WINDOWS_GNU_LD_RESPONSE})
Pass include directories with response files to GNU on Windows The GNU 4.x toolchain on MinGW (and therefore MSYS) allows compiler options to be passed via response files. Use this to pass include directory -I options. This allows the include file search path to be very long despite shell and mingw32-make command line length limits.
2011-03-17 22:44:57 +03:00
set(CMAKE_${lang}_USE_RESPONSE_FILE_FOR_INCLUDES 1)
MinGW: Support long object file lists Use a combination of response files and the archiver to support long object file lists that do not fit in the Windows command-line length limit. This can work only with GCC >= 4 because the MinGW GCC 3.x front-ends do not support response-file syntax.
2010-09-17 17:25:36 +04:00
# We prefer "@" for response files but it is not supported by gcc 3.
execute_process(COMMAND ${CMAKE_${lang}_COMPILER} --version OUTPUT_VARIABLE _ver ERROR_VARIABLE _ver)
if("${_ver}" MATCHES "\\(GCC\\) 3\\.")
if("${lang}" STREQUAL "Fortran")
# The GNU Fortran compiler reports an error:
# no input files; unwilling to write output files
# when the response file is passed with "-Wl,@".
set(CMAKE_Fortran_USE_RESPONSE_FILE_FOR_OBJECTS 0)
else()
# Use "-Wl,@" to pass the response file to the linker.
set(CMAKE_${lang}_RESPONSE_FILE_LINK_FLAG "-Wl,@")
endif()
Pass include directories with response files to GNU on Windows The GNU 4.x toolchain on MinGW (and therefore MSYS) allows compiler options to be passed via response files. Use this to pass include directory -I options. This allows the include file search path to be very long despite shell and mingw32-make command line length limits.
2011-03-17 22:44:57 +03:00
# The GNU 3.x compilers do not support response files (only linkers).
set(CMAKE_${lang}_USE_RESPONSE_FILE_FOR_INCLUDES 0)
Windows: Use response files to specify link libraries for GNU tools Work around the command-line-length limit by using an @linklibs.rsp response file to pass the flags for link libraries. This allows very long lists of libraries to be used in addition to the existing support for passing object files via response file. Suggested-by: Peter Keuschnigg <peter.keuschnigg@pmu.ac.at>
2014-03-04 22:25:42 +04:00
# Link libraries are generated only for the front-end.
set(CMAKE_${lang}_USE_RESPONSE_FILE_FOR_LIBRARIES 0)
else()
MinGW: Support long object file lists Use a combination of response files and the archiver to support long object file lists that do not fit in the Windows command-line length limit. This can work only with GCC >= 4 because the MinGW GCC 3.x front-ends do not support response-file syntax.
2010-09-17 17:25:36 +04:00
# Use "@" to pass the response file to the front-end.
set(CMAKE_${lang}_RESPONSE_FILE_LINK_FLAG "@")
endif()
Suppress GNU flag -fPIC on Windows Commit "Modernize GNU compiler info on Windows" (2009-12-02) reorganized GNU flags on Windows but let -fPIC slip through for compilation of objects in shared libraries. While this flag is valid on most GNU compiler platforms we need to suppress it in Windows-GNU.cmake just as we already do in CYGWIN-GNU.cmake.
2010-02-19 16:23:31 +03:00
Modernize GNU compiler info on Windows This moves GNU compiler info on Windows into new-style modules Platform/Windows-GNU-<lang>.cmake using language-independent helper module Platform/Windows-GNU.cmake to define macros consolidating the information.
2009-12-02 19:27:59 +03:00
# Binary link rules.
set(CMAKE_${lang}_CREATE_SHARED_MODULE
MinGW: link like on Unix and use compile flags when linking
2014-04-13 15:12:35 +04:00
"<CMAKE_${lang}_COMPILER> <CMAKE_SHARED_MODULE_${lang}_FLAGS> <LANGUAGE_COMPILE_FLAGS> <LINK_FLAGS> <CMAKE_SHARED_MODULE_CREATE_${lang}_FLAGS> -o <TARGET> ${CMAKE_GNULD_IMAGE_VERSION} <OBJECTS> <LINK_LIBRARIES>")
Modernize GNU compiler info on Windows This moves GNU compiler info on Windows into new-style modules Platform/Windows-GNU-<lang>.cmake using language-independent helper module Platform/Windows-GNU.cmake to define macros consolidating the information.
2009-12-02 19:27:59 +03:00
set(CMAKE_${lang}_CREATE_SHARED_LIBRARY
MinGW: link like on Unix and use compile flags when linking
2014-04-13 15:12:35 +04:00
"<CMAKE_${lang}_COMPILER> <CMAKE_SHARED_LIBRARY_${lang}_FLAGS> <LANGUAGE_COMPILE_FLAGS> <LINK_FLAGS> <CMAKE_SHARED_LIBRARY_CREATE_${lang}_FLAGS> -o <TARGET> -Wl,--out-implib,<TARGET_IMPLIB> ${CMAKE_GNULD_IMAGE_VERSION} <OBJECTS> <LINK_LIBRARIES>")
Modernize GNU compiler info on Windows This moves GNU compiler info on Windows into new-style modules Platform/Windows-GNU-<lang>.cmake using language-independent helper module Platform/Windows-GNU.cmake to define macros consolidating the information.
2009-12-02 19:27:59 +03:00
set(CMAKE_${lang}_LINK_EXECUTABLE
"<CMAKE_${lang}_COMPILER> <FLAGS> <CMAKE_${lang}_LINK_FLAGS> <LINK_FLAGS> <OBJECTS> -o <TARGET> -Wl,--out-implib,<TARGET_IMPLIB> ${CMAKE_GNULD_IMAGE_VERSION} <LINK_LIBRARIES>")
MinGW: Support long object file lists Use a combination of response files and the archiver to support long object file lists that do not fit in the Windows command-line length limit. This can work only with GCC >= 4 because the MinGW GCC 3.x front-ends do not support response-file syntax.
2010-09-17 17:25:36 +04:00
Add CMAKE_GNUtoMS option to convert GNU .dll.a to MS .lib Teach the Windows-GNU.cmake platform file to look for Visual Studio tools matching the target ABI. Add an extra step to the link command for shared libraries and executables that export symbols and on which a new GNUtoMS property is set (initialized by the CMAKE_GNUtoMS option). Tell the GNU linker to output a module definition (.def) file listing exported symbols in addition to the GNU-format import library (.dll.a). Pass the .def file to the MS "lib" tool to construct a MS-format DLL import library (.lib). Teach the install(TARGETS) command to install the MS import library next to the GNU one. Teach the install(EXPORT) and export() command to set the IMPORTED_IMPLIB property pointing at the import library to use the import library matching the tools in the importing project.
2011-12-06 01:39:07 +04:00
list(APPEND CMAKE_${lang}_ABI_FILES "Platform/Windows-GNU-${lang}-ABI")
MinGW: Support long object file lists Use a combination of response files and the archiver to support long object file lists that do not fit in the Windows command-line length limit. This can work only with GCC >= 4 because the MinGW GCC 3.x front-ends do not support response-file syntax.
2010-09-17 17:25:36 +04:00
# Support very long lists of object files.
Ninja: disable work around when linking with mingw The work around is only needed by older GCCs (only testet 4.4/4.7) Ninja is very new so chances are high that there is also a new mingw. Use slashes in link rsp file, because ar.exe can't handle \.
2012-07-11 10:55:00 +04:00
# TODO: check for which gcc versions this is still needed, not needed for gcc >= 4.4.
# Ninja generator doesn't support this work around.
if("${CMAKE_${lang}_RESPONSE_FILE_LINK_FLAG}" STREQUAL "@" AND NOT CMAKE_GENERATOR MATCHES "Ninja")
MinGW: Support long object file lists Use a combination of response files and the archiver to support long object file lists that do not fit in the Windows command-line length limit. This can work only with GCC >= 4 because the MinGW GCC 3.x front-ends do not support response-file syntax.
2010-09-17 17:25:36 +04:00
foreach(rule CREATE_SHARED_MODULE CREATE_SHARED_LIBRARY LINK_EXECUTABLE)
# The gcc/collect2/ld toolchain does not use response files
# internally so we cannot pass long object lists. Instead pass
# the object file list in a response file to the archiver to put
# them in a temporary archive. Hand the archive to the linker.
string(REPLACE "<OBJECTS>" "-Wl,--whole-archive <OBJECT_DIR>/objects.a -Wl,--no-whole-archive"
CMAKE_${lang}_${rule} "${CMAKE_${lang}_${rule}}")
set(CMAKE_${lang}_${rule}
"<CMAKE_COMMAND> -E remove -f <OBJECT_DIR>/objects.a"
"<CMAKE_AR> cr <OBJECT_DIR>/objects.a <OBJECTS>"
"${CMAKE_${lang}_${rule}}"
)
endforeach()
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
RC: Do not override MinGW Makefiles generator preference Update logic added in commit 957c2aac (RC: Simplify selection of resource compiler based on C/C++ toolchain, 2015-05-07) to avoid overriding CMAKE_GENERATOR_RC. The MinGW and MSYS Makefiles generators use it to select a windres next to the compiler even if it is not in the PATH.
2015-05-11 16:00:25 +03:00
if(NOT CMAKE_RC_COMPILER_INIT AND NOT CMAKE_GENERATOR_RC)
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
set(CMAKE_RC_COMPILER_INIT windres)
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)
Modernize GNU compiler info on Windows This moves GNU compiler info on Windows into new-style modules Platform/Windows-GNU-<lang>.cmake using language-independent helper module Platform/Windows-GNU.cmake to define macros consolidating the information.
2009-12-02 19:27:59 +03:00
endmacro()
Add CMAKE_GNUtoMS option to convert GNU .dll.a to MS .lib Teach the Windows-GNU.cmake platform file to look for Visual Studio tools matching the target ABI. Add an extra step to the link command for shared libraries and executables that export symbols and on which a new GNUtoMS property is set (initialized by the CMAKE_GNUtoMS option). Tell the GNU linker to output a module definition (.def) file listing exported symbols in addition to the GNU-format import library (.dll.a). Pass the .def file to the MS "lib" tool to construct a MS-format DLL import library (.lib). Teach the install(TARGETS) command to install the MS import library next to the GNU one. Teach the install(EXPORT) and export() command to set the IMPORTED_IMPLIB property pointing at the import library to use the import library matching the tools in the importing project.
2011-12-06 01:39:07 +04:00
macro(__windows_compiler_gnu_abi lang)
if(CMAKE_NO_GNUtoMS)
set(CMAKE_GNUtoMS 0)
else()
option(CMAKE_GNUtoMS "Convert GNU import libraries to MS format (requires Visual Studio)" OFF)
endif()
if(CMAKE_GNUtoMS AND NOT CMAKE_GNUtoMS_LIB)
# Find MS development environment setup script for this architecture.
if("${CMAKE_SIZEOF_VOID_P}" EQUAL 4)
find_program(CMAKE_GNUtoMS_VCVARS NAMES vcvars32.bat
DOC "Visual Studio vcvars32.bat"
PATHS
GNUtoMS: Add support for VS 2013 (#14936) Add to the Platform/Windows-GNU module list of VS registry entries those for VS 2013. Also add the name "vcvars64.bat" used by VS 10 and above for 64-bit tools.
2014-05-27 17:05:57 +04:00
"[HKEY_LOCAL_MACHINE\\SOFTWARE\\Microsoft\\VisualStudio\\12.0\\Setup\\VC;ProductDir]/bin"
Add CMAKE_GNUtoMS option to convert GNU .dll.a to MS .lib Teach the Windows-GNU.cmake platform file to look for Visual Studio tools matching the target ABI. Add an extra step to the link command for shared libraries and executables that export symbols and on which a new GNUtoMS property is set (initialized by the CMAKE_GNUtoMS option). Tell the GNU linker to output a module definition (.def) file listing exported symbols in addition to the GNU-format import library (.dll.a). Pass the .def file to the MS "lib" tool to construct a MS-format DLL import library (.lib). Teach the install(TARGETS) command to install the MS import library next to the GNU one. Teach the install(EXPORT) and export() command to set the IMPORTED_IMPLIB property pointing at the import library to use the import library matching the tools in the importing project.
2011-12-06 01:39:07 +04:00
"[HKEY_LOCAL_MACHINE\\SOFTWARE\\Microsoft\\VisualStudio\\11.0\\Setup\\VC;ProductDir]/bin"
"[HKEY_LOCAL_MACHINE\\SOFTWARE\\Microsoft\\VisualStudio\\10.0\\Setup\\VC;ProductDir]/bin"
"[HKEY_LOCAL_MACHINE\\SOFTWARE\\Microsoft\\VisualStudio\\9.0\\Setup\\VC;ProductDir]/bin"
"[HKEY_LOCAL_MACHINE\\SOFTWARE\\Microsoft\\VisualStudio\\8.0\\Setup\\VC;ProductDir]/bin"
"[HKEY_LOCAL_MACHINE\\SOFTWARE\\Microsoft\\VisualStudio\\7.1\\Setup\\VC;ProductDir]/bin"
"[HKEY_LOCAL_MACHINE\\SOFTWARE\\Microsoft\\VisualStudio\\6.0\\Setup\\Microsoft Visual C++;ProductDir]/bin"
)
set(CMAKE_GNUtoMS_ARCH x86)
elseif("${CMAKE_SIZEOF_VOID_P}" EQUAL 8)
GNUtoMS: Add support for VS 2013 (#14936) Add to the Platform/Windows-GNU module list of VS registry entries those for VS 2013. Also add the name "vcvars64.bat" used by VS 10 and above for 64-bit tools.
2014-05-27 17:05:57 +04:00
find_program(CMAKE_GNUtoMS_VCVARS NAMES vcvars64.bat vcvarsamd64.bat
Add CMAKE_GNUtoMS option to convert GNU .dll.a to MS .lib Teach the Windows-GNU.cmake platform file to look for Visual Studio tools matching the target ABI. Add an extra step to the link command for shared libraries and executables that export symbols and on which a new GNUtoMS property is set (initialized by the CMAKE_GNUtoMS option). Tell the GNU linker to output a module definition (.def) file listing exported symbols in addition to the GNU-format import library (.dll.a). Pass the .def file to the MS "lib" tool to construct a MS-format DLL import library (.lib). Teach the install(TARGETS) command to install the MS import library next to the GNU one. Teach the install(EXPORT) and export() command to set the IMPORTED_IMPLIB property pointing at the import library to use the import library matching the tools in the importing project.
2011-12-06 01:39:07 +04:00
DOC "Visual Studio vcvarsamd64.bat"
PATHS
GNUtoMS: Add support for VS 2013 (#14936) Add to the Platform/Windows-GNU module list of VS registry entries those for VS 2013. Also add the name "vcvars64.bat" used by VS 10 and above for 64-bit tools.
2014-05-27 17:05:57 +04:00
"[HKEY_LOCAL_MACHINE\\SOFTWARE\\Microsoft\\VisualStudio\\12.0\\Setup\\VC;ProductDir]/bin/amd64"
Add CMAKE_GNUtoMS option to convert GNU .dll.a to MS .lib Teach the Windows-GNU.cmake platform file to look for Visual Studio tools matching the target ABI. Add an extra step to the link command for shared libraries and executables that export symbols and on which a new GNUtoMS property is set (initialized by the CMAKE_GNUtoMS option). Tell the GNU linker to output a module definition (.def) file listing exported symbols in addition to the GNU-format import library (.dll.a). Pass the .def file to the MS "lib" tool to construct a MS-format DLL import library (.lib). Teach the install(TARGETS) command to install the MS import library next to the GNU one. Teach the install(EXPORT) and export() command to set the IMPORTED_IMPLIB property pointing at the import library to use the import library matching the tools in the importing project.
2011-12-06 01:39:07 +04:00
"[HKEY_LOCAL_MACHINE\\SOFTWARE\\Microsoft\\VisualStudio\\11.0\\Setup\\VC;ProductDir]/bin/amd64"
"[HKEY_LOCAL_MACHINE\\SOFTWARE\\Microsoft\\VisualStudio\\10.0\\Setup\\VC;ProductDir]/bin/amd64"
"[HKEY_LOCAL_MACHINE\\SOFTWARE\\Microsoft\\VisualStudio\\9.0\\Setup\\VC;ProductDir]/bin/amd64"
"[HKEY_LOCAL_MACHINE\\SOFTWARE\\Microsoft\\VisualStudio\\8.0\\Setup\\VC;ProductDir]/bin/amd64"
)
set(CMAKE_GNUtoMS_ARCH amd64)
endif()
set_property(CACHE CMAKE_GNUtoMS_VCVARS PROPERTY ADVANCED 1)
if(CMAKE_GNUtoMS_VCVARS)
# Create helper script to run lib.exe from MS environment.
string(REPLACE "/" "\\" CMAKE_GNUtoMS_BAT "${CMAKE_GNUtoMS_VCVARS}")
set(CMAKE_GNUtoMS_LIB ${CMAKE_BINARY_DIR}/CMakeFiles/CMakeGNUtoMS_lib.bat)
configure_file(${CMAKE_ROOT}/Modules/Platform/GNUtoMS_lib.bat.in ${CMAKE_GNUtoMS_LIB})
else()
message(WARNING "Disabling CMAKE_GNUtoMS option because CMAKE_GNUtoMS_VCVARS is not set.")
set(CMAKE_GNUtoMS 0)
endif()
endif()
if(CMAKE_GNUtoMS)
# Teach CMake how to create a MS import library at link time.
set(CMAKE_${lang}_GNUtoMS_RULE " -Wl,--output-def,<TARGET_NAME>.def"
Windows-GNU: Remove extra quotes in GNUtoMS rule variable CMake replaces the <TARGET...> tokens with properly quoted values so we do not need an extra set of quotes around them.
2011-12-08 22:28:14 +04:00
"<CMAKE_COMMAND> -Dlib=\"${CMAKE_GNUtoMS_LIB}\" -Ddef=<TARGET_NAME>.def -Ddll=<TARGET> -Dimp=<TARGET_IMPLIB> -P \"${CMAKE_ROOT}/Modules/Platform/GNUtoMS_lib.cmake\""
Add CMAKE_GNUtoMS option to convert GNU .dll.a to MS .lib Teach the Windows-GNU.cmake platform file to look for Visual Studio tools matching the target ABI. Add an extra step to the link command for shared libraries and executables that export symbols and on which a new GNUtoMS property is set (initialized by the CMAKE_GNUtoMS option). Tell the GNU linker to output a module definition (.def) file listing exported symbols in addition to the GNU-format import library (.dll.a). Pass the .def file to the MS "lib" tool to construct a MS-format DLL import library (.lib). Teach the install(TARGETS) command to install the MS import library next to the GNU one. Teach the install(EXPORT) and export() command to set the IMPORTED_IMPLIB property pointing at the import library to use the import library matching the tools in the importing project.
2011-12-06 01:39:07 +04:00
)
endif()
endmacro()