[test-suite] Test CUDA in C++14 mode with C++11 stdlibs.

[jlebar]

Summary

Previously (D46993) std::min/max didn't work in C++14 mode with a C++11
stdlib; we'd assumed that compiler std=c++14 implied stdlib in C++14
mode.

[tra]

External/CUDA/CMakeLists.txt

339–345 ↗

(On Diff #147225)

Looks like the file should be un-tabified.

[jlebar]

Thanks for the reviews, Art. Submitting with this change...

test-suite/trunk/External/CUDA/CMakeLists.txt

foreach(_CudaPath ${CUDA_PATHS})
 
     set(_Cuda_Libs cudart-${_CudaVersion})
     foreach(_Std IN ITEMS "c++98" "c++11" "c++14")
       set(_Std_Suffix "${_Std}")
       set(_Std_CPPFLAGS -std=${_Std})
       set(_Std_LDFLAGS -std=${_Std})
       foreach(_GccPath IN LISTS GCC_PATHS)
         get_version(_GccVersion ${_GccPath})
-        # libstdc++ seems not to support C++14 before version 5.0.
-        if(${_Std} STREQUAL "c++14" AND ${_GccVersion} VERSION_LESS "5.0")
-          continue()
-        endif()
         set(_Gcc_Suffix "libstdc++-${_GccVersion}")
         # Tell clang to use libstdc++ and where to find it.
         set(_Stdlib_CPPFLAGS -stdlib=libstdc++ -gcc-toolchain ${_GccPath})
         set(_Stdlib_LDFLAGS  -stdlib=libstdc++)
         # Add libstdc++ as link dependency.
         set(_Stdlib_Libs libstdcxx-${_GccVersion})
 
+        # libstdc++ seems not to support C++14 before version 5.0.  We still
+        # want to run in C++14 mode with old libstdc++s to test compiler C++14
+        # with stdlib C++11, but we add a -D so that our tests can detect this.
+        if (${_GccVersion} VERSION_LESS "5.0")
+          list(APPEND _Stdlib_CPPFLAGS -DSTDLIB_VERSION=2011)
+        else()
+          list(APPEND _Stdlib_CPPFLAGS -DSTDLIB_VERSION=2014)
+        endif()
+
         create_cuda_test_variant(${_Std} "${_Cuda_Suffix}-${_Std_Suffix}-${_Gcc_Suffix}")
       endforeach()
 
       if(HAVE_LIBCXX)
-  # Same as above, but for libc++
-  # Tell clang to use libc++
-  # We also need to add compiler's include path for cxxabi.h
-  get_filename_component(_compiler_path ${CMAKE_CXX_COMPILER} DIRECTORY)
-  set(_Stdlib_CPPFLAGS -stdlib=libc++ -I${_compiler_path}/../include/c++-build)
-  set(_Stdlib_LDFLAGS  -stdlib=libc++)
-  set(_Stdlib_Libs libcxx)
+        # Same as above, but for libc++
+        # Tell clang to use libc++
+        # We also need to add compiler's include path for cxxabi.h
+        get_filename_component(_compiler_path ${CMAKE_CXX_COMPILER} DIRECTORY)
+        set(_Stdlib_CPPFLAGS -stdlib=libc++ -I${_compiler_path}/../include/c++-build -DSTDLIB_VERSION=2017)
+        set(_Stdlib_LDFLAGS  -stdlib=libc++)
+        set(_Stdlib_Libs libcxx)
         create_cuda_test_variant(${_Std} "${_Cuda_Suffix}-${_Std_Suffix}-libc++")
       endif()
     endforeach()
   endforeach()
 
   # convenience target to build all CUDA tests.
   add_custom_target(cuda-tests-all DEPENDS cuda-tests-simple cuda-tests-thrust
     COMMENT "Build all CUDA tests.")

test-suite/trunk/External/CUDA/algorithm.cu

__device__ void max() {
   assert(std::max(0, 1) == 1);
 }
 
 // Clang has device-side shims implementing std::min and std::max for scalars
 // starting in C++11, but doesn't implement minimax or std::min/max on
 // initializer_lists until C++14, when it gets these for free from the standard
 // library (because they're constexpr).
 __device__ void cpp14_tests() {
-#if __cplusplus >= 201402L
+#if __cplusplus >= 201402L && STDLIB_VERSION >= 2014
   assert(std::greater<int>()(1, 0));
   assert(std::min({5, 1, 10}) == 1);
   assert(std::max({5, 1, 10}, std::less<int>()) == 10);
 
   assert(std::minmax(1, 0).first == 0);
   assert(std::minmax(1, 0).second == 1);
   assert(std::minmax({0, 10, -10, 100}, std::less<int>()).first == -10);
   assert(std::minmax({0, 10, -10, 100}, std::less<int>()).second == 100);

test-suite/trunk/External/CUDA/cmath.cu

__device__ void test_hypot()
     assert(std::hypot(3., 4) == 5);
     assert(std::hypot(3., 4.) == 5);
     assert(std::hypot(3., 4.f) == 5);
 
     assert(std::hypot(3.f, 4) == 5);
     assert(std::hypot(3.f, 4.) == 5);
     assert(std::hypot(3.f, 4.f) == 5);
 
-#if TEST_STD_VER > 14
+#if __cplusplus >= 201703L && STDLIB_VERSION >= 2017
     static_assert((std::is_same<decltype(std::hypot((float)0, (float)0, (float)0)), float>::value), "");
     static_assert((std::is_same<decltype(std::hypot((float)0, (bool)0, (float)0)), double>::value), "");
     static_assert((std::is_same<decltype(std::hypot((float)0, (unsigned short)0, (double)0)), double>::value), "");
     static_assert((std::is_same<decltype(std::hypot((float)0, (unsigned int)0)), double>::value), "");
     static_assert((std::is_same<decltype(std::hypot((float)0, (double)0, (long)0)), double>::value), "");
     static_assert((std::is_same<decltype(std::hypot((float)0, (int)0, (long long)0)), double>::value), "");
     static_assert((std::is_same<decltype(std::hypot((float)0, (int)0, (unsigned long long)0)), double>::value), "");
     static_assert((std::is_same<decltype(std::hypot((float)0, (double)0, (double)0)), double>::value), "");
     static_assert((std::is_same<decltype(std::hypot((float)0, (float)0, (double)0)), double>::value), "");
     static_assert((std::is_same<decltype(std::hypot((int)0, (int)0, (int)0)), double>::value), "");
     static_assert((std::is_same<decltype(hypot(Ambiguous(), Ambiguous(), Ambiguous())), Ambiguous>::value), "");
 
-    assert(std::hypot(2,3,6) == 7);
-    assert(std::hypot(1,4,8) == 9);
+    assert(std::hypot(2, 3, 6) == 7);
+    assert(std::hypot(1, 4, 8) == 9);
 #endif
 }
 
 __device__ void test_ilogb()
 {
     static_assert((std::is_same<decltype(std::ilogb((float)0)), int>::value), "");
     static_assert((std::is_same<decltype(std::ilogb((bool)0)), int>::value), "");
     static_assert((std::is_same<decltype(std::ilogb((unsigned short)0)), int>::value), "");

test-suite/trunk/External/CUDA/complex.cu

 //===----------------------------------------------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is dual licensed under the MIT and the University of Illinois Open
 // Source Licenses. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
-#include <assert.h>
-#include <stdio.h>
-#include <complex>
-
 // These are loosely adapted from libc++'s tests.  In general, we don't care a
 // ton about verifying the return types or results we get, on the assumption
 // that our standard library is correct. But we care deeply about calling every
 // overload of every function (so that we verify that everything compiles).
 //
 // We do care about the results of complex multiplication / division, since
 // these use code we've written.
 
+#include <stdio.h>
+
 // These tests are pretty annoying to write without C++11, so we require that.
 // In addition, these tests currently don't compile with libc++, because of the
 // issue in https://reviews.llvm.org/D25403.
 //
 // TODO: Once that issue is resolved, take out !defined(_LIBCPP_VERSION) here.
-#if __cplusplus >= 201103L && !defined(_LIBCPP_VERSION)
+//
+// In addition, these tests don't work in C++14 mode with pre-C++14 versions of
+// libstdc++ (compile errors in <complex>).
+#if __cplusplus >= 201103L && !defined(_LIBCPP_VERSION) && \
+    (__cplusplus < 201402L || STDLIB_VERSION >= 2014)
 
+#include <assert.h>
+#include <complex>
 #include <type_traits>
 
 template <class T>
 __device__ double promote(
     T, typename std::enable_if<std::is_integral<T>::value>::type* = 0);
 __device__ float promote(float);
 __device__ double promote(double);
 
for (int i : vals) {
     test_promotion_impl<double>(i);
     test_promotion_impl<int>(i);
     test_promotion_impl<unsigned>(i);
     test_promotion_impl<long long>(i);
   }
 }
 
 __device__ void test_literals() {
-#if __cplusplus >= 201402L
+#if __cplusplus >= 201402L && STDLIB_VERSION >= 2014
   using namespace std::literals::complex_literals;
 
   {
     std::complex<double> c1 = 3.0i;
     assert(c1 == std::complex<double>(0, 3.0));
     auto c2 = 3i;
     assert(c1 == c2);
   }