[libcxx] Guard C++20 atomic type aliases

[miyuki]

Summary

The std::atomic_signed_lock_free and std::atomic_unsigned_lock_free
typedefs are a C++20 feature and should be guarded with an #if, so
that they don't get defined in C++17 and prior versions.

Also with the current implementation inclusion of the <atomic> header
will fail the compilation for targets that don't have lock-free atomic
integers (e.g. Armv6-M) because libcpp_signed_lock_free and
libcpp_unsigned_lock_free will not get defined. We should not try to
define std::atomic_signed_lock_free and std::atomic_unsigned_lock_free
in this case as well (according to [atomics.alias]/2 these typedefs
are optional in freestanding implementations).

[jfb]

Please add extensive tests, this will absolutely break in the future without them.

libcxx/include/atomic

2756

This should check that the configuration is indeed freestanding, and bail out if it's hosted.

[jfb]

Actually: how are your locks implemented to support atomic? You disable interrupts? I think you want to contribute a version of atomic which does this, instead of saying "nothing is lock free, use locks" and then doing all the magic in the locks.

[miyuki]

In D75183#1893997, @jfb wrote:

Actually: how are your locks implemented to support atomic? You disable interrupts? I think you want to contribute a version of atomic which does this, instead of saying "nothing is lock free, use locks" and then doing all the magic in the locks.

For operations used in libc++abi (atomic exchange, atomic compare-exchange) we provide weak definitions of atomic functions which work correctly in single-threaded environments. The idea is that the user will provide multithreaded versions, which would typically rely on RTOS API to disable/enable interrupts. Unfortunately the implementation is not complete.

I think I am going to abandon the patch for now.

[dim]

It's a pity this never landed. Now libc++ can't work on older arm without non-standard patches... :)

libcxx/include/atomic

 // atomic_*_lock_free : prefer the contention type most highly, then the largest lock-free type
 
 #ifdef __cpp_lib_atomic_is_always_lock_free
 # define _LIBCPP_CONTENTION_LOCK_FREE __atomic_always_lock_free(sizeof(__cxx_contention_t), 0)
 #else
 # define _LIBCPP_CONTENTION_LOCK_FREE false
 #endif
 
+#if _LIBCPP_STD_VER > 17
+
 #if ATOMIC_LLONG_LOCK_FREE == 2
 typedef conditional<_LIBCPP_CONTENTION_LOCK_FREE, __cxx_contention_t, long long>::type          __libcpp_signed_lock_free;
 typedef conditional<_LIBCPP_CONTENTION_LOCK_FREE, __cxx_contention_t, unsigned long long>::type __libcpp_unsigned_lock_free;
 #elif ATOMIC_INT_LOCK_FREE == 2
 typedef conditional<_LIBCPP_CONTENTION_LOCK_FREE, __cxx_contention_t, int>::type                __libcpp_signed_lock_free;
 typedef conditional<_LIBCPP_CONTENTION_LOCK_FREE, __cxx_contention_t, unsigned int>::type       __libcpp_unsigned_lock_free;
 #elif ATOMIC_SHORT_LOCK_FREE == 2
 typedef conditional<_LIBCPP_CONTENTION_LOCK_FREE, __cxx_contention_t, short>::type              __libcpp_signed_lock_free;
 typedef conditional<_LIBCPP_CONTENTION_LOCK_FREE, __cxx_contention_t, unsigned short>::type     __libcpp_unsigned_lock_free;
 #elif ATOMIC_CHAR_LOCK_FREE == 2
 typedef conditional<_LIBCPP_CONTENTION_LOCK_FREE, __cxx_contention_t, char>::type               __libcpp_signed_lock_free;
 typedef conditional<_LIBCPP_CONTENTION_LOCK_FREE, __cxx_contention_t, unsigned char>::type      __libcpp_unsigned_lock_free;
 #else
     // No signed/unsigned lock-free types
+# define _LIBCPP_CANNOT_DEFINE_ATOMIC_LOCK_FREE_TYPE_ALIASES
 #endif
 
+#ifndef _LIBCPP_CANNOT_DEFINE_ATOMIC_LOCK_FREE_TYPE_ALIASES
 typedef atomic<__libcpp_signed_lock_free> atomic_signed_lock_free;
 typedef atomic<__libcpp_unsigned_lock_free> atomic_unsigned_lock_free;
+#endif
+
+#endif // _LIBCPP_STD_VER > 17
 
 #define ATOMIC_FLAG_INIT {false}
 #define ATOMIC_VAR_INIT(__v) {__v}
 
 _LIBCPP_END_NAMESPACE_STD
 
 #endif  // _LIBCPP_ATOMIC