[libcxx][atomic] Remove workaround for PR31864

[lkail]

Summary

I believe the origin issue in PR31864 has been addressed by https://reviews.llvm.org/D59566.

As discussed in https://github.com/llvm/llvm-project/issues/53840, ATOMIC_LLONG_LOCK_FREE == 2 sometimes is not consistent with std::atomic<long long>::is_always_lock_free, since the macro takes long long's ABI alignment into account. https://reviews.llvm.org/D28213 proposed we should not rely on ABI alignment of types, thus we have consistent ATOMIC_LLONG_LOCK_FREE and std::atomic<long long>::is_always_lock_free on x86's old cpu. Currently, I plan to move on to remove the workaround which should have been addressed and don't want to break current tests.

[ldionne]

Looks pretty good, but I think we can dumb it down further.

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

38

We shouldn't need to check __atomic_always_lock_free at all, we're only trying to test std::atomic<T>::is_always_lock_free.

[lkail]

Ping.

[• Quuxplusone]

LGTM FWIW.

[ldionne]

Sorry, this slipped through the cracks. Too many review emails!

Thank you!

[rprichard]

I'm seeing this test fail on 32-bit x86 Linux currently because __CLANG_ATOMIC_LLONG_LOCK_FREE is still 1.

D28213 would probably fix it? It was briefly merged, but it was reverted because it broke FreeBSD. D59566 corrected MaxAtomicInlineWidth for pre-586 CPUs, which should make it possible to remerge D28213.

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

 # error Feature test macro missing.
 #endif
 
 template <typename T> void checkAlwaysLockFree() {
   if (std::atomic<T>::is_always_lock_free)
     assert(std::atomic<T>().is_lock_free());
 }
 
-// FIXME: This separate test is needed to work around llvm.org/PR31864
-// which causes ATOMIC_LLONG_LOCK_FREE to be defined as '1' in 32-bit builds
-// even though __atomic_always_lock_free returns true for the same type.
-constexpr bool NeedWorkaroundForPR31864 =
-#if defined(__clang__)
-(sizeof(void*) == 4); // Needed on 32 bit builds
-#else
-false;
-#endif
-
-template <bool Disable = NeedWorkaroundForPR31864,
-  std::enable_if_t<!Disable>* = nullptr,
-  class LLong = long long,
-  class ULLong = unsigned long long>
-void checkLongLongTypes() {
-  static_assert(std::atomic<LLong>::is_always_lock_free == (2 == ATOMIC_LLONG_LOCK_FREE), "");
-  static_assert(std::atomic<ULLong>::is_always_lock_free == (2 == ATOMIC_LLONG_LOCK_FREE), "");
-}
-
-// Used to make the calls to __atomic_always_lock_free dependent on a template
-// parameter.
-template <class T> constexpr size_t getSizeOf() { return sizeof(T); }
-
-template <bool Enable = NeedWorkaroundForPR31864,
-  std::enable_if_t<Enable>* = nullptr,
-  class LLong = long long,
-  class ULLong = unsigned long long>
-void checkLongLongTypes() {
-  constexpr bool ExpectLockFree = __atomic_always_lock_free(getSizeOf<LLong>(), 0);
-  static_assert(std::atomic<LLong>::is_always_lock_free == ExpectLockFree, "");
-  static_assert(std::atomic<ULLong>::is_always_lock_free == ExpectLockFree, "");
-  static_assert((0 != ATOMIC_LLONG_LOCK_FREE) == ExpectLockFree, "");
-}
-
 void run()
 {
 // structs and unions can't be defined in the template invocation.
 // Work around this with a typedef.
 #define CHECK_ALWAYS_LOCK_FREE(T)                                              \
   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)
#endif
     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), "");
     static_assert(std::atomic<unsigned long>::is_always_lock_free == (2 == ATOMIC_LONG_LOCK_FREE), "");
-    checkLongLongTypes();
+    static_assert(std::atomic<long long>::is_always_lock_free == (2 == ATOMIC_LLONG_LOCK_FREE), "");
+    static_assert(std::atomic<unsigned long long>::is_always_lock_free == (2 == ATOMIC_LLONG_LOCK_FREE), "");
     static_assert(std::atomic<void*>::is_always_lock_free == (2 == ATOMIC_POINTER_LOCK_FREE), "");
     static_assert(std::atomic<std::nullptr_t>::is_always_lock_free == (2 == ATOMIC_POINTER_LOCK_FREE), "");
 
 #if TEST_STD_VER >= 20
     static_assert(std::atomic_signed_lock_free::is_always_lock_free, "");
     static_assert(std::atomic_unsigned_lock_free::is_always_lock_free, "");
 #endif
 }
 
 int main(int, char**) { run(); return 0; }