[cmake] Check the compiler version first

[rnk]

Summary

Otherwise users get messages from CheckAtomic about missing libatomic
instead of a sensible message that says "use GCC 4.7 or newer".

I structured the change along the lines of HandleLLVMStdlib.cmake, which
I'm not sure I like. I'm open to suggestions on how to make sure we do
this check early in LLVM, and do it at some point in the standalone
clang build.

[beanz]

LGTM. One comment below to be addressed before commit.

cmake/modules/CheckCompilerVersion.cmake

2 ↗

(On Diff #49566)

The comment here says clang 3.2, but below you check for 3.1. We should make that consistent.

llvm/trunk/cmake/config-ix.cmake

 if( WIN32 AND NOT CYGWIN )
   # We consider Cygwin as another Unix
   set(PURE_WINDOWS 1)
 endif()
 
 include(CheckIncludeFile)
 include(CheckIncludeFileCXX)
 include(CheckLibraryExists)
 include(CheckSymbolExists)
 include(CheckFunctionExists)
 include(CheckCXXSourceCompiles)
 include(TestBigEndian)
 
+include(CheckCompilerVersion)
 include(HandleLLVMStdlib)
 
 if( UNIX AND NOT (BEOS OR HAIKU) )
   # Used by check_symbol_exists:
   set(CMAKE_REQUIRED_LIBRARIES m)
 endif()
 # x86_64 FreeBSD 9.2 requires libcxxrt to be specified explicitly.
 if( CMAKE_SYSTEM MATCHES "FreeBSD-9.2-RELEASE" AND

llvm/trunk/cmake/modules/CheckCompilerVersion.cmake

+# Check if the host compiler is new enough. LLVM requires at least GCC 4.7,
+# MSVC 2013, or Clang 3.1.
+
+if(NOT DEFINED LLVM_COMPILER_CHECKED)
+  set(LLVM_COMPILER_CHECKED ON)
+
+  if(NOT LLVM_FORCE_USE_OLD_TOOLCHAIN)
+    if(CMAKE_CXX_COMPILER_ID STREQUAL "GNU")
+      if(CMAKE_CXX_COMPILER_VERSION VERSION_LESS 4.7)
+        message(FATAL_ERROR "Host GCC version must be at least 4.7!")
+      endif()
+    elseif(CMAKE_CXX_COMPILER_ID STREQUAL "Clang")
+      if(CMAKE_CXX_COMPILER_VERSION VERSION_LESS 3.1)
+        message(FATAL_ERROR "Host Clang version must be at least 3.1!")
+      endif()
+
+      if (CMAKE_CXX_SIMULATE_ID MATCHES "MSVC")
+        if (CMAKE_CXX_SIMULATE_VERSION VERSION_LESS 18.0)
+          message(FATAL_ERROR "Host Clang must have at least -fms-compatibility-version=18.0")
+        endif()
+        set(CLANG_CL 1)
+      elseif(NOT LLVM_ENABLE_LIBCXX)
+        # Otherwise, test that we aren't using too old of a version of libstdc++
+        # with the Clang compiler. This is tricky as there is no real way to
+        # check the version of libstdc++ directly. Instead we test for a known
+        # bug in libstdc++4.6 that is fixed in libstdc++4.7.
+        set(OLD_CMAKE_REQUIRED_FLAGS ${CMAKE_REQUIRED_FLAGS})
+        set(OLD_CMAKE_REQUIRED_LIBRARIES ${CMAKE_REQUIRED_LIBRARIES})
+        set(CMAKE_REQUIRED_FLAGS "-std=c++0x")
+        check_cxx_source_compiles("
+#include <atomic>
+std::atomic<float> x(0.0f);
+int main() { return (float)x; }"
+          LLVM_NO_OLD_LIBSTDCXX)
+        if(NOT LLVM_NO_OLD_LIBSTDCXX)
+          message(FATAL_ERROR "Host Clang must be able to find libstdc++4.7 or newer!")
+        endif()
+        set(CMAKE_REQUIRED_FLAGS ${OLD_CMAKE_REQUIRED_FLAGS})
+        set(CMAKE_REQUIRED_LIBRARIES ${OLD_CMAKE_REQUIRED_LIBRARIES})
+      endif()
+    elseif(CMAKE_CXX_COMPILER_ID MATCHES "MSVC")
+      if(CMAKE_CXX_COMPILER_VERSION VERSION_LESS 18.0)
+        message(FATAL_ERROR "Host Visual Studio must be at least 2013")
+      elseif(CMAKE_CXX_COMPILER_VERSION VERSION_LESS 18.0.31101)
+        message(WARNING "Host Visual Studio should at least be 2013 Update 4 (MSVC 18.0.31101)"
+          "  due to miscompiles from earlier versions")
+      endif()
+    endif()
+  endif()
+endif()

llvm/trunk/cmake/modules/HandleLLVMOptions.cmake

 # This CMake module is responsible for interpreting the user defined LLVM_
 # options and executing the appropriate CMake commands to realize the users'
 # selections.
 
 # This is commonly needed so make sure it's defined before we include anything
 # else.
 string(TOUPPER "${CMAKE_BUILD_TYPE}" uppercase_CMAKE_BUILD_TYPE)
 
+include(CheckCompilerVersion)
 include(HandleLLVMStdlib)
 include(AddLLVMDefinitions)
 include(CheckCCompilerFlag)
 include(CheckCXXCompilerFlag)
 
-if(NOT LLVM_FORCE_USE_OLD_TOOLCHAIN)
-  if(CMAKE_CXX_COMPILER_ID STREQUAL "GNU")
-    if(CMAKE_CXX_COMPILER_VERSION VERSION_LESS 4.7)
-      message(FATAL_ERROR "Host GCC version must be at least 4.7!")
-    endif()
-  elseif(CMAKE_CXX_COMPILER_ID STREQUAL "Clang")
-    if(CMAKE_CXX_COMPILER_VERSION VERSION_LESS 3.1)
-      message(FATAL_ERROR "Host Clang version must be at least 3.1!")
-    endif()
-
-    if (CMAKE_CXX_SIMULATE_ID MATCHES "MSVC")
-      if (CMAKE_CXX_SIMULATE_VERSION VERSION_LESS 18.0)
-        message(FATAL_ERROR "Host Clang must have at least -fms-compatibility-version=18.0")
-      endif()
-      set(CLANG_CL 1)
-    elseif(NOT LLVM_ENABLE_LIBCXX)
-      # Otherwise, test that we aren't using too old of a version of libstdc++
-      # with the Clang compiler. This is tricky as there is no real way to
-      # check the version of libstdc++ directly. Instead we test for a known
-      # bug in libstdc++4.6 that is fixed in libstdc++4.7.
-      set(OLD_CMAKE_REQUIRED_FLAGS ${CMAKE_REQUIRED_FLAGS})
-      set(OLD_CMAKE_REQUIRED_LIBRARIES ${CMAKE_REQUIRED_LIBRARIES})
-      set(CMAKE_REQUIRED_FLAGS "-std=c++0x")
-      check_cxx_source_compiles("
-#include <atomic>
-std::atomic<float> x(0.0f);
-int main() { return (float)x; }"
-        LLVM_NO_OLD_LIBSTDCXX)
-      if(NOT LLVM_NO_OLD_LIBSTDCXX)
-        message(FATAL_ERROR "Host Clang must be able to find libstdc++4.7 or newer!")
-      endif()
-      set(CMAKE_REQUIRED_FLAGS ${OLD_CMAKE_REQUIRED_FLAGS})
-      set(CMAKE_REQUIRED_LIBRARIES ${OLD_CMAKE_REQUIRED_LIBRARIES})
-    endif()
-  elseif(CMAKE_CXX_COMPILER_ID MATCHES "MSVC")
-    if(CMAKE_CXX_COMPILER_VERSION VERSION_LESS 18.0)
-      message(FATAL_ERROR "Host Visual Studio must be at least 2013")
-    elseif(CMAKE_CXX_COMPILER_VERSION VERSION_LESS 18.0.31101)
-      message(WARNING "Host Visual Studio should at least be 2013 Update 4 (MSVC 18.0.31101)"
-        "  due to miscompiles from earlier versions")
-    endif()
-  endif()
-endif()
 
 if (CMAKE_LINKER MATCHES "lld-link.exe")
   # Pass /MANIFEST:NO so that CMake doesn't run mt.exe on our binaries.  Adding
   # manifests with mt.exe breaks LLD's symbol tables and takes as much time as
   # the link. See PR24476.
   append("/MANIFEST:NO"
     CMAKE_EXE_LINKER_FLAGS CMAKE_MODULE_LINKER_FLAGS CMAKE_SHARED_LINKER_FLAGS)
 endif()