[libcxx] Cleanup <atomic> and cleanup support for C++03.

[EricWF]

Summary

There are many places where libc++ want to use <atomic> internally in C++03 code. Unfortunately <atomic> currently only supports C++11 and later. This patch extends <atomic> so that everything except ATOMIC_VAR_INIT and ATOMIC_FLAG_INIT can be used in c++03 code.

This patch introduces the macros:

• _LIBCPP_HAS_C11_ATOMICS: Defined if __has_extension(c_atomic) is true.
• _LIBCPP_HAS_CXX_ATOMICS: Defined if we have C11 atomics from clang or the __atomic_* builtin family from GCC and libc++ is configured for threads. If _LIBCPP_HAS_CXX_ATOMICS is defined then the <atomic> header should be safe to include.

Other Misc changes:

• __gcc_atomic_t default constructs the stored value. This make it perform the same as _Atomic.
• constexpr -> _LIBCPP_CONSTEXPR
• noexcept -> TEST_NOEXCEPT in the tests.
• re-implement std::atomic::is_lock_free() to prevent needing libatomic with GCC.

[EricWF]

Remove unused implementation of __c11_is_atomic_lock_free for GCC.

[EricWF]

Sorry for the spam. Abandoning again. I'm going to submit the critical parts of this patch separately from the C++03 stuff.

include/__config

 #  define _LIBCPP_HAS_IS_BASE_OF
 #endif
 
+#if __has_extension(c_atomic)
+#define _LIBCPP_HAS_C11_ATOMICS
+#endif
+
 // Objective-C++ features (opt-in)
 #if __has_feature(objc_arc)
 #define _LIBCPP_HAS_OBJC_ARC

 #define _LIBCPP_PROVIDES_DEFAULT_RUNE_TABLE
 #endif
 
+#if (defined(_LIBCPP_HAS_C11_ATOMICS) || _GNUC_VER >= 407) \
+  && !defined(_LIBCPP_HAS_NO_THREADS)
+#define _LIBCPP_HAS_CXX_ATOMICS
+#endif
+
 #endif  // _LIBCPP_CONFIG

include/atomic

 #error <atomic> is not supported on this single threaded system
 #else // !_LIBCPP_HAS_NO_THREADS
 
+#ifndef _LIBCPP_HAS_CXX_ATOMICS
+#error <atomic> is not implemented
+#endif
+
 _LIBCPP_BEGIN_NAMESPACE_STD
 
-#if !__has_feature(cxx_atomic) && _GNUC_VER < 407
-#error <atomic> is not implemented
-#else
+#ifdef _LIBCPP_HAS_CXX_ATOMICS
 
 typedef enum memory_order
 {

     memory_order_release, memory_order_acq_rel, memory_order_seq_cst
 } memory_order;
 
-#if _GNUC_VER >= 407
+#if !defined(_LIBCPP_HAS_C11_ATOMICS)
 namespace __gcc_atomic {
 template <typename _Tp>
 struct __gcc_atomic_t {
-  __gcc_atomic_t() _NOEXCEPT {}
+  __gcc_atomic_t() _NOEXCEPT : __a_value() {}
   explicit __gcc_atomic_t(_Tp value) _NOEXCEPT : __a_value(value) {}
   _Tp __a_value;
 };

       sizeof(__test_atomic_assignable<_Tp, _Td>(1)) == sizeof(char);
 };
 
-static inline constexpr int __to_gcc_order(memory_order __order) {
+static inline _LIBCPP_CONSTEXPR int __to_gcc_order(memory_order __order) {
   // Avoid switch statement to make this a constexpr.
   return __order == memory_order_relaxed ? __ATOMIC_RELAXED:
          (__order == memory_order_acquire ? __ATOMIC_ACQUIRE:

               __ATOMIC_CONSUME))));
 }
 
-static inline constexpr int __to_gcc_failure_order(memory_order __order) {
+static inline _LIBCPP_CONSTEXPR int __to_gcc_failure_order(memory_order __order) {
   // Avoid switch statement to make this a constexpr.
   return __order == memory_order_relaxed ? __ATOMIC_RELAXED:
          (__order == memory_order_acquire ? __ATOMIC_ACQUIRE:

   __atomic_signal_fence(__gcc_atomic::__to_gcc_order(__order));
 }
 
-static inline bool __c11_atomic_is_lock_free(size_t __size) {
-  return __atomic_is_lock_free(__size, 0);
-}
-
 template <typename _Tp>
 static inline void __c11_atomic_store(volatile _Atomic(_Tp)* __a,  _Tp __val,
                                       memory_order __order) {

   return __atomic_fetch_xor(&__a->__a_value, __pattern,
                             __gcc_atomic::__to_gcc_order(__order));
 }
-#endif // _GNUC_VER >= 407
+#endif // !defined(_LIBCPP_HAS_NO_C11_ATOMICS)
 
 template <class _Tp>
 inline _LIBCPP_INLINE_VISIBILITY

 
     _LIBCPP_INLINE_VISIBILITY
     bool is_lock_free() const volatile _NOEXCEPT
-        {return __c11_atomic_is_lock_free(sizeof(_Tp));}
+    {
+#ifdef _LIBCPP_HAS_C11_ATOMICS
+      return __c11_atomic_is_lock_free(sizeof(_Tp));
+#else
+      return __atomic_is_lock_free(sizeof(_Tp), 0);
+#endif
+    }
+
     _LIBCPP_INLINE_VISIBILITY
     bool is_lock_free() const _NOEXCEPT
-        {return __c11_atomic_is_lock_free(sizeof(_Tp));}
+    {
+      return static_cast<__atomic_base const volatile*>(this)->is_lock_free();
+    }
+
     _LIBCPP_INLINE_VISIBILITY
     void store(_Tp __d, memory_order __m = memory_order_seq_cst) volatile _NOEXCEPT
         {__c11_atomic_store(&__a_, __d, __m);}

 typedef atomic<intmax_t>  atomic_intmax_t;
 typedef atomic<uintmax_t> atomic_uintmax_t;
 
+#if _LIBCPP_STD_VER >= 11
 #define ATOMIC_FLAG_INIT {false}
 #define ATOMIC_VAR_INIT(__v) {__v}
+#endif
 
 // lock-free property
 

 #define ATOMIC_LLONG_LOCK_FREE     __GCC_ATOMIC_LLONG_LOCK_FREE
 #define ATOMIC_POINTER_LOCK_FREE   __GCC_ATOMIC_POINTER_LOCK_FREE
 
-#endif  //  !__has_feature(cxx_atomic)
+#endif  //  _LIBCPP_HAS_C11_ATOMICS
 
 _LIBCPP_END_NAMESPACE_STD
 
-#endif  // !_LIBCPP_HAS_NO_THREADS
+#endif // _LIBCPP_HAS_CXX_ATOMICS
 
 #endif  // _LIBCPP_ATOMIC

include/ios

 #include <__locale>
 #include <system_error>
 
-#if __has_feature(cxx_atomic) && !defined(_LIBCPP_HAS_NO_THREADS)
+#ifdef _LIBCPP_HAS_CXX_ATOMICS
 #include <atomic>     // for __xindex_
 #endif
 

     int*            __index_;
     size_t          __event_size_;
     size_t          __event_cap_;
-#if __has_feature(cxx_atomic) && !defined(_LIBCPP_HAS_NO_THREADS)
+#ifdef _LIBCPP_HAS_CXX_ATOMICS
     static atomic<int> __xindex_;
 #else
     static int      __xindex_;

include/memory

     #include <cassert>
 #endif
 
-#if __has_feature(cxx_atomic) && !defined(_LIBCPP_HAS_NO_THREADS)
+#ifdef _LIBCPP_HAS_CXX_ATOMICS
 #  include <atomic>
 #endif
 

 basic_ostream<_CharT, _Traits>&
 operator<<(basic_ostream<_CharT, _Traits>& __os, shared_ptr<_Yp> const& __p);
 
-#if __has_feature(cxx_atomic) && !defined(_LIBCPP_HAS_NO_THREADS)
+#ifdef _LIBCPP_HAS_CXX_ATOMICS
 
 class _LIBCPP_TYPE_VIS __sp_mut
 {

     return atomic_compare_exchange_weak(__p, __v, __w);
 }
 
-#endif  // __has_feature(cxx_atomic) && !defined(_LIBCPP_HAS_NO_THREADS)
+#endif  // defined(_LIBCPP_HAS_CXX_ATOMICS)
 
 //enum class
 struct _LIBCPP_TYPE_VIS pointer_safety

src/ios.cpp

 }
 
 // xalloc
-#if __has_feature(cxx_atomic) && !defined(_LIBCPP_HAS_NO_THREADS)
+#ifdef _LIBCPP_HAS_CXX_ATOMICS
 atomic<int> ios_base::__xindex_ = ATOMIC_VAR_INIT(0);
 #else
 int ios_base::__xindex_ = 0;

src/memory.cpp

 
 #endif  // _LIBCPP_NO_RTTI
 
-#if __has_feature(cxx_atomic) && !defined(_LIBCPP_HAS_NO_THREADS)
+#ifdef _LIBCPP_HAS_CXX_ATOMICS
 
 static const std::size_t __sp_mut_count = 16;
 static pthread_mutex_t mut_back_imp[__sp_mut_count] =

     return muts[hash<const void*>()(p) & (__sp_mut_count-1)];
 }
 
-#endif // __has_feature(cxx_atomic) && !_LIBCPP_HAS_NO_THREADS
+#endif // _LIBCPP_HAS_CXX_ATOMICS
 
 void
 declare_reachable(void*)

test/libcxx/atomics/init_macros.pass.cpp

+//===----------------------------------------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// UNSUPPORTED: libcpp-has-no-threads
+
+// <atomic>
+
+#include <atomic>
+
+#if __cplusplus >= 201103L
+#
+# ifndef ATOMIC_VAR_INIT
+#   error ATOMIC_VAR_INIT should be defined
+# endif
+#
+# ifndef ATOMIC_FLAG_INIT
+#   error ATOMIC_FLAG_INIT should be defined
+# endif
+#
+#else // C++03
+#
+# ifndef ATOMIC_VAR_INIT
+#   error ATOMIC_VAR_INIT should not be defined
+# endif
+#
+# ifndef ATOMIC_FLAG_INIT
+#   error ATOMIC_FLAG_INIT should not be defined
+# endif
+#
+#endif
+
+int main()
+{
+}

test/libcxx/atomics/libcpp-has-no-threads.fail.cpp

+//===----------------------------------------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+// <atomic>
+
+// Test that including <atomic> fails to compile when _LIBCPP_HAS_NO_THREADS
+// is defined.
+
+#ifndef _LIBCPP_HAS_NO_THREADS
+#define _LIBCPP_HAS_NO_THREADS
+#endif
+
+#include <atomic>
+
+int main()
+{
+}

test/libcxx/atomics/libcpp-has-no-threads.pass.cpp

+//===----------------------------------------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+// XFAIL: libcpp-has-no-threads
+
+#ifdef _LIBCPP_HAS_NO_THREADS
+#error This should be XFAIL'd for the purpose of detecting that the LIT feature\
+ 'libcpp-has-no-threads' is available iff _LIBCPP_HAS_NO_THREADS is defined
+#endif
+
+int main()
+{
+}

test/libcxx/atomics/version.pass.cpp

+//===----------------------------------------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// UNSUPPORTED: libcpp-has-no-threads
+
+// <atomic>
+
+#include <atomic>
+
+#ifndef _LIBCPP_VERSION
+#error _LIBCPP_VERSION not defined
+#endif
+
+int main()
+{
+}

test/std/atomics/atomics.flag/atomic_flag_clear.pass.cpp

 int main()
 {
     {
-        std::atomic_flag f = ATOMIC_FLAG_INIT;
+        std::atomic_flag f;
+        f.clear();
         f.test_and_set();
         atomic_flag_clear(&f);
         assert(f.test_and_set() == 0);
     }
     {
-        volatile std::atomic_flag f = ATOMIC_FLAG_INIT;
+        volatile std::atomic_flag f;
+        f.clear();
         f.test_and_set();
         atomic_flag_clear(&f);
         assert(f.test_and_set() == 0);

test/std/atomics/atomics.flag/atomic_flag_clear_explicit.pass.cpp

 int main()
 {
     {
-        std::atomic_flag f = ATOMIC_FLAG_INIT;
+        std::atomic_flag f;
+        f.clear();
         f.test_and_set();
         atomic_flag_clear_explicit(&f, std::memory_order_relaxed);
         assert(f.test_and_set() == 0);
     }
     {
-        std::atomic_flag f = ATOMIC_FLAG_INIT;
+        std::atomic_flag f;
+        f.clear();
         f.test_and_set();
         atomic_flag_clear_explicit(&f, std::memory_order_release);
         assert(f.test_and_set() == 0);
     }
     {
-        std::atomic_flag f = ATOMIC_FLAG_INIT;
+        std::atomic_flag f;
+        f.clear();
         f.test_and_set();
         atomic_flag_clear_explicit(&f, std::memory_order_seq_cst);
         assert(f.test_and_set() == 0);
     }
     {
-        volatile std::atomic_flag f = ATOMIC_FLAG_INIT;
+        volatile std::atomic_flag f;
+        f.clear();
         f.test_and_set();
         atomic_flag_clear_explicit(&f, std::memory_order_relaxed);
         assert(f.test_and_set() == 0);
     }
     {
-        volatile std::atomic_flag f = ATOMIC_FLAG_INIT;
+        volatile std::atomic_flag f;
+        f.clear();
         f.test_and_set();
         atomic_flag_clear_explicit(&f, std::memory_order_release);
         assert(f.test_and_set() == 0);
     }
     {
-        volatile std::atomic_flag f = ATOMIC_FLAG_INIT;
+        volatile std::atomic_flag f;
+        f.clear();
         f.test_and_set();
         atomic_flag_clear_explicit(&f, std::memory_order_seq_cst);
         assert(f.test_and_set() == 0);

test/std/atomics/atomics.flag/clear.pass.cpp

 int main()
 {
     {
-        std::atomic_flag f = ATOMIC_FLAG_INIT;
+        std::atomic_flag f;
+        f.clear();
         f.test_and_set();
         f.clear();
         assert(f.test_and_set() == 0);
     }
     {
-        std::atomic_flag f = ATOMIC_FLAG_INIT;
+        std::atomic_flag f;
+        f.clear();
         f.test_and_set();
         f.clear(std::memory_order_relaxed);
         assert(f.test_and_set() == 0);
     }
     {
-        std::atomic_flag f = ATOMIC_FLAG_INIT;
+        std::atomic_flag f;
+        f.clear();
         f.test_and_set();
         f.clear(std::memory_order_release);
         assert(f.test_and_set() == 0);
     }
     {
-        std::atomic_flag f = ATOMIC_FLAG_INIT;
+        std::atomic_flag f;
+        f.clear();
         f.test_and_set();
         f.clear(std::memory_order_seq_cst);
         assert(f.test_and_set() == 0);
     }
     {
-        volatile std::atomic_flag f = ATOMIC_FLAG_INIT;
+        volatile std::atomic_flag f;
+        f.clear();
         f.test_and_set();
         f.clear();
         assert(f.test_and_set() == 0);
     }
     {
-        volatile std::atomic_flag f = ATOMIC_FLAG_INIT;
+        volatile std::atomic_flag f;
+        f.clear();
         f.test_and_set();
         f.clear(std::memory_order_relaxed);
         assert(f.test_and_set() == 0);
     }
     {
-        volatile std::atomic_flag f = ATOMIC_FLAG_INIT;
+        volatile std::atomic_flag f;
+        f.clear();
         f.test_and_set();
         f.clear(std::memory_order_release);
         assert(f.test_and_set() == 0);
     }
     {
-        volatile std::atomic_flag f = ATOMIC_FLAG_INIT;
+        volatile std::atomic_flag f;
+        f.clear();
         f.test_and_set();
         f.clear(std::memory_order_seq_cst);
         assert(f.test_and_set() == 0);

test/std/atomics/atomics.flag/init.pass.cpp

 //
 // UNSUPPORTED: libcpp-has-no-threads
 
+// TODO: ATOMIC_FLAG_INIT is not defined before C++11 because it cannot be
+// implemented.
+// UNSUPPORTED: c++98, c++03
+
 // <atomic>
 
 // struct atomic_flag

test/std/atomics/atomics.types.generic/trivially_copyable.fail.cpp

 //     T operator=(T) noexcept;
 // };
 
+// TODO: There is currently no way to check if a type if trivially copyable
+// using GCC.
+// XFAIL: gcc
+
 #include <atomic>
 #include <new>
 #include <cassert>

test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_compare_exchange_strong.pass.cpp

 #include <atomic>
 #include <type_traits>
 #include <cassert>
+#include "test_macros.h"
 
 template <class T>
 void

 {
     int i;
 
-    explicit A(int d = 0) noexcept {i=d;}
+    explicit A(int d = 0) TEST_NOEXCEPT {i=d;}
 
     friend bool operator==(const A& x, const A& y)
         {return x.i == y.i;}

test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_compare_exchange_strong_explicit.pass.cpp

 #include <atomic>
 #include <type_traits>
 #include <cassert>
+#include "test_macros.h"
 
 template <class T>
 void

 {
     int i;
 
-    explicit A(int d = 0) noexcept {i=d;}
+    explicit A(int d = 0) TEST_NOEXCEPT {i=d;}
 
     friend bool operator==(const A& x, const A& y)
         {return x.i == y.i;}

test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_compare_exchange_weak.pass.cpp

 
 #include <cmpxchg_loop.h>
 
+#include "test_macros.h"
+
 template <class T>
 void
 test()

 {
     int i;
 
-    explicit A(int d = 0) noexcept {i=d;}
+    explicit A(int d = 0) TEST_NOEXCEPT {i=d;}
 
     friend bool operator==(const A& x, const A& y)
         {return x.i == y.i;}

test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_compare_exchange_weak_explicit.pass.cpp

 
 #include <cmpxchg_loop.h>
 
+#include "test_macros.h"
+
 template <class T>
 void
 test()

 {
     int i;
 
-    explicit A(int d = 0) noexcept {i=d;}
+    explicit A(int d = 0) TEST_NOEXCEPT {i=d;}
 
     friend bool operator==(const A& x, const A& y)
         {return x.i == y.i;}

test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_exchange.pass.cpp

 #include <type_traits>
 #include <cassert>
 
+#include "test_macros.h"
+
 template <class T>
 void
 test()

 {
     int i;
 
-    explicit A(int d = 0) noexcept {i=d;}
+    explicit A(int d = 0) TEST_NOEXCEPT {i=d;}
 
     friend bool operator==(const A& x, const A& y)
         {return x.i == y.i;}

test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_exchange_explicit.pass.cpp

 #include <type_traits>
 #include <cassert>
 
+#include "test_macros.h"
+
 template <class T>
 void
 test()

 {
     int i;
 
-    explicit A(int d = 0) noexcept {i=d;}
+    explicit A(int d = 0) TEST_NOEXCEPT {i=d;}
 
     friend bool operator==(const A& x, const A& y)
         {return x.i == y.i;}

test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_fetch_add.pass.cpp

 #include <type_traits>
 #include <cassert>
 
+#include "test_macros.h"
+
 template <class T>
 void
 test()

 {
     int i;
 
-    explicit A(int d = 0) noexcept {i=d;}
+    explicit A(int d = 0) TEST_NOEXCEPT {i=d;}
     A(const A& a) : i(a.i) {}
     A(const volatile A& a) : i(a.i) {}
 

test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_fetch_add_explicit.pass.cpp

 #include <type_traits>
 #include <cassert>
 
+#include "test_macros.h"
+
 template <class T>
 void
 test()

 {
     int i;
 
-    explicit A(int d = 0) noexcept {i=d;}
+    explicit A(int d = 0) TEST_NOEXCEPT {i=d;}
     A(const A& a) : i(a.i) {}
     A(const volatile A& a) : i(a.i) {}
 

test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_fetch_sub.pass.cpp

 #include <type_traits>
 #include <cassert>
 
+#include "test_macros.h"
+
 template <class T>
 void
 test()

 {
     int i;
 
-    explicit A(int d = 0) noexcept {i=d;}
+    explicit A(int d = 0) TEST_NOEXCEPT {i=d;}
     A(const A& a) : i(a.i) {}
     A(const volatile A& a) : i(a.i) {}
 

test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_fetch_sub_explicit.pass.cpp

 #include <type_traits>
 #include <cassert>
 
+#include "test_macros.h"
+
 template <class T>
 void
 test()

 {
     int i;
 
-    explicit A(int d = 0) noexcept {i=d;}
+    explicit A(int d = 0) TEST_NOEXCEPT {i=d;}
     A(const A& a) : i(a.i) {}
     A(const volatile A& a) : i(a.i) {}
 

test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_init.pass.cpp

 #include <type_traits>
 #include <cassert>
 
+#include "test_macros.h"
+
 template <class T>
 void
 test()

 {
     int i;
 
-    explicit A(int d = 0) noexcept {i=d;}
+    explicit A(int d = 0) TEST_NOEXCEPT {i=d;}
 
     friend bool operator==(const A& x, const A& y)
         {return x.i == y.i;}

test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_load.pass.cpp

 #include <type_traits>
 #include <cassert>
 
+#include "test_macros.h"
+
 template <class T>
 void
 test()

 {
     int i;
 
-    explicit A(int d = 0) noexcept {i=d;}
+    explicit A(int d = 0) TEST_NOEXCEPT {i=d;}
 
     friend bool operator==(const A& x, const A& y)
         {return x.i == y.i;}

test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_load_explicit.pass.cpp

 #include <type_traits>
 #include <cassert>
 
+#include "test_macros.h"
+
 template <class T>
 void
 test()

 {
     int i;
 
-    explicit A(int d = 0) noexcept {i=d;}
+    explicit A(int d = 0) TEST_NOEXCEPT {i=d;}
 
     friend bool operator==(const A& x, const A& y)
         {return x.i == y.i;}

test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_store.pass.cpp

 #include <type_traits>
 #include <cassert>
 
+#include "test_macros.h"
+
 template <class T>
 void
 test()

 {
     int i;
 
-    explicit A(int d = 0) noexcept {i=d;}
+    explicit A(int d = 0) TEST_NOEXCEPT {i=d;}
 
     friend bool operator==(const A& x, const A& y)
         {return x.i == y.i;}

test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_store_explicit.pass.cpp

 #include <type_traits>
 #include <cassert>
 
+#include "test_macros.h"
+
 template <class T>
 void
 test()

 {
     int i;
 
-    explicit A(int d = 0) noexcept {i=d;}
+    explicit A(int d = 0) TEST_NOEXCEPT {i=d;}
 
     friend bool operator==(const A& x, const A& y)
         {return x.i == y.i;}

test/std/atomics/atomics.types.operations/atomics.types.operations.req/atomic_var_init.pass.cpp

 //
 // UNSUPPORTED: libcpp-has-no-threads
 
+// TODO: ATOMIC_VAR_INIT is not defined before C++11 because it cannot be
+// implemented.
+// UNSUPPORTED: c++98, c++03
+
 // <atomic>
 
 // #define ATOMIC_VAR_INIT(value)

test/std/atomics/libcpp-has-no-threads.fail.cpp

-//===----------------------------------------------------------------------===//
-//
-//                     The LLVM Compiler Infrastructure
-//
-// This file is dual licensed under the MIT and the University of Illinois Open
-// Source Licenses. See LICENSE.TXT for details.
-//
-//===----------------------------------------------------------------------===//
-
-// <atomic>
-
-// Test that including <atomic> fails to compile when _LIBCPP_HAS_NO_THREADS
-// is defined.
-
-#ifndef _LIBCPP_HAS_NO_THREADS
-#define _LIBCPP_HAS_NO_THREADS
-#endif
-
-#include <atomic>
-
-int main()
-{
-}

test/std/atomics/libcpp-has-no-threads.pass.cpp

-//===----------------------------------------------------------------------===//
-//
-//                     The LLVM Compiler Infrastructure
-//
-// This file is dual licensed under the MIT and the University of Illinois Open
-// Source Licenses. See LICENSE.TXT for details.
-//
-//===----------------------------------------------------------------------===//
-// XFAIL: libcpp-has-no-threads
-
-#ifdef _LIBCPP_HAS_NO_THREADS
-#error This should be XFAIL'd for the purpose of detecting that the LIT feature\
- 'libcpp-has-no-threads' is available iff _LIBCPP_HAS_NO_THREADS is defined
-#endif
-
-int main()
-{
-}

test/std/atomics/version.pass.cpp

-//===----------------------------------------------------------------------===//
-//
-//                     The LLVM Compiler Infrastructure
-//
-// This file is dual licensed under the MIT and the University of Illinois Open
-// Source Licenses. See LICENSE.TXT for details.
-//
-//===----------------------------------------------------------------------===//
-//
-// UNSUPPORTED: libcpp-has-no-threads
-
-// <atomic>
-
-#include <atomic>
-
-#ifndef _LIBCPP_VERSION
-#error _LIBCPP_VERSION not defined
-#endif
-
-int main()
-{
-}

test/std/utilities/memory/util.smartptr/util.smartptr.shared.atomic/atomic_compare_exchange_strong.pass.cpp

 
 int main()
 {
-#if __has_feature(cxx_atomic)
     {
         std::shared_ptr<int> p(new int(4));
         std::shared_ptr<int> v(new int(3));

         assert(*v == 4);
         assert(*w == 2);
     }
-#endif
 }

test/std/utilities/memory/util.smartptr/util.smartptr.shared.atomic/atomic_compare_exchange_strong_explicit.pass.cpp

 
 int main()
 {
-#if __has_feature(cxx_atomic)
     {
         std::shared_ptr<int> p(new int(4));
         std::shared_ptr<int> v(new int(3));

         assert(*v == 4);
         assert(*w == 2);
     }
-#endif
 }

test/std/utilities/memory/util.smartptr/util.smartptr.shared.atomic/atomic_compare_exchange_weak.pass.cpp

 
 int main()
 {
-#if __has_feature(cxx_atomic)
     {
         std::shared_ptr<int> p(new int(4));
         std::shared_ptr<int> v(new int(3));

         assert(*v == 4);
         assert(*w == 2);
     }
-#endif
 }

test/std/utilities/memory/util.smartptr/util.smartptr.shared.atomic/atomic_compare_exchange_weak_explicit.pass.cpp

 
 int main()
 {
-#if __has_feature(cxx_atomic)
     {
         std::shared_ptr<int> p(new int(4));
         std::shared_ptr<int> v(new int(3));

         assert(*v == 4);
         assert(*w == 2);
     }
-#endif
 }

test/std/utilities/memory/util.smartptr/util.smartptr.shared.atomic/atomic_exchange.pass.cpp

 
 int main()
 {
-#if __has_feature(cxx_atomic)
     {
         std::shared_ptr<int> p(new int(4));
         std::shared_ptr<int> r(new int(3));

         assert(*p == 3);
         assert(*r == 4);
     }
-#endif
 }

test/std/utilities/memory/util.smartptr/util.smartptr.shared.atomic/atomic_exchange_explicit.pass.cpp

 
 int main()
 {
-#if __has_feature(cxx_atomic)
     {
         std::shared_ptr<int> p(new int(4));
         std::shared_ptr<int> r(new int(3));

         assert(*p == 3);
         assert(*r == 4);
     }
-#endif
 }

test/std/utilities/memory/util.smartptr/util.smartptr.shared.atomic/atomic_is_lock_free.pass.cpp

 
 int main()
 {
-#if __has_feature(cxx_atomic)
     {
         const std::shared_ptr<int> p(new int(3));
         assert(std::atomic_is_lock_free(&p) == false);
     }
-#endif
 }

test/std/utilities/memory/util.smartptr/util.smartptr.shared.atomic/atomic_load.pass.cpp

 
 int main()
 {
-#if __has_feature(cxx_atomic)
     {
         std::shared_ptr<int> p(new int(3));
         std::shared_ptr<int> q = std::atomic_load(&p);
         assert(*q == *p);
     }
-#endif
 }

test/std/utilities/memory/util.smartptr/util.smartptr.shared.atomic/atomic_load_explicit.pass.cpp

 
 int main()
 {
-#if __has_feature(cxx_atomic)
     {
         const std::shared_ptr<int> p(new int(3));
         std::shared_ptr<int> q = std::atomic_load_explicit(&p, std::memory_order_relaxed);
         assert(*q == *p);
     }
-#endif
 }

test/std/utilities/memory/util.smartptr/util.smartptr.shared.atomic/atomic_store.pass.cpp

 
 int main()
 {
-#if __has_feature(cxx_atomic)
     {
         std::shared_ptr<int> p;
         std::shared_ptr<int> r(new int(3));
         std::atomic_store(&p, r);
         assert(*p == *r);
     }
-#endif
 }

test/std/utilities/memory/util.smartptr/util.smartptr.shared.atomic/atomic_store_explicit.pass.cpp

 
 int main()
 {
-#if __has_feature(cxx_atomic)
     {
         std::shared_ptr<int> p;
         std::shared_ptr<int> r(new int(3));
         std::atomic_store_explicit(&p, r, std::memory_order_seq_cst);
         assert(*p == *r);
     }
-#endif
 }