From a6fd17ce50b18dd9d06cdd7fdb34bf68e987f7fc Mon Sep 17 00:00:00 2001 From: Brad King Date: Wed, 9 Oct 2013 13:50:59 -0400 Subject: VS: Fix CMAKE__COMPILER detection with Intel toolset (#14471) When the platform toolset is from Intel, look for "icl.exe" instead of "cl.exe". --- Modules/CMakeDetermineCompilerId.cmake | 3 +++ 1 file changed, 3 insertions(+) diff --git a/Modules/CMakeDetermineCompilerId.cmake b/Modules/CMakeDetermineCompilerId.cmake index de4a882..71f15df 100644 --- a/Modules/CMakeDetermineCompilerId.cmake +++ b/Modules/CMakeDetermineCompilerId.cmake @@ -130,6 +130,9 @@ Id flags: ${testflags} endif() if(CMAKE_VS_PLATFORM_TOOLSET) set(id_toolset "${CMAKE_VS_PLATFORM_TOOLSET}") + if(CMAKE_VS_PLATFORM_TOOLSET MATCHES "Intel") + set(id_cl icl.exe) + endif() else() set(id_toolset "") endif() -- cgit v0.12 From 2d36c9ab60f9d1fa5304ebf23b09fa79ff8b667e Mon Sep 17 00:00:00 2001 From: Brad King Date: Fri, 11 Oct 2013 10:40:18 -0400 Subject: CMakeDetermineCompilerId: Fix Intel Fortran compiler id detection The Intel Fortran compiler needs the /fpp option to enable C preprocessing. Without the option the compiler may warn and ignore preprocessor lines instead of failing with an error. Detect the warning and treat it as failure so that we move on to try /fpp and detect the correct id. Without this it works only by luck because Intel is the first compiler id in our detection source file. --- Modules/CMakeDetermineCompilerId.cmake | 5 ++++- 1 file changed, 4 insertions(+), 1 deletion(-) diff --git a/Modules/CMakeDetermineCompilerId.cmake b/Modules/CMakeDetermineCompilerId.cmake index 71f15df..4c2b506 100644 --- a/Modules/CMakeDetermineCompilerId.cmake +++ b/Modules/CMakeDetermineCompilerId.cmake @@ -248,7 +248,10 @@ Id flags: ${testflags} endif() # Check the result of compilation. - if(CMAKE_${lang}_COMPILER_ID_RESULT) + if(CMAKE_${lang}_COMPILER_ID_RESULT + # Intel Fortran warns and ignores preprocessor lines without /fpp + OR CMAKE_${lang}_COMPILER_ID_OUTPUT MATCHES "Bad # preprocessor line" + ) # Compilation failed. set(MSG "Compiling the ${lang} compiler identification source file \"${src}\" failed. -- cgit v0.12 From b8522a8c8a64d6f86dc3618f658b07f7ba1d8fcd Mon Sep 17 00:00:00 2001 From: Brad King Date: Wed, 16 Oct 2013 15:48:44 -0400 Subject: VS: Expose Intel Fortran .vfproj format version to CMake language Lookup the Intel VS plugin version on demand in the VS global generator, compute the corresponding .vfproj format version number, and memoize it. Add it as a CMAKE_VS_INTEL_Fortran_PROJECT_VERSION platform definition. --- Help/manual/cmake-variables.7.rst | 1 + .../CMAKE_VS_INTEL_Fortran_PROJECT_VERSION.rst | 7 ++++ Source/cmGlobalVisualStudio7Generator.cxx | 42 ++++++++++++++++++++++ Source/cmGlobalVisualStudio7Generator.h | 7 ++++ Source/cmLocalVisualStudio7Generator.cxx | 30 +--------------- 5 files changed, 58 insertions(+), 29 deletions(-) create mode 100644 Help/variable/CMAKE_VS_INTEL_Fortran_PROJECT_VERSION.rst diff --git a/Help/manual/cmake-variables.7.rst b/Help/manual/cmake-variables.7.rst index 99c782d..2311ac8 100644 --- a/Help/manual/cmake-variables.7.rst +++ b/Help/manual/cmake-variables.7.rst @@ -61,6 +61,7 @@ Variables that Provide Information /variable/CMAKE_TWEAK_VERSION /variable/CMAKE_VERBOSE_MAKEFILE /variable/CMAKE_VERSION + /variable/CMAKE_VS_INTEL_Fortran_PROJECT_VERSION /variable/CMAKE_VS_PLATFORM_TOOLSET /variable/CMAKE_XCODE_PLATFORM_TOOLSET /variable/PROJECT_BINARY_DIR diff --git a/Help/variable/CMAKE_VS_INTEL_Fortran_PROJECT_VERSION.rst b/Help/variable/CMAKE_VS_INTEL_Fortran_PROJECT_VERSION.rst new file mode 100644 index 0000000..7e9d317 --- /dev/null +++ b/Help/variable/CMAKE_VS_INTEL_Fortran_PROJECT_VERSION.rst @@ -0,0 +1,7 @@ +CMAKE_VS_INTEL_Fortran_PROJECT_VERSION +-------------------------------------- + +When generating for Visual Studio 7 or greater with the Intel Fortran +plugin installed, this specifies the .vfproj project file format +version. This is intended for internal use by CMake and should not be +used by project code. diff --git a/Source/cmGlobalVisualStudio7Generator.cxx b/Source/cmGlobalVisualStudio7Generator.cxx index 0b9796d..6247f7d 100644 --- a/Source/cmGlobalVisualStudio7Generator.cxx +++ b/Source/cmGlobalVisualStudio7Generator.cxx @@ -21,6 +21,7 @@ cmGlobalVisualStudio7Generator::cmGlobalVisualStudio7Generator( const char* platformName) { this->FindMakeProgramFile = "CMakeVS7FindMake.cmake"; + this->IntelProjectVersion = 0; if (!platformName) { @@ -29,6 +30,45 @@ cmGlobalVisualStudio7Generator::cmGlobalVisualStudio7Generator( this->PlatformName = platformName; } +cmGlobalVisualStudio7Generator::~cmGlobalVisualStudio7Generator() +{ + free(this->IntelProjectVersion); +} + +// Package GUID of Intel Visual Fortran plugin to VS IDE +#define CM_INTEL_PLUGIN_GUID "{B68A201D-CB9B-47AF-A52F-7EEC72E217E4}" + +const char* cmGlobalVisualStudio7Generator::GetIntelProjectVersion() +{ + if(!this->IntelProjectVersion) + { + // Compute the version of the Intel plugin to the VS IDE. + // If the key does not exist then use a default guess. + std::string intelVersion; + std::string vskey = this->GetRegistryBase(); + vskey += "\\Packages\\" CM_INTEL_PLUGIN_GUID ";ProductVersion"; + cmSystemTools::ReadRegistryValue(vskey.c_str(), intelVersion, + cmSystemTools::KeyWOW64_32); + unsigned int intelVersionNumber = ~0u; + sscanf(intelVersion.c_str(), "%u", &intelVersionNumber); + if(intelVersionNumber >= 11) + { + // Default to latest known project file version. + intelVersion = "11.0"; + } + else if(intelVersionNumber == 10) + { + // Version 10.x actually uses 9.10 in project files! + intelVersion = "9.10"; + } + else + { + // Version <= 9: use ProductVersion from registry. + } + this->IntelProjectVersion = strdup(intelVersion.c_str()); + } + return this->IntelProjectVersion; +} void cmGlobalVisualStudio7Generator ::EnableLanguage(std::vectorconst & lang, @@ -156,6 +196,8 @@ void cmGlobalVisualStudio7Generator::AddPlatformDefinitions(cmMakefile* mf) { cmGlobalVisualStudioGenerator::AddPlatformDefinitions(mf); mf->AddDefinition("CMAKE_VS_PLATFORM_NAME", this->GetPlatformName()); + mf->AddDefinition("CMAKE_VS_INTEL_Fortran_PROJECT_VERSION", + this->GetIntelProjectVersion()); } void cmGlobalVisualStudio7Generator::GenerateConfigurations(cmMakefile* mf) diff --git a/Source/cmGlobalVisualStudio7Generator.h b/Source/cmGlobalVisualStudio7Generator.h index 4d22cff..66dc443 100644 --- a/Source/cmGlobalVisualStudio7Generator.h +++ b/Source/cmGlobalVisualStudio7Generator.h @@ -27,6 +27,8 @@ class cmGlobalVisualStudio7Generator : public cmGlobalVisualStudioGenerator { public: cmGlobalVisualStudio7Generator(const char* platformName = NULL); + ~cmGlobalVisualStudio7Generator(); + static cmGlobalGeneratorFactory* NewFactory() { return new cmGlobalGeneratorSimpleFactory (); } @@ -101,6 +103,8 @@ public: LinkLibraryDependencies and link to .sln dependencies. */ virtual bool NeedLinkLibraryDependencies(cmTarget&) { return false; } + const char* GetIntelProjectVersion(); + protected: virtual const char* GetIDEVersion() { return "7.0"; } @@ -159,6 +163,9 @@ protected: // There is one SLN file per project. std::string CurrentProject; std::string PlatformName; + +private: + char* IntelProjectVersion; }; #define CMAKE_CHECK_BUILD_SYSTEM_TARGET "ZERO_CHECK" diff --git a/Source/cmLocalVisualStudio7Generator.cxx b/Source/cmLocalVisualStudio7Generator.cxx index 64de448..f21abc3 100644 --- a/Source/cmLocalVisualStudio7Generator.cxx +++ b/Source/cmLocalVisualStudio7Generator.cxx @@ -27,9 +27,6 @@ #include // for isspace -// Package GUID of Intel Visual Fortran plugin to VS IDE -#define CM_INTEL_PLUGIN_GUID "{B68A201D-CB9B-47AF-A52F-7EEC72E217E4}" - static bool cmLVS6G_IsFAT(const char* dir); class cmLocalVisualStudio7GeneratorInternals @@ -1961,35 +1958,10 @@ cmLocalVisualStudio7Generator cmGlobalVisualStudio7Generator* gg = static_cast(this->GlobalGenerator); - - // Compute the version of the Intel plugin to the VS IDE. - // If the key does not exist then use a default guess. - std::string intelVersion; - std::string vskey = gg->GetRegistryBase(); - vskey += "\\Packages\\" CM_INTEL_PLUGIN_GUID ";ProductVersion"; - cmSystemTools::ReadRegistryValue(vskey.c_str(), intelVersion, - cmSystemTools::KeyWOW64_32); - unsigned int intelVersionNumber = ~0u; - sscanf(intelVersion.c_str(), "%u", &intelVersionNumber); - if(intelVersionNumber >= 11) - { - // Default to latest known project file version. - intelVersion = "11.0"; - } - else if(intelVersionNumber == 10) - { - // Version 10.x actually uses 9.10 in project files! - intelVersion = "9.10"; - } - else - { - // Version <= 9: use ProductVersion from registry. - } - fout << "\n" << "GetIntelProjectVersion() << "\"\n"; const char* keyword = target.GetProperty("VS_KEYWORD"); if(!keyword) { -- cgit v0.12 From af40e8c31256095eb8436b798fa1fbc0c71b0319 Mon Sep 17 00:00:00 2001 From: Brad King Date: Fri, 11 Oct 2013 13:40:43 -0400 Subject: VS: Detect Intel Fortran compiler id and version Teach CMakeDetermineCompilerId to use a .vfproj project file to build the Fortran compiler id source file under the Visual Studio generators. --- Modules/CMakeDetermineCompilerId.cmake | 6 ++++- Modules/CMakeDetermineFortranCompiler.cmake | 4 --- Modules/CompilerId/VS-Intel.vfproj.in | 42 +++++++++++++++++++++++++++++ Source/cmGlobalVisualStudio7Generator.cxx | 1 - 4 files changed, 47 insertions(+), 6 deletions(-) create mode 100644 Modules/CompilerId/VS-Intel.vfproj.in diff --git a/Modules/CMakeDetermineCompilerId.cmake b/Modules/CMakeDetermineCompilerId.cmake index 4c2b506..e591f2c 100644 --- a/Modules/CMakeDetermineCompilerId.cmake +++ b/Modules/CMakeDetermineCompilerId.cmake @@ -114,7 +114,11 @@ Id flags: ${testflags} set(id_platform ${CMAKE_VS_PLATFORM_NAME}) set(id_lang "${lang}") set(id_cl cl.exe) - if(NOT "${vs_version}" VERSION_LESS 10) + if(lang STREQUAL Fortran) + set(v Intel) + set(ext vfproj) + set(id_cl ifort.exe) + elseif(NOT "${vs_version}" VERSION_LESS 10) set(v 10) set(ext vcxproj) elseif(NOT "${vs_version}" VERSION_LESS 7) diff --git a/Modules/CMakeDetermineFortranCompiler.cmake b/Modules/CMakeDetermineFortranCompiler.cmake index 4d3fb90..13cfb00 100644 --- a/Modules/CMakeDetermineFortranCompiler.cmake +++ b/Modules/CMakeDetermineFortranCompiler.cmake @@ -26,10 +26,6 @@ if(NOT CMAKE_Fortran_COMPILER_NAMES) endif() if(${CMAKE_GENERATOR} MATCHES "Visual Studio") - set(CMAKE_Fortran_COMPILER_ID_RUN 1) - set(CMAKE_Fortran_PLATFORM_ID "Windows") - set(CMAKE_Fortran_COMPILER_ID "Intel") - set(CMAKE_Fortran_COMPILER "${CMAKE_GENERATOR_FC}") elseif("${CMAKE_GENERATOR}" MATCHES "Xcode") set(CMAKE_Fortran_COMPILER_XCODE_TYPE sourcecode.fortran.f90) else() diff --git a/Modules/CompilerId/VS-Intel.vfproj.in b/Modules/CompilerId/VS-Intel.vfproj.in new file mode 100644 index 0000000..044dd20 --- /dev/null +++ b/Modules/CompilerId/VS-Intel.vfproj.in @@ -0,0 +1,42 @@ + + + + + + + + + + + + + + + + + + + diff --git a/Source/cmGlobalVisualStudio7Generator.cxx b/Source/cmGlobalVisualStudio7Generator.cxx index 6247f7d..d476c24 100644 --- a/Source/cmGlobalVisualStudio7Generator.cxx +++ b/Source/cmGlobalVisualStudio7Generator.cxx @@ -76,7 +76,6 @@ void cmGlobalVisualStudio7Generator { mf->AddDefinition("CMAKE_GENERATOR_RC", "rc"); mf->AddDefinition("CMAKE_GENERATOR_NO_COMPILER_ENV", "1"); - mf->AddDefinition("CMAKE_GENERATOR_FC", "ifort"); this->AddPlatformDefinitions(mf); if(!mf->GetDefinition("CMAKE_CONFIGURATION_TYPES")) { -- cgit v0.12 From a85e17e660c47820ccccd8378349497804d94483 Mon Sep 17 00:00:00 2001 From: Brad King Date: Fri, 11 Oct 2013 13:54:50 -0400 Subject: 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). --- Modules/CMakeCCompilerId.c.in | 6 +++ Modules/CMakeCXXCompilerId.cpp.in | 6 +++ Modules/CMakeFindBinUtils.cmake | 1 + Modules/CMakeFortranCompiler.cmake.in | 2 + Modules/CMakeFortranCompilerId.F.in | 20 +++++++ Modules/Platform/Windows-Intel-CXX.cmake | 1 - Modules/Platform/Windows-Intel.cmake | 93 +++----------------------------- Modules/Platform/Windows-MSVC.cmake | 15 ++++-- 8 files changed, 51 insertions(+), 93 deletions(-) diff --git a/Modules/CMakeCCompilerId.c.in b/Modules/CMakeCCompilerId.c.in index 6dde1c3..871cccd 100644 --- a/Modules/CMakeCCompilerId.c.in +++ b/Modules/CMakeCCompilerId.c.in @@ -19,6 +19,12 @@ /* __INTEL_COMPILER_BUILD_DATE = YYYYMMDD */ # define COMPILER_VERSION_TWEAK DEC(__INTEL_COMPILER_BUILD_DATE) # endif +# if defined(_MSC_VER) +# define SIMULATE_ID "MSVC" + /* _MSC_VER = VVRR */ +# define SIMULATE_VERSION_MAJOR DEC(_MSC_VER / 100) +# define SIMULATE_VERSION_MINOR DEC(_MSC_VER % 100) +# endif #elif defined(__PATHCC__) # define COMPILER_ID "PathScale" diff --git a/Modules/CMakeCXXCompilerId.cpp.in b/Modules/CMakeCXXCompilerId.cpp.in index 3a60922..f32fee0 100644 --- a/Modules/CMakeCXXCompilerId.cpp.in +++ b/Modules/CMakeCXXCompilerId.cpp.in @@ -24,6 +24,12 @@ /* __INTEL_COMPILER_BUILD_DATE = YYYYMMDD */ # define COMPILER_VERSION_TWEAK DEC(__INTEL_COMPILER_BUILD_DATE) # endif +# if defined(_MSC_VER) +# define SIMULATE_ID "MSVC" + /* _MSC_VER = VVRR */ +# define SIMULATE_VERSION_MAJOR DEC(_MSC_VER / 100) +# define SIMULATE_VERSION_MINOR DEC(_MSC_VER % 100) +# endif #elif defined(__PATHCC__) # define COMPILER_ID "PathScale" diff --git a/Modules/CMakeFindBinUtils.cmake b/Modules/CMakeFindBinUtils.cmake index b4e2ae5..315d57e 100644 --- a/Modules/CMakeFindBinUtils.cmake +++ b/Modules/CMakeFindBinUtils.cmake @@ -32,6 +32,7 @@ # if it's the MS C/CXX compiler, search for link if("${CMAKE_C_SIMULATE_ID}" STREQUAL "MSVC" OR "${CMAKE_CXX_SIMULATE_ID}" STREQUAL "MSVC" + OR "${CMAKE_Fortran_SIMULATE_ID}" STREQUAL "MSVC" OR "${CMAKE_C_COMPILER_ID}" STREQUAL "MSVC" OR "${CMAKE_CXX_COMPILER_ID}" STREQUAL "MSVC" OR "${CMAKE_GENERATOR}" MATCHES "Visual Studio") diff --git a/Modules/CMakeFortranCompiler.cmake.in b/Modules/CMakeFortranCompiler.cmake.in index d193881..e4c7618 100644 --- a/Modules/CMakeFortranCompiler.cmake.in +++ b/Modules/CMakeFortranCompiler.cmake.in @@ -2,6 +2,8 @@ set(CMAKE_Fortran_COMPILER "@CMAKE_Fortran_COMPILER@") set(CMAKE_Fortran_COMPILER_ARG1 "@CMAKE_Fortran_COMPILER_ARG1@") set(CMAKE_Fortran_COMPILER_ID "@CMAKE_Fortran_COMPILER_ID@") set(CMAKE_Fortran_PLATFORM_ID "@CMAKE_Fortran_PLATFORM_ID@") +set(CMAKE_Fortran_SIMULATE_ID "@CMAKE_Fortran_SIMULATE_ID@") +set(CMAKE_Fortran_SIMULATE_VERSION "@CMAKE_Fortran_SIMULATE_VERSION@") @SET_MSVC_Fortran_ARCHITECTURE_ID@ set(CMAKE_AR "@CMAKE_AR@") set(CMAKE_RANLIB "@CMAKE_RANLIB@") diff --git a/Modules/CMakeFortranCompilerId.F.in b/Modules/CMakeFortranCompilerId.F.in index f84852a..b8f8f7d 100644 --- a/Modules/CMakeFortranCompilerId.F.in +++ b/Modules/CMakeFortranCompilerId.F.in @@ -4,6 +4,26 @@ #endif #if defined(__INTEL_COMPILER) || defined(__ICC) PRINT *, 'INFO:compiler[Intel]' +# if defined(_MSC_VER) + PRINT *, 'INFO:simulate[MSVC]' +# if _MSC_VER >= 1800 + PRINT *, 'INFO:simulate_version[018.00]' +# elif _MSC_VER >= 1700 + PRINT *, 'INFO:simulate_version[017.00]' +# elif _MSC_VER >= 1600 + PRINT *, 'INFO:simulate_version[016.00]' +# elif _MSC_VER >= 1500 + PRINT *, 'INFO:simulate_version[015.00]' +# elif _MSC_VER >= 1400 + PRINT *, 'INFO:simulate_version[014.00]' +# elif _MSC_VER >= 1310 + PRINT *, 'INFO:simulate_version[013.01]' +# elif _MSC_VER >= 1300 + PRINT *, 'INFO:simulate_version[013.00]' +# elif _MSC_VER >= 1200 + PRINT *, 'INFO:simulate_version[012.00]' +# endif +# endif #elif defined(__SUNPRO_F90) || defined(__SUNPRO_F95) PRINT *, 'INFO:compiler[SunPro]' #elif defined(_CRAYFTN) diff --git a/Modules/Platform/Windows-Intel-CXX.cmake b/Modules/Platform/Windows-Intel-CXX.cmake index ec5f0ae..84cd303 100644 --- a/Modules/Platform/Windows-Intel-CXX.cmake +++ b/Modules/Platform/Windows-Intel-CXX.cmake @@ -1,4 +1,3 @@ include(Platform/Windows-Intel) set(_COMPILE_CXX " /TP") -set(_FLAGS_CXX " /EHsc /GR") __windows_compiler_intel(CXX) diff --git a/Modules/Platform/Windows-Intel.cmake b/Modules/Platform/Windows-Intel.cmake index 69a7f2f..34e6b37 100644 --- a/Modules/Platform/Windows-Intel.cmake +++ b/Modules/Platform/Windows-Intel.cmake @@ -18,92 +18,11 @@ if(__WINDOWS_INTEL) endif() set(__WINDOWS_INTEL 1) -# make sure to enable languages after setting configuration types -enable_language(RC) -set(CMAKE_COMPILE_RESOURCE "rc /fo ") - -set(CMAKE_LIBRARY_PATH_FLAG "-LIBPATH:") -set(CMAKE_LINK_LIBRARY_FLAG "") -set(WIN32 1) -if(CMAKE_VERBOSE_MAKEFILE) - set(CMAKE_CL_NOLOGO) -else() - set(CMAKE_CL_NOLOGO "/nologo") -endif() -set(CMAKE_COMPILE_RESOURCE "rc /fo ") -set(CMAKE_CREATE_WIN32_EXE /subsystem:windows) -set(CMAKE_CREATE_CONSOLE_EXE /subsystem:console) - -# default to Debug builds -#set(CMAKE_BUILD_TYPE_INIT Debug) -set(CMAKE_BUILD_TYPE_INIT Release) - -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 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib") -set(CMAKE_CXX_STANDARD_LIBRARIES_INIT "${CMAKE_C_STANDARD_LIBRARIES_INIT}") - -# executable linker flags -set (CMAKE_LINK_DEF_FILE_FLAG "/DEF:") -if(MSVC_C_ARCHITECTURE_ID) - set(_MACHINE_ARCH_FLAG "/machine:${MSVC_C_ARCHITECTURE_ID}") -elseif(MSVC_CXX_ARCHITECTURE_ID) - set(_MACHINE_ARCH_FLAG "/machine:${MSVC_CXX_ARCHITECTURE_ID}") -elseif(MSVC_Fortran_ARCHITECTURE_ID) - set(_MACHINE_ARCH_FLAG "/machine:${MSVC_Fortran_ARCHITECTURE_ID}") -endif() -set (CMAKE_EXE_LINKER_FLAGS_INIT "/INCREMENTAL:YES ${_MACHINE_ARCH_FLAG}") -set (CMAKE_EXE_LINKER_FLAGS_DEBUG_INIT "/debug") -set (CMAKE_EXE_LINKER_FLAGS_RELWITHDEBINFO_INIT "/debug") - -set (CMAKE_SHARED_LINKER_FLAGS_INIT ${CMAKE_EXE_LINKER_FLAGS_INIT}) -set (CMAKE_SHARED_LINKER_FLAGS_DEBUG_INIT ${CMAKE_EXE_LINKER_FLAGS_DEBUG_INIT}) -set (CMAKE_SHARED_LINKER_FLAGS_RELWITHDEBINFO_INIT ${CMAKE_EXE_LINKER_FLAGS_DEBUG_INIT}) -set (CMAKE_MODULE_LINKER_FLAGS_INIT ${CMAKE_SHARED_LINKER_FLAGS_INIT}) -set (CMAKE_MODULE_LINKER_FLAGS_DEBUG_INIT ${CMAKE_SHARED_LINKER_FLAGS_DEBUG_INIT}) -set (CMAKE_MODULE_LINKER_FLAGS_RELWITHDEBINFO_INIT ${CMAKE_EXE_LINKER_FLAGS_RELWITHDEBINFO_INIT}) - -include("${CMAKE_PLATFORM_INFO_DIR}/CMakeIntelInformation.cmake" OPTIONAL) - -if(NOT _INTEL_XILINK_TEST_RUN) - execute_process(COMMAND xilink /? - ERROR_VARIABLE _XILINK_ERR - OUTPUT_VARIABLE _XILINK_HELP) - if(_XILINK_HELP MATCHES MANIFEST) - set(_INTEL_COMPILER_SUPPORTS_MANIFEST 1) - endif() - if(NOT EXISTS "${CMAKE_PLATFORM_INFO_DIR}/CMakeIntelInformation.cmake") - file(WRITE ${CMAKE_PLATFORM_INFO_DIR}/CMakeIntelInformation.cmake - " -set(_INTEL_XILINK_TEST_RUN 1) -set(_INTEL_COMPILER_SUPPORTS_MANIFEST ${_INTEL_COMPILER_SUPPORTS_MANIFEST}) -") - endif() -endif() - +include(Platform/Windows-MSVC) macro(__windows_compiler_intel lang) - set(CMAKE_${lang}_COMPILE_OBJECT - " ${CMAKE_START_TEMP_FILE} ${CMAKE_CL_NOLOGO}${_COMPILE_${lang}} /Fo /Fd/ -c ${CMAKE_END_TEMP_FILE}") - set(CMAKE_${lang}_CREATE_PREPROCESSED_SOURCE - " > ${CMAKE_START_TEMP_FILE} ${CMAKE_CL_NOLOGO}${_COMPILE_${lang}} -E ${CMAKE_END_TEMP_FILE}") - set(CMAKE_${lang}_USE_RESPONSE_FILE_FOR_OBJECTS 1) - set(CMAKE_${lang}_CREATE_STATIC_LIBRARY "lib ${CMAKE_CL_NOLOGO} /out: ") - set(CMAKE_${lang}_CREATE_SHARED_LIBRARY - "xilink ${CMAKE_CL_NOLOGO} ${CMAKE_START_TEMP_FILE} /out: /implib: /pdb: /dll ${CMAKE_END_TEMP_FILE}") - set(CMAKE_${lang}_CREATE_SHARED_MODULE "${CMAKE_${lang}_CREATE_SHARED_LIBRARY}") - set(CMAKE_${lang}_COMPILER_LINKER_OPTION_FLAG_EXECUTABLE "/link") - set(CMAKE_${lang}_LINK_EXECUTABLE - " ${CMAKE_CL_NOLOGO} ${CMAKE_START_TEMP_FILE} /Fe /link /implib: /pdb: ${CMAKE_END_TEMP_FILE}") - set(CMAKE_${lang}_FLAGS_INIT "/DWIN32 /D_WINDOWS /W3 /Zm1000${_FLAGS_${lang}}") - set(CMAKE_${lang}_FLAGS_DEBUG_INIT "/D_DEBUG /MDd /Zi /Od /RTC1") - set(CMAKE_${lang}_FLAGS_MINSIZEREL_INIT "/DNDEBUG /MD /O1") - set(CMAKE_${lang}_FLAGS_RELEASE_INIT "/DNDEBUG /MD /O2") - set(CMAKE_${lang}_FLAGS_RELWITHDEBINFO_INIT "/DNDEBUG /MD /Zi /O2") - - if(_INTEL_COMPILER_SUPPORTS_MANIFEST) - set(CMAKE_${lang}_LINK_EXECUTABLE - " -E vs_link_exe ${CMAKE_${lang}_LINK_EXECUTABLE}") - set(CMAKE_${lang}_CREATE_SHARED_LIBRARY - " -E vs_link_dll ${CMAKE_${lang}_CREATE_SHARED_LIBRARY}") - set(CMAKE_${lang}_CREATE_SHARED_MODULE - " -E vs_link_dll ${CMAKE_${lang}_CREATE_SHARED_MODULE}") - endif() + __windows_compiler_msvc(${lang}) + string(REPLACE " /lib" "lib" CMAKE_${lang}_CREATE_STATIC_LIBRARY "${CMAKE_${lang}_CREATE_STATIC_LIBRARY}") + foreach(rule CREATE_SHARED_LIBRARY CREATE_SHARED_MODULE LINK_EXECUTABLE) + string(REPLACE "" "xilink" CMAKE_${lang}_${rule} "${CMAKE_${lang}_${rule}}") + endforeach() endmacro() diff --git a/Modules/Platform/Windows-MSVC.cmake b/Modules/Platform/Windows-MSVC.cmake index a2cfe33..8f0add7 100644 --- a/Modules/Platform/Windows-MSVC.cmake +++ b/Modules/Platform/Windows-MSVC.cmake @@ -69,6 +69,8 @@ if(NOT MSVC_VERSION) set(_compiler_version ${CMAKE_C_SIMULATE_VERSION}) elseif(CMAKE_CXX_SIMULATE_VERSION) set(_compiler_version ${CMAKE_CXX_SIMULATE_VERSION}) + elseif(CMAKE_Fortran_SIMULATE_VERSION) + set(_compiler_version ${CMAKE_Fortran_SIMULATE_VERSION}) elseif(CMAKE_C_COMPILER_VERSION) set(_compiler_version ${CMAKE_C_COMPILER_VERSION}) else() @@ -182,12 +184,15 @@ set(CMAKE_CXX_STANDARD_LIBRARIES_INIT "${CMAKE_C_STANDARD_LIBRARIES_INIT}") # executable linker flags set (CMAKE_LINK_DEF_FILE_FLAG "/DEF:") # set the machine type -set(_MACHINE_ARCH_FLAG ${MSVC_C_ARCHITECTURE_ID}) -if(NOT _MACHINE_ARCH_FLAG) - set(_MACHINE_ARCH_FLAG ${MSVC_CXX_ARCHITECTURE_ID}) +if(MSVC_C_ARCHITECTURE_ID) + set(_MACHINE_ARCH_FLAG "/machine:${MSVC_C_ARCHITECTURE_ID}") +elseif(MSVC_CXX_ARCHITECTURE_ID) + set(_MACHINE_ARCH_FLAG "/machine:${MSVC_CXX_ARCHITECTURE_ID}") +elseif(MSVC_Fortran_ARCHITECTURE_ID) + set(_MACHINE_ARCH_FLAG "/machine:${MSVC_Fortran_ARCHITECTURE_ID}") endif() -set (CMAKE_EXE_LINKER_FLAGS_INIT - "${CMAKE_EXE_LINKER_FLAGS_INIT} /machine:${_MACHINE_ARCH_FLAG}") +set(CMAKE_EXE_LINKER_FLAGS_INIT "${CMAKE_EXE_LINKER_FLAGS_INIT} ${_MACHINE_ARCH_FLAG}") +unset(_MACHINE_ARCH_FLAG) # add /debug and /INCREMENTAL:YES to DEBUG and RELWITHDEBINFO also add pdbtype # on versions that support it -- cgit v0.12 From d14898b6dc4f5f20c96b02fccb313ba0c119033f Mon Sep 17 00:00:00 2001 From: Brad King Date: Wed, 16 Oct 2013 15:27:14 -0400 Subject: Intel: Fix detection of MSVC version simulated by pre-11.0 Fortran The Intel Fortran 10 64-bit compiler incorrectly defines _MSC_VER to its own version (1020) instead of the underlying MSVC tools version. Since we expect the compiler to be used only with VS >= 7 tools, assume MSVC version 13.0 if _MSC_VER is not greater than 1300. --- Modules/CMakeFortranCompilerId.F.in | 4 +--- 1 file changed, 1 insertion(+), 3 deletions(-) diff --git a/Modules/CMakeFortranCompilerId.F.in b/Modules/CMakeFortranCompilerId.F.in index b8f8f7d..5349505 100644 --- a/Modules/CMakeFortranCompilerId.F.in +++ b/Modules/CMakeFortranCompilerId.F.in @@ -18,10 +18,8 @@ PRINT *, 'INFO:simulate_version[014.00]' # elif _MSC_VER >= 1310 PRINT *, 'INFO:simulate_version[013.01]' -# elif _MSC_VER >= 1300 +# else PRINT *, 'INFO:simulate_version[013.00]' -# elif _MSC_VER >= 1200 - PRINT *, 'INFO:simulate_version[012.00]' # endif # endif #elif defined(__SUNPRO_F90) || defined(__SUNPRO_F95) -- cgit v0.12