[compiler-rt] Avoid pulling libatomic to sanitizer tests

[krytarowski]

Summary

Avoid fallbacking to software emulated compiler atomics, that are usually
provided by libatomic, which is not always present.

This fixes the test on NetBSD, which does not provide libatomic in base.

[vitalybuka]

this is about test
how can you avoid this in runtime code?

[krytarowski]

std::atomic_is_lock_free or an reimplementation of it (without pulling C++ runtime), testing a type and asserting that in runtime or build time that it is lockfree.

https://en.cppreference.com/w/cpp/atomic/atomic_is_lock_free

[vitalybuka]

In D87568#2269792, @krytarowski wrote:

std::atomic_is_lock_free or an reimplementation of it (without pulling C++ runtime), testing a type and asserting that in runtime or build time that it is lockfree.

https://en.cppreference.com/w/cpp/atomic/atomic_is_lock_free

I mean the existing compiler-rt code already has atomic_uint64_t, do we need to do something about it?

[vitalybuka]

compiler-rt/lib/sanitizer_common/tests/sanitizer_atomic_test.cpp

76

Not for this patch but these tests must be TYPED_TEST_P

compiler-rt/lib/sanitizer_common/tests/sanitizer_atomic_test.cpp

 //===-- sanitizer_atomic_test.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
 //
 //===----------------------------------------------------------------------===//
 //
 // This file is a part of ThreadSanitizer/AddressSanitizer runtime.
 //
 //===----------------------------------------------------------------------===//
 #include "sanitizer_common/sanitizer_atomic.h"
 #include "gtest/gtest.h"
 
+#ifndef __has_extension
+#define __has_extension(x) 0
+#endif
+
+#if __has_extension(c_atomic) || __has_extension(cxx_atomic)
+#define ATOMIC_LLONG_LOCK_FREE __CLANG_ATOMIC_LLONG_LOCK_FREE
+#elif (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 7))
+#define ATOMIC_LLONG_LOCK_FREE __GCC_ATOMIC_LLONG_LOCK_FREE
+#else
+#error Unsupported compiler.
+#endif
+
 namespace __sanitizer {
 
 template<typename T>
 struct ValAndMagic {
   typename T::Type magic0;
   T a;
   typename T::Type magic1;
 
TEST(SanitizerCommon, AtomicStoreLoad) {
   CheckStoreLoad<atomic_uint8_t, memory_order_acquire, memory_order_relaxed>();
   CheckStoreLoad<atomic_uint8_t, memory_order_relaxed, memory_order_release>();
   CheckStoreLoad<atomic_uint8_t, memory_order_seq_cst, memory_order_seq_cst>();
 
   CheckStoreLoad<atomic_uint16_t, memory_order_relaxed, memory_order_relaxed>();
   CheckStoreLoad<atomic_uint16_t, memory_order_consume, memory_order_relaxed>();
   CheckStoreLoad<atomic_uint16_t, memory_order_acquire, memory_order_relaxed>();
   CheckStoreLoad<atomic_uint16_t, memory_order_relaxed, memory_order_release>();
   CheckStoreLoad<atomic_uint16_t, memory_order_seq_cst, memory_order_seq_cst>();
 
   CheckStoreLoad<atomic_uint32_t, memory_order_relaxed, memory_order_relaxed>();
   CheckStoreLoad<atomic_uint32_t, memory_order_consume, memory_order_relaxed>();
   CheckStoreLoad<atomic_uint32_t, memory_order_acquire, memory_order_relaxed>();
   CheckStoreLoad<atomic_uint32_t, memory_order_relaxed, memory_order_release>();
   CheckStoreLoad<atomic_uint32_t, memory_order_seq_cst, memory_order_seq_cst>();
 
+  // Avoid fallbacking to software emulated compiler atomics, that are usually
+  // provided by libatomic, which is not always present.
+#if ATOMIC_LLONG_LOCK_FREE == 2
   CheckStoreLoad<atomic_uint64_t, memory_order_relaxed, memory_order_relaxed>();
   CheckStoreLoad<atomic_uint64_t, memory_order_consume, memory_order_relaxed>();
   CheckStoreLoad<atomic_uint64_t, memory_order_acquire, memory_order_relaxed>();
   CheckStoreLoad<atomic_uint64_t, memory_order_relaxed, memory_order_release>();
   CheckStoreLoad<atomic_uint64_t, memory_order_seq_cst, memory_order_seq_cst>();
+#endif
 
   CheckStoreLoad<atomic_uintptr_t, memory_order_relaxed, memory_order_relaxed>
       ();
   CheckStoreLoad<atomic_uintptr_t, memory_order_consume, memory_order_relaxed>
       ();
   CheckStoreLoad<atomic_uintptr_t, memory_order_acquire, memory_order_relaxed>
       ();
   CheckStoreLoad<atomic_uintptr_t, memory_order_relaxed, memory_order_release>
typedef typename T::Type Type;
     EXPECT_EQ(new_val, old_val);
   }
 }
 
 TEST(SanitizerCommon, AtomicCompareExchangeTest) {
   CheckAtomicCompareExchange<atomic_uint8_t>();
   CheckAtomicCompareExchange<atomic_uint16_t>();
   CheckAtomicCompareExchange<atomic_uint32_t>();
+#if ATOMIC_LLONG_LOCK_FREE == 2
   CheckAtomicCompareExchange<atomic_uint64_t>();
+#endif
   CheckAtomicCompareExchange<atomic_uintptr_t>();
 }
 #endif  //!SANITIZER_ANDROID
 
 }  // namespace __sanitizer