[libc++] Guard __cpp_lib_constexpr_dynamic_alloc with compiler support

[ldionne]

Summary

This fix test failures in std/utilities/memory with Clang 8. Clang 8
supports the -std=c++2a flag, but does not implement
__cpp_constexpr_dynamic_alloc, so we get errors when evaluating some static
asserts in these test files.

I am not sure if the library version macro needs to depend on compiler
support, but some of the other macros already do this.

[arichardson]

• allocate_hint.pass.cpp also fails with clang 10: https://godbolt.org/z/7aKon9

[ldionne]

Thanks for looking into this. I just recently hacked up something to silence these failures on the Clang 8 builders, but I think this is better.

However, the tests like libcxx/test/std/language.support/support.limits/support.limits.general/memory.version.pass.cpp are auto-generated. You need to modify libcxx/utils/generate_feature_test_macro_components.py instead.

[arichardson]

In D91154#2408774, @ldionne wrote:

Thanks for looking into this. I just recently hacked up something to silence these failures on the Clang 8 builders, but I think this is better.

However, the tests like libcxx/test/std/language.support/support.limits/support.limits.general/memory.version.pass.cpp are auto-generated. You need to modify libcxx/utils/generate_feature_test_macro_components.py instead.

Will do. I clearly can't read, it even says so in the first few lines of that file...

[arichardson]

• update the script instead

[ldionne]

libcxx/test/std/utilities/memory/allocator.traits/allocator.traits.members/construct.pass.cpp

172

Same as below.

libcxx/test/std/utilities/memory/allocator.traits/allocator.traits.members/destroy.pass.cpp

130

I'd much rather keep this conditioned on TEST_STD_VER. Otherwise, we're assuming that __cpp_constexpr_dynamic_alloc is defined properly, else this will never get tested.

This shouldn't be an issue since the test is disabled with older Clangs anyway.

libcxx/test/std/utilities/memory/default.allocator/allocator.members/allocate.pass.cpp

80

Same.

[arichardson]

rebase

libcxx/utils/generate_feature_test_macro_components.py

1 ↗

(On Diff #315334)

I made this change because running the script failed with python2.7

[ldionne]

I'm not a big fan of making __cpp_lib_constexpr_dynamic_alloc depend on __cpp_constexpr_dynamic_alloc. I'd rather we assume the compiler provides the right support when C++20 is enabled, since this simplifies everything. But since we currently claim to support older compilers, let's make this change.

[ldionne]

Abandoning since we don't support Clang 8 anymore.

libcxx/include/version

 #   define __cpp_lib_atomic_wait                        201907L
 # endif
 // # define __cpp_lib_bind_front                           201811L
 // # define __cpp_lib_bit_cast                             201806L
 # if !defined(_LIBCPP_NO_HAS_CHAR8_T)
 #   define __cpp_lib_char8_t                            201811L
 # endif
 // # define __cpp_lib_concepts                             201806L
-# define __cpp_lib_constexpr_dynamic_alloc              201907L
+# if defined(__cpp_constexpr_dynamic_alloc)
+#   define __cpp_lib_constexpr_dynamic_alloc            201907L
+# endif
 // # define __cpp_lib_constexpr_misc                       201811L
 // # define __cpp_lib_constexpr_swap_algorithms            201806L
 # define __cpp_lib_constexpr_utility                    201811L
 # if _LIBCPP_STD_VER > 17 && defined(__cpp_impl_destroying_delete) && __cpp_impl_destroying_delete >= 201806L
 #   define __cpp_lib_destroying_delete                  201806L
 # endif
 # define __cpp_lib_endian                               201907L
 # define __cpp_lib_erase_if                             202002L

libcxx/test/std/language.support/support.limits/support.limits.general/memory.version.pass.cpp

 #     error "__cpp_lib_atomic_value_initialization should have the value 201911L in c++2a"
 #   endif
 # else // _LIBCPP_VERSION
 #   ifdef __cpp_lib_atomic_value_initialization
 #     error "__cpp_lib_atomic_value_initialization should not be defined because it is unimplemented in libc++!"
 #   endif
 # endif
 
-# ifndef __cpp_lib_constexpr_dynamic_alloc
-#   error "__cpp_lib_constexpr_dynamic_alloc should be defined in c++2a"
-# endif
-# if __cpp_lib_constexpr_dynamic_alloc != 201907L
-#   error "__cpp_lib_constexpr_dynamic_alloc should have the value 201907L in c++2a"
-# endif
+# if !defined(__cpp_constexpr_dynamic_alloc)
+#   ifdef __cpp_lib_constexpr_dynamic_alloc
+#     error "__cpp_lib_constexpr_dynamic_alloc should be not be defined without compiler support"
+#   endif
+# else
+#   ifndef __cpp_lib_constexpr_dynamic_alloc
+#     error "__cpp_lib_constexpr_dynamic_alloc should be defined in c++2a"
+#   endif
+#   if __cpp_lib_constexpr_dynamic_alloc != 201907L
+#     error "__cpp_lib_constexpr_dynamic_alloc should have the value 201907L in c++2a"
+#   endif
+# endif
 
 # ifndef __cpp_lib_enable_shared_from_this
 #   error "__cpp_lib_enable_shared_from_this should be defined in c++2a"
 # endif
 # if __cpp_lib_enable_shared_from_this != 201603L
 #   error "__cpp_lib_enable_shared_from_this should have the value 201603L in c++2a"
 # endif
 

libcxx/test/std/language.support/support.limits/support.limits.general/version.version.pass.cpp

 #     error "__cpp_lib_concepts should have the value 201806L in c++2a"
 #   endif
 # else // _LIBCPP_VERSION
 #   ifdef __cpp_lib_concepts
 #     error "__cpp_lib_concepts should not be defined because it is unimplemented in libc++!"
 #   endif
 # endif
 
-# ifndef __cpp_lib_constexpr_dynamic_alloc
-#   error "__cpp_lib_constexpr_dynamic_alloc should be defined in c++2a"
-# endif
-# if __cpp_lib_constexpr_dynamic_alloc != 201907L
-#   error "__cpp_lib_constexpr_dynamic_alloc should have the value 201907L in c++2a"
-# endif
+# if TEST_STD_VER > 17 && defined(__cpp_constexpr_dynamic_alloc)
+#   ifndef __cpp_lib_constexpr_dynamic_alloc
+#     error "__cpp_lib_constexpr_dynamic_alloc should be defined in c++2a"
+#   endif
+#   if __cpp_lib_constexpr_dynamic_alloc != 201907L
+#     error "__cpp_lib_constexpr_dynamic_alloc should have the value 201907L in c++2a"
+#   endif
+# endif
 
 # if !defined(_LIBCPP_VERSION)
 #   ifndef __cpp_lib_constexpr_misc
 #     error "__cpp_lib_constexpr_misc should be defined in c++2a"
 #   endif
 #   if __cpp_lib_constexpr_misc != 201811L
 #     error "__cpp_lib_constexpr_misc should have the value 201811L in c++2a"
 #   endif

libcxx/test/std/utilities/memory/allocator.traits/allocator.traits.members/allocate_hint.pass.cpp

 
 // template <class Alloc>
 // struct allocator_traits
 // {
 //     static constexpr pointer allocate(allocator_type& a, size_type n, const_void_pointer hint);
 //     ...
 // };
 
+// constexpr bool test() results in "error: constexpr function never produces a
+// constant expression" before clang 11
+// UNSUPPORTED: clang-5, clang-6, clang-7, clang-8, clang-9
+
 #include <memory>
 #include <cstdint>
 #include <cassert>
 
 #include "test_macros.h"
 #include "incomplete_type_helper.h"
 
 template <class T>
#endif
 
     return true;
 }
 
 
 int main(int, char**)
 {
     test();
-#if TEST_STD_VER > 17
+#if defined(__cpp_constexpr_dynamic_alloc)
     static_assert(test());
 #endif
     return 0;
 }

libcxx/test/std/utilities/memory/allocator.traits/allocator.traits.members/construct.pass.cpp

#endif
 
     return true;
 }
 
 int main(int, char**)
 {
     test();
 
-#if TEST_STD_VER > 17
+#if defined(__cpp_constexpr_dynamic_alloc)
     static_assert(test());
 #endif
 
     return 0;
 }

libcxx/test/std/utilities/memory/allocator.traits/allocator.traits.members/destroy.pass.cpp

 // template <class Alloc>
 // struct allocator_traits
 // {
 //     template <class Ptr>
 //     static constexpr void destroy(allocator_type& a, Ptr p);
 //     ...
 // };
 
+// constexpr destructors are only supported starting with clang 10
+// UNSUPPORTED: clang-5, clang-6, clang-7, clang-8, clang-9
+
 #include <memory>
 #include <cassert>
 #include <cstddef>
 
 #include "test_macros.h"
 #include "incomplete_type_helper.h"
 
 template <class T>
TEST_CONSTEXPR_CXX20 bool test()
         std::allocator_traits<Alloc>::deallocate(alloc, pool, 1);
     }
     return true;
 }
 
 int main(int, char**)
 {
     test();
-#if TEST_STD_VER > 17
+#if defined(__cpp_constexpr_dynamic_alloc)
     static_assert(test());
 #endif
     return 0;
 }

libcxx/test/std/utilities/memory/default.allocator/allocator.members/allocate.pass.cpp

const bool ExpectAligned = IsOverAlignedType && UsingAlignedNew;
     assert(globalMemCounter.checkOutstandingNewEq(0));
     assert(globalMemCounter.checkDeleteCalledEq(1));
     assert(globalMemCounter.checkAlignedDeleteCalledEq(ExpectAligned));
     assert(globalMemCounter.checkLastDeleteAlignEq(ExpectAligned ? Align : 0));
     assert(T::constructed == 0);
   }
 }
 
-#if TEST_STD_VER > 17
+#if defined(__cpp_constexpr_dynamic_alloc)
 template <size_t Align>
 constexpr bool test_aligned_constexpr() {
     typedef AlignedType<Align> T;
     std::allocator<T> a;
     T* ap = a.allocate(3);
     a.deallocate(ap, 3);
 
     return true;
 }
 #endif
 
 int main(int, char**) {
     test_aligned<1>();
     test_aligned<2>();
     test_aligned<4>();
     test_aligned<8>();
     test_aligned<16>();
     test_aligned<MaxAligned>();
     test_aligned<OverAligned>();
     test_aligned<OverAligned * 2>();
 
-#if TEST_STD_VER > 17
+#if defined(__cpp_constexpr_dynamic_alloc)
     static_assert(test_aligned_constexpr<1>());
     static_assert(test_aligned_constexpr<2>());
     static_assert(test_aligned_constexpr<4>());
     static_assert(test_aligned_constexpr<8>());
     static_assert(test_aligned_constexpr<16>());
     static_assert(test_aligned_constexpr<MaxAligned>());
     static_assert(test_aligned_constexpr<OverAligned>());
     static_assert(test_aligned_constexpr<OverAligned * 2>());
 #endif
 
   return 0;
 }