Merge topic 'cmake-platform-info-version'

e5fee8a Store ABI detection results in compiler information files
3df81b4 Move CMAKE_<LANG>_COMPILER_WORKS to compiler information files
7195aca Make platform information files specific to the CMake version

Modules/CMakeCCompiler.cmake.in

@@ -9,6 +9,8 @@ set(CMAKE_RANLIB "@CMAKE_RANLIB@")
 set(CMAKE_LINKER "@CMAKE_LINKER@")
 set(CMAKE_COMPILER_IS_GNUCC @CMAKE_COMPILER_IS_GNUCC@)
 set(CMAKE_C_COMPILER_LOADED 1)
+set(CMAKE_C_COMPILER_WORKS @CMAKE_C_COMPILER_WORKS@)
+set(CMAKE_C_ABI_COMPILED @CMAKE_C_ABI_COMPILED@)
 set(CMAKE_COMPILER_IS_MINGW @CMAKE_COMPILER_IS_MINGW@)
 set(CMAKE_COMPILER_IS_CYGWIN @CMAKE_COMPILER_IS_CYGWIN@)
 if(CMAKE_COMPILER_IS_CYGWIN)

Modules/CMakeCXXCompiler.cmake.in

@@ -9,6 +9,8 @@ set(CMAKE_RANLIB "@CMAKE_RANLIB@")
 set(CMAKE_LINKER "@CMAKE_LINKER@")
 set(CMAKE_COMPILER_IS_GNUCXX @CMAKE_COMPILER_IS_GNUCXX@)
 set(CMAKE_CXX_COMPILER_LOADED 1)
+set(CMAKE_CXX_COMPILER_WORKS @CMAKE_CXX_COMPILER_WORKS@)
+set(CMAKE_CXX_ABI_COMPILED @CMAKE_CXX_ABI_COMPILED@)
 set(CMAKE_COMPILER_IS_MINGW @CMAKE_COMPILER_IS_MINGW@)
 set(CMAKE_COMPILER_IS_CYGWIN @CMAKE_COMPILER_IS_CYGWIN@)
 if(CMAKE_COMPILER_IS_CYGWIN)

Modules/CMakeDetermineASMCompiler.cmake

@@ -163,7 +163,7 @@ set(_CMAKE_ASM_COMPILER_ENV_VAR "${CMAKE_ASM${ASM_DIALECT}_COMPILER_ENV_VAR}")
 
 # configure variables set in this file for fast reload later on
 configure_file(${CMAKE_ROOT}/Modules/CMakeASMCompiler.cmake.in
-  ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeASM${ASM_DIALECT}Compiler.cmake IMMEDIATE @ONLY)
+  ${CMAKE_PLATFORM_INFO_DIR}/CMakeASM${ASM_DIALECT}Compiler.cmake IMMEDIATE @ONLY)
 
 set(_CMAKE_ASM_COMPILER)
 set(_CMAKE_ASM_COMPILER_ARG1)

Modules/CMakeDetermineCCompiler.cmake

@@ -169,7 +169,7 @@ if(MSVC_C_ARCHITECTURE_ID)
 endif()
 # configure variables set in this file for fast reload later on
 configure_file(${CMAKE_ROOT}/Modules/CMakeCCompiler.cmake.in
-  "${CMAKE_PLATFORM_ROOT_BIN}/CMakeCCompiler.cmake"
+  ${CMAKE_PLATFORM_INFO_DIR}/CMakeCCompiler.cmake
   @ONLY IMMEDIATE # IMMEDIATE must be here for compatibility mode <= 2.0
   )
 set(CMAKE_C_COMPILER_ENV_VAR "CC")

Modules/CMakeDetermineCXXCompiler.cmake

@@ -165,7 +165,7 @@ if(MSVC_CXX_ARCHITECTURE_ID)
 endif()
 # configure all variables set in this file
 configure_file(${CMAKE_ROOT}/Modules/CMakeCXXCompiler.cmake.in
-  ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeCXXCompiler.cmake
+  ${CMAKE_PLATFORM_INFO_DIR}/CMakeCXXCompiler.cmake
   @ONLY IMMEDIATE # IMMEDIATE must be here for compatibility mode <= 2.0
   )
 

Modules/CMakeDetermineCompilerABI.cmake

@@ -19,16 +19,16 @@
 include(${CMAKE_ROOT}/Modules/CMakeParseImplicitLinkInfo.cmake)
 
 function(CMAKE_DETERMINE_COMPILER_ABI lang src)
-  if(NOT DEFINED CMAKE_DETERMINE_${lang}_ABI_COMPILED)
+  if(NOT DEFINED CMAKE_${lang}_ABI_COMPILED)
     message(STATUS "Detecting ${lang} compiler ABI info")
 
     # Compile the ABI identification source.
-    set(BIN "${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeDetermineCompilerABI_${lang}.bin")
+    set(BIN "${CMAKE_PLATFORM_INFO_DIR}/CMakeDetermineCompilerABI_${lang}.bin")
     set(CMAKE_FLAGS )
     if(DEFINED CMAKE_${lang}_VERBOSE_FLAG)
       set(CMAKE_FLAGS "-DCMAKE_EXE_LINKER_FLAGS=${CMAKE_${lang}_VERBOSE_FLAG}")
     endif()
-    try_compile(CMAKE_DETERMINE_${lang}_ABI_COMPILED
+    try_compile(CMAKE_${lang}_ABI_COMPILED
       ${CMAKE_BINARY_DIR} ${src}
       CMAKE_FLAGS "${CMAKE_FLAGS}"
                   "-DCMAKE_${lang}_STANDARD_LIBRARIES="
@@ -39,9 +39,13 @@ function(CMAKE_DETERMINE_COMPILER_ABI lang src)
       OUTPUT_VARIABLE OUTPUT
       COPY_FILE "${BIN}"
       )
+    # Move result from cache to normal variable.
+    set(CMAKE_${lang}_ABI_COMPILED ${CMAKE_${lang}_ABI_COMPILED})
+    unset(CMAKE_${lang}_ABI_COMPILED CACHE)
+    set(CMAKE_${lang}_ABI_COMPILED ${CMAKE_${lang}_ABI_COMPILED} PARENT_SCOPE)
 
     # Load the resulting information strings.
-    if(CMAKE_DETERMINE_${lang}_ABI_COMPILED)
+    if(CMAKE_${lang}_ABI_COMPILED)
       message(STATUS "Detecting ${lang} compiler ABI info - done")
       file(APPEND ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeOutput.log
         "Detecting ${lang} compiler ABI info compiled with the following output:\n${OUTPUT}\n\n")

Modules/CMakeDetermineCompilerId.cmake

@@ -30,7 +30,7 @@ function(CMAKE_DETERMINE_COMPILER_ID lang flagvar src)
   string(REGEX REPLACE " " ";" CMAKE_${lang}_COMPILER_ID_FLAGS_LIST "${CMAKE_${lang}_COMPILER_ID_FLAGS}")
 
   # Compute the directory in which to run the test.
-  set(CMAKE_${lang}_COMPILER_ID_DIR ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CompilerId${lang})
+  set(CMAKE_${lang}_COMPILER_ID_DIR ${CMAKE_PLATFORM_INFO_DIR}/CompilerId${lang})
 
   # Try building with no extra flags and then try each set
   # of helper flags.  Stop when the compiler is identified.
@@ -393,7 +393,7 @@ function(CMAKE_DETERMINE_COMPILER_ID_VENDOR lang)
     # We get here when this function is called not from within CMAKE_DETERMINE_COMPILER_ID()
     # This is done e.g. for detecting the compiler ID for assemblers.
     # Compute the directory in which to run the test and Create a clean working directory.
-    set(CMAKE_${lang}_COMPILER_ID_DIR ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CompilerId${lang})
+    set(CMAKE_${lang}_COMPILER_ID_DIR ${CMAKE_PLATFORM_INFO_DIR}/CompilerId${lang})
     file(REMOVE_RECURSE ${CMAKE_${lang}_COMPILER_ID_DIR})
     file(MAKE_DIRECTORY ${CMAKE_${lang}_COMPILER_ID_DIR})
   endif()

Modules/CMakeDetermineFortranCompiler.cmake

@@ -197,7 +197,7 @@ if(MSVC_Fortran_ARCHITECTURE_ID)
 endif()
 # configure variables set in this file for fast reload later on
 configure_file(${CMAKE_ROOT}/Modules/CMakeFortranCompiler.cmake.in
-  ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeFortranCompiler.cmake
+  ${CMAKE_PLATFORM_INFO_DIR}/CMakeFortranCompiler.cmake
   @ONLY IMMEDIATE # IMMEDIATE must be here for compatibility mode <= 2.0
   )
 set(CMAKE_Fortran_COMPILER_ENV_VAR "FC")

Modules/CMakeDetermineJavaCompiler.cmake

@@ -98,5 +98,5 @@ mark_as_advanced(CMAKE_Java_COMPILER)
 
 # configure variables set in this file for fast reload later on
 configure_file(${CMAKE_ROOT}/Modules/CMakeJavaCompiler.cmake.in
-  ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeJavaCompiler.cmake IMMEDIATE @ONLY)
+  ${CMAKE_PLATFORM_INFO_DIR}/CMakeJavaCompiler.cmake IMMEDIATE @ONLY)
 set(CMAKE_Java_COMPILER_ENV_VAR "JAVA_COMPILER")

Modules/CMakeDetermineRCCompiler.cmake

@@ -63,5 +63,5 @@ endif()
 
 # configure variables set in this file for fast reload later on
 configure_file(${CMAKE_ROOT}/Modules/CMakeRCCompiler.cmake.in
-               ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeRCCompiler.cmake IMMEDIATE)
+               ${CMAKE_PLATFORM_INFO_DIR}/CMakeRCCompiler.cmake IMMEDIATE)
 set(CMAKE_RC_COMPILER_ENV_VAR "RC")

Modules/CMakeDetermineSystem.cmake

@@ -170,7 +170,7 @@ if(CMAKE_BINARY_DIR)
 
   # configure variables set in this file for fast reload, the template file is defined at the top of this file
   configure_file(${CMAKE_ROOT}/Modules/CMakeSystem.cmake.in
-                ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeSystem.cmake
+                ${CMAKE_PLATFORM_INFO_DIR}/CMakeSystem.cmake
                 IMMEDIATE @ONLY)
 
 endif()

Modules/CMakeFindPackageMode.cmake

@@ -47,6 +47,8 @@ macro(ENABLE_LANGUAGE)
   # But in --find-package mode, we don't want (and can't) enable any language.
 endmacro()
 
+set(CMAKE_PLATFORM_INFO_DIR ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY})
+
 include(CMakeDetermineSystem)
 
 # short-cut some tests on Darwin, see Darwin-GNU.cmake:

Modules/CMakeForceCompiler.cmake

@@ -46,7 +46,6 @@ macro(CMAKE_FORCE_C_COMPILER compiler id)
   set(CMAKE_C_COMPILER "${compiler}")
   set(CMAKE_C_COMPILER_ID_RUN TRUE)
   set(CMAKE_C_COMPILER_ID ${id})
-  set(CMAKE_C_COMPILER_WORKS TRUE)
   set(CMAKE_C_COMPILER_FORCED TRUE)
 
   # Set old compiler id variables.
@@ -59,7 +58,6 @@ macro(CMAKE_FORCE_CXX_COMPILER compiler id)
   set(CMAKE_CXX_COMPILER "${compiler}")
   set(CMAKE_CXX_COMPILER_ID_RUN TRUE)
   set(CMAKE_CXX_COMPILER_ID ${id})
-  set(CMAKE_CXX_COMPILER_WORKS TRUE)
   set(CMAKE_CXX_COMPILER_FORCED TRUE)
 
   # Set old compiler id variables.
@@ -72,7 +70,6 @@ macro(CMAKE_FORCE_Fortran_COMPILER compiler id)
   set(CMAKE_Fortran_COMPILER "${compiler}")
   set(CMAKE_Fortran_COMPILER_ID_RUN TRUE)
   set(CMAKE_Fortran_COMPILER_ID ${id})
-  set(CMAKE_Fortran_COMPILER_WORKS TRUE)
   set(CMAKE_Fortran_COMPILER_FORCED TRUE)
 
   # Set old compiler id variables.

Modules/CMakeFortranCompiler.cmake.in

@@ -7,6 +7,8 @@ set(CMAKE_AR "@CMAKE_AR@")
 set(CMAKE_RANLIB "@CMAKE_RANLIB@")
 set(CMAKE_COMPILER_IS_GNUG77 @CMAKE_COMPILER_IS_GNUG77@)
 set(CMAKE_Fortran_COMPILER_LOADED 1)
+set(CMAKE_Fortran_COMPILER_WORKS @CMAKE_Fortran_COMPILER_WORKS@)
+set(CMAKE_Fortran_ABI_COMPILED @CMAKE_Fortran_ABI_COMPILED@)
 set(CMAKE_COMPILER_IS_MINGW @CMAKE_COMPILER_IS_MINGW@)
 set(CMAKE_COMPILER_IS_CYGWIN @CMAKE_COMPILER_IS_CYGWIN@)
 if(CMAKE_COMPILER_IS_CYGWIN)

Modules/CMakeTestCCompiler.cmake

@@ -1,6 +1,6 @@
 
 #=============================================================================
-# Copyright 2003-2009 Kitware, Inc.
+# Copyright 2003-2012 Kitware, Inc.
 #
 # Distributed under the OSI-approved BSD License (the "License");
 # see accompanying file Copyright.txt for details.
@@ -12,8 +12,19 @@
 # (To distribute this file outside of CMake, substitute the full
 #  License text for the above reference.)
 
+if(CMAKE_C_COMPILER_FORCED)
+  # The compiler configuration was forced by the user.
+  # Assume the user has configured all compiler information.
+  set(CMAKE_C_COMPILER_WORKS TRUE)
+  return()
+endif()
+
 include(CMakeTestCompilerCommon)
 
+# Remove any cached result from an older CMake version.
+# We now store this in CMakeCCompiler.cmake.
+unset(CMAKE_C_COMPILER_WORKS CACHE)
+
 # This file is used by EnableLanguage in cmGlobalGenerator to
 # determine that that selected C compiler can actually compile
 # and link the most basic of programs.   If not, a fatal error
@@ -36,6 +47,9 @@ if(NOT CMAKE_C_COMPILER_WORKS)
   try_compile(CMAKE_C_COMPILER_WORKS ${CMAKE_BINARY_DIR}
     ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeTmp/testCCompiler.c
     OUTPUT_VARIABLE __CMAKE_C_COMPILER_OUTPUT)
+  # Move result from cache to normal variable.
+  set(CMAKE_C_COMPILER_WORKS ${CMAKE_C_COMPILER_WORKS})
+  unset(CMAKE_C_COMPILER_WORKS CACHE)
   set(C_TEST_WAS_RUN 1)
 endif()
 
@@ -47,8 +61,8 @@ if(NOT CMAKE_C_COMPILER_WORKS)
   # if the compiler is broken make sure to remove the platform file
   # since Windows-cl configures both c/cxx files both need to be removed
   # when c or c++ fails
-  file(REMOVE ${CMAKE_PLATFORM_ROOT_BIN}/CMakeCPlatform.cmake )
+  file(REMOVE ${CMAKE_PLATFORM_INFO_DIR}/CMakeCPlatform.cmake )
-  file(REMOVE ${CMAKE_PLATFORM_ROOT_BIN}/CMakeCXXPlatform.cmake )
+  file(REMOVE ${CMAKE_PLATFORM_INFO_DIR}/CMakeCXXPlatform.cmake )
   message(FATAL_ERROR "The C compiler \"${CMAKE_C_COMPILER}\" "
     "is not able to compile a simple test program.\nIt fails "
     "with the following output:\n ${__CMAKE_C_COMPILER_OUTPUT}\n\n"
@@ -60,22 +74,19 @@ else()
       "Determining if the C compiler works passed with "
       "the following output:\n${__CMAKE_C_COMPILER_OUTPUT}\n\n")
   endif()
-  set(CMAKE_C_COMPILER_WORKS 1 CACHE INTERNAL "")
 
-  if(CMAKE_C_COMPILER_FORCED)
+  # Try to identify the ABI and configure it into CMakeCCompiler.cmake
-    # The compiler configuration was forced by the user.
+  include(${CMAKE_ROOT}/Modules/CMakeDetermineCompilerABI.cmake)
-    # Assume the user has configured all compiler information.
+  CMAKE_DETERMINE_COMPILER_ABI(C ${CMAKE_ROOT}/Modules/CMakeCCompilerABI.c)
-  else()
+
-    # Try to identify the ABI and configure it into CMakeCCompiler.cmake
+  # Re-configure to save learned information.
-    include(${CMAKE_ROOT}/Modules/CMakeDetermineCompilerABI.cmake)
+  configure_file(
-    CMAKE_DETERMINE_COMPILER_ABI(C ${CMAKE_ROOT}/Modules/CMakeCCompilerABI.c)
+    ${CMAKE_ROOT}/Modules/CMakeCCompiler.cmake.in
-    configure_file(
+    ${CMAKE_PLATFORM_INFO_DIR}/CMakeCCompiler.cmake
-      ${CMAKE_ROOT}/Modules/CMakeCCompiler.cmake.in
+    @ONLY IMMEDIATE # IMMEDIATE must be here for compatibility mode <= 2.0
-      ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeCCompiler.cmake
+    )
-      @ONLY IMMEDIATE # IMMEDIATE must be here for compatibility mode <= 2.0
+  include(${CMAKE_PLATFORM_INFO_DIR}/CMakeCCompiler.cmake)
-      )
+
-    include(${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeCCompiler.cmake)
-  endif()
   if(CMAKE_C_SIZEOF_DATA_PTR)
     foreach(f ${CMAKE_C_ABI_FILES})
       include(${f})

Modules/CMakeTestCXXCompiler.cmake

@@ -1,6 +1,6 @@
 
 #=============================================================================
-# Copyright 2003-2009 Kitware, Inc.
+# Copyright 2003-2012 Kitware, Inc.
 #
 # Distributed under the OSI-approved BSD License (the "License");
 # see accompanying file Copyright.txt for details.
@@ -12,8 +12,19 @@
 # (To distribute this file outside of CMake, substitute the full
 #  License text for the above reference.)
 
+if(CMAKE_CXX_COMPILER_FORCED)
+  # The compiler configuration was forced by the user.
+  # Assume the user has configured all compiler information.
+  set(CMAKE_CXX_COMPILER_WORKS TRUE)
+  return()
+endif()
+
 include(CMakeTestCompilerCommon)
 
+# Remove any cached result from an older CMake version.
+# We now store this in CMakeCXXCompiler.cmake.
+unset(CMAKE_CXX_COMPILER_WORKS CACHE)
+
 # This file is used by EnableLanguage in cmGlobalGenerator to
 # determine that that selected C++ compiler can actually compile
 # and link the most basic of programs.   If not, a fatal error
@@ -29,6 +40,9 @@ if(NOT CMAKE_CXX_COMPILER_WORKS)
   try_compile(CMAKE_CXX_COMPILER_WORKS ${CMAKE_BINARY_DIR}
     ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeTmp/testCXXCompiler.cxx
     OUTPUT_VARIABLE __CMAKE_CXX_COMPILER_OUTPUT)
+  # Move result from cache to normal variable.
+  set(CMAKE_CXX_COMPILER_WORKS ${CMAKE_CXX_COMPILER_WORKS})
+  unset(CMAKE_CXX_COMPILER_WORKS CACHE)
   set(CXX_TEST_WAS_RUN 1)
 endif()
 
@@ -37,8 +51,8 @@ if(NOT CMAKE_CXX_COMPILER_WORKS)
   # if the compiler is broken make sure to remove the platform file
   # since Windows-cl configures both c/cxx files both need to be removed
   # when c or c++ fails
-  file(REMOVE ${CMAKE_PLATFORM_ROOT_BIN}/CMakeCPlatform.cmake )
+  file(REMOVE ${CMAKE_PLATFORM_INFO_DIR}/CMakeCPlatform.cmake )
-  file(REMOVE ${CMAKE_PLATFORM_ROOT_BIN}/CMakeCXXPlatform.cmake )
+  file(REMOVE ${CMAKE_PLATFORM_INFO_DIR}/CMakeCXXPlatform.cmake )
   file(APPEND ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeError.log
     "Determining if the CXX compiler works failed with "
     "the following output:\n${__CMAKE_CXX_COMPILER_OUTPUT}\n\n")
@@ -53,22 +67,19 @@ else()
       "Determining if the CXX compiler works passed with "
       "the following output:\n${__CMAKE_CXX_COMPILER_OUTPUT}\n\n")
   endif()
-  set(CMAKE_CXX_COMPILER_WORKS 1 CACHE INTERNAL "")
 
-  if(CMAKE_CXX_COMPILER_FORCED)
+  # Try to identify the ABI and configure it into CMakeCXXCompiler.cmake
-    # The compiler configuration was forced by the user.
+  include(${CMAKE_ROOT}/Modules/CMakeDetermineCompilerABI.cmake)
-    # Assume the user has configured all compiler information.
+  CMAKE_DETERMINE_COMPILER_ABI(CXX ${CMAKE_ROOT}/Modules/CMakeCXXCompilerABI.cpp)
-  else()
+
-    # Try to identify the ABI and configure it into CMakeCXXCompiler.cmake
+  # Re-configure to save learned information.
-    include(${CMAKE_ROOT}/Modules/CMakeDetermineCompilerABI.cmake)
+  configure_file(
-    CMAKE_DETERMINE_COMPILER_ABI(CXX ${CMAKE_ROOT}/Modules/CMakeCXXCompilerABI.cpp)
+    ${CMAKE_ROOT}/Modules/CMakeCXXCompiler.cmake.in
-    configure_file(
+    ${CMAKE_PLATFORM_INFO_DIR}/CMakeCXXCompiler.cmake
-      ${CMAKE_ROOT}/Modules/CMakeCXXCompiler.cmake.in
+    @ONLY IMMEDIATE # IMMEDIATE must be here for compatibility mode <= 2.0
-      ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeCXXCompiler.cmake
+    )
-      @ONLY IMMEDIATE # IMMEDIATE must be here for compatibility mode <= 2.0
+  include(${CMAKE_PLATFORM_INFO_DIR}/CMakeCXXCompiler.cmake)
-      )
+
-    include(${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeCXXCompiler.cmake)
-  endif()
   if(CMAKE_CXX_SIZEOF_DATA_PTR)
     foreach(f ${CMAKE_CXX_ABI_FILES})
       include(${f})

Modules/CMakeTestFortranCompiler.cmake

@@ -1,6 +1,6 @@
 
 #=============================================================================
-# Copyright 2004-2009 Kitware, Inc.
+# Copyright 2004-2012 Kitware, Inc.
 #
 # Distributed under the OSI-approved BSD License (the "License");
 # see accompanying file Copyright.txt for details.
@@ -12,8 +12,19 @@
 # (To distribute this file outside of CMake, substitute the full
 #  License text for the above reference.)
 
+if(CMAKE_Fortran_COMPILER_FORCED)
+  # The compiler configuration was forced by the user.
+  # Assume the user has configured all compiler information.
+  set(CMAKE_Fortran_COMPILER_WORKS TRUE)
+  return()
+endif()
+
 include(CMakeTestCompilerCommon)
 
+# Remove any cached result from an older CMake version.
+# We now store this in CMakeFortranCompiler.cmake.
+unset(CMAKE_Fortran_COMPILER_WORKS CACHE)
+
 # This file is used by EnableLanguage in cmGlobalGenerator to
 # determine that that selected Fortran compiler can actually compile
 # and link the most basic of programs.   If not, a fatal error
@@ -29,6 +40,9 @@ if(NOT CMAKE_Fortran_COMPILER_WORKS)
   try_compile(CMAKE_Fortran_COMPILER_WORKS ${CMAKE_BINARY_DIR}
     ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeTmp/testFortranCompiler.f
     OUTPUT_VARIABLE OUTPUT)
+  # Move result from cache to normal variable.
+  set(CMAKE_Fortran_COMPILER_WORKS ${CMAKE_Fortran_COMPILER_WORKS})
+  unset(CMAKE_Fortran_COMPILER_WORKS CACHE)
   set(FORTRAN_TEST_WAS_RUN 1)
 endif()
 
@@ -48,50 +62,46 @@ else()
       "Determining if the Fortran compiler works passed with "
       "the following output:\n${OUTPUT}\n\n")
   endif()
-  set(CMAKE_Fortran_COMPILER_WORKS 1 CACHE INTERNAL "")
 
-  if(CMAKE_Fortran_COMPILER_FORCED)
+  # Try to identify the ABI and configure it into CMakeFortranCompiler.cmake
-    # The compiler configuration was forced by the user.
+  include(${CMAKE_ROOT}/Modules/CMakeDetermineCompilerABI.cmake)
-    # Assume the user has configured all compiler information.
+  CMAKE_DETERMINE_COMPILER_ABI(Fortran ${CMAKE_ROOT}/Modules/CMakeFortranCompilerABI.F)
-  else()
-    # Try to identify the ABI and configure it into CMakeFortranCompiler.cmake
-    include(${CMAKE_ROOT}/Modules/CMakeDetermineCompilerABI.cmake)
-    CMAKE_DETERMINE_COMPILER_ABI(Fortran ${CMAKE_ROOT}/Modules/CMakeFortranCompilerABI.F)
 
-    # Test for Fortran 90 support by using an f90-specific construct.
+  # Test for Fortran 90 support by using an f90-specific construct.
-    if(NOT DEFINED CMAKE_Fortran_COMPILER_SUPPORTS_F90)
+  if(NOT DEFINED CMAKE_Fortran_COMPILER_SUPPORTS_F90)
-      message(STATUS "Checking whether ${CMAKE_Fortran_COMPILER} supports Fortran 90")
+    message(STATUS "Checking whether ${CMAKE_Fortran_COMPILER} supports Fortran 90")
-      file(WRITE ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeTmp/testFortranCompilerF90.f90 "
+    file(WRITE ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeTmp/testFortranCompilerF90.f90 "
       PROGRAM TESTFortran90
       stop = 1 ; do while ( stop .eq. 0 ) ; end do
       END PROGRAM TESTFortran90
 ")
-      try_compile(CMAKE_Fortran_COMPILER_SUPPORTS_F90 ${CMAKE_BINARY_DIR}
+    try_compile(CMAKE_Fortran_COMPILER_SUPPORTS_F90 ${CMAKE_BINARY_DIR}
-        ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeTmp/testFortranCompilerF90.f90
+      ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeTmp/testFortranCompilerF90.f90
-        OUTPUT_VARIABLE OUTPUT)
+      OUTPUT_VARIABLE OUTPUT)
-      if(CMAKE_Fortran_COMPILER_SUPPORTS_F90)
+    if(CMAKE_Fortran_COMPILER_SUPPORTS_F90)
-        message(STATUS "Checking whether ${CMAKE_Fortran_COMPILER} supports Fortran 90 -- yes")
+      message(STATUS "Checking whether ${CMAKE_Fortran_COMPILER} supports Fortran 90 -- yes")
-        file(APPEND ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeOutput.log
+      file(APPEND ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeOutput.log
-          "Determining if the Fortran compiler supports Fortran 90 passed with "
+        "Determining if the Fortran compiler supports Fortran 90 passed with "
-          "the following output:\n${OUTPUT}\n\n")
+        "the following output:\n${OUTPUT}\n\n")
-        set(CMAKE_Fortran_COMPILER_SUPPORTS_F90 1)
+      set(CMAKE_Fortran_COMPILER_SUPPORTS_F90 1)
-      else()
+    else()
-        message(STATUS "Checking whether ${CMAKE_Fortran_COMPILER} supports Fortran 90 -- no")
+      message(STATUS "Checking whether ${CMAKE_Fortran_COMPILER} supports Fortran 90 -- no")
-        file(APPEND ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeError.log
+      file(APPEND ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeError.log
-          "Determining if the Fortran compiler supports Fortran 90 failed with "
+        "Determining if the Fortran compiler supports Fortran 90 failed with "
-          "the following output:\n${OUTPUT}\n\n")
+        "the following output:\n${OUTPUT}\n\n")
-        set(CMAKE_Fortran_COMPILER_SUPPORTS_F90 0)
+      set(CMAKE_Fortran_COMPILER_SUPPORTS_F90 0)
-      endif()
-      unset(CMAKE_Fortran_COMPILER_SUPPORTS_F90 CACHE)
     endif()
-
+    unset(CMAKE_Fortran_COMPILER_SUPPORTS_F90 CACHE)
-    configure_file(
-      ${CMAKE_ROOT}/Modules/CMakeFortranCompiler.cmake.in
-      ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeFortranCompiler.cmake
-      @ONLY IMMEDIATE # IMMEDIATE must be here for compatibility mode <= 2.0
-      )
-    include(${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeFortranCompiler.cmake)
   endif()
+
+  # Re-configure to save learned information.
+  configure_file(
+    ${CMAKE_ROOT}/Modules/CMakeFortranCompiler.cmake.in
+    ${CMAKE_PLATFORM_INFO_DIR}/CMakeFortranCompiler.cmake
+    @ONLY IMMEDIATE # IMMEDIATE must be here for compatibility mode <= 2.0
+    )
+  include(${CMAKE_PLATFORM_INFO_DIR}/CMakeFortranCompiler.cmake)
+
   if(CMAKE_Fortran_SIZEOF_DATA_PTR)
     foreach(f ${CMAKE_Fortran_ABI_FILES})
       include(${f})

Modules/Platform/Windows-Intel.cmake

@@ -61,7 +61,7 @@ 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_ROOT_BIN}/CMakeIntelInformation.cmake" OPTIONAL)
+include("${CMAKE_PLATFORM_INFO_DIR}/CMakeIntelInformation.cmake" OPTIONAL)
 
 if(NOT _INTEL_XILINK_TEST_RUN)
   execute_process(COMMAND xilink /?
@@ -70,8 +70,8 @@ if(NOT _INTEL_XILINK_TEST_RUN)
   if(_XILINK_HELP MATCHES MANIFEST)
     set(_INTEL_COMPILER_SUPPORTS_MANIFEST 1)
   endif()
-  if(NOT  EXISTS "${CMAKE_PLATFORM_ROOT_BIN}/CMakeIntelInformation.cmake")
+  if(NOT  EXISTS "${CMAKE_PLATFORM_INFO_DIR}/CMakeIntelInformation.cmake")
-    file(WRITE ${CMAKE_PLATFORM_ROOT_BIN}/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})

Modules/Platform/Windows-cl.cmake

@@ -1,7 +1,7 @@
 # try to load any previously computed information for C on this platform
-include( ${CMAKE_PLATFORM_ROOT_BIN}/CMakeCPlatform.cmake OPTIONAL)
+include( ${CMAKE_PLATFORM_INFO_DIR}/CMakeCPlatform.cmake OPTIONAL)
 # try to load any previously computed information for CXX on this platform
-include( ${CMAKE_PLATFORM_ROOT_BIN}/CMakeCXXPlatform.cmake OPTIONAL)
+include( ${CMAKE_PLATFORM_INFO_DIR}/CMakeCXXPlatform.cmake OPTIONAL)
 
 set(WIN32 1)
 
@@ -242,12 +242,12 @@ set (CMAKE_MODULE_LINKER_FLAGS_RELEASE_INIT ${CMAKE_EXE_LINKER_FLAGS_RELEASE_INI
 set (CMAKE_MODULE_LINKER_FLAGS_MINSIZEREL_INIT ${CMAKE_EXE_LINKER_FLAGS_MINSIZEREL_INIT})
 
 # save computed information for this platform
-if(NOT EXISTS "${CMAKE_PLATFORM_ROOT_BIN}/CMakeCPlatform.cmake")
+if(NOT EXISTS "${CMAKE_PLATFORM_INFO_DIR}/CMakeCPlatform.cmake")
   configure_file(${CMAKE_ROOT}/Modules/Platform/Windows-cl.cmake.in
-    ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeCPlatform.cmake IMMEDIATE)
+    ${CMAKE_PLATFORM_INFO_DIR}/CMakeCPlatform.cmake IMMEDIATE)
 endif()
 
-if(NOT EXISTS "${CMAKE_PLATFORM_ROOT_BIN}/CMakeCXXPlatform.cmake")
+if(NOT EXISTS "${CMAKE_PLATFORM_INFO_DIR}/CMakeCXXPlatform.cmake")
   configure_file(${CMAKE_ROOT}/Modules/Platform/Windows-cl.cmake.in
-               ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeCXXPlatform.cmake IMMEDIATE)
+                 ${CMAKE_PLATFORM_INFO_DIR}/CMakeCXXPlatform.cmake IMMEDIATE)
 endif()

Source/cmGlobalGenerator.cxx

@@ -315,9 +315,11 @@ cmGlobalGenerator::EnableLanguage(std::vector<std::string>const& languages,
     {
     rootBin = this->ConfiguredFilesPath;
     }
+  rootBin += "/";
+  rootBin += cmVersion::GetCMakeVersion();
 
   // set the dir for parent files so they can be used by modules
-  mf->AddDefinition("CMAKE_PLATFORM_ROOT_BIN",rootBin.c_str());
+  mf->AddDefinition("CMAKE_PLATFORM_INFO_DIR",rootBin.c_str());
 
   // find and make sure CMAKE_MAKE_PROGRAM is defined
   this->FindMakeProgram(mf);
@@ -386,14 +388,7 @@ cmGlobalGenerator::EnableLanguage(std::vector<std::string>const& languages,
       // If the existing build tree was already configured with this
       // version of CMake then try to load the configured file first
       // to avoid duplicate compiler tests.
-      unsigned int cacheMajor = mf->GetCacheMajorVersion();
+      if(cmSystemTools::FileExists(fpath.c_str()))
-      unsigned int cacheMinor = mf->GetCacheMinorVersion();
-      unsigned int selfMajor = cmVersion::GetMajorVersion();
-      unsigned int selfMinor = cmVersion::GetMinorVersion();
-      if((this->CMakeInstance->GetIsInTryCompile() ||
-          (cacheMajor == 0 && cacheMinor == 0) ||
-          (selfMajor == cacheMajor && selfMinor == cacheMinor)) &&
-         cmSystemTools::FileExists(fpath.c_str()))
         {
         if(!mf->ReadListFile(0,fpath.c_str()))
           {

Source/cmake.cxx

@@ -2438,9 +2438,6 @@ int cmake::Run(const std::vector<std::string>& args, bool noconfigure)
 
   this->PreLoadCMakeFiles();
 
-  std::string systemFile = this->GetHomeOutputDirectory();
-  systemFile += "/CMakeSystem.cmake";
-
   if ( noconfigure )
     {
     return 0;

Tests/CMakeTests/ToolchainTest.cmake.in

@@ -6,7 +6,7 @@
 macro(MARK_AS_ADVANCED)
 endmacro()
 # set this to a place where we are allowed to write
-set(CMAKE_PLATFORM_ROOT_BIN "${CMAKE_CURRENT_BINARY_DIR}")
+set(CMAKE_PLATFORM_INFO_DIR "${CMAKE_CURRENT_BINARY_DIR}")
 
 # don't run the compiler detection
 set(CMAKE_C_COMPILER_ID_RUN 1)

bootstrap

@@ -160,6 +160,9 @@ CMAKE_PROBLEMATIC_FILES="\
   CMakeSystem.cmake \
   CMakeCCompiler.cmake \
   CMakeCXXCompiler.cmake \
+  */CMakeSystem.cmake \
+  */CMakeCCompiler.cmake \
+  */CMakeCXXCompiler.cmake \
   Source/cmConfigure.h \
   Source/CTest/Curl/config.h \
   Utilities/cmexpat/expatConfig.h \