[NFC] Factor out + document build requirements

[jfb]

Summary

This change factors out compiler checking / warning, and documents LLVM_FORCE_USE_OLD_TOOLCHAIN. It doesn't introduce any functional changes nor policy changes, these will come late.

[mehdi_amini]

LGTM.

cmake/modules/CheckCompilerVersion.cmake

21

(I assume the message will be updated later)

63

(spurious?)

[jfb]

cmake/modules/CheckCompilerVersion.cmake

21

That's my intent, yes. I'm trying to make the future diff smaller with this patch.

63

I added it on purpose, it made the flow easier to read IMO. Not that CMake is ever easy or nice to read 😭

[smeenai]

cmake/modules/CheckCompilerVersion.cmake

11–12

Did you really mean these to be the same as CLANG_MIN and CLANG_WARN?

17

You could invert this condition and do an early return instead, which would reduce the remainder of the function by one indent level.

[erichkeane]

I think this is a good start. That said, this is also a bug-fix (not exactly NFC), since it adds the Clang check to AppleClang.

cmake/modules/CheckCompilerVersion.cmake

11–12

According to this: https://gist.github.com/yamaya/2924292 those are the same versions. AppleClang 3.1 IS Clang 3.1.

[jfb]

• Use early return.

[jfb]

cmake/modules/CheckCompilerVersion.cmake

11–12

Right, this is on purpose. The divergence in version numbers came later.

17

Much nicer, thanks!

[russell.gallop]

llvm/trunk/cmake/modules/CheckCompilerVersion.cmake

44 ↗

(On Diff #182151)

I think that this should report *SIMULATE* VERSION rather than *COMPILER* version. i.e.
message(FATAL_ERROR "Host Clang must have at least -fms-compatibility-version=${MSVC_MIN}, your version is ${CMAKE_CXX_SIMULATE_VERSION}.")

cmake/modules/CheckCompilerVersion.cmake

-# Check if the host compiler is new enough. LLVM requires at least GCC 4.8,
-# MSVC 2015 (Update 3), or Clang 3.1.
+# Check if the host compiler is new enough.
+# These versions are updated based on the following policy:
+#   llvm.org/docs/GettingStarted.html#host-c-toolchain-both-compiler-and-standard-library
 
 include(CheckCXXSourceCompiles)
 
-if(NOT DEFINED LLVM_COMPILER_CHECKED)
-  set(LLVM_COMPILER_CHECKED ON)
+set(GCC_MIN 4.8)
+set(GCC_WARN 4.8)
+set(CLANG_MIN 3.1)
+set(CLANG_WARN 3.1)
+set(APPLECLANG_MIN 3.1)
+set(APPLECLANG_WARN 3.1)
+set(MSVC_MIN 19.0)
+set(MSVC_WARN 19.00.24213.1)
+
+if(DEFINED LLVM_COMPILER_CHECKED)
+  return()
+endif()
 
-  if(NOT LLVM_FORCE_USE_OLD_TOOLCHAIN)
-    if(CMAKE_CXX_COMPILER_ID STREQUAL "GNU")
-      if(CMAKE_CXX_COMPILER_VERSION VERSION_LESS 4.8)
-        message(FATAL_ERROR "Host GCC version must be at least 4.8!")
-      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(LLVM_FORCE_USE_OLD_TOOLCHAIN)
+  return()
+endif()
+
+function(check_compiler_version NAME NICE_NAME MINIMUM_VERSION WARN_VERSION)
+  if(NOT CMAKE_CXX_COMPILER_ID STREQUAL NAME)
+    return()
+  endif()
+  if(CMAKE_CXX_COMPILER_VERSION VERSION_LESS MINIMUM_VERSION)
+    message(FATAL_ERROR "Host ${NICE_NAME} version must be at least ${MINIMUM_VERSION}, your version is ${CMAKE_CXX_COMPILER_VERSION}.")
+  elseif(CMAKE_CXX_COMPILER_VERSION VERSION_LESS WARN_VERSION)
+    message(WARNING "Host ${NICE_NAME} version must be at least ${WARN_VERSION} due to miscompiles from earlier versions, your version is ${CMAKE_CXX_COMPILER_VERSION}.")
+endfunction(check_compiler_version)
 
-      if (CMAKE_CXX_SIMULATE_ID MATCHES "MSVC")
-        if (CMAKE_CXX_SIMULATE_VERSION VERSION_LESS 19.0)
-          message(FATAL_ERROR "Host Clang must have at least -fms-compatibility-version=19.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 "${CMAKE_REQUIRED_FLAGS} -std=c++0x")
-        check_cxx_source_compiles("
+check_compiler_version("GNU" "GCC" ${GCC_MIN} ${GCC_WARN})
+check_compiler_version("Clang" "Clang" ${CLANG_MIN} ${CLANG_WARN})
+check_compiler_version("AppleClang" "Apple Clang" ${APPLECLANG_MIN} ${APPLECLANG_WARN})
+check_compiler_version("MSVC" "Visual Studio" ${MSVC_MIN} ${MSVC_WARN})
+
+if(CMAKE_CXX_COMPILER_ID STREQUAL "Clang")
+    if (CMAKE_CXX_SIMULATE_VERSION VERSION_LESS MSVC_MIN)
+      message(FATAL_ERROR "Host Clang must have at least -fms-compatibility-version=${MSVC_MIN}, your version is ${CMAKE_CXX_COMPILER_VERSION}.")
+    # Test that we aren't using too old of a version of libstdc++
 #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.8 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 19.0)
-        message(FATAL_ERROR "Host Visual Studio must be at least 2015")
-      elseif(CMAKE_CXX_COMPILER_VERSION VERSION_LESS 19.00.24213.1)
-        message(WARNING "Host Visual Studio should at least be 2015 Update 3 (MSVC 19.00.24213.1)"
-          "  due to miscompiles from earlier versions")
-      endif()
-    endif()
-  endif()
 endif()

docs/CMake.rst

 **LLVM_CCACHE_BUILD**:BOOL
   If enabled and the ``ccache`` program is available, then LLVM will be
   built using ``ccache`` to speed up rebuilds of LLVM and its components.
   Defaults to OFF.  The size and location of the cache maintained
   by ``ccache`` can be adjusted via the LLVM_CCACHE_MAXSIZE and LLVM_CCACHE_DIR
   options, which are passed to the CCACHE_MAXSIZE and CCACHE_DIR environment
   variables, respectively.
 
+**LLVM_FORCE_USE_OLD_TOOLCHAIN**:BOOL
+  If enabled, the compiler and standard library versions won't be checked. LLVM
+  may not compile at all, or might fail at runtime due to known bugs in these
+  toolchains.
+
 CMake Caches
 ============
 
 Recently LLVM and Clang have been adding some more complicated build system
 features. Utilizing these new features often involves a complicated chain of
 CMake variables passed on the command line. Clang provides a collection of CMake
 cache scripts to make these features more approachable.