[heap] Old-to-new pointer updates need atomic accessors.

src/base/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"
@@ skipping 33 matching lines @@
 
   V8_INLINE T operator+=(T value) { return Increment(value); }
   V8_INLINE T operator-=(T value) { return Decrement(value); }
 
  private:
   STATIC_ASSERT(sizeof(T) <= sizeof(base::AtomicWord));
 
   base::AtomicWord value_;
 };
 
+// This type uses no barrier accessors to change atomic value. Be careful with
+// data races.
+template <typename T>
+class NonAtomicValue {

[Michael Lippautz, 2016/10/12 08:04:15]

You sure about this name?

I'd rather call it NoBarrierAtomicValue or something similar. NonAtomicValue
doesn't suggest the use of atomics.

[ulan, 2016/10/12 08:32:39]

+1 to NoBarrierAtomicValue

[Hannes Payer (out of office), 2016/10/12 11:27:45]

Changed the name. Note that the no barrier accessors are indeed non-atomic
accessors.

+ public:
+  NonAtomicValue() : value_(0) {}
+
+  explicit NonAtomicValue(T initial)
+      : value_(cast_helper<T>::to_storage_type(initial)) {}
+
+  V8_INLINE T Value() const {
+    return cast_helper<T>::to_return_type(base::NoBarrier_Load(&value_));
+  }
+
+  V8_INLINE void SetValue(T new_value) {
+    base::NoBarrier_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);
+    }
+    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_;
+};
 
 // Flag using T atomically. Also accepts void* as T.
 template <typename T>
 class AtomicValue {
  public:
   AtomicValue() : value_(0) {}
 
   explicit AtomicValue(T initial)
       : value_(cast_helper<T>::to_storage_type(initial)) {}
 
@@ skipping 127 matching lines @@
     return static_cast<base::AtomicWord>(1) << element;
   }
 
   base::AtomicWord bits_;
 };
 
 }  // namespace base
 }  // namespace v8
 
 #endif  // #define V8_ATOMIC_UTILS_H_