Rename "NoBarrier" memory operations to "Relaxed".

src/objects/object-macros.h

 // Copyright 2016 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.
 
 // Note 1: Any file that includes this one should include object-macros-undef.h
 // at the bottom.
 
 // Note 2: This file is deliberately missing the include guards (the undeffing
 // approach wouldn't work otherwise).
 
@@ skipping 62 matching lines @@
 
 #define SYNCHRONIZED_SMI_ACCESSORS(holder, name, offset)    \
   int holder::synchronized_##name() const {                 \
     Object* value = ACQUIRE_READ_FIELD(this, offset);       \
     return Smi::cast(value)->value();                       \
   }                                                         \
   void holder::synchronized_set_##name(int value) {         \
     RELEASE_WRITE_FIELD(this, offset, Smi::FromInt(value)); \
   }
 
-#define NOBARRIER_SMI_ACCESSORS(holder, name, offset)         \
-  int holder::nobarrier_##name() const {                      \
-    Object* value = NOBARRIER_READ_FIELD(this, offset);       \
-    return Smi::cast(value)->value();                         \
-  }                                                           \
-  void holder::nobarrier_set_##name(int value) {              \
-    NOBARRIER_WRITE_FIELD(this, offset, Smi::FromInt(value)); \
+#define RELAXED_SMI_ACCESSORS(holder, name, offset)         \

[Hannes Payer (out of office), 2017/05/29 13:12:39]

Let's also add a big comment on top of this file explaining their semantics,
what should be the default to use, and what are the dangers.

[ulan, 2017/05/29 13:41:06]

atomicops.h has a comment explaining relaxed, acquire, and release on the
high-level.
I added a comment that refers to that.

+  int holder::relaxed_read_##name() const {                 \
+    Object* value = RELAXED_READ_FIELD(this, offset);       \
+    return Smi::cast(value)->value();                       \
+  }                                                         \
+  void holder::relaxed_write_##name(int value) {            \
+    RELAXED_WRITE_FIELD(this, offset, Smi::FromInt(value)); \
   }
 
 #define BOOL_GETTER(holder, field, name, offset) \
   bool holder::name() const { return BooleanBit::get(field(), offset); }
 
 #define BOOL_ACCESSORS(holder, field, name, offset)                      \
   bool holder::name() const { return BooleanBit::get(field(), offset); } \
   void holder::set_##name(bool value) {                                  \
     set_##field(BooleanBit::set(field(), offset, value));                \
   }
 
 #define TYPE_CHECKER(type, instancetype)           \
   bool HeapObject::Is##type() const {              \
     return map()->instance_type() == instancetype; \
   }
 
 #define FIELD_ADDR(p, offset) \
   (reinterpret_cast<byte*>(p) + offset - kHeapObjectTag)
 
 #define FIELD_ADDR_CONST(p, offset) \
   (reinterpret_cast<const byte*>(p) + offset - kHeapObjectTag)
 
 #define READ_FIELD(p, offset) \
   (*reinterpret_cast<Object* const*>(FIELD_ADDR_CONST(p, offset)))
 
 #define ACQUIRE_READ_FIELD(p, offset)           \
   reinterpret_cast<Object*>(base::Acquire_Load( \
       reinterpret_cast<const base::AtomicWord*>(FIELD_ADDR_CONST(p, offset))))
 
-#define NOBARRIER_READ_FIELD(p, offset)           \
-  reinterpret_cast<Object*>(base::NoBarrier_Load( \
+#define RELAXED_READ_FIELD(p, offset)           \
+  reinterpret_cast<Object*>(base::Relaxed_Load( \
       reinterpret_cast<const base::AtomicWord*>(FIELD_ADDR_CONST(p, offset))))
 
 #ifdef V8_CONCURRENT_MARKING
 #define WRITE_FIELD(p, offset, value)                             \
-  base::NoBarrier_Store(                                          \
+  base::Relaxed_Store(                                            \
       reinterpret_cast<base::AtomicWord*>(FIELD_ADDR(p, offset)), \
       reinterpret_cast<base::AtomicWord>(value));
 #else
 #define WRITE_FIELD(p, offset, value) \
   (*reinterpret_cast<Object**>(FIELD_ADDR(p, offset)) = value)
 #endif
 
 #define RELEASE_WRITE_FIELD(p, offset, value)                     \
   base::Release_Store(                                            \
       reinterpret_cast<base::AtomicWord*>(FIELD_ADDR(p, offset)), \
       reinterpret_cast<base::AtomicWord>(value));
 
-#define NOBARRIER_WRITE_FIELD(p, offset, value)                   \
-  base::NoBarrier_Store(                                          \
+#define RELAXED_WRITE_FIELD(p, offset, value)                     \
+  base::Relaxed_Store(                                            \
       reinterpret_cast<base::AtomicWord*>(FIELD_ADDR(p, offset)), \
       reinterpret_cast<base::AtomicWord>(value));
 
 #define WRITE_BARRIER(heap, object, offset, value)          \
   heap->incremental_marking()->RecordWrite(                 \
       object, HeapObject::RawField(object, offset), value); \
   heap->RecordWrite(object, offset, value);
 
 #define CONDITIONAL_WRITE_BARRIER(heap, object, offset, value, mode) \
   if (mode != SKIP_WRITE_BARRIER) {                                  \
@@ skipping 72 matching lines @@
 
 #define READ_INT64_FIELD(p, offset) \
   (*reinterpret_cast<const int64_t*>(FIELD_ADDR_CONST(p, offset)))
 
 #define WRITE_INT64_FIELD(p, offset, value) \
   (*reinterpret_cast<int64_t*>(FIELD_ADDR(p, offset)) = value)
 
 #define READ_BYTE_FIELD(p, offset) \
   (*reinterpret_cast<const byte*>(FIELD_ADDR_CONST(p, offset)))
 
-#define NOBARRIER_READ_BYTE_FIELD(p, offset) \
-  static_cast<byte>(base::NoBarrier_Load(    \
+#define RELAXED_READ_BYTE_FIELD(p, offset) \
+  static_cast<byte>(base::Relaxed_Load(    \
       reinterpret_cast<base::Atomic8*>(FIELD_ADDR(p, offset))))
 
 #define WRITE_BYTE_FIELD(p, offset, value) \
   (*reinterpret_cast<byte*>(FIELD_ADDR(p, offset)) = value)
 
-#define NOBARRIER_WRITE_BYTE_FIELD(p, offset, value)           \
-  base::NoBarrier_Store(                                       \
-      reinterpret_cast<base::Atomic8*>(FIELD_ADDR(p, offset)), \
-      static_cast<base::Atomic8>(value));
+#define RELAXED_WRITE_BYTE_FIELD(p, offset, value)                             \
+  base::Relaxed_Store(reinterpret_cast<base::Atomic8*>(FIELD_ADDR(p, offset)), \
+                      static_cast<base::Atomic8>(value));
 
 #ifdef VERIFY_HEAP
 #define DECLARE_VERIFIER(Name) void Name##Verify();
 #else
 #define DECLARE_VERIFIER(Name)
 #endif