Add template parameter and unittests 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 {
 
-class AtomicValue {
+template <class T>
+class AtomicNumber {
  public:
-  AtomicValue() : value_(0) {}
-  explicit AtomicValue(base::AtomicWord initial) : value_(initial) {}
+  AtomicNumber() : value_(0) {}
+  explicit AtomicNumber(T initial) : value_(initial) {}
 
-  V8_INLINE void Increment(base::AtomicWord increment) {
-    base::NoBarrier_AtomicIncrement(&value_, increment);
+  V8_INLINE void Increment(T increment) {
+    base::NoBarrier_AtomicIncrement(&value_,
+                                    static_cast<base::AtomicWord>(increment));
   }
 
-  V8_INLINE base::AtomicWord Value() { return base::NoBarrier_Load(&value_); }
+  V8_INLINE T Value() { return static_cast<T>(base::NoBarrier_Load(&value_)); }
 
-  V8_INLINE void SetValue(base::AtomicWord new_value) {
-    base::NoBarrier_Store(&value_, new_value);
+  V8_INLINE void SetValue(T new_value) {
+    base::NoBarrier_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_));
+  }
+
+  V8_INLINE bool TrySetValue(T old_value, T new_value) {
+    return base::NoBarrier_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)));
+  }
+
+ private:
+  STATIC_ASSERT(sizeof(T) <= sizeof(base::AtomicWord));
+
+  template <typename S>
+  struct cast_helper {

[Michael Starzinger, 2015/09/04 13:28:46]

Got a rhyme for you:

You sneaky C++ wiz,
I am fine with this.
But my C++ foo isn't strong,
so I might just be wrong.

[Michael Lippautz, 2015/09/04 13:37:12]

Hah! Good enough for me!

+    static base::AtomicWord to_storage_type(S value) {
+      return static_cast<base::AtomicWord>(value);
+    }
+    static S to_return_type(base::AtomicWord value) {
+      return static_cast<S>(value);
+    }
+  };
+
+  template <typename S>
+  struct cast_helper<S*> {
+    static base::AtomicWord to_storage_type(S* value) {
+      return reinterpret_cast<base::AtomicWord>(value);
+    }
+    static S* to_return_type(base::AtomicWord value) {
+      return reinterpret_cast<S*>(value);
+    }
+  };
+
+  base::AtomicWord value_;
+};
+
 
 // See utils.h for EnumSet. Storage is always base::AtomicWord.
 // Requirements on E:
 // - No explicit values.
 // - E::kLastValue defined to be the last actually used value.
 //
 // Example:
 // enum E { kA, kB, kC, kLastValue = kC };
 template <class E>
 class AtomicEnumSet {
@@ skipping 30 matching lines @@
     do {                                                                  \
       old = base::Acquire_Load(&bits_);                                   \
     } while (base::Release_CompareAndSwap(&bits_, old, old OP NEW_VAL) != \
              old);                                                        \
   } while (false)
 
   void Add(E element) { ATOMIC_SET_WRITE(|, Mask(element)); }
 
   void Add(const AtomicEnumSet& set) { ATOMIC_SET_WRITE(|, set.ToIntegral()); }
 
-  void Remove(E element) { ATOMIC_SET_WRITE(&, Mask(element)); }
+  void Remove(E element) { ATOMIC_SET_WRITE(&, ~Mask(element)); }
 
   void Remove(const AtomicEnumSet& set) {
     ATOMIC_SET_WRITE(&, ~set.ToIntegral());
   }
 
   void Intersect(const AtomicEnumSet& set) {
     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_);
   }
 
   V8_INLINE base::AtomicWord Mask(E element) const {
     return static_cast<base::AtomicWord>(1) << element;
   }
 
   base::AtomicWord bits_;
 };
 
-
-// Flag using enums atomically.
-template <class E>
-class AtomicEnumFlag {
- public:
-  explicit AtomicEnumFlag(E initial) : value_(initial) {}
-
-  V8_INLINE E Value() { return static_cast<E>(base::NoBarrier_Load(&value_)); }
-
-  V8_INLINE bool TrySetValue(E old_value, E new_value) {
-    return base::NoBarrier_CompareAndSwap(
-               &value_, static_cast<base::AtomicWord>(old_value),
-               static_cast<base::AtomicWord>(new_value)) ==
-           static_cast<base::AtomicWord>(old_value);
-  }
-
- private:
-  base::AtomicWord value_;
-};
-
 }  // namespace internal
 }  // namespace v8
 
 #endif  // #define V8_ATOMIC_UTILS_H_