[libcxx] Update the way the -std= flag is chosen by CMake and LibcxxTestFormat

[EricWF]

Summary

This patch does two things:
CMake Update:

• Add compiler flag checks for -std=c++11 and -std=c++1y and remove check for -std=c++0x.
• Add configuration option LIBCXX_ENABLE_CXX1Y to prevent/allow -std=c++1y from being chosen as the std version. LIBCXX_ENABLE_CXX1Y is set to OFF by default.
• if LIBCXX_ENABLE_CXX1Y is enabled then set LIBCXX_STD_VERSION to c++1y and fail if the compiler does not support -std=c++1y
• If c++1y is not enabled then use c++11 and fail if the compiler does not support c++11.

Lit Update:

• Update lit.site.cfg.in to capture LIBCXX_STD_VERSION information as config.std.
• Remove mentions of has_cxx0X configuration option.
• Check for `--param std=X' passed to lit on the command line.
• Choose the std for the tests either from command line parameter or (if it doesn't exist) the lit.site.cfg.

[EricWF]

CMakeLists.txt

46

Should this be on by default?

test/lit.cfg

210

I am going to change this to omit the version flag as opposed to defaulting to c++0x. If the version flag was empty then no suitable version flag was found by CMake.

[EricWF]

Added the ability for the user to override the -std=<version> flag used by lit on the command line by passing --param std=<version>.

[danalbert]

CMakeLists.txt

193

Should the else case be an error? Can libc++ be compiled with less than c++0x?

[EricWF]

Add error message during configuration if the CMakeLists.txt cannot find standards version >= c++0x.

I also fixed misnamed flag options.

[mclow.lists]

I would prefer to just drop the whole "c++0x" case. That was a placeholder until c++11 was approved; which happened three years ago.

I'm pretty sure that the LLVM build system just uses "-std=c++11" to build clang.

[EricWF]

I've dropped support for C++0x.

This patch is somewhat related to this bug. If this patch is merged the CMake build system will require that libc++ be built with c++11 or greater.
http://llvm.org/bugs/show_bug.cgi?id=13081

[mclow.lists]

I'm fine with dropping the ability to build libc++ with a C++03 compiler.
[ I'm *not* fine with dropping the ability to use libc++ from c++03 code ]

Responsible opposing viewpoints... ?

[rnk]

In D4329#18, @mclow.lists wrote:

I'm fine with dropping the ability to build libc++ with a C++03 compiler.
[ I'm *not* fine with dropping the ability to use libc++ from c++03 code ]

Responsible opposing viewpoints... ?

Albert, is the Android NDK version of GCC new enough?

[ajwong]

In D4329#19, @rnk wrote:

In D4329#18, @mclow.lists wrote:

I'm fine with dropping the ability to build libc++ with a C++03 compiler.
[ I'm *not* fine with dropping the ability to use libc++ from c++03 code ]

Responsible opposing viewpoints... ?

Albert, is the Android NDK version of GCC new enough?

NDK has both gcc-4.6 and gcc-4.8. I think we only expect libc++ to work with gcc-4.8 so we're probably okay. Let me verify with Andrew Hseih, head of android NDK. He's in Taiwan though so it'll be a few hours before he responds.

[ajwong]

In D4329#22, @ajwong wrote:

In D4329#19, @rnk wrote:

In D4329#18, @mclow.lists wrote:

I'm fine with dropping the ability to build libc++ with a C++03 compiler.
[ I'm *not* fine with dropping the ability to use libc++ from c++03 code ]

Responsible opposing viewpoints... ?

Albert, is the Android NDK version of GCC new enough?

NDK has both gcc-4.6 and gcc-4.8. I think we only expect libc++ to work with gcc-4.8 so we're probably okay. Let me verify with Andrew Hseih, head of android NDK. He's in Taiwan though so it'll be a few hours before he responds.

Verified that we're only supporting gcc >= 4.8. Android NDK should be fine. :)

[EricWF]

I don't think libc++ currently builds in C++03 mode anyway. I've tried building it with GCC 4.8 and Clang 3.4 with no version flag and both compilers fail to build future.cpp, hash.cpp and shared_mutex.cpp.

[EricWF]

Change the default value for LIBCXX_ENABLE_CXX1Y to OFF instead of ON. GCC does not support the relaxed constexpr rules to compile libc++ as C++1y.

(Also a gentle ping)

[mclow.lists]

This looks fine to me, and builds w/o any problems on my (Mac OSX) system.

[EricWF]

Any outstanding corrections or suggestions?

[EricWF]

Rework patch and update patch summary.

[EricWF]

Remove dead code in test/CMakeLists.txt

[danalbert]

CMakeLists.txt

197

I think the case of LIBCXX_ENABLE_CXX1Y && !LIBCXX_HAS_STDCXX1Y_FLAG should raise an error, not fall back to C++11.

test/lit.cfg

311

It wouldn't be inferred, since it was defined by the user. I also don't think we need to be asserting on the line above. If std isn't defined either from the command line or from lit.site.cfg, we should probably just not pass any -std flag to the compiler and let it do the default. Might add a lit_config.note() stating that this is happening in that case.

[EricWF]

Thanks for the notes! I'll update the way lit.cfg handles the std parameter.

CMakeLists.txt

197

If that were to be the case then we should turn LIBCXX_ENABLE_CXX1Y off by default. There is no need for CMake to fail because it can't find a c++1y flag since libc++ builds as c++11.

Selfishly I want the c++1y to be enabled by default because I'm doing a lot of work on the LFTS that requires c++1y and I don't want to specify it to run the tests.

test/lit.cfg

311

I'm not sure if we should fall back to default. The majority of the test-suite does not build unless its tested with >=c++11. I think we should instead fall back to c++11.

[EricWF]

Implement Dans suggestion for finding the std flag in lit.cfg

[danalbert]

CMakeLists.txt

197

We'll have to make that not the default for the time being then. Having cmake lie isn't an option. We might know about this non-intuitive behavior, but most people aren't going to read the cmake files and would just assume it worked. We shouldn't do a warning or other message either. There usually isn't a reason to look at the cmake output unless it fails.

test/lit.cfg

301

Yeah, this is fine. C++11 is probably a safe default these days.

[EricWF]

Implement Dan's comments regarding the c++1y flag. It is now off by default. If it is enabled CMake will fail instead of falling back on c++11. If the c++1y flag is off then c++11 will be selected. If the compiler does not support c++11 CMake will fail.

[danalbert]

LGTM.

CMakeLists.txt

 option(LIBCXX_ENABLE_ASSERTIONS "Enable assertions independent of build mode." ON)
 option(LIBCXX_ENABLE_PEDANTIC "Compile with pedantic enabled." ON)
 option(LIBCXX_ENABLE_WERROR "Fail and stop if a warning is triggered." OFF)
-option(LIBCXX_ENABLE_CXX0X "Enable -std=c++0x and use of c++0x language features if the compiler supports it." ON)
+option(LIBCXX_ENABLE_CXX1Y "Enable -std=c++1y and use of c++1y language features if the compiler supports it." OFF)
 option(LIBCXX_ENABLE_SHARED "Build libc++ as a shared library." ON)
 option(LIBCXX_INSTALL_SUPPORT_HEADERS "Install libc++ support headers." ON)
 

     list(APPEND LIBCXX_CXX_REQUIRED_FLAGS -nostdinc++)
     string(REPLACE "-stdlib=libc++" "" CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS}")
   endif()
-  if (LIBCXX_ENABLE_CXX0X AND LIBCXX_HAS_STDCXX0X_FLAG)
-    list(APPEND LIBCXX_CXX_REQUIRED_FLAGS -std=c++0x)
+  # If c++1y has been enabled then attempt to use it. Fail if it is no supported
+  # by the compiler. Otherwise choose c++11 and ensure the compiler supports it.
+  if (LIBCXX_ENABLE_CXX1Y)
+    if (LIBCXX_HAS_STDCXX1Y_FLAG)
+      set(LIBCXX_STD_VERSION c++1y)
+    else()
+      message(FATAL_ERROR "c++1y was enabled but the compiler does not support it.")
+    endif()
+  else()
+    if (LIBCXX_HAS_STDCXX11_FLAG)
+      set(LIBCXX_STD_VERSION c++11)
+    else()
+      message(FATAL_ERROR "c++11 is required by libc++ but is not supported by the compiler")
+    endif()
   endif()
+  # LIBCXX_STD_VERSION should always be set at this point.
+  list(APPEND LIBCXX_CXX_REQUIRED_FLAGS "-std=${LIBCXX_STD_VERSION}")
 endif()
 
 macro(append_if list condition var)

cmake/config-ix.cmake

 include(CheckCXXCompilerFlag)
 
 # Check compiler flags
-check_cxx_compiler_flag(-std=c++0x            LIBCXX_HAS_STDCXX0X_FLAG)
+check_cxx_compiler_flag(-std=c++11            LIBCXX_HAS_STDCXX11_FLAG)
+check_cxx_compiler_flag(-std=c++1y            LIBCXX_HAS_STDCXX1Y_FLAG)
 check_cxx_compiler_flag(-fPIC                 LIBCXX_HAS_FPIC_FLAG)
 check_cxx_compiler_flag(-nodefaultlibs        LIBCXX_HAS_NODEFAULTLIBS_FLAG)
 check_cxx_compiler_flag(-nostdinc++           LIBCXX_HAS_NOSTDINCXX_FLAG)

test/CMakeLists.txt

   set(LIBCXX_BINARY_DIR ${CMAKE_BINARY_DIR})
   set(PYTHON_EXECUTABLE ${PYTHON_EXECUTABLE})
   pythonize_bool(LIBCXX_ENABLE_SHARED)
-  pythonize_bool(LIBCXX_HAS_STDCXX0X_FLAG)
 
   set(AUTO_GEN_COMMENT "## Autogenerated by libcxx configuration.\n# Do not edit!")
 

test/lit.cfg

     if libcxx_obj_root is None:
         libcxx_obj_root = libcxx_src_root
 
-cxx_has_stdcxx0x_flag_str = lit_config.params.get('cxx_has_stdcxx0x_flag', None)
-if cxx_has_stdcxx0x_flag_str is not None:
-    if cxx_has_stdcxx0x_flag_str.lower() in ('1', 'true'):
-        cxx_has_stdcxx0x_flag = True
-    elif cxx_has_stdcxx0x_flag_str.lower() in ('', '0', 'false'):
-        cxx_has_stdcxx0x_flag = False
-    else:
-        lit_config.fatal(
-            'user parameter cxx_has_stdcxx0x_flag_str should be 0 or 1')
-else:
-    cxx_has_stdcxx0x_flag = getattr(config, 'cxx_has_stdcxx0x_flag', True)
-
 # This test suite supports testing against either the system library or the
 # locally built one; the former mode is useful for testing ABI compatibility
 # between the current headers and a shipping dynamic library.

     '-I' + libcxx_src_root + '/test/support']
 library_paths = ['-L' + libcxx_obj_root + '/lib']
 compile_flags = []
-if cxx_has_stdcxx0x_flag:
-    compile_flags += ['-std=c++0x']
+
+# Try and get the std version from the command line. Fall back to default given
+# in lit.site.cfg is not present. If default is not present then force c++11.
+std = lit_config.params.get('std', None)
+if std is None:
+    std = getattr(config, 'std', None)
+    if std is None:
+        std = 'c++11'
+        lit_config.note('using default std: \'-std=c++11\'')
+else:
+    lit_config.note('using user specified std: \'-std={}\''.format(std))
+compile_flags += ['-std={}'.format(std)]
 
 # Configure extra linker parameters.
 exec_env = {}

test/lit.site.cfg.in

 @AUTO_GEN_COMMENT@
 config.cxx_under_test        = "@LIBCXX_COMPILER@"
-config.cxx_has_stdcxx0x_flag = @LIBCXX_HAS_STDCXX0X_FLAG@
+config.std                   = "@LIBCXX_STD_VERSION@"
 config.libcxx_src_root       = "@LIBCXX_SOURCE_DIR@"
 config.libcxx_obj_root       = "@LIBCXX_BINARY_DIR@"
 config.python_executable     = "@PYTHON_EXECUTABLE@"