Omit atomic_{,un}signed_lock_free if unsupported

[bcain]

Summary

On targets that have limited atomic support, e.g. ones that define
ATOMIC_*_LOCK_FREE to '1' ("sometimes lock free"), we would end up
referencing yet-undefined __libcpp_{,un}signed_lock_free.

This commit adds a guard to prevent these references for such
targets.

[ldionne]

This kooks sensible to me. I assume this is based on compiling for a funky target and it not working (and this is the fix).

Is this configuration (target, etc.) something we could run in our CI? Like is it possible to run this configuration in a Docker image or something? It would be awesome to have tests for it.

[bcain]

In D118391#3277519, @ldionne wrote:

This kooks sensible to me. I assume this is based on compiling for a funky target and it not working (and this is the fix).

Is this configuration (target, etc.) something we could run in our CI? Like is it possible to run this configuration in a Docker image or something? It would be awesome to have tests for it.

This configuration that encountered the failure is an ARMv6 baremetal target -- not sure if we can run it in the CI. @efriedma do you happen to know if all the bits required to reproduce this configuration that hit the issue downstream are present upstream? I suspect so.

[ldionne]

FWIW I would really love to have a baremetal target tested in the CI. I'd be willing to put in some work on this if you can help out, since I think there would be wide benefits for various types of users.

[efriedma]

The way to reproduce this is to build libc++ using a triple that doesn't have any lock-free atomic types. For example, arm-none-gnueabi, or armv6m-none-gnueabi, or riscv32-unknown-elf. As far as I know, all commonly used non-baremetal targets have lock-free atomics, so this is only an issue for baremetal. (e.g. riscv32-linux assumes atomics, and arm-linux uses kernel emulation of atomics.)

Internally, we use a proprietary C library, so I don't think we can really help with setting up a public buildbot.

libcxx/include/atomic

 #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_NO_LOCK_FREE_TYPES
 #endif
 
+#if !defined(_LIBCPP_NO_LOCK_FREE_TYPES)
 typedef atomic<__libcpp_signed_lock_free> atomic_signed_lock_free;
 typedef atomic<__libcpp_unsigned_lock_free> atomic_unsigned_lock_free;
+#endif
 
 #define ATOMIC_FLAG_INIT {false}
 #define ATOMIC_VAR_INIT(__v) {__v}
 
 #if _LIBCPP_STD_VER > 17 && !defined(_LIBCPP_DISABLE_DEPRECATION_WARNINGS)
 # if defined(_LIBCPP_CLANG_VER) && _LIBCPP_CLANG_VER >= 1400
 #  pragma clang deprecated(ATOMIC_FLAG_INIT)
 #  pragma clang deprecated(ATOMIC_VAR_INIT)
 # endif
 #endif // _LIBCPP_STD_VER > 17 && !defined(_LIBCPP_DISABLE_DEPRECATION_WARNINGS)
 
 _LIBCPP_END_NAMESPACE_STD
 
 #endif // _LIBCPP_ATOMIC