Add barriers to atomic utils.

src/atomic-utils.h

 // Copyright 2015 the V8 project authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #ifndef V8_ATOMIC_UTILS_H_
 #define V8_ATOMIC_UTILS_H_
 
 #include <limits.h>
 
 #include "src/base/atomicops.h"
 #include "src/base/macros.h"
 
 namespace v8 {
 namespace internal {
 
 template <class T>
 class AtomicNumber {
  public:
   AtomicNumber() : value_(0) {}
   explicit AtomicNumber(T initial) : value_(initial) {}
 
   V8_INLINE void Increment(T increment) {
-    base::NoBarrier_AtomicIncrement(&value_,
-                                    static_cast<base::AtomicWord>(increment));
+    base::Barrier_AtomicIncrement(&value_,
+                                  static_cast<base::AtomicWord>(increment));
   }
 
-  V8_INLINE T Value() { return static_cast<T>(base::NoBarrier_Load(&value_)); }
+  V8_INLINE T Value() { return static_cast<T>(base::Acquire_Load(&value_)); }
 
   V8_INLINE void SetValue(T new_value) {
-    base::NoBarrier_Store(&value_, static_cast<base::AtomicWord>(new_value));
+    base::Release_Store(&value_, static_cast<base::AtomicWord>(new_value));
   }
 
  private:
   STATIC_ASSERT(sizeof(T) <= sizeof(base::AtomicWord));
 
   base::AtomicWord value_;
 };
 
 
 // Flag using T atomically. Also accepts void* as T.
 template <typename T>
 class AtomicValue {
  public:
   explicit AtomicValue(T initial)
       : value_(cast_helper<T>::to_storage_type(initial)) {}
 
   V8_INLINE T Value() {
-    return cast_helper<T>::to_return_type(base::NoBarrier_Load(&value_));
+    return cast_helper<T>::to_return_type(base::Acquire_Load(&value_));
   }
 
   V8_INLINE bool TrySetValue(T old_value, T new_value) {
-    return base::NoBarrier_CompareAndSwap(
+    return base::Release_CompareAndSwap(
                &value_, cast_helper<T>::to_storage_type(old_value),
                cast_helper<T>::to_storage_type(new_value)) ==
            cast_helper<T>::to_storage_type(old_value);
   }
 
-  V8_INLINE T /*old_value*/ SetValue(T new_value) {
-    return cast_helper<T>::to_return_type(base::NoBarrier_AtomicExchange(
-        &value_, cast_helper<T>::to_storage_type(new_value)));
+  V8_INLINE void SetValue(T new_value) {
+    base::Release_Store(&value_, cast_helper<T>::to_storage_type(new_value));
   }
 
  private:
   STATIC_ASSERT(sizeof(T) <= sizeof(base::AtomicWord));
 
   template <typename S>
   struct cast_helper {
     static base::AtomicWord to_storage_type(S value) {
       return static_cast<base::AtomicWord>(value);
     }
@@ skipping 24 matching lines @@
 // Example:
 // enum E { kA, kB, kC, kLastValue = kC };
 template <class E>
 class AtomicEnumSet {
  public:
   explicit AtomicEnumSet(base::AtomicWord bits = 0) : bits_(bits) {}
 
   bool IsEmpty() const { return ToIntegral() == 0; }
 
   bool Contains(E element) const { return (ToIntegral() & Mask(element)) != 0; }
-
   bool ContainsAnyOf(const AtomicEnumSet& set) const {
     return (ToIntegral() & set.ToIntegral()) != 0;
   }
 
-  void RemoveAll() { base::NoBarrier_Store(&bits_, 0); }
+  void RemoveAll() { base::Release_Store(&bits_, 0); }
 
   bool operator==(const AtomicEnumSet& set) const {
     return ToIntegral() == set.ToIntegral();
   }
 
   bool operator!=(const AtomicEnumSet& set) const {
     return ToIntegral() != set.ToIntegral();
   }
 
   AtomicEnumSet<E> operator|(const AtomicEnumSet& set) const {
@@ skipping 25 matching lines @@
     ATOMIC_SET_WRITE(&, set.ToIntegral());
   }
 
 #undef ATOMIC_SET_OP
 
  private:
   // Check whether there's enough storage to hold E.
   STATIC_ASSERT(E::kLastValue < (sizeof(base::AtomicWord) * CHAR_BIT));
 
   V8_INLINE base::AtomicWord ToIntegral() const {
-    return base::NoBarrier_Load(&bits_);
+    return base::Acquire_Load(&bits_);
   }
 
   V8_INLINE base::AtomicWord Mask(E element) const {
     return static_cast<base::AtomicWord>(1) << element;
   }
 
   base::AtomicWord bits_;
 };
 
 }  // namespace internal
 }  // namespace v8
 
 #endif  // #define V8_ATOMIC_UTILS_H_