[CMake] Replace LLVM_ENABLE_CXX1Y and friends with LLVM_CXX_STD

[bogner]

Summary

Simplify building with particular C++ standards by replacing the
specific "enable standard X" flags with a flag that allows specifying
the standard you want directly.

We preserve compatibility with the existing flags so that anyone with
those flags in existing caches won't break mysteriously.

[MaskRay]

Can we use CMAKE_CXX_STANDARD instead? https://cmake.org/cmake/help/latest/variable/CMAKE_CXX_STANDARD.html

[bogner]

In D60399#1458258, @MaskRay wrote:

Can we use CMAKE_CXX_STANDARD instead? https://cmake.org/cmake/help/latest/variable/CMAKE_CXX_STANDARD.html

Maybe, but that flag's behaviour is a bit complicated/surprising.

• It uses gnu++ by default instead of c++, but it looks like we could set CXX_EXTENSIONS to no to disable that. This would mean that if someone wants to use gnu++ they'll need to know about the CXX_EXTENSIONS flag, of course.
• Based on some testing, cmake doesn't really do the right thing with CMAKE_CXX_STANDARD very reliably. On cmake 3.12, at least, specifying 20 uses gnu++1z rather than gnu++2a like it should. It also seems to use gnu++1z rather than gnu++17 for 17 still, which is a bit odd but not the end of the world.

[phosek]

This broke all our builders that use the LLVM runtimes build with the following error:

-- Performing Test CXX_SUPPORTS_CXX_STD
-- Performing Test CXX_SUPPORTS_CXX_STD - Failed
CMake Error at /b/s/w/ir/k/llvm-project/llvm/cmake/modules/HandleLLVMOptions.cmake:451 (message):
  The host compiler does not support '-std='.
Call Stack (most recent call first):
  CMakeLists.txt:111 (include)


-- Configuring incomplete, errors occurred!

The full log is here: https://logs.chromium.org/logs/fuchsia/buildbucket/cr-buildbucket.appspot.com/8916679531057446976/+/steps/clang/0/steps/build/0/stdout

I suspect it's because we include HandleLLVMOptions at https://github.com/llvm/llvm-project/blob/master/llvm/runtimes/CMakeLists.txt#L111, but at that point we haven't yet compiled libc++, so any attempt to use is going to fail which is why this check is failing.

[mstorsjo]

In D60399#1459215, @phosek wrote:

This broke all our builders that use the LLVM runtimes build with the following error:

-- Performing Test CXX_SUPPORTS_CXX_STD
-- Performing Test CXX_SUPPORTS_CXX_STD - Failed
CMake Error at /b/s/w/ir/k/llvm-project/llvm/cmake/modules/HandleLLVMOptions.cmake:451 (message):
  The host compiler does not support '-std='.
Call Stack (most recent call first):
  CMakeLists.txt:111 (include)


-- Configuring incomplete, errors occurred!

The full log is here: https://logs.chromium.org/logs/fuchsia/buildbucket/cr-buildbucket.appspot.com/8916679531057446976/+/steps/clang/0/steps/build/0/stdout

I suspect it's because we include HandleLLVMOptions at https://github.com/llvm/llvm-project/blob/master/llvm/runtimes/CMakeLists.txt#L111, but at that point we haven't yet compiled libc++, so any attempt to use is going to fail which is why this check is failing.

I'm looking at the same failure in my cross-bootstrap of mingw as well.

The failure isn't due to not compiling libc++ yet, but when building individual runtime projects standalone outside of the llvm tree, HandleLLVMOptions.cmake is included in that cmake project, but not the llvm main CMake file. After this change, HandleLLVMOptions.cmake adds -std=${LLVM_CXX_STD} to the compiler options, but nothing has set ${LLVM_CXX_STD} yet, because the CMake file that sets it isn't included in standalone project builds.

[bogner]

I moved where we set the default into HandleLLVMOptions in r357976, this should fix both issues. Sorry for the breakage!

[mstorsjo]

In D60399#1459372, @bogner wrote:

I moved where we set the default into HandleLLVMOptions in r357976, this should fix both issues. Sorry for the breakage!

Thanks for fixing! That fix, together with rL357979, seems to have gotten things back in working order for me now.

llvm/trunk/CMakeLists.txt

 option(LLVM_ENABLE_MODULES "Compile with C++ modules enabled." OFF)
 if(${CMAKE_SYSTEM_NAME} MATCHES "Darwin")
   option(LLVM_ENABLE_MODULE_DEBUGGING "Compile with -gmodules." ON)
   option(LLVM_ENABLE_LOCAL_SUBMODULE_VISIBILITY "Compile with -fmodules-local-submodule-visibility." OFF)
 else()
   option(LLVM_ENABLE_MODULE_DEBUGGING "Compile with -gmodules." OFF)
   option(LLVM_ENABLE_LOCAL_SUBMODULE_VISIBILITY "Compile with -fmodules-local-submodule-visibility." ON)
 endif()
-option(LLVM_ENABLE_CXX1Y "Compile with C++1y enabled." OFF)
-option(LLVM_ENABLE_CXX1Z "Compile with C++1z enabled." OFF)
 option(LLVM_ENABLE_LIBCXX "Use libc++ if available." OFF)
 option(LLVM_ENABLE_LLD "Use lld as C and C++ linker." OFF)
 option(LLVM_ENABLE_PEDANTIC "Compile with pedantic enabled." ON)
 option(LLVM_ENABLE_WERROR "Fail and stop if a warning is triggered." OFF)
 
+set(LLVM_CXX_STD_default "c++11")
+# Preserve behaviour of legacy cache variables
+if (LLVM_ENABLE_CXX1Y)
+  set(LLVM_CXX_STD_default "c++1y")
+elseif (LLVM_ENABLE_CXX1Z)
+  set(LLVM_CXX_STD_default "c++1z")
+endif()
+set(LLVM_CXX_STD ${LLVM_CXX_STD_default}
+    CACHE STRING "C++ standard to use for compilation.")
+
 option(LLVM_ENABLE_DUMP "Enable dump functions even when assertions are disabled" OFF)
 
 if( NOT uppercase_CMAKE_BUILD_TYPE STREQUAL "DEBUG" )
   option(LLVM_ENABLE_ASSERTIONS "Enable assertions" OFF)
 else()
   option(LLVM_ENABLE_ASSERTIONS "Enable assertions" ON)
 endif()
 

llvm/trunk/cmake/modules/HandleLLVMOptions.cmake

if (CMAKE_CXX_COMPILER_ID MATCHES "Clang" AND NOT LLVM_ENABLE_LTO)
     endif()
   endif()
 
 elseif( LLVM_COMPILER_IS_GCC_COMPATIBLE )
   append_if(LLVM_ENABLE_WERROR "-Werror" CMAKE_C_FLAGS CMAKE_CXX_FLAGS)
   append_if(LLVM_ENABLE_WERROR "-Wno-error" CMAKE_REQUIRED_FLAGS)
   add_flag_if_supported("-Werror=date-time" WERROR_DATE_TIME)
   add_flag_if_supported("-Werror=unguarded-availability-new" WERROR_UNGUARDED_AVAILABILITY_NEW)
-  if (LLVM_ENABLE_CXX1Y)
-    check_cxx_compiler_flag("-std=c++1y" CXX_SUPPORTS_CXX1Y)
-    append_if(CXX_SUPPORTS_CXX1Y "-std=c++1y" CMAKE_CXX_FLAGS)
-  elseif(LLVM_ENABLE_CXX1Z)
-    check_cxx_compiler_flag("-std=c++1z" CXX_SUPPORTS_CXX1Z)
-    append_if(CXX_SUPPORTS_CXX1Z "-std=c++1z" CMAKE_CXX_FLAGS)
-  else()
-    check_cxx_compiler_flag("-std=c++11" CXX_SUPPORTS_CXX11)
-    if (CXX_SUPPORTS_CXX11)
-      if (CYGWIN OR MINGW)
-        # MinGW and Cygwin are a bit stricter and lack things like
-        # 'strdup', 'stricmp', etc in c++11 mode.
-        append("-std=gnu++11" CMAKE_CXX_FLAGS)
-      else()
-        append("-std=c++11" CMAKE_CXX_FLAGS)
-      endif()
-    else()
-      message(FATAL_ERROR "LLVM requires C++11 support but the '-std=c++11' flag isn't supported.")
-    endif()
+  check_cxx_compiler_flag("-std=${LLVM_CXX_STD}" CXX_SUPPORTS_CXX_STD)
+  if (CXX_SUPPORTS_CXX_STD)
+      string(REPLACE "c++" "gnu++" "${LLVM_CXX_STD}" gnu_LLVM_CXX_STD)
+      append("-std=${gnu_LLVM_CXX_STD}" CMAKE_CXX_FLAGS)
+      append("-std=${LLVM_CXX_STD}" CMAKE_CXX_FLAGS)
+    message(FATAL_ERROR "The host compiler does not support '-std=${LLVM_CXX_STD}'.")
   endif()
   if (LLVM_ENABLE_MODULES)
     set(OLD_CMAKE_REQUIRED_FLAGS ${CMAKE_REQUIRED_FLAGS})
     set(module_flags "-fmodules -fmodules-cache-path=${PROJECT_BINARY_DIR}/module.cache")
     if (${CMAKE_SYSTEM_NAME} MATCHES "Darwin")
       # On Darwin -fmodules does not imply -fcxx-modules.
       set(module_flags "${module_flags} -fcxx-modules")
     endif()

llvm/trunk/docs/CMake.rst

**LLVM_APPEND_VC_REV**:BOOL
   The version info is provided by the ``LLVM_REVISION`` macro in
   ``llvm/include/llvm/Support/VCSRevision.h``. Developers using git who don't
   need revision info can disable this option to avoid re-linking most binaries
   after a branch switch. Defaults to ON.
 
 **LLVM_ENABLE_THREADS**:BOOL
   Build with threads support, if available. Defaults to ON.
 
-**LLVM_ENABLE_CXX1Y**:BOOL
-  Build in C++1y mode, if available. Defaults to OFF.
+**LLVM_CXX_STD**:STRING
+  Build with the specified C++ standard. Defaults to "c++11".
 
 **LLVM_ENABLE_ASSERTIONS**:BOOL
   Enables code assertions. Defaults to ON if and only if ``CMAKE_BUILD_TYPE``
   is *Debug*.
 
 **LLVM_ENABLE_EH**:BOOL
   Build LLVM with exception-handling support. This is necessary if you wish to
   link against LLVM libraries and make use of C++ exceptions in your own code