Remove test_atomic.h header

Because <atomic> can now be used in C++03 there is no need for the test_atomic.h header.
This commit removes the header and converts all usages to use <atomic> instead.


git-svn-id: https://llvm.org/svn/llvm-project/libcxx/trunk@245468 91177308-0d34-0410-b5e6-96231b3b80d8

test/std/thread/thread.condition/thread.condition.condvar/notify_one.pass.cpp

@@ -16,17 +16,17 @@
 // void notify_one();
 
 #include <condition_variable>
+#include <atomic>
 #include <mutex>
 #include <thread>
 #include <cassert>
 
-#include "test_atomic.h"
 
 std::condition_variable cv;
 std::mutex mut;
 
-AtomicInt test1(0);
-AtomicInt test2(0);
+std::atomic_int test1(0);
+std::atomic_int test2(0);
 
 void f1()
 {

test/std/thread/thread.condition/thread.condition.condvarany/wait_terminates.sh.cpp

@@ -56,14 +56,13 @@
 
 
 #include <condition_variable>
+#include <atomic>
 #include <thread>
 #include <chrono>
 #include <string>
 #include <cstdlib>
 #include <cassert>
 
-#include "test_atomic.h"
-
 void my_terminate() {
   std::_Exit(0); // Use _Exit to prevent cleanup from taking place.
 }
@@ -76,12 +75,14 @@ bool pred_function() {
 
 class ThrowingMutex
 {
-  AtomicBool locked;
+  std::atomic_bool locked;
   unsigned state = 0;
   ThrowingMutex(const ThrowingMutex&) = delete;
   ThrowingMutex& operator=(const ThrowingMutex&) = delete;
 public:
-  ThrowingMutex() = default;
+  ThrowingMutex() {
+    locked = false;
+  }
   ~ThrowingMutex() = default;
 
   void lock() {

test/std/thread/thread.threads/thread.thread.class/thread.thread.member/detach.pass.cpp

@@ -16,11 +16,10 @@
 // void detach();
 
 #include <thread>
+#include <atomic>
 #include <cassert>
 
-#include "test_atomic.h"
-
-AtomicBool done(false);
+std::atomic_bool done(false);
 
 class G
 {

test/support/test_atomic.h

@@ -1,109 +0,0 @@
-#ifndef SUPPORT_TEST_ATOMIC_H
-#define SUPPORT_TEST_ATOMIC_H
-
-// If the atomic memory order macros are defined then assume
-// the compiler supports the required atomic builtins.
-#if !defined(__ATOMIC_SEQ_CST)
-#define TEST_HAS_NO_ATOMICS
-#endif
-
-template <class ValType>
-class Atomic {
-   ValType value;
-   Atomic(Atomic const&);
-   Atomic& operator=(Atomic const&);
-   Atomic& operator=(Atomic const&) volatile;
-private:
-  enum {
-#if !defined(TEST_HAS_NO_ATOMICS)
-    AO_Relaxed = __ATOMIC_RELAXED,
-    AO_Seq     = __ATOMIC_SEQ_CST
-#else
-    AO_Relaxed,
-    AO_Seq
-#endif
-  };
-  template <class Tp, class FromType>
-  static inline void atomic_store_imp(Tp* dest, FromType from, int order = AO_Seq) {
-#if !defined(TEST_HAS_NO_ATOMICS)
-      __atomic_store_n(dest, from, order);
-#else
-    *dest = from;
-#endif
-  }
-
-  template <class Tp>
-  static inline Tp atomic_load_imp(Tp* from, int order = AO_Seq) {
-#if !defined(TEST_HAS_NO_ATOMICS)
-    return __atomic_load_n(from, order);
-#else
-    return *from;
-#endif
-  }
-
-  template <class Tp, class AddType>
-  static inline Tp atomic_add_imp(Tp* val, AddType add, int order = AO_Seq) {
-#if !defined(TEST_HAS_NO_ATOMICS)
-      return __atomic_add_fetch(val, add, order);
-#else
-    return *val += add;
-#endif
-  }
-
-  template <class Tp>
-  static inline Tp atomic_exchange_imp(Tp* val, Tp other, int order = AO_Seq) {
-#if !defined(TEST_HAS_NO_ATOMICS)
-      return __atomic_exchange_n(val, other, order);
-#else
-      Tp old = *val;
-      *val = other;
-      return old;
-#endif
-  }
-public:
-    Atomic() : value(0) {}
-    Atomic(ValType x) : value(x) {}
-
-    ValType operator=(ValType val) {
-       atomic_store_imp(&value, val);
-       return val;
-    }
-
-    ValType operator=(ValType val) volatile {
-        atomic_store_imp(&value, val);
-        return val;
-    }
-
-    ValType load() const volatile { return atomic_load_imp(&value); }
-    void    store(ValType val) volatile { atomic_store_imp(&value, val); }
-
-    ValType relaxedLoad() const volatile { return atomic_load_imp(&value, AO_Relaxed); }
-    void    relaxedStore(ValType val) volatile { atomic_store_imp(&value, val, AO_Relaxed); }
-
-    ValType exchange(ValType other) volatile { return atomic_exchange_imp(&value, other); }
-    bool    testAndSet() volatile { return atomic_exchange_imp(&value, 1); }
-    void    clear() volatile { atomic_store_imp(&value, 0); }
-
-    operator ValType() const { return atomic_load_imp(&value); }
-    operator ValType() const volatile { return atomic_load_imp(&value); }
-
-    ValType operator+=(ValType val)  { return atomic_add_imp(&value, val); }
-    ValType operator-=(ValType val)  { return atomic_add_imp(&value, -val); }
-    ValType operator+=(ValType val) volatile { return atomic_add_imp(&value, val); }
-    ValType operator-=(ValType val) volatile { return atomic_add_imp(&value, -val); }
-
-    ValType operator++()  { return *this += 1; }
-    ValType operator++(int) { return (*this += 1) - 1;  }
-    ValType operator++() volatile { return *this += 1; }
-    ValType operator++(int) volatile { return (*this += 1) - 1;  }
-
-    ValType operator--() { return *this -= 1; }
-    ValType operator--(int) { return (*this -= 1) + 1; }
-    ValType operator--() volatile { return *this -= 1; }
-    ValType operator--(int) volatile { return (*this -= 1) + 1; }
-};
-
-typedef Atomic<int> AtomicInt;
-typedef Atomic<bool> AtomicBool;
-
-#endif // SUPPORT_TEST_ATOMIC_H