[libc++] [P0482] [C++20] Implement missing bits for atomic

[curdeius]

Summary

Added: ATOMIC_CHAR8_T_LOCK_FREE, atomic<char8_t>, atomic_char8_t.
http://wg21.link/P0482

[curdeius]

• Add atomic<char8_t>.

[curdeius]

• Fix tests for compilers with C++20 but without char8_t (clang < 8, gcc < 9).
• Rebase.

[curdeius]

Ready for review!
I've fixed forgotten guards for compilers that support C++20 but don't have char8_t.
Would it make sense to add one of these compilers to BuildKite premerge tests?

[ldionne]

In D91706#2410541, @curdeius wrote:

I've fixed forgotten guards for compilers that support C++20 but don't have char8_t.
Would it make sense to add one of these compilers to BuildKite premerge tests?

No, because we don't really want to support these compilers anyway. What we want to do instead is move towards a world where we build libc++ with modern compilers, usually the just-built Clang, while still supporting maybe 1 year back for other toolchain use cases.

libcxx/include/atomic

  inline constexpr auto memory_order_seq_cst = memory_order::seq_cst;
 
 template <class T> T kill_dependency(T y) noexcept;
 
 // lock-free property
 
 #define ATOMIC_BOOL_LOCK_FREE unspecified
 #define ATOMIC_CHAR_LOCK_FREE unspecified
+#define ATOMIC_CHAR8_T_LOCK_FREE unspecified // C++20
 #define ATOMIC_CHAR16_T_LOCK_FREE unspecified
 #define ATOMIC_CHAR32_T_LOCK_FREE unspecified
 #define ATOMIC_WCHAR_T_LOCK_FREE unspecified
 #define ATOMIC_SHORT_LOCK_FREE unspecified
 #define ATOMIC_INT_LOCK_FREE unspecified
 #define ATOMIC_LONG_LOCK_FREE unspecified
 #define ATOMIC_LLONG_LOCK_FREE unspecified
 #define ATOMIC_POINTER_LOCK_FREE unspecified

 typedef atomic<short>              atomic_short;
 typedef atomic<unsigned short>     atomic_ushort;
 typedef atomic<int>                atomic_int;
 typedef atomic<unsigned int>       atomic_uint;
 typedef atomic<long>               atomic_long;
 typedef atomic<unsigned long>      atomic_ulong;
 typedef atomic<long long>          atomic_llong;
 typedef atomic<unsigned long long> atomic_ullong;
+typedef atomic<char8_t>            atomic_char8_t; // C++20
 typedef atomic<char16_t>           atomic_char16_t;
 typedef atomic<char32_t>           atomic_char32_t;
 typedef atomic<wchar_t>            atomic_wchar_t;
 
 typedef atomic<int_least8_t>   atomic_int_least8_t;
 typedef atomic<uint_least8_t>  atomic_uint_least8_t;
 typedef atomic<int_least16_t>  atomic_int_least16_t;
 typedef atomic<uint_least16_t> atomic_uint_least16_t;

 _Tp kill_dependency(_Tp __y) _NOEXCEPT
 {
     return __y;
 }
 
 #if defined(__CLANG_ATOMIC_BOOL_LOCK_FREE)
 # define ATOMIC_BOOL_LOCK_FREE      __CLANG_ATOMIC_BOOL_LOCK_FREE
 # define ATOMIC_CHAR_LOCK_FREE      __CLANG_ATOMIC_CHAR_LOCK_FREE
+#ifndef _LIBCPP_NO_HAS_CHAR8_T
+# define ATOMIC_CHAR8_T_LOCK_FREE   __CLANG_ATOMIC_CHAR8_T_LOCK_FREE
+#endif
 # define ATOMIC_CHAR16_T_LOCK_FREE  __CLANG_ATOMIC_CHAR16_T_LOCK_FREE
 # define ATOMIC_CHAR32_T_LOCK_FREE  __CLANG_ATOMIC_CHAR32_T_LOCK_FREE
 # define ATOMIC_WCHAR_T_LOCK_FREE   __CLANG_ATOMIC_WCHAR_T_LOCK_FREE
 # define ATOMIC_SHORT_LOCK_FREE     __CLANG_ATOMIC_SHORT_LOCK_FREE
 # define ATOMIC_INT_LOCK_FREE       __CLANG_ATOMIC_INT_LOCK_FREE
 # define ATOMIC_LONG_LOCK_FREE      __CLANG_ATOMIC_LONG_LOCK_FREE
 # define ATOMIC_LLONG_LOCK_FREE     __CLANG_ATOMIC_LLONG_LOCK_FREE
 # define ATOMIC_POINTER_LOCK_FREE   __CLANG_ATOMIC_POINTER_LOCK_FREE
 #elif defined(__GCC_ATOMIC_BOOL_LOCK_FREE)
 # define ATOMIC_BOOL_LOCK_FREE      __GCC_ATOMIC_BOOL_LOCK_FREE
 # define ATOMIC_CHAR_LOCK_FREE      __GCC_ATOMIC_CHAR_LOCK_FREE
+#ifndef _LIBCPP_NO_HAS_CHAR8_T
+# define ATOMIC_CHAR8_T_LOCK_FREE   __GCC_ATOMIC_CHAR8_T_LOCK_FREE
+#endif
 # define ATOMIC_CHAR16_T_LOCK_FREE  __GCC_ATOMIC_CHAR16_T_LOCK_FREE
 # define ATOMIC_CHAR32_T_LOCK_FREE  __GCC_ATOMIC_CHAR32_T_LOCK_FREE
 # define ATOMIC_WCHAR_T_LOCK_FREE   __GCC_ATOMIC_WCHAR_T_LOCK_FREE
 # define ATOMIC_SHORT_LOCK_FREE     __GCC_ATOMIC_SHORT_LOCK_FREE
 # define ATOMIC_INT_LOCK_FREE       __GCC_ATOMIC_INT_LOCK_FREE
 # define ATOMIC_LONG_LOCK_FREE      __GCC_ATOMIC_LONG_LOCK_FREE
 # define ATOMIC_LLONG_LOCK_FREE     __GCC_ATOMIC_LLONG_LOCK_FREE
 # define ATOMIC_POINTER_LOCK_FREE   __GCC_ATOMIC_POINTER_LOCK_FREE

 #else
 
 template<typename _Tp> struct __cxx_is_always_lock_free { enum { __value = false }; };
 // Implementations must match the C ATOMIC_*_LOCK_FREE macro values.
 template<> struct __cxx_is_always_lock_free<bool> { enum { __value = 2 == ATOMIC_BOOL_LOCK_FREE }; };
 template<> struct __cxx_is_always_lock_free<char> { enum { __value = 2 == ATOMIC_CHAR_LOCK_FREE }; };
 template<> struct __cxx_is_always_lock_free<signed char> { enum { __value = 2 == ATOMIC_CHAR_LOCK_FREE }; };
 template<> struct __cxx_is_always_lock_free<unsigned char> { enum { __value = 2 == ATOMIC_CHAR_LOCK_FREE }; };
+#ifndef _LIBCPP_NO_HAS_CHAR8_T
+template<> struct __cxx_is_always_lock_free<char8_t> { enum { __value = 2 == ATOMIC_CHAR8_T_LOCK_FREE }; };
+#endif
 template<> struct __cxx_is_always_lock_free<char16_t> { enum { __value = 2 == ATOMIC_CHAR16_T_LOCK_FREE }; };
 template<> struct __cxx_is_always_lock_free<char32_t> { enum { __value = 2 == ATOMIC_CHAR32_T_LOCK_FREE }; };
 template<> struct __cxx_is_always_lock_free<wchar_t> { enum { __value = 2 == ATOMIC_WCHAR_T_LOCK_FREE }; };
 template<> struct __cxx_is_always_lock_free<short> { enum { __value = 2 == ATOMIC_SHORT_LOCK_FREE }; };
 template<> struct __cxx_is_always_lock_free<unsigned short> { enum { __value = 2 == ATOMIC_SHORT_LOCK_FREE }; };
 template<> struct __cxx_is_always_lock_free<int> { enum { __value = 2 == ATOMIC_INT_LOCK_FREE }; };
 template<> struct __cxx_is_always_lock_free<unsigned int> { enum { __value = 2 == ATOMIC_INT_LOCK_FREE }; };
 template<> struct __cxx_is_always_lock_free<long> { enum { __value = 2 == ATOMIC_LONG_LOCK_FREE }; };

 typedef atomic<short>              atomic_short;
 typedef atomic<unsigned short>     atomic_ushort;
 typedef atomic<int>                atomic_int;
 typedef atomic<unsigned int>       atomic_uint;
 typedef atomic<long>               atomic_long;
 typedef atomic<unsigned long>      atomic_ulong;
 typedef atomic<long long>          atomic_llong;
 typedef atomic<unsigned long long> atomic_ullong;
+#ifndef _LIBCPP_NO_HAS_CHAR8_T
+typedef atomic<char8_t>            atomic_char8_t;
+#endif
 typedef atomic<char16_t>           atomic_char16_t;
 typedef atomic<char32_t>           atomic_char32_t;
 typedef atomic<wchar_t>            atomic_wchar_t;
 
 typedef atomic<int_least8_t>   atomic_int_least8_t;
 typedef atomic<uint_least8_t>  atomic_uint_least8_t;
 typedef atomic<int_least16_t>  atomic_int_least16_t;
 typedef atomic<uint_least16_t> atomic_uint_least16_t;

libcxx/test/std/atomics/atomics.lockfree/isalwayslockfree.pass.cpp

do {                                                                         \
     typedef T type;                                                            \
     checkAlwaysLockFree<type>();                                               \
   } while (0)
 
     CHECK_ALWAYS_LOCK_FREE(bool);
     CHECK_ALWAYS_LOCK_FREE(char);
     CHECK_ALWAYS_LOCK_FREE(signed char);
     CHECK_ALWAYS_LOCK_FREE(unsigned char);
+#if TEST_STD_VER > 17 && defined(__cpp_char8_t)
+    CHECK_ALWAYS_LOCK_FREE(char8_t);
+#endif
     CHECK_ALWAYS_LOCK_FREE(char16_t);
     CHECK_ALWAYS_LOCK_FREE(char32_t);
     CHECK_ALWAYS_LOCK_FREE(wchar_t);
     CHECK_ALWAYS_LOCK_FREE(short);
     CHECK_ALWAYS_LOCK_FREE(unsigned short);
     CHECK_ALWAYS_LOCK_FREE(int);
     CHECK_ALWAYS_LOCK_FREE(unsigned int);
     CHECK_ALWAYS_LOCK_FREE(long);
#endif // __has_attribute(vector_size) && defined(_LIBCPP_VERSION)
     CHECK_ALWAYS_LOCK_FREE(struct Padding { char c; /* padding */ long long int i; });
     CHECK_ALWAYS_LOCK_FREE(union IntFloat { int i; float f; });
 
     // C macro and static constexpr must be consistent.
     static_assert(std::atomic<bool>::is_always_lock_free == (2 == ATOMIC_BOOL_LOCK_FREE), "");
     static_assert(std::atomic<char>::is_always_lock_free == (2 == ATOMIC_CHAR_LOCK_FREE), "");
     static_assert(std::atomic<signed char>::is_always_lock_free == (2 == ATOMIC_CHAR_LOCK_FREE), "");
     static_assert(std::atomic<unsigned char>::is_always_lock_free == (2 == ATOMIC_CHAR_LOCK_FREE), "");
+#if TEST_STD_VER > 17 && defined(__cpp_char8_t)
+    static_assert(std::atomic<char8_t>::is_always_lock_free == (2 == ATOMIC_CHAR8_T_LOCK_FREE), "");
+#endif
     static_assert(std::atomic<char16_t>::is_always_lock_free == (2 == ATOMIC_CHAR16_T_LOCK_FREE), "");
     static_assert(std::atomic<char32_t>::is_always_lock_free == (2 == ATOMIC_CHAR32_T_LOCK_FREE), "");
     static_assert(std::atomic<wchar_t>::is_always_lock_free == (2 == ATOMIC_WCHAR_T_LOCK_FREE), "");
     static_assert(std::atomic<short>::is_always_lock_free == (2 == ATOMIC_SHORT_LOCK_FREE), "");
     static_assert(std::atomic<unsigned short>::is_always_lock_free == (2 == ATOMIC_SHORT_LOCK_FREE), "");
     static_assert(std::atomic<int>::is_always_lock_free == (2 == ATOMIC_INT_LOCK_FREE), "");
     static_assert(std::atomic<unsigned int>::is_always_lock_free == (2 == ATOMIC_INT_LOCK_FREE), "");
     static_assert(std::atomic<long>::is_always_lock_free == (2 == ATOMIC_LONG_LOCK_FREE), "");

libcxx/test/std/atomics/atomics.lockfree/lockfree.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
 // UNSUPPORTED: libcpp-has-no-threads
 
 // <atomic>
 
 // #define ATOMIC_BOOL_LOCK_FREE unspecified
 // #define ATOMIC_CHAR_LOCK_FREE unspecified
+// #define ATOMIC_CHAR8_T_LOCK_FREE unspecified // C++20
 // #define ATOMIC_CHAR16_T_LOCK_FREE unspecified
 // #define ATOMIC_CHAR32_T_LOCK_FREE unspecified
 // #define ATOMIC_WCHAR_T_LOCK_FREE unspecified
 // #define ATOMIC_SHORT_LOCK_FREE unspecified
 // #define ATOMIC_INT_LOCK_FREE unspecified
 // #define ATOMIC_LONG_LOCK_FREE unspecified
 // #define ATOMIC_LLONG_LOCK_FREE unspecified
 // #define ATOMIC_POINTER_LOCK_FREE unspecified
 
 #include <atomic>
 #include <cassert>
 
 #include "test_macros.h"
 
 int main(int, char**)
 {
     assert(ATOMIC_BOOL_LOCK_FREE == 0 ||
            ATOMIC_BOOL_LOCK_FREE == 1 ||
            ATOMIC_BOOL_LOCK_FREE == 2);
     assert(ATOMIC_CHAR_LOCK_FREE == 0 ||
            ATOMIC_CHAR_LOCK_FREE == 1 ||
            ATOMIC_CHAR_LOCK_FREE == 2);
+#if TEST_STD_VER > 17 && defined(__cpp_char8_t)
+    assert(ATOMIC_CHAR8_T_LOCK_FREE == 0 ||
+           ATOMIC_CHAR8_T_LOCK_FREE == 1 ||
+           ATOMIC_CHAR8_T_LOCK_FREE == 2);
+#endif
     assert(ATOMIC_CHAR16_T_LOCK_FREE == 0 ||
            ATOMIC_CHAR16_T_LOCK_FREE == 1 ||
            ATOMIC_CHAR16_T_LOCK_FREE == 2);
     assert(ATOMIC_CHAR32_T_LOCK_FREE == 0 ||
            ATOMIC_CHAR32_T_LOCK_FREE == 1 ||
            ATOMIC_CHAR32_T_LOCK_FREE == 2);
     assert(ATOMIC_WCHAR_T_LOCK_FREE == 0 ||
            ATOMIC_WCHAR_T_LOCK_FREE == 1 ||

libcxx/test/std/atomics/atomics.types.generic/integral.pass.cpp

int main(int, char**)
     test<std::atomic_short, short>();
     test<std::atomic_ushort, unsigned short>();
     test<std::atomic_int, int>();
     test<std::atomic_uint, unsigned int>();
     test<std::atomic_long, long>();
     test<std::atomic_ulong, unsigned long>();
     test<std::atomic_llong, long long>();
     test<std::atomic_ullong, unsigned long long>();
+#if TEST_STD_VER > 17 && defined(__cpp_char8_t)
+    test<std::atomic_char8_t, char8_t>();
+#endif
 #ifndef _LIBCPP_HAS_NO_UNICODE_CHARS
     test<std::atomic_char16_t, char16_t>();
     test<std::atomic_char32_t, char32_t>();
 #endif  // _LIBCPP_HAS_NO_UNICODE_CHARS
     test<std::atomic_wchar_t, wchar_t>();
 
     test<std::atomic_int8_t,    int8_t>();
     test<std::atomic_uint8_t,  uint8_t>();

libcxx/test/std/atomics/atomics.types.generic/integral_typedefs.pass.cpp

 // typedef atomic<short>              atomic_short;
 // typedef atomic<unsigned short>     atomic_ushort;
 // typedef atomic<int>                atomic_int;
 // typedef atomic<unsigned int>       atomic_uint;
 // typedef atomic<long>               atomic_long;
 // typedef atomic<unsigned long>      atomic_ulong;
 // typedef atomic<long long>          atomic_llong;
 // typedef atomic<unsigned long long> atomic_ullong;
+// typedef atomic<char8_t>            atomic_char8_t; // C++20
 // typedef atomic<char16_t>           atomic_char16_t;
 // typedef atomic<char32_t>           atomic_char32_t;
 // typedef atomic<wchar_t>            atomic_wchar_t;
 //
 // typedef atomic<intptr_t>           atomic_intptr_t;
 // typedef atomic<uintptr_t>          atomic_uintptr_t;
 //
 // typedef atomic<int8_t>             atomic_int8_t;
int main(int, char**)
     static_assert((std::is_same<std::atomic<unsigned short>, std::atomic_ushort>::value), "");
     static_assert((std::is_same<std::atomic<int>, std::atomic_int>::value), "");
     static_assert((std::is_same<std::atomic<unsigned int>, std::atomic_uint>::value), "");
     static_assert((std::is_same<std::atomic<long>, std::atomic_long>::value), "");
     static_assert((std::is_same<std::atomic<unsigned long>, std::atomic_ulong>::value), "");
     static_assert((std::is_same<std::atomic<long long>, std::atomic_llong>::value), "");
     static_assert((std::is_same<std::atomic<unsigned long long>, std::atomic_ullong>::value), "");
     static_assert((std::is_same<std::atomic<wchar_t>, std::atomic_wchar_t>::value), "");
+#if TEST_STD_VER > 17 && defined(__cpp_char8_t)
+    static_assert((std::is_same<std::atomic<char8_t>, std::atomic_char8_t>::value), "");
+#endif
 #ifndef _LIBCPP_HAS_NO_UNICODE_CHARS
     static_assert((std::is_same<std::atomic<char16_t>, std::atomic_char16_t>::value), "");
     static_assert((std::is_same<std::atomic<char32_t>, std::atomic_char32_t>::value), "");
 #endif  // _LIBCPP_HAS_NO_UNICODE_CHARS
 
 //  Added by LWG 2441
     static_assert((std::is_same<std::atomic<intptr_t>,  std::atomic_intptr_t>::value), "");
     static_assert((std::is_same<std::atomic<uintptr_t>, std::atomic_uintptr_t>::value), "");

libcxx/test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_helpers.h

void operator()() const {
         TestFunctor<unsigned short>()();
         TestFunctor<int>()();
         TestFunctor<unsigned int>()();
         TestFunctor<long>()();
         TestFunctor<unsigned long>()();
         TestFunctor<long long>()();
         TestFunctor<unsigned long long>()();
         TestFunctor<wchar_t>();
+#if TEST_STD_VER > 17 && defined(__cpp_char8_t)
+        TestFunctor<char8_t>()();
+#endif
 #ifndef _LIBCPP_HAS_NO_UNICODE_CHARS
         TestFunctor<char16_t>()();
         TestFunctor<char32_t>()();
 #endif
         TestFunctor<  int8_t>()();
         TestFunctor< uint8_t>()();
         TestFunctor< int16_t>()();
         TestFunctor<uint16_t>()();

libcxx/test/std/atomics/types.pass.cpp

int main(int, char**)
     test<short>              ();
     test<unsigned short>     ();
     test<int>                ();
     test<unsigned int>       ();
     test<long>               ();
     test<unsigned long>      ();
     test<long long>          ();
     test<unsigned long long> ();
+#if TEST_STD_VER > 17 && defined(__cpp_char8_t)
+    test<char8_t>            ();
+#endif
     test<char16_t>           ();
     test<char32_t>           ();
     test<wchar_t>            ();
 
     test<int_least8_t>   ();
     test<uint_least8_t>  ();
     test<int_least16_t>  ();
     test<uint_least16_t> ();