Replace heap object access macros with functions and move them to the heap class

src/objects-inl.h

 // Copyright 2012 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.
 //
 // Review notes:
 //
 // - The use of macros in these inline functions may seem superfluous
 // but it is absolutely needed to make sure gcc generates optimal
 // code. gcc is not happy when attempting to inline too deep.
 //
@@ skipping 47 matching lines @@
 
 
 #define CAST_ACCESSOR(type)                     \
   type* type::cast(Object* object) {            \
     SLOW_ASSERT(object->Is##type());            \
     return reinterpret_cast<type*>(object);     \
   }
 
 
 #define INT_ACCESSORS(holder, name, offset)                             \
-  int holder::name() { return READ_INT_FIELD(this, offset); }           \
-  void holder::set_##name(int value) { WRITE_INT_FIELD(this, offset, value); }
+  int holder::name() { return Heap::read_int_field(this, offset); }     \
+  void holder::set_##name(int value) {                                  \
+    Heap::write_int_field(this, offset, value); }
 
 
-#define ACCESSORS(holder, name, type, offset)                           \
-  type* holder::name() { return type::cast(READ_FIELD(this, offset)); } \
-  void holder::set_##name(type* value, WriteBarrierMode mode) {         \
-    WRITE_FIELD(this, offset, value);                                   \
-    CONDITIONAL_WRITE_BARRIER(GetHeap(), this, offset, value, mode);    \
+#define ACCESSORS(holder, name, type, offset)                                 \
+  type* holder::name() { return type::cast(Heap::read_field(this, offset)); } \
+  void holder::set_##name(type* value, WriteBarrierMode mode) {               \
+    Heap::write_field(this, offset, value, mode);                             \
   }
 
 
 // Getter that returns a tagged Smi and setter that writes a tagged Smi.
-#define ACCESSORS_TO_SMI(holder, name, offset)                          \
-  Smi* holder::name() { return Smi::cast(READ_FIELD(this, offset)); }   \
-  void holder::set_##name(Smi* value, WriteBarrierMode mode) {          \
-    WRITE_FIELD(this, offset, value);                                   \
+#define ACCESSORS_TO_SMI(holder, name, offset)                                \
+  Smi* holder::name() { return Smi::cast(Heap::read_field(this, offset)); }   \
+  void holder::set_##name(Smi* value, WriteBarrierMode mode) {                \
+    Heap::write_field(this, offset, value, SKIP_WRITE_BARRIER);               \
   }
 
 
 // Getter that returns a Smi as an int and writes an int as a Smi.
 #define SMI_ACCESSORS(holder, name, offset)             \
   int holder::name() {                                  \
-    Object* value = READ_FIELD(this, offset);           \
+    Object* value = Heap::read_field(this, offset);     \
     return Smi::cast(value)->value();                   \
   }                                                     \
   void holder::set_##name(int value) {                  \
-    WRITE_FIELD(this, offset, Smi::FromInt(value));     \
+    Heap::write_field(this, offset,                     \
+        Smi::FromInt(value), SKIP_WRITE_BARRIER);       \
   }
 
 #define SYNCHRONIZED_SMI_ACCESSORS(holder, name, offset)    \
   int holder::synchronized_##name() {                       \
-    Object* value = ACQUIRE_READ_FIELD(this, offset);       \
+    Object* value = Heap::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)); \
+    Heap::release_write_field(this, offset, Smi::FromInt(value)); \
   }
 
 #define NOBARRIER_SMI_ACCESSORS(holder, name, offset)          \
   int holder::nobarrier_##name() {                             \
-    Object* value = NOBARRIER_READ_FIELD(this, offset);        \
+    Object* value = Heap::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));  \
+    Heap::nobarrier_write_field(this, offset, Smi::FromInt(value));  \
   }
 
 #define BOOL_GETTER(holder, field, name, offset)           \
   bool holder::name() {                                    \
     return BooleanBit::get(field(), offset);               \
   }                                                        \
 
 
 #define BOOL_ACCESSORS(holder, field, name, offset)        \
   bool holder::name() {                                    \
@@ skipping 998 matching lines @@
 }
 
 
 bool JSProxy::HasElementWithHandler(Handle<JSProxy> proxy, uint32_t index) {
   Isolate* isolate = proxy->GetIsolate();
   Handle<String> name = isolate->factory()->Uint32ToString(index);
   return HasPropertyWithHandler(proxy, name);
 }
 
 
-#define FIELD_ADDR(p, offset) \
-  (reinterpret_cast<byte*>(p) + offset - kHeapObjectTag)
-
-#define READ_FIELD(p, offset) \
-  (*reinterpret_cast<Object**>(FIELD_ADDR(p, offset)))
-
-#define ACQUIRE_READ_FIELD(p, offset)                                    \
-  reinterpret_cast<Object*>(                                             \
-      Acquire_Load(reinterpret_cast<AtomicWord*>(FIELD_ADDR(p, offset))))
-
-#define NOBARRIER_READ_FIELD(p, offset)                                     \
-  reinterpret_cast<Object*>(                                                \
-      NoBarrier_Load(reinterpret_cast<AtomicWord*>(FIELD_ADDR(p, offset))))
-
-#define WRITE_FIELD(p, offset, value) \
-  (*reinterpret_cast<Object**>(FIELD_ADDR(p, offset)) = value)
-
-#define RELEASE_WRITE_FIELD(p, offset, value)                           \
-  Release_Store(reinterpret_cast<AtomicWord*>(FIELD_ADDR(p, offset)),   \
-                reinterpret_cast<AtomicWord>(value));
-
-#define NOBARRIER_WRITE_FIELD(p, offset, value)                            \
-  NoBarrier_Store(reinterpret_cast<AtomicWord*>(FIELD_ADDR(p, offset)),    \
-                  reinterpret_cast<AtomicWord>(value));
-
-#define WRITE_BARRIER(heap, object, offset, value)                      \
-  heap->incremental_marking()->RecordWrite(                             \
-      object, HeapObject::RawField(object, offset), value);             \
-  if (heap->InNewSpace(value)) {                                        \
-    heap->RecordWrite(object->address(), offset);                       \
-  }
-
-#define CONDITIONAL_WRITE_BARRIER(heap, object, offset, value, mode)    \
-  if (mode == UPDATE_WRITE_BARRIER) {                                   \
-    heap->incremental_marking()->RecordWrite(                           \
-      object, HeapObject::RawField(object, offset), value);             \
-    if (heap->InNewSpace(value)) {                                      \
-      heap->RecordWrite(object->address(), offset);                     \
-    }                                                                   \
-  }
-
-#ifndef V8_TARGET_ARCH_MIPS
-  #define READ_DOUBLE_FIELD(p, offset) \
-    (*reinterpret_cast<double*>(FIELD_ADDR(p, offset)))
-#else  // V8_TARGET_ARCH_MIPS
-  // Prevent gcc from using load-double (mips ldc1) on (possibly)
-  // non-64-bit aligned HeapNumber::value.
-  static inline double read_double_field(void* p, int offset) {
-    union conversion {
-      double d;
-      uint32_t u[2];
-    } c;
-    c.u[0] = (*reinterpret_cast<uint32_t*>(FIELD_ADDR(p, offset)));
-    c.u[1] = (*reinterpret_cast<uint32_t*>(FIELD_ADDR(p, offset + 4)));
-    return c.d;
-  }
-  #define READ_DOUBLE_FIELD(p, offset) read_double_field(p, offset)
-#endif  // V8_TARGET_ARCH_MIPS
-
-#ifndef V8_TARGET_ARCH_MIPS
-  #define WRITE_DOUBLE_FIELD(p, offset, value) \
-    (*reinterpret_cast<double*>(FIELD_ADDR(p, offset)) = value)
-#else  // V8_TARGET_ARCH_MIPS
-  // Prevent gcc from using store-double (mips sdc1) on (possibly)
-  // non-64-bit aligned HeapNumber::value.
-  static inline void write_double_field(void* p, int offset,
-                                        double value) {
-    union conversion {
-      double d;
-      uint32_t u[2];
-    } c;
-    c.d = value;
-    (*reinterpret_cast<uint32_t*>(FIELD_ADDR(p, offset))) = c.u[0];
-    (*reinterpret_cast<uint32_t*>(FIELD_ADDR(p, offset + 4))) = c.u[1];
-  }
-  #define WRITE_DOUBLE_FIELD(p, offset, value) \
-    write_double_field(p, offset, value)
-#endif  // V8_TARGET_ARCH_MIPS
-
-
-#define READ_INT_FIELD(p, offset) \
-  (*reinterpret_cast<int*>(FIELD_ADDR(p, offset)))
-
-#define WRITE_INT_FIELD(p, offset, value) \
-  (*reinterpret_cast<int*>(FIELD_ADDR(p, offset)) = value)
-
-#define READ_INTPTR_FIELD(p, offset) \
-  (*reinterpret_cast<intptr_t*>(FIELD_ADDR(p, offset)))
-
-#define WRITE_INTPTR_FIELD(p, offset, value) \
-  (*reinterpret_cast<intptr_t*>(FIELD_ADDR(p, offset)) = value)
-
-#define READ_UINT32_FIELD(p, offset) \
-  (*reinterpret_cast<uint32_t*>(FIELD_ADDR(p, offset)))
-
-#define WRITE_UINT32_FIELD(p, offset, value) \
-  (*reinterpret_cast<uint32_t*>(FIELD_ADDR(p, offset)) = value)
-
-#define READ_INT32_FIELD(p, offset) \
-  (*reinterpret_cast<int32_t*>(FIELD_ADDR(p, offset)))
-
-#define WRITE_INT32_FIELD(p, offset, value) \
-  (*reinterpret_cast<int32_t*>(FIELD_ADDR(p, offset)) = value)
-
-#define READ_INT64_FIELD(p, offset) \
-  (*reinterpret_cast<int64_t*>(FIELD_ADDR(p, offset)))
-
-#define WRITE_INT64_FIELD(p, offset, value) \
-  (*reinterpret_cast<int64_t*>(FIELD_ADDR(p, offset)) = value)
-
-#define READ_SHORT_FIELD(p, offset) \
-  (*reinterpret_cast<uint16_t*>(FIELD_ADDR(p, offset)))
-
-#define WRITE_SHORT_FIELD(p, offset, value) \
-  (*reinterpret_cast<uint16_t*>(FIELD_ADDR(p, offset)) = value)
-
-#define READ_BYTE_FIELD(p, offset) \
-  (*reinterpret_cast<byte*>(FIELD_ADDR(p, offset)))
-
-#define NOBARRIER_READ_BYTE_FIELD(p, offset)               \
-  static_cast<byte>(NoBarrier_Load(                        \
-      reinterpret_cast<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)                 \
-  NoBarrier_Store(reinterpret_cast<Atomic8*>(FIELD_ADDR(p, offset)), \
-                  static_cast<Atomic8>(value));
-
 Object** HeapObject::RawField(HeapObject* obj, int byte_offset) {
-  return &READ_FIELD(obj, byte_offset);
+  return reinterpret_cast<Object**>(Heap::get_field_address(obj, byte_offset));
 }
 
 
 int Smi::value() {
   return Internals::SmiValue(this);
 }
 
 
 Smi* Smi::FromInt(int value) {
   ASSERT(Smi::IsValid(value));
@@ skipping 78 matching lines @@
 
 
 HeapObject* MapWord::ToForwardingAddress() {
   ASSERT(IsForwardingAddress());
   return HeapObject::FromAddress(reinterpret_cast<Address>(value_));
 }
 
 
 #ifdef VERIFY_HEAP
 void HeapObject::VerifyObjectField(int offset) {
-  VerifyPointer(READ_FIELD(this, offset));
+  VerifyPointer(Heap::read_field(this, offset));
 }
 
 void HeapObject::VerifySmiField(int offset) {
-  CHECK(READ_FIELD(this, offset)->IsSmi());
+  CHECK(Heap::read_field(this, offset)->IsSmi());
 }
 #endif
 
 
 Heap* HeapObject::GetHeap() {
   Heap* heap =
       MemoryChunk::FromAddress(reinterpret_cast<Address>(this))->heap();
   SLOW_ASSERT(heap != NULL);
   return heap;
 }
@@ skipping 39 matching lines @@
 }
 
 
 // Unsafe accessor omitting write barrier.
 void HeapObject::set_map_no_write_barrier(Map* value) {
   set_map_word(MapWord::FromMap(value));
 }
 
 
 MapWord HeapObject::map_word() {
-  return MapWord(
-      reinterpret_cast<uintptr_t>(NOBARRIER_READ_FIELD(this, kMapOffset)));
+  return MapWord(reinterpret_cast<uintptr_t>(
+      Heap::nobarrier_read_field(this, kMapOffset)));
 }
 
 
 void HeapObject::set_map_word(MapWord map_word) {
-  NOBARRIER_WRITE_FIELD(
+  Heap::nobarrier_write_field(
       this, kMapOffset, reinterpret_cast<Object*>(map_word.value_));
 }
 
 
 MapWord HeapObject::synchronized_map_word() {
   return MapWord(
-      reinterpret_cast<uintptr_t>(ACQUIRE_READ_FIELD(this, kMapOffset)));
+      reinterpret_cast<uintptr_t>(Heap::acquire_read_field(this, kMapOffset)));
 }
 
 
 void HeapObject::synchronized_set_map_word(MapWord map_word) {
-  RELEASE_WRITE_FIELD(
+  Heap::release_write_field(
       this, kMapOffset, reinterpret_cast<Object*>(map_word.value_));
 }
 
 
 HeapObject* HeapObject::FromAddress(Address address) {
   ASSERT_TAG_ALIGNED(address);
   return reinterpret_cast<HeapObject*>(address + kHeapObjectTag);
 }
 
 
 Address HeapObject::address() {
   return reinterpret_cast<Address>(this) - kHeapObjectTag;
 }
 
 
 int HeapObject::Size() {
   return SizeFromMap(map());
 }
 
 
 void HeapObject::IteratePointers(ObjectVisitor* v, int start, int end) {
-  v->VisitPointers(reinterpret_cast<Object**>(FIELD_ADDR(this, start)),
-                   reinterpret_cast<Object**>(FIELD_ADDR(this, end)));
+  v->VisitPointers(
+      reinterpret_cast<Object**>(Heap::get_field_address(this, start)),
+      reinterpret_cast<Object**>(Heap::get_field_address(this, end)));
 }
 
 
 void HeapObject::IteratePointer(ObjectVisitor* v, int offset) {
-  v->VisitPointer(reinterpret_cast<Object**>(FIELD_ADDR(this, offset)));
+  v->VisitPointer(
+      reinterpret_cast<Object**>(Heap::get_field_address(this, offset)));
 }
 
 
 void HeapObject::IterateNextCodeLink(ObjectVisitor* v, int offset) {
-  v->VisitNextCodeLink(reinterpret_cast<Object**>(FIELD_ADDR(this, offset)));
+  v->VisitNextCodeLink(
+      reinterpret_cast<Object**>(Heap::get_field_address(this, offset)));
 }
 
 
 double HeapNumber::value() {
-  return READ_DOUBLE_FIELD(this, kValueOffset);
+  return Heap::read_double_field(this, kValueOffset);
 }
 
 
 void HeapNumber::set_value(double value) {
-  WRITE_DOUBLE_FIELD(this, kValueOffset, value);
+  Heap::write_double_field(this, kValueOffset, value);
 }
 
 
 int HeapNumber::get_exponent() {
-  return ((READ_INT_FIELD(this, kExponentOffset) & kExponentMask) >>
+  return ((Heap::read_int_field(this, kExponentOffset) & kExponentMask) >>
           kExponentShift) - kExponentBias;
 }
 
 
 int HeapNumber::get_sign() {
-  return READ_INT_FIELD(this, kExponentOffset) & kSignMask;
+  return Heap::read_int_field(this, kExponentOffset) & kSignMask;
 }
 
 
 ACCESSORS(JSObject, properties, FixedArray, kPropertiesOffset)
 
 
 Object** FixedArray::GetFirstElementAddress() {
-  return reinterpret_cast<Object**>(FIELD_ADDR(this, OffsetOfElementAt(0)));
+  return reinterpret_cast<Object**>(
+      Heap::get_field_address(this, OffsetOfElementAt(0)));
 }
 
 
 bool FixedArray::ContainsOnlySmisOrHoles() {
   Object* the_hole = GetHeap()->the_hole_value();
   Object** current = GetFirstElementAddress();
   for (int i = 0; i < length(); ++i) {
     Object* candidate = *current++;
     if (!candidate->IsSmi() && candidate != the_hole) return false;
   }
   return true;
 }
 
 
 FixedArrayBase* JSObject::elements() {
-  Object* array = READ_FIELD(this, kElementsOffset);
+  Object* array = Heap::read_field(this, kElementsOffset);
   return static_cast<FixedArrayBase*>(array);
 }
 
 
 void JSObject::ValidateElements(Handle<JSObject> object) {
 #ifdef ENABLE_SLOW_ASSERTS
   if (FLAG_enable_slow_asserts) {
     ElementsAccessor* accessor = object->GetElementsAccessor();
     accessor->Validate(object);
   }
@@ skipping 232 matching lines @@
          (value->map() == object->GetHeap()->fixed_array_map() ||
           value->map() == object->GetHeap()->fixed_cow_array_map()));
   ASSERT((*value == object->GetHeap()->empty_fixed_array()) ||
          (object->map()->has_fast_double_elements() ==
           value->IsFixedDoubleArray()));
   object->set_elements(*value);
 }
 
 
 void JSObject::set_elements(FixedArrayBase* value, WriteBarrierMode mode) {
-  WRITE_FIELD(this, kElementsOffset, value);
-  CONDITIONAL_WRITE_BARRIER(GetHeap(), this, kElementsOffset, value, mode);
+  Heap::write_field(this, kElementsOffset, value, mode);
 }
 
 
 void JSObject::initialize_properties() {
   ASSERT(!GetHeap()->InNewSpace(GetHeap()->empty_fixed_array()));
-  WRITE_FIELD(this, kPropertiesOffset, GetHeap()->empty_fixed_array());
+  Heap::write_field(this,
+                    kPropertiesOffset,
+                    GetHeap()->empty_fixed_array(),
+                    SKIP_WRITE_BARRIER);
 }
 
 
 void JSObject::initialize_elements() {
   FixedArrayBase* elements = map()->GetInitialElements();
-  WRITE_FIELD(this, kElementsOffset, elements);
+  Heap::write_field(this, kElementsOffset, elements, SKIP_WRITE_BARRIER);
 }
 
 
 Handle<String> JSObject::ExpectedTransitionKey(Handle<Map> map) {
   DisallowHeapAllocation no_gc;
   if (!map->HasTransitionArray()) return Handle<String>::null();
   TransitionArray* transitions = map->transitions();
   if (!transitions->IsSimpleTransition()) return Handle<String>::null();
   int transition = TransitionArray::kSimpleTransitionIndex;
   PropertyDetails details = transitions->GetTargetDetails(transition);
@@ skipping 23 matching lines @@
   if (target_details.attributes() != NONE) return Handle<Map>::null();
   return Handle<Map>(transitions->GetTarget(transition));
 }
 
 
 ACCESSORS(Oddball, to_string, String, kToStringOffset)
 ACCESSORS(Oddball, to_number, Object, kToNumberOffset)
 
 
 byte Oddball::kind() {
-  return Smi::cast(READ_FIELD(this, kKindOffset))->value();
+  return Smi::cast(Heap::read_field(this, kKindOffset))->value();
 }
 
 
 void Oddball::set_kind(byte value) {
-  WRITE_FIELD(this, kKindOffset, Smi::FromInt(value));
+  Heap::write_field(this, kKindOffset, Smi::FromInt(value), SKIP_WRITE_BARRIER);
 }
 
 
 Object* Cell::value() {
-  return READ_FIELD(this, kValueOffset);
+  return Heap::read_field(this, kValueOffset);
 }
 
 
 void Cell::set_value(Object* val, WriteBarrierMode ignored) {
   // The write barrier is not used for global property cells.
   ASSERT(!val->IsPropertyCell() && !val->IsCell());
-  WRITE_FIELD(this, kValueOffset, val);
+  Heap::write_field(this, kValueOffset, val, SKIP_WRITE_BARRIER);
 }
 
 ACCESSORS(PropertyCell, dependent_code, DependentCode, kDependentCodeOffset)
 
 Object* PropertyCell::type_raw() {
-  return READ_FIELD(this, kTypeOffset);
+  return Heap::read_field(this, kTypeOffset);
 }
 
 
 void PropertyCell::set_type_raw(Object* val, WriteBarrierMode ignored) {
-  WRITE_FIELD(this, kTypeOffset, val);
+  Heap::write_field(this, kTypeOffset, val, SKIP_WRITE_BARRIER);
 }
 
 
 int JSObject::GetHeaderSize() {
   InstanceType type = map()->instance_type();
   // Check for the most common kind of JavaScript object before
   // falling into the generic switch. This speeds up the internal
   // field operations considerably on average.
   if (type == JS_OBJECT_TYPE) return JSObject::kHeaderSize;
   switch (type) {
@@ skipping 61 matching lines @@
   ASSERT(index < GetInternalFieldCount() && index >= 0);
   return GetHeaderSize() + (kPointerSize * index);
 }
 
 
 Object* JSObject::GetInternalField(int index) {
   ASSERT(index < GetInternalFieldCount() && index >= 0);
   // Internal objects do follow immediately after the header, whereas in-object
   // properties are at the end of the object. Therefore there is no need
   // to adjust the index here.
-  return READ_FIELD(this, GetHeaderSize() + (kPointerSize * index));
+  return Heap::read_field(this, GetHeaderSize() + (kPointerSize * index));
 }
 
 
 void JSObject::SetInternalField(int index, Object* value) {
   ASSERT(index < GetInternalFieldCount() && index >= 0);
   // Internal objects do follow immediately after the header, whereas in-object
   // properties are at the end of the object. Therefore there is no need
   // to adjust the index here.
   int offset = GetHeaderSize() + (kPointerSize * index);
-  WRITE_FIELD(this, offset, value);
-  WRITE_BARRIER(GetHeap(), this, offset, value);
+  Heap::write_field(this, offset, value, UPDATE_WRITE_BARRIER);
 }
 
 
 void JSObject::SetInternalField(int index, Smi* value) {
   ASSERT(index < GetInternalFieldCount() && index >= 0);
   // Internal objects do follow immediately after the header, whereas in-object
   // properties are at the end of the object. Therefore there is no need
   // to adjust the index here.
   int offset = GetHeaderSize() + (kPointerSize * index);
-  WRITE_FIELD(this, offset, value);
+  Heap::write_field(this, offset, value, SKIP_WRITE_BARRIER);
 }
 
 
 // Access fast-case object properties at index. The use of these routines
 // is needed to correctly distinguish between properties stored in-object and
 // properties stored in the properties array.
 Object* JSObject::RawFastPropertyAt(int index) {
   // Adjust for the number of properties stored in the object.
   index -= map()->inobject_properties();
   if (index < 0) {
     int offset = map()->instance_size() + (index * kPointerSize);
-    return READ_FIELD(this, offset);
+    return Heap::read_field(this, offset);
   } else {
     ASSERT(index < properties()->length());
     return properties()->get(index);
   }
 }
 
 
 void JSObject::FastPropertyAtPut(int index, Object* value) {
   // Adjust for the number of properties stored in the object.
   index -= map()->inobject_properties();
   if (index < 0) {
     int offset = map()->instance_size() + (index * kPointerSize);
-    WRITE_FIELD(this, offset, value);
-    WRITE_BARRIER(GetHeap(), this, offset, value);
+    Heap::write_field(this, offset, value, UPDATE_WRITE_BARRIER);
   } else {
     ASSERT(index < properties()->length());
     properties()->set(index, value);
   }
 }
 
 
 int JSObject::GetInObjectPropertyOffset(int index) {
   return map()->GetInObjectPropertyOffset(index);
 }
 
 
 Object* JSObject::InObjectPropertyAt(int index) {
   int offset = GetInObjectPropertyOffset(index);
-  return READ_FIELD(this, offset);
+  return Heap::read_field(this, offset);
 }
 
 
 Object* JSObject::InObjectPropertyAtPut(int index,
                                         Object* value,
                                         WriteBarrierMode mode) {
   // Adjust for the number of properties stored in the object.
   int offset = GetInObjectPropertyOffset(index);
-  WRITE_FIELD(this, offset, value);
-  CONDITIONAL_WRITE_BARRIER(GetHeap(), this, offset, value, mode);
+  Heap::write_field(this, offset, value, mode);
   return value;
 }
 
 
 
 void JSObject::InitializeBody(Map* map,
                               Object* pre_allocated_value,
                               Object* filler_value) {
   ASSERT(!filler_value->IsHeapObject() ||
          !GetHeap()->InNewSpace(filler_value));
   ASSERT(!pre_allocated_value->IsHeapObject() ||
          !GetHeap()->InNewSpace(pre_allocated_value));
   int size = map->instance_size();
   int offset = kHeaderSize;
   if (filler_value != pre_allocated_value) {
     int pre_allocated = map->pre_allocated_property_fields();
     ASSERT(pre_allocated * kPointerSize + kHeaderSize <= size);
     for (int i = 0; i < pre_allocated; i++) {
-      WRITE_FIELD(this, offset, pre_allocated_value);
+      Heap::write_field(this, offset, pre_allocated_value, SKIP_WRITE_BARRIER);
       offset += kPointerSize;
     }
   }
   while (offset < size) {
-    WRITE_FIELD(this, offset, filler_value);
+    Heap::write_field(this, offset, filler_value, SKIP_WRITE_BARRIER);
     offset += kPointerSize;
   }
 }
 
 
 bool JSObject::HasFastProperties() {
   ASSERT(properties()->IsDictionary() == map()->is_dictionary_map());
   return !properties()->IsDictionary();
 }
 
@@ skipping 14 matching lines @@
   } else {
     limit = Max(inobject, kFastPropertiesSoftLimit);
   }
   return properties()->length() > limit;
 }
 
 
 void Struct::InitializeBody(int object_size) {
   Object* value = GetHeap()->undefined_value();
   for (int offset = kHeaderSize; offset < object_size; offset += kPointerSize) {
-    WRITE_FIELD(this, offset, value);
+    Heap::write_field(this, offset, value, SKIP_WRITE_BARRIER);
   }
 }
 
 
 bool Object::ToArrayIndex(uint32_t* index) {
   if (IsSmi()) {
     int value = Smi::cast(this)->value();
     if (value < 0) return false;
     *index = value;
     return true;
@@ skipping 41 matching lines @@
 
 
 FixedArrayBase* FixedArrayBase::cast(Object* object) {
   ASSERT(object->IsFixedArrayBase());
   return reinterpret_cast<FixedArrayBase*>(object);
 }
 
 
 Object* FixedArray::get(int index) {
   SLOW_ASSERT(index >= 0 && index < this->length());
-  return READ_FIELD(this, kHeaderSize + index * kPointerSize);
+  return Heap::read_field(this, kHeaderSize + index * kPointerSize);
 }
 
 
 Handle<Object> FixedArray::get(Handle<FixedArray> array, int index) {
   return handle(array->get(index), array->GetIsolate());
 }
 
 
 bool FixedArray::is_the_hole(int index) {
   return get(index) == GetHeap()->the_hole_value();
 }
 
 
 void FixedArray::set(int index, Smi* value) {
   ASSERT(map() != GetHeap()->fixed_cow_array_map());
   ASSERT(index >= 0 && index < this->length());
   ASSERT(reinterpret_cast<Object*>(value)->IsSmi());
   int offset = kHeaderSize + index * kPointerSize;
-  WRITE_FIELD(this, offset, value);
+  Heap::write_field(this, offset, value, SKIP_WRITE_BARRIER);
 }
 
 
 void FixedArray::set(int index, Object* value) {
   ASSERT(map() != GetHeap()->fixed_cow_array_map());
   ASSERT(index >= 0 && index < this->length());
   int offset = kHeaderSize + index * kPointerSize;
-  WRITE_FIELD(this, offset, value);
-  WRITE_BARRIER(GetHeap(), this, offset, value);
+  Heap::write_field(this, offset, value, UPDATE_WRITE_BARRIER);
 }
 
 
 inline bool FixedDoubleArray::is_the_hole_nan(double value) {
   return BitCast<uint64_t, double>(value) == kHoleNanInt64;
 }
 
 
 inline double FixedDoubleArray::hole_nan_as_double() {
   return BitCast<double, uint64_t>(kHoleNanInt64);
 }
 
 
 inline double FixedDoubleArray::canonical_not_the_hole_nan_as_double() {
   ASSERT(BitCast<uint64_t>(OS::nan_value()) != kHoleNanInt64);
   ASSERT((BitCast<uint64_t>(OS::nan_value()) >> 32) != kHoleNanUpper32);
   return OS::nan_value();
 }
 
 
 double FixedDoubleArray::get_scalar(int index) {
   ASSERT(map() != GetHeap()->fixed_cow_array_map() &&
          map() != GetHeap()->fixed_array_map());
   ASSERT(index >= 0 && index < this->length());
-  double result = READ_DOUBLE_FIELD(this, kHeaderSize + index * kDoubleSize);
+  double result =
+      Heap::read_double_field(this, kHeaderSize + index * kDoubleSize);
   ASSERT(!is_the_hole_nan(result));
   return result;
 }
 
 int64_t FixedDoubleArray::get_representation(int index) {
   ASSERT(map() != GetHeap()->fixed_cow_array_map() &&
          map() != GetHeap()->fixed_array_map());
   ASSERT(index >= 0 && index < this->length());
-  return READ_INT64_FIELD(this, kHeaderSize + index * kDoubleSize);
+  return Heap::read_int64_field(this, kHeaderSize + index * kDoubleSize);
 }
 
 
 Handle<Object> FixedDoubleArray::get(Handle<FixedDoubleArray> array,
                                      int index) {
   if (array->is_the_hole(index)) {
     return array->GetIsolate()->factory()->the_hole_value();
   } else {
     return array->GetIsolate()->factory()->NewNumber(array->get_scalar(index));
   }
 }
 
 
 void FixedDoubleArray::set(int index, double value) {
   ASSERT(map() != GetHeap()->fixed_cow_array_map() &&
          map() != GetHeap()->fixed_array_map());
   int offset = kHeaderSize + index * kDoubleSize;
   if (std::isnan(value)) value = canonical_not_the_hole_nan_as_double();
-  WRITE_DOUBLE_FIELD(this, offset, value);
+  Heap::write_double_field(this, offset, value);
 }
 
 
 void FixedDoubleArray::set_the_hole(int index) {
   ASSERT(map() != GetHeap()->fixed_cow_array_map() &&
          map() != GetHeap()->fixed_array_map());
   int offset = kHeaderSize + index * kDoubleSize;
-  WRITE_DOUBLE_FIELD(this, offset, hole_nan_as_double());
+  Heap::write_double_field(this, offset, hole_nan_as_double());
 }
 
 
 bool FixedDoubleArray::is_the_hole(int index) {
   int offset = kHeaderSize + index * kDoubleSize;
-  return is_the_hole_nan(READ_DOUBLE_FIELD(this, offset));
+  return is_the_hole_nan(Heap::read_double_field(this, offset));
 }
 
 
 double* FixedDoubleArray::data_start() {
-  return reinterpret_cast<double*>(FIELD_ADDR(this, kHeaderSize));
+  return reinterpret_cast<double*>(Heap::get_field_address(this, kHeaderSize));
 }
 
 
 void FixedDoubleArray::FillWithHoles(int from, int to) {
   for (int i = from; i < to; i++) {
     set_the_hole(i);
   }
 }
 
 
 void ConstantPoolArray::set_weak_object_state(
       ConstantPoolArray::WeakObjectState state) {
-  int old_layout_field = READ_INT_FIELD(this, kArrayLayoutOffset);
+  int old_layout_field = Heap::read_int_field(this, kArrayLayoutOffset);
   int new_layout_field = WeakObjectStateField::update(old_layout_field, state);
-  WRITE_INT_FIELD(this, kArrayLayoutOffset, new_layout_field);
+  Heap::write_int_field(this, kArrayLayoutOffset, new_layout_field);
 }
 
 
 ConstantPoolArray::WeakObjectState ConstantPoolArray::get_weak_object_state() {
-  int layout_field = READ_INT_FIELD(this, kArrayLayoutOffset);
+  int layout_field = Heap::read_int_field(this, kArrayLayoutOffset);
   return WeakObjectStateField::decode(layout_field);
 }
 
 
 int ConstantPoolArray::first_int64_index() {
   return 0;
 }
 
 
 int ConstantPoolArray::first_code_ptr_index() {
-  int layout_field = READ_INT_FIELD(this, kArrayLayoutOffset);
+  int layout_field = Heap::read_int_field(this, kArrayLayoutOffset);
   return first_int64_index() +
       NumberOfInt64EntriesField::decode(layout_field);
 }
 
 
 int ConstantPoolArray::first_heap_ptr_index() {
-  int layout_field = READ_INT_FIELD(this, kArrayLayoutOffset);
+  int layout_field = Heap::read_int_field(this, kArrayLayoutOffset);
   return first_code_ptr_index() +
       NumberOfCodePtrEntriesField::decode(layout_field);
 }
 
 
 int ConstantPoolArray::first_int32_index() {
-  int layout_field = READ_INT_FIELD(this, kArrayLayoutOffset);
+  int layout_field = Heap::read_int_field(this, kArrayLayoutOffset);
   return first_heap_ptr_index() +
       NumberOfHeapPtrEntriesField::decode(layout_field);
 }
 
 
 int ConstantPoolArray::count_of_int64_entries() {
   return first_code_ptr_index();
 }
 
 
@@ skipping 18 matching lines @@
                              int number_of_int32_entries) {
   set_length(number_of_int64_entries +
              number_of_code_ptr_entries +
              number_of_heap_ptr_entries +
              number_of_int32_entries);
   int layout_field =
       NumberOfInt64EntriesField::encode(number_of_int64_entries) |
       NumberOfCodePtrEntriesField::encode(number_of_code_ptr_entries) |
       NumberOfHeapPtrEntriesField::encode(number_of_heap_ptr_entries) |
       WeakObjectStateField::encode(NO_WEAK_OBJECTS);
-  WRITE_INT_FIELD(this, kArrayLayoutOffset, layout_field);
+  Heap::write_int_field(this, kArrayLayoutOffset, layout_field);
 }
 
 
 int64_t ConstantPoolArray::get_int64_entry(int index) {
   ASSERT(map() == GetHeap()->constant_pool_array_map());
   ASSERT(index >= 0 && index < first_code_ptr_index());
-  return READ_INT64_FIELD(this, OffsetOfElementAt(index));
+  return Heap::read_int64_field(this, OffsetOfElementAt(index));
 }
 
 double ConstantPoolArray::get_int64_entry_as_double(int index) {
   STATIC_ASSERT(kDoubleSize == kInt64Size);
   ASSERT(map() == GetHeap()->constant_pool_array_map());
   ASSERT(index >= 0 && index < first_code_ptr_index());
-  return READ_DOUBLE_FIELD(this, OffsetOfElementAt(index));
+  return Heap::read_double_field(this, OffsetOfElementAt(index));
 }
 
 
 Address ConstantPoolArray::get_code_ptr_entry(int index) {
   ASSERT(map() == GetHeap()->constant_pool_array_map());
   ASSERT(index >= first_code_ptr_index() && index < first_heap_ptr_index());
-  return reinterpret_cast<Address>(READ_FIELD(this, OffsetOfElementAt(index)));
+  return reinterpret_cast<Address>(
+      Heap::read_field(this, OffsetOfElementAt(index)));
 }
 
 
 Object* ConstantPoolArray::get_heap_ptr_entry(int index) {
   ASSERT(map() == GetHeap()->constant_pool_array_map());
   ASSERT(index >= first_heap_ptr_index() && index < first_int32_index());
-  return READ_FIELD(this, OffsetOfElementAt(index));
+  return Heap::read_field(this, OffsetOfElementAt(index));
 }
 
 
 int32_t ConstantPoolArray::get_int32_entry(int index) {
   ASSERT(map() == GetHeap()->constant_pool_array_map());
   ASSERT(index >= first_int32_index() && index < length());
-  return READ_INT32_FIELD(this, OffsetOfElementAt(index));
+  return Heap::read_int32_field(this, OffsetOfElementAt(index));
 }
 
 
 void ConstantPoolArray::set(int index, Address value) {
   ASSERT(map() == GetHeap()->constant_pool_array_map());
   ASSERT(index >= first_code_ptr_index() && index < first_heap_ptr_index());
-  WRITE_FIELD(this, OffsetOfElementAt(index), reinterpret_cast<Object*>(value));
+  Heap::write_field(this,
+                    OffsetOfElementAt(index),
+                    reinterpret_cast<Object*>(value),
+                    SKIP_WRITE_BARRIER);
 }
 
 
 void ConstantPoolArray::set(int index, Object* value) {
   ASSERT(map() == GetHeap()->constant_pool_array_map());
   ASSERT(index >= first_code_ptr_index() && index < first_int32_index());
-  WRITE_FIELD(this, OffsetOfElementAt(index), value);
-  WRITE_BARRIER(GetHeap(), this, OffsetOfElementAt(index), value);
+  Heap::write_field(this,
+                    OffsetOfElementAt(index),
+                    value,
+                    UPDATE_WRITE_BARRIER);
 }
 
 
 void ConstantPoolArray::set(int index, int64_t value) {
   ASSERT(map() == GetHeap()->constant_pool_array_map());
   ASSERT(index >= first_int64_index() && index < first_code_ptr_index());
-  WRITE_INT64_FIELD(this, OffsetOfElementAt(index), value);
+  Heap::write_int64_field(this, OffsetOfElementAt(index), value);
 }
 
 
 void ConstantPoolArray::set(int index, double value) {
   STATIC_ASSERT(kDoubleSize == kInt64Size);
   ASSERT(map() == GetHeap()->constant_pool_array_map());
   ASSERT(index >= first_int64_index() && index < first_code_ptr_index());
-  WRITE_DOUBLE_FIELD(this, OffsetOfElementAt(index), value);
+  Heap::write_double_field(this, OffsetOfElementAt(index), value);
 }
 
 
 void ConstantPoolArray::set(int index, int32_t value) {
   ASSERT(map() == GetHeap()->constant_pool_array_map());
   ASSERT(index >= this->first_int32_index() && index < length());
-  WRITE_INT32_FIELD(this, OffsetOfElementAt(index), value);
+  Heap::write_int32_field(this, OffsetOfElementAt(index), value);
 }
 
 
 WriteBarrierMode HeapObject::GetWriteBarrierMode(
     const DisallowHeapAllocation& promise) {
   Heap* heap = GetHeap();
   if (heap->incremental_marking()->IsMarking()) return UPDATE_WRITE_BARRIER;
   if (heap->InNewSpace(this)) return SKIP_WRITE_BARRIER;
   return UPDATE_WRITE_BARRIER;
 }
 
 
 void FixedArray::set(int index,
                      Object* value,
                      WriteBarrierMode mode) {
   ASSERT(map() != GetHeap()->fixed_cow_array_map());
   ASSERT(index >= 0 && index < this->length());
   int offset = kHeaderSize + index * kPointerSize;
-  WRITE_FIELD(this, offset, value);
-  CONDITIONAL_WRITE_BARRIER(GetHeap(), this, offset, value, mode);
+  Heap::write_field(this, offset, value, mode);
 }
 
 
 void FixedArray::NoIncrementalWriteBarrierSet(FixedArray* array,
                                               int index,
                                               Object* value) {
   ASSERT(array->map() != array->GetHeap()->fixed_cow_array_map());
   ASSERT(index >= 0 && index < array->length());
   int offset = kHeaderSize + index * kPointerSize;
-  WRITE_FIELD(array, offset, value);
+  Heap::write_field(array, offset, value, SKIP_WRITE_BARRIER);
   Heap* heap = array->GetHeap();
   if (heap->InNewSpace(value)) {
     heap->RecordWrite(array->address(), offset);
   }
 }
 
 
 void FixedArray::NoWriteBarrierSet(FixedArray* array,
                                    int index,
                                    Object* value) {
   ASSERT(array->map() != array->GetHeap()->fixed_cow_array_map());
   ASSERT(index >= 0 && index < array->length());
   ASSERT(!array->GetHeap()->InNewSpace(value));
-  WRITE_FIELD(array, kHeaderSize + index * kPointerSize, value);
+  Heap::write_field(array,
+                    kHeaderSize + index * kPointerSize,
+                    value,
+                    SKIP_WRITE_BARRIER);
 }
 
 
 void FixedArray::set_undefined(int index) {
   ASSERT(map() != GetHeap()->fixed_cow_array_map());
   ASSERT(index >= 0 && index < this->length());
   ASSERT(!GetHeap()->InNewSpace(GetHeap()->undefined_value()));
-  WRITE_FIELD(this,
+  Heap::write_field(this,
               kHeaderSize + index * kPointerSize,
-              GetHeap()->undefined_value());
+              GetHeap()->undefined_value(),
+              SKIP_WRITE_BARRIER);
 }
 
 
 void FixedArray::set_null(int index) {
   ASSERT(index >= 0 && index < this->length());
   ASSERT(!GetHeap()->InNewSpace(GetHeap()->null_value()));
-  WRITE_FIELD(this,
+  Heap::write_field(this,
               kHeaderSize + index * kPointerSize,
-              GetHeap()->null_value());
+              GetHeap()->null_value(),
+              SKIP_WRITE_BARRIER);
 }
 
 
 void FixedArray::set_the_hole(int index) {
   ASSERT(map() != GetHeap()->fixed_cow_array_map());
   ASSERT(index >= 0 && index < this->length());
   ASSERT(!GetHeap()->InNewSpace(GetHeap()->the_hole_value()));
-  WRITE_FIELD(this,
+  Heap::write_field(this,
               kHeaderSize + index * kPointerSize,
-              GetHeap()->the_hole_value());
+              GetHeap()->the_hole_value(),
+              SKIP_WRITE_BARRIER);
 }
 
 
 void FixedArray::FillWithHoles(int from, int to) {
   for (int i = from; i < to; i++) {
     set_the_hole(i);
   }
 }
 
 
 Object** FixedArray::data_start() {
   return HeapObject::RawField(this, kHeaderSize);
 }
 
 
 bool DescriptorArray::IsEmpty() {
   ASSERT(length() >= kFirstIndex ||
          this == GetHeap()->empty_descriptor_array());
   return length() < kFirstIndex;
 }
 
 
 void DescriptorArray::SetNumberOfDescriptors(int number_of_descriptors) {
-  WRITE_FIELD(
-      this, kDescriptorLengthOffset, Smi::FromInt(number_of_descriptors));
+  Heap::write_field(
+      this,
+      kDescriptorLengthOffset,
+      Smi::FromInt(number_of_descriptors),
+      SKIP_WRITE_BARRIER);
 }
 
 
 // Perform a binary search in a fixed array. Low and high are entry indices. If
 // there are three entries in this array it should be called with low=0 and
 // high=2.
 template<SearchMode search_mode, typename T>
 int BinarySearch(T* array, Name* name, int low, int high, int valid_entries) {
   uint32_t hash = name->Hash();
   int limit = high;
@@ skipping 506 matching lines @@
 SYNCHRONIZED_SMI_ACCESSORS(FixedArrayBase, length, kLengthOffset)
 
 SMI_ACCESSORS(FreeSpace, size, kSizeOffset)
 NOBARRIER_SMI_ACCESSORS(FreeSpace, size, kSizeOffset)
 
 SMI_ACCESSORS(String, length, kLengthOffset)
 SYNCHRONIZED_SMI_ACCESSORS(String, length, kLengthOffset)
 
 
 uint32_t Name::hash_field() {
-  return READ_UINT32_FIELD(this, kHashFieldOffset);
+  return Heap::read_uint32_field(this, kHashFieldOffset);
 }
 
 
 void Name::set_hash_field(uint32_t value) {
-  WRITE_UINT32_FIELD(this, kHashFieldOffset, value);
+  Heap::write_uint32_field(this, kHashFieldOffset, value);
 #if V8_HOST_ARCH_64_BIT
-  WRITE_UINT32_FIELD(this, kHashFieldOffset + kIntSize, 0);
+  Heap::write_uint32_field(this, kHashFieldOffset + kIntSize, 0);
 #endif
 }
 
 
 bool Name::Equals(Name* other) {
   if (other == this) return true;
   if ((this->IsInternalizedString() && other->IsInternalizedString()) ||
       this->IsSymbol() || other->IsSymbol()) {
     return false;
   }
@@ skipping 85 matching lines @@
 }
 
 
 String* String::GetUnderlying() {
   // Giving direct access to underlying string only makes sense if the
   // wrapping string is already flattened.
   ASSERT(this->IsFlat());
   ASSERT(StringShape(this).IsIndirect());
   STATIC_ASSERT(ConsString::kFirstOffset == SlicedString::kParentOffset);
   const int kUnderlyingOffset = SlicedString::kParentOffset;
-  return String::cast(READ_FIELD(this, kUnderlyingOffset));
+  return String::cast(Heap::read_field(this, kUnderlyingOffset));
 }
 
 
 template<class Visitor>
 ConsString* String::VisitFlat(Visitor* visitor,
                               String* string,
                               const int offset) {
   int slice_offset = offset;
   const int length = string->length();
   ASSERT(offset <= length);
@@ skipping 39 matching lines @@
       default:
         UNREACHABLE();
         return NULL;
     }
   }
 }
 
 
 uint16_t SeqOneByteString::SeqOneByteStringGet(int index) {
   ASSERT(index >= 0 && index < length());
-  return READ_BYTE_FIELD(this, kHeaderSize + index * kCharSize);
+  return Heap::read_byte_field(this, kHeaderSize + index * kCharSize);
 }
 
 
 void SeqOneByteString::SeqOneByteStringSet(int index, uint16_t value) {
   ASSERT(index >= 0 && index < length() && value <= kMaxOneByteCharCode);
-  WRITE_BYTE_FIELD(this, kHeaderSize + index * kCharSize,
+  Heap::write_byte_field(this, kHeaderSize + index * kCharSize,
                    static_cast<byte>(value));
 }
 
 
 Address SeqOneByteString::GetCharsAddress() {
-  return FIELD_ADDR(this, kHeaderSize);
+  return Heap::get_field_address(this, kHeaderSize);
 }
 
 
 uint8_t* SeqOneByteString::GetChars() {
   return reinterpret_cast<uint8_t*>(GetCharsAddress());
 }
 
 
 Address SeqTwoByteString::GetCharsAddress() {
-  return FIELD_ADDR(this, kHeaderSize);
+  return Heap::get_field_address(this, kHeaderSize);
 }
 
 
 uc16* SeqTwoByteString::GetChars() {
-  return reinterpret_cast<uc16*>(FIELD_ADDR(this, kHeaderSize));
+  return reinterpret_cast<uc16*>(Heap::get_field_address(this, kHeaderSize));
 }
 
 
 uint16_t SeqTwoByteString::SeqTwoByteStringGet(int index) {
   ASSERT(index >= 0 && index < length());
-  return READ_SHORT_FIELD(this, kHeaderSize + index * kShortSize);
+  return Heap::read_short_field(this, kHeaderSize + index * kShortSize);
 }
 
 
 void SeqTwoByteString::SeqTwoByteStringSet(int index, uint16_t value) {
   ASSERT(index >= 0 && index < length());
-  WRITE_SHORT_FIELD(this, kHeaderSize + index * kShortSize, value);
+  Heap::write_short_field(this, kHeaderSize + index * kShortSize, value);
 }
 
 
 int SeqTwoByteString::SeqTwoByteStringSize(InstanceType instance_type) {
   return SizeFor(length());
 }
 
 
 int SeqOneByteString::SeqOneByteStringSize(InstanceType instance_type) {
   return SizeFor(length());
 }
 
 
 String* SlicedString::parent() {
-  return String::cast(READ_FIELD(this, kParentOffset));
+  return String::cast(Heap::read_field(this, kParentOffset));
 }
 
 
 void SlicedString::set_parent(String* parent, WriteBarrierMode mode) {
   ASSERT(parent->IsSeqString() || parent->IsExternalString());
-  WRITE_FIELD(this, kParentOffset, parent);
-  CONDITIONAL_WRITE_BARRIER(GetHeap(), this, kParentOffset, parent, mode);
+  Heap::write_field(this, kParentOffset, parent, mode);
 }
 
 
 SMI_ACCESSORS(SlicedString, offset, kOffsetOffset)
 
 
 String* ConsString::first() {
-  return String::cast(READ_FIELD(this, kFirstOffset));
+  return String::cast(Heap::read_field(this, kFirstOffset));
 }
 
 
 Object* ConsString::unchecked_first() {
-  return READ_FIELD(this, kFirstOffset);
+  return Heap::read_field(this, kFirstOffset);
 }
 
 
 void ConsString::set_first(String* value, WriteBarrierMode mode) {
-  WRITE_FIELD(this, kFirstOffset, value);
-  CONDITIONAL_WRITE_BARRIER(GetHeap(), this, kFirstOffset, value, mode);
+  Heap::write_field(this, kFirstOffset, value, mode);
 }
 
 
 String* ConsString::second() {
-  return String::cast(READ_FIELD(this, kSecondOffset));
+  return String::cast(Heap::read_field(this, kSecondOffset));
 }
 
 
 Object* ConsString::unchecked_second() {
-  return READ_FIELD(this, kSecondOffset);
+  return Heap::read_field(this, kSecondOffset);
 }
 
 
 void ConsString::set_second(String* value, WriteBarrierMode mode) {
-  WRITE_FIELD(this, kSecondOffset, value);
-  CONDITIONAL_WRITE_BARRIER(GetHeap(), this, kSecondOffset, value, mode);
+  Heap::write_field(this, kSecondOffset, value, mode);
 }
 
 
 bool ExternalString::is_short() {
   InstanceType type = map()->instance_type();
   return (type & kShortExternalStringMask) == kShortExternalStringTag;
 }
 
 
 const ExternalAsciiString::Resource* ExternalAsciiString::resource() {
-  return *reinterpret_cast<Resource**>(FIELD_ADDR(this, kResourceOffset));
+  return *reinterpret_cast<Resource**>(
+      Heap::get_field_address(this, kResourceOffset));
 }
 
 
 void ExternalAsciiString::update_data_cache() {
   if (is_short()) return;
-  const char** data_field =
-      reinterpret_cast<const char**>(FIELD_ADDR(this, kResourceDataOffset));
+  const char** data_field = reinterpret_cast<const char**>(
+      Heap::get_field_address(this, kResourceDataOffset));
   *data_field = resource()->data();
 }
 
 
 void ExternalAsciiString::set_resource(
     const ExternalAsciiString::Resource* resource) {
   ASSERT(IsAligned(reinterpret_cast<intptr_t>(resource), kPointerSize));
   *reinterpret_cast<const Resource**>(
-      FIELD_ADDR(this, kResourceOffset)) = resource;
+      Heap::get_field_address(this, kResourceOffset)) = resource;
   if (resource != NULL) update_data_cache();
 }
 
 
 const uint8_t* ExternalAsciiString::GetChars() {
   return reinterpret_cast<const uint8_t*>(resource()->data());
 }
 
 
 uint16_t ExternalAsciiString::ExternalAsciiStringGet(int index) {
   ASSERT(index >= 0 && index < length());
   return GetChars()[index];
 }
 
 
 const ExternalTwoByteString::Resource* ExternalTwoByteString::resource() {
-  return *reinterpret_cast<Resource**>(FIELD_ADDR(this, kResourceOffset));
+  return *reinterpret_cast<Resource**>(
+      Heap::get_field_address(this, kResourceOffset));
 }
 
 
 void ExternalTwoByteString::update_data_cache() {
   if (is_short()) return;
-  const uint16_t** data_field =
-      reinterpret_cast<const uint16_t**>(FIELD_ADDR(this, kResourceDataOffset));
+  const uint16_t** data_field = reinterpret_cast<const uint16_t**>(
+      Heap::get_field_address(this, kResourceDataOffset));
   *data_field = resource()->data();
 }
 
 
 void ExternalTwoByteString::set_resource(
     const ExternalTwoByteString::Resource* resource) {
   *reinterpret_cast<const Resource**>(
-      FIELD_ADDR(this, kResourceOffset)) = resource;
+      Heap::get_field_address(this, kResourceOffset)) = resource;
   if (resource != NULL) update_data_cache();
 }
 
 
 const uint16_t* ExternalTwoByteString::GetChars() {
   return resource()->data();
 }
 
 
 uint16_t ExternalTwoByteString::ExternalTwoByteStringGet(int index) {
@@ skipping 125 matching lines @@
 }
 
 
 void JSFunctionResultCache::set_finger_index(int finger_index) {
   set(kFingerIndex, Smi::FromInt(finger_index));
 }
 
 
 byte ByteArray::get(int index) {
   ASSERT(index >= 0 && index < this->length());
-  return READ_BYTE_FIELD(this, kHeaderSize + index * kCharSize);
+  return Heap::read_byte_field(this, kHeaderSize + index * kCharSize);
 }
 
 
 void ByteArray::set(int index, byte value) {
   ASSERT(index >= 0 && index < this->length());
-  WRITE_BYTE_FIELD(this, kHeaderSize + index * kCharSize, value);
+  Heap::write_byte_field(this, kHeaderSize + index * kCharSize, value);
 }
 
 
 int ByteArray::get_int(int index) {
   ASSERT(index >= 0 && (index * kIntSize) < this->length());
-  return READ_INT_FIELD(this, kHeaderSize + index * kIntSize);
+  return Heap::read_int_field(this, kHeaderSize + index * kIntSize);
 }
 
 
 ByteArray* ByteArray::FromDataStartAddress(Address address) {
   ASSERT_TAG_ALIGNED(address);
   return reinterpret_cast<ByteArray*>(address - kHeaderSize + kHeapObjectTag);
 }
 
 
 Address ByteArray::GetDataStartAddress() {
@@ skipping 22 matching lines @@
 
 
 void ExternalUint8ClampedArray::set(int index, uint8_t value) {
   ASSERT((index >= 0) && (index < this->length()));
   uint8_t* ptr = external_uint8_clamped_pointer();
   ptr[index] = value;
 }
 
 
 void* ExternalArray::external_pointer() {
-  intptr_t ptr = READ_INTPTR_FIELD(this, kExternalPointerOffset);
+  intptr_t ptr = Heap::read_intptr_field(this, kExternalPointerOffset);
   return reinterpret_cast<void*>(ptr);
 }
 
 
 void ExternalArray::set_external_pointer(void* value, WriteBarrierMode mode) {
   intptr_t ptr = reinterpret_cast<intptr_t>(value);
-  WRITE_INTPTR_FIELD(this, kExternalPointerOffset, ptr);
+  Heap::write_intptr_field(this, kExternalPointerOffset, ptr);
 }
 
 
 int8_t ExternalInt8Array::get_scalar(int index) {
   ASSERT((index >= 0) && (index < this->length()));
   int8_t* ptr = static_cast<int8_t*>(external_pointer());
   return ptr[index];
 }
 
 
@@ skipping 150 matching lines @@
 
 
 void ExternalFloat64Array::set(int index, double value) {
   ASSERT((index >= 0) && (index < this->length()));
   double* ptr = static_cast<double*>(external_pointer());
   ptr[index] = value;
 }
 
 
 void* FixedTypedArrayBase::DataPtr() {
-  return FIELD_ADDR(this, kDataOffset);
+  return Heap::get_field_address(this, kDataOffset);
 }
 
 
 int FixedTypedArrayBase::DataSize() {
   InstanceType instance_type = map()->instance_type();
   int element_size;
   switch (instance_type) {
 #define TYPED_ARRAY_CASE(Type, type, TYPE, ctype, size)                       \
     case FIXED_##TYPE##_ARRAY_TYPE:                                           \
       element_size = size;                                                    \
@@ skipping 40 matching lines @@
 }
 
 
 double Float64ArrayTraits::defaultValue() { return OS::nan_value(); }
 
 
 template <class Traits>
 typename Traits::ElementType FixedTypedArray<Traits>::get_scalar(int index) {
   ASSERT((index >= 0) && (index < this->length()));
   ElementType* ptr = reinterpret_cast<ElementType*>(
-      FIELD_ADDR(this, kDataOffset));
+      Heap::get_field_address(this, kDataOffset));
   return ptr[index];
 }
 
 
 template<> inline
 FixedTypedArray<Float64ArrayTraits>::ElementType
     FixedTypedArray<Float64ArrayTraits>::get_scalar(int index) {
   ASSERT((index >= 0) && (index < this->length()));
-  return READ_DOUBLE_FIELD(this, ElementOffset(index));
+  return Heap::read_double_field(this, ElementOffset(index));
 }
 
 
 template <class Traits>
 void FixedTypedArray<Traits>::set(int index, ElementType value) {
   ASSERT((index >= 0) && (index < this->length()));
   ElementType* ptr = reinterpret_cast<ElementType*>(
-      FIELD_ADDR(this, kDataOffset));
+      Heap::get_field_address(this, kDataOffset));
   ptr[index] = value;
 }
 
 
 template<> inline
 void FixedTypedArray<Float64ArrayTraits>::set(
     int index, Float64ArrayTraits::ElementType value) {
   ASSERT((index >= 0) && (index < this->length()));
-  WRITE_DOUBLE_FIELD(this, ElementOffset(index), value);
+  Heap::write_double_field(this, ElementOffset(index), value);
 }
 
 
 template <class Traits>
 typename Traits::ElementType FixedTypedArray<Traits>::from_int(int value) {
   return static_cast<ElementType>(value);
 }
 
 
 template <> inline
@@ skipping 103 matching lines @@
   return isolate->factory()->NewNumber(scalar);
 }
 
 
 Handle<Object> Float64ArrayTraits::ToHandle(Isolate* isolate, double scalar) {
   return isolate->factory()->NewNumber(scalar);
 }
 
 
 int Map::visitor_id() {
-  return READ_BYTE_FIELD(this, kVisitorIdOffset);
+  return Heap::read_byte_field(this, kVisitorIdOffset);
 }
 
 
 void Map::set_visitor_id(int id) {
   ASSERT(0 <= id && id < 256);
-  WRITE_BYTE_FIELD(this, kVisitorIdOffset, static_cast<byte>(id));
+  Heap::write_byte_field(this, kVisitorIdOffset, static_cast<byte>(id));
 }
 
 
 int Map::instance_size() {
-  return NOBARRIER_READ_BYTE_FIELD(
+  return Heap::nobarrier_read_byte_field(
       this, kInstanceSizeOffset) << kPointerSizeLog2;
 }
 
 
 int Map::inobject_properties() {
-  return READ_BYTE_FIELD(this, kInObjectPropertiesOffset);
+  return Heap::read_byte_field(this, kInObjectPropertiesOffset);
 }
 
 
 int Map::pre_allocated_property_fields() {
-  return READ_BYTE_FIELD(this, kPreAllocatedPropertyFieldsOffset);
+  return Heap::read_byte_field(this, kPreAllocatedPropertyFieldsOffset);
 }
 
 
 int Map::GetInObjectPropertyOffset(int index) {
   // Adjust for the number of properties stored in the object.
   index -= inobject_properties();
   ASSERT(index < 0);
   return instance_size() + (index * kPointerSize);
 }
 
@@ skipping 39 matching lines @@
   }
   ASSERT(instance_type == CODE_TYPE);
   return reinterpret_cast<Code*>(this)->CodeSize();
 }
 
 
 void Map::set_instance_size(int value) {
   ASSERT_EQ(0, value & (kPointerSize - 1));
   value >>= kPointerSizeLog2;
   ASSERT(0 <= value && value < 256);
-  NOBARRIER_WRITE_BYTE_FIELD(
+  Heap::nobarrier_write_byte_field(
       this, kInstanceSizeOffset, static_cast<byte>(value));
 }
 
 
 void Map::set_inobject_properties(int value) {
   ASSERT(0 <= value && value < 256);
-  WRITE_BYTE_FIELD(this, kInObjectPropertiesOffset, static_cast<byte>(value));
+  Heap::write_byte_field(
+      this,
+      kInObjectPropertiesOffset,
+      static_cast<byte>(value));
 }
 
 
 void Map::set_pre_allocated_property_fields(int value) {
   ASSERT(0 <= value && value < 256);
-  WRITE_BYTE_FIELD(this,
+  Heap::write_byte_field(this,
                    kPreAllocatedPropertyFieldsOffset,
                    static_cast<byte>(value));
 }
 
 
 InstanceType Map::instance_type() {
-  return static_cast<InstanceType>(READ_BYTE_FIELD(this, kInstanceTypeOffset));
+  return static_cast<InstanceType>(
+      Heap::read_byte_field(this, kInstanceTypeOffset));
 }
 
 
 void Map::set_instance_type(InstanceType value) {
-  WRITE_BYTE_FIELD(this, kInstanceTypeOffset, value);
+  Heap::write_byte_field(this, kInstanceTypeOffset, value);
 }
 
 
 int Map::unused_property_fields() {
-  return READ_BYTE_FIELD(this, kUnusedPropertyFieldsOffset);
+  return Heap::read_byte_field(this, kUnusedPropertyFieldsOffset);
 }
 
 
 void Map::set_unused_property_fields(int value) {
-  WRITE_BYTE_FIELD(this, kUnusedPropertyFieldsOffset, Min(value, 255));
+  Heap::write_byte_field(this, kUnusedPropertyFieldsOffset, Min(value, 255));
 }
 
 
 byte Map::bit_field() {
-  return READ_BYTE_FIELD(this, kBitFieldOffset);
+  return Heap::read_byte_field(this, kBitFieldOffset);
 }
 
 
 void Map::set_bit_field(byte value) {
-  WRITE_BYTE_FIELD(this, kBitFieldOffset, value);
+  Heap::write_byte_field(this, kBitFieldOffset, value);
 }
 
 
 byte Map::bit_field2() {
-  return READ_BYTE_FIELD(this, kBitField2Offset);
+  return Heap::read_byte_field(this, kBitField2Offset);
 }
 
 
 void Map::set_bit_field2(byte value) {
-  WRITE_BYTE_FIELD(this, kBitField2Offset, value);
+  Heap::write_byte_field(this, kBitField2Offset, value);
 }
 
 
 void Map::set_non_instance_prototype(bool value) {
   if (value) {
     set_bit_field(bit_field() | (1 << kHasNonInstancePrototype));
   } else {
     set_bit_field(bit_field() & ~(1 << kHasNonInstancePrototype));
   }
 }
@@ skipping 69 matching lines @@
   set_bit_field3(new_bit_field3);
 }
 
 
 bool Map::is_dictionary_map() {
   return DictionaryMap::decode(bit_field3());
 }
 
 
 Code::Flags Code::flags() {
-  return static_cast<Flags>(READ_INT_FIELD(this, kFlagsOffset));
+  return static_cast<Flags>(Heap::read_int_field(this, kFlagsOffset));
 }
 
 
 void Map::set_owns_descriptors(bool is_shared) {
   set_bit_field3(OwnsDescriptors::update(bit_field3(), is_shared));
 }
 
 
 bool Map::owns_descriptors() {
   return OwnsDescriptors::decode(bit_field3());
@@ skipping 140 matching lines @@
   for (int g = kGroupCount - 1; g > group; g--) {
     if (starts.at(g) < starts.at(g + 1)) {
       copy(starts.at(g), starts.at(g + 1));
     }
   }
 }
 
 
 void Code::set_flags(Code::Flags flags) {
   STATIC_ASSERT(Code::NUMBER_OF_KINDS <= KindField::kMax + 1);
-  WRITE_INT_FIELD(this, kFlagsOffset, flags);
+  Heap::write_int_field(this, kFlagsOffset, flags);
 }
 
 
 Code::Kind Code::kind() {
   return ExtractKindFromFlags(flags());
 }
 
 
 InlineCacheState Code::ic_state() {
   InlineCacheState result = ExtractICStateFromFlags(flags());
@@ skipping 13 matching lines @@
 }
 
 
 Code::StubType Code::type() {
   return ExtractTypeFromFlags(flags());
 }
 
 
 // For initialization.
 void Code::set_raw_kind_specific_flags1(int value) {
-  WRITE_INT_FIELD(this, kKindSpecificFlags1Offset, value);
+  Heap::write_int_field(this, kKindSpecificFlags1Offset, value);
 }
 
 
 void Code::set_raw_kind_specific_flags2(int value) {
-  WRITE_INT_FIELD(this, kKindSpecificFlags2Offset, value);
+  Heap::write_int_field(this, kKindSpecificFlags2Offset, value);
 }
 
 
 inline bool Code::is_crankshafted() {
   return IsCrankshaftedField::decode(
-      READ_UINT32_FIELD(this, kKindSpecificFlags2Offset));
+      Heap::read_uint32_field(this, kKindSpecificFlags2Offset));
 }
 
 
 inline void Code::set_is_crankshafted(bool value) {
-  int previous = READ_UINT32_FIELD(this, kKindSpecificFlags2Offset);
+  int previous = Heap::read_uint32_field(this, kKindSpecificFlags2Offset);
   int updated = IsCrankshaftedField::update(previous, value);
-  WRITE_UINT32_FIELD(this, kKindSpecificFlags2Offset, updated);
+  Heap::write_uint32_field(this, kKindSpecificFlags2Offset, updated);
 }
 
 
 int Code::major_key() {
   ASSERT(has_major_key());
   return StubMajorKeyField::decode(
-      READ_UINT32_FIELD(this, kKindSpecificFlags2Offset));
+      Heap::read_uint32_field(this, kKindSpecificFlags2Offset));
 }
 
 
 void Code::set_major_key(int major) {
   ASSERT(has_major_key());
   ASSERT(0 <= major && major < 256);
-  int previous = READ_UINT32_FIELD(this, kKindSpecificFlags2Offset);
+  int previous = Heap::read_uint32_field(this, kKindSpecificFlags2Offset);
   int updated = StubMajorKeyField::update(previous, major);
-  WRITE_UINT32_FIELD(this, kKindSpecificFlags2Offset, updated);
+  Heap::write_uint32_field(this, kKindSpecificFlags2Offset, updated);
 }
 
 
 bool Code::has_major_key() {
   return kind() == STUB ||
       kind() == HANDLER ||
       kind() == BINARY_OP_IC ||
       kind() == COMPARE_IC ||
       kind() == COMPARE_NIL_IC ||
       kind() == LOAD_IC ||
       kind() == KEYED_LOAD_IC ||
       kind() == STORE_IC ||
       kind() == KEYED_STORE_IC ||
       kind() == TO_BOOLEAN_IC;
 }
 
 
 bool Code::optimizable() {
   ASSERT_EQ(FUNCTION, kind());
-  return READ_BYTE_FIELD(this, kOptimizableOffset) == 1;
+  return Heap::read_byte_field(this, kOptimizableOffset) == 1;
 }
 
 
 void Code::set_optimizable(bool value) {
   ASSERT_EQ(FUNCTION, kind());
-  WRITE_BYTE_FIELD(this, kOptimizableOffset, value ? 1 : 0);
+  Heap::write_byte_field(this, kOptimizableOffset, value ? 1 : 0);
 }
 
 
 bool Code::has_deoptimization_support() {
   ASSERT_EQ(FUNCTION, kind());
-  byte flags = READ_BYTE_FIELD(this, kFullCodeFlags);
+  byte flags = Heap::read_byte_field(this, kFullCodeFlags);
   return FullCodeFlagsHasDeoptimizationSupportField::decode(flags);
 }
 
 
 void Code::set_has_deoptimization_support(bool value) {
   ASSERT_EQ(FUNCTION, kind());
-  byte flags = READ_BYTE_FIELD(this, kFullCodeFlags);
+  byte flags = Heap::read_byte_field(this, kFullCodeFlags);
   flags = FullCodeFlagsHasDeoptimizationSupportField::update(flags, value);
-  WRITE_BYTE_FIELD(this, kFullCodeFlags, flags);
+  Heap::write_byte_field(this, kFullCodeFlags, flags);
 }
 
 
 bool Code::has_debug_break_slots() {
   ASSERT_EQ(FUNCTION, kind());
-  byte flags = READ_BYTE_FIELD(this, kFullCodeFlags);
+  byte flags = Heap::read_byte_field(this, kFullCodeFlags);
   return FullCodeFlagsHasDebugBreakSlotsField::decode(flags);
 }
 
 
 void Code::set_has_debug_break_slots(bool value) {
   ASSERT_EQ(FUNCTION, kind());
-  byte flags = READ_BYTE_FIELD(this, kFullCodeFlags);
+  byte flags = Heap::read_byte_field(this, kFullCodeFlags);
   flags = FullCodeFlagsHasDebugBreakSlotsField::update(flags, value);
-  WRITE_BYTE_FIELD(this, kFullCodeFlags, flags);
+  Heap::write_byte_field(this, kFullCodeFlags, flags);
 }
 
 
 bool Code::is_compiled_optimizable() {
   ASSERT_EQ(FUNCTION, kind());
-  byte flags = READ_BYTE_FIELD(this, kFullCodeFlags);
+  byte flags = Heap::read_byte_field(this, kFullCodeFlags);
   return FullCodeFlagsIsCompiledOptimizable::decode(flags);
 }
 
 
 void Code::set_compiled_optimizable(bool value) {
   ASSERT_EQ(FUNCTION, kind());
-  byte flags = READ_BYTE_FIELD(this, kFullCodeFlags);
+  byte flags = Heap::read_byte_field(this, kFullCodeFlags);
   flags = FullCodeFlagsIsCompiledOptimizable::update(flags, value);
-  WRITE_BYTE_FIELD(this, kFullCodeFlags, flags);
+  Heap::write_byte_field(this, kFullCodeFlags, flags);
 }
 
 
 int Code::allow_osr_at_loop_nesting_level() {
   ASSERT_EQ(FUNCTION, kind());
-  return READ_BYTE_FIELD(this, kAllowOSRAtLoopNestingLevelOffset);
+  return Heap::read_byte_field(this, kAllowOSRAtLoopNestingLevelOffset);
 }
 
 
 void Code::set_allow_osr_at_loop_nesting_level(int level) {
   ASSERT_EQ(FUNCTION, kind());
   ASSERT(level >= 0 && level <= kMaxLoopNestingMarker);
-  WRITE_BYTE_FIELD(this, kAllowOSRAtLoopNestingLevelOffset, level);
+  Heap::write_byte_field(this, kAllowOSRAtLoopNestingLevelOffset, level);
 }
 
 
 int Code::profiler_ticks() {
   ASSERT_EQ(FUNCTION, kind());
-  return READ_BYTE_FIELD(this, kProfilerTicksOffset);
+  return Heap::read_byte_field(this, kProfilerTicksOffset);
 }
 
 
 void Code::set_profiler_ticks(int ticks) {
   ASSERT_EQ(FUNCTION, kind());
   ASSERT(ticks < 256);
-  WRITE_BYTE_FIELD(this, kProfilerTicksOffset, ticks);
+  Heap::write_byte_field(this, kProfilerTicksOffset, ticks);
 }
 
 
 unsigned Code::stack_slots() {
   ASSERT(is_crankshafted());
   return StackSlotsField::decode(
-      READ_UINT32_FIELD(this, kKindSpecificFlags1Offset));
+      Heap::read_uint32_field(this, kKindSpecificFlags1Offset));
 }
 
 
 void Code::set_stack_slots(unsigned slots) {
   CHECK(slots <= (1 << kStackSlotsBitCount));
   ASSERT(is_crankshafted());
-  int previous = READ_UINT32_FIELD(this, kKindSpecificFlags1Offset);
+  int previous = Heap::read_uint32_field(this, kKindSpecificFlags1Offset);
   int updated = StackSlotsField::update(previous, slots);
-  WRITE_UINT32_FIELD(this, kKindSpecificFlags1Offset, updated);
+  Heap::write_uint32_field(this, kKindSpecificFlags1Offset, updated);
 }
 
 
 unsigned Code::safepoint_table_offset() {
   ASSERT(is_crankshafted());
   return SafepointTableOffsetField::decode(
-      READ_UINT32_FIELD(this, kKindSpecificFlags2Offset));
+      Heap::read_uint32_field(this, kKindSpecificFlags2Offset));
 }
 
 
 void Code::set_safepoint_table_offset(unsigned offset) {
   CHECK(offset <= (1 << kSafepointTableOffsetBitCount));
   ASSERT(is_crankshafted());
   ASSERT(IsAligned(offset, static_cast<unsigned>(kIntSize)));
-  int previous = READ_UINT32_FIELD(this, kKindSpecificFlags2Offset);
+  int previous = Heap::read_uint32_field(this, kKindSpecificFlags2Offset);
   int updated = SafepointTableOffsetField::update(previous, offset);
-  WRITE_UINT32_FIELD(this, kKindSpecificFlags2Offset, updated);
+  Heap::write_uint32_field(this, kKindSpecificFlags2Offset, updated);
 }
 
 
 unsigned Code::back_edge_table_offset() {
   ASSERT_EQ(FUNCTION, kind());
   return BackEdgeTableOffsetField::decode(
-      READ_UINT32_FIELD(this, kKindSpecificFlags2Offset));
+      Heap::read_uint32_field(this, kKindSpecificFlags2Offset));
 }
 
 
 void Code::set_back_edge_table_offset(unsigned offset) {
   ASSERT_EQ(FUNCTION, kind());
   ASSERT(IsAligned(offset, static_cast<unsigned>(kIntSize)));
-  int previous = READ_UINT32_FIELD(this, kKindSpecificFlags2Offset);
+  int previous = Heap::read_uint32_field(this, kKindSpecificFlags2Offset);
   int updated = BackEdgeTableOffsetField::update(previous, offset);
-  WRITE_UINT32_FIELD(this, kKindSpecificFlags2Offset, updated);
+  Heap::write_uint32_field(this, kKindSpecificFlags2Offset, updated);
 }
 
 
 bool Code::back_edges_patched_for_osr() {
   ASSERT_EQ(FUNCTION, kind());
   return BackEdgesPatchedForOSRField::decode(
-      READ_UINT32_FIELD(this, kKindSpecificFlags2Offset));
+      Heap::read_uint32_field(this, kKindSpecificFlags2Offset));
 }
 
 
 void Code::set_back_edges_patched_for_osr(bool value) {
   ASSERT_EQ(FUNCTION, kind());
-  int previous = READ_UINT32_FIELD(this, kKindSpecificFlags2Offset);
+  int previous = Heap::read_uint32_field(this, kKindSpecificFlags2Offset);
   int updated = BackEdgesPatchedForOSRField::update(previous, value);
-  WRITE_UINT32_FIELD(this, kKindSpecificFlags2Offset, updated);
+  Heap::write_uint32_field(this, kKindSpecificFlags2Offset, updated);
 }
 
 
 
 byte Code::to_boolean_state() {
   return extra_ic_state();
 }
 
 
 bool Code::has_function_cache() {
   ASSERT(kind() == STUB);
   return HasFunctionCacheField::decode(
-      READ_UINT32_FIELD(this, kKindSpecificFlags1Offset));
+      Heap::read_uint32_field(this, kKindSpecificFlags1Offset));
 }
 
 
 void Code::set_has_function_cache(bool flag) {
   ASSERT(kind() == STUB);
-  int previous = READ_UINT32_FIELD(this, kKindSpecificFlags1Offset);
+  int previous = Heap::read_uint32_field(this, kKindSpecificFlags1Offset);
   int updated = HasFunctionCacheField::update(previous, flag);
-  WRITE_UINT32_FIELD(this, kKindSpecificFlags1Offset, updated);
+  Heap::write_uint32_field(this, kKindSpecificFlags1Offset, updated);
 }
 
 
 bool Code::marked_for_deoptimization() {
   ASSERT(kind() == OPTIMIZED_FUNCTION);
   return MarkedForDeoptimizationField::decode(
-      READ_UINT32_FIELD(this, kKindSpecificFlags1Offset));
+      Heap::read_uint32_field(this, kKindSpecificFlags1Offset));
 }
 
 
 void Code::set_marked_for_deoptimization(bool flag) {
   ASSERT(kind() == OPTIMIZED_FUNCTION);
   ASSERT(!flag || AllowDeoptimization::IsAllowed(GetIsolate()));
-  int previous = READ_UINT32_FIELD(this, kKindSpecificFlags1Offset);
+  int previous = Heap::read_uint32_field(this, kKindSpecificFlags1Offset);
   int updated = MarkedForDeoptimizationField::update(previous, flag);
-  WRITE_UINT32_FIELD(this, kKindSpecificFlags1Offset, updated);
+  Heap::write_uint32_field(this, kKindSpecificFlags1Offset, updated);
 }
 
 
 bool Code::is_weak_stub() {
   return CanBeWeakStub() && WeakStubField::decode(
-      READ_UINT32_FIELD(this, kKindSpecificFlags1Offset));
+      Heap::read_uint32_field(this, kKindSpecificFlags1Offset));
 }
 
 
 void Code::mark_as_weak_stub() {
   ASSERT(CanBeWeakStub());
-  int previous = READ_UINT32_FIELD(this, kKindSpecificFlags1Offset);
+  int previous = Heap::read_uint32_field(this, kKindSpecificFlags1Offset);
   int updated = WeakStubField::update(previous, true);
-  WRITE_UINT32_FIELD(this, kKindSpecificFlags1Offset, updated);
+  Heap::write_uint32_field(this, kKindSpecificFlags1Offset, updated);
 }
 
 
 bool Code::is_invalidated_weak_stub() {
   return is_weak_stub() && InvalidatedWeakStubField::decode(
-      READ_UINT32_FIELD(this, kKindSpecificFlags1Offset));
+      Heap::read_uint32_field(this, kKindSpecificFlags1Offset));
 }
 
 
 void Code::mark_as_invalidated_weak_stub() {
   ASSERT(is_inline_cache_stub());
-  int previous = READ_UINT32_FIELD(this, kKindSpecificFlags1Offset);
+  int previous = Heap::read_uint32_field(this, kKindSpecificFlags1Offset);
   int updated = InvalidatedWeakStubField::update(previous, true);
-  WRITE_UINT32_FIELD(this, kKindSpecificFlags1Offset, updated);
+  Heap::write_uint32_field(this, kKindSpecificFlags1Offset, updated);
 }
 
 
 bool Code::is_inline_cache_stub() {
   Kind kind = this->kind();
   switch (kind) {
 #define CASE(name) case name: return true;
     IC_KIND_LIST(CASE)
 #undef CASE
     default: return false;
   }
 }
 
 
 bool Code::is_keyed_stub() {
   return is_keyed_load_stub() || is_keyed_store_stub();
 }
 
 
 bool Code::is_debug_stub() {
   return ic_state() == DEBUG_STUB;
 }
 
 
 ConstantPoolArray* Code::constant_pool() {
-  return ConstantPoolArray::cast(READ_FIELD(this, kConstantPoolOffset));
+  return ConstantPoolArray::cast(Heap::read_field(this, kConstantPoolOffset));
 }
 
 
 void Code::set_constant_pool(Object* value) {
   ASSERT(value->IsConstantPoolArray());
-  WRITE_FIELD(this, kConstantPoolOffset, value);
-  WRITE_BARRIER(GetHeap(), this, kConstantPoolOffset, value);
+  Heap::write_field(this, kConstantPoolOffset, value, UPDATE_WRITE_BARRIER);
 }
 
 
 Code::Flags Code::ComputeFlags(Kind kind,
                                InlineCacheState ic_state,
                                ExtraICState extra_ic_state,
                                StubType type,
                                InlineCacheHolderFlag holder) {
   // Compute the bit mask.
   unsigned int bits = KindField::encode(kind)
@@ skipping 101 matching lines @@
 
 
 bool Code::IsWeakObjectInIC(Object* object) {
   return object->IsMap() && Map::cast(object)->CanTransition() &&
          FLAG_collect_maps &&
          FLAG_weak_embedded_maps_in_ic;
 }
 
 
 Object* Map::prototype() {
-  return READ_FIELD(this, kPrototypeOffset);
+  return Heap::read_field(this, kPrototypeOffset);
 }
 
 
 void Map::set_prototype(Object* value, WriteBarrierMode mode) {
   ASSERT(value->IsNull() || value->IsJSReceiver());
-  WRITE_FIELD(this, kPrototypeOffset, value);
-  CONDITIONAL_WRITE_BARRIER(GetHeap(), this, kPrototypeOffset, value, mode);
+  Heap::write_field(this, kPrototypeOffset, value, mode);
 }
 
 
 // If the descriptor is using the empty transition array, install a new empty
 // transition array that will have place for an element transition.
 static void EnsureHasTransitionArray(Handle<Map> map) {
   Handle<TransitionArray> transitions;
   if (!map->HasTransitionArray()) {
     transitions = TransitionArray::Allocate(map->GetIsolate(), 0);
     transitions->set_back_pointer_storage(map->GetBackPointer());
@@ skipping 13 matching lines @@
 }
 
 
 ACCESSORS(Map, instance_descriptors, DescriptorArray, kDescriptorsOffset)
 
 
 void Map::set_bit_field3(uint32_t bits) {
   // Ensure the upper 2 bits have the same value by sign extending it. This is
   // necessary to be able to use the 31st bit.
   int value = bits << 1;
-  WRITE_FIELD(this, kBitField3Offset, Smi::FromInt(value >> 1));
+  Heap::write_field(this,
+                    kBitField3Offset,
+                    Smi::FromInt(value >> 1),
+                    SKIP_WRITE_BARRIER);
 }
 
 
 uint32_t Map::bit_field3() {
-  Object* value = READ_FIELD(this, kBitField3Offset);
+  Object* value = Heap::read_field(this, kBitField3Offset);
   return Smi::cast(value)->value();
 }
 
 
 void Map::AppendDescriptor(Descriptor* desc) {
   DescriptorArray* descriptors = instance_descriptors();
   int number_of_own_descriptors = NumberOfOwnDescriptors();
   ASSERT(descriptors->number_of_descriptors() == number_of_own_descriptors);
   descriptors->Append(desc);
   SetNumberOfOwnDescriptors(number_of_own_descriptors + 1);
 }
 
 
 Object* Map::GetBackPointer() {
-  Object* object = READ_FIELD(this, kTransitionsOrBackPointerOffset);
+  Object* object = Heap::read_field(this, kTransitionsOrBackPointerOffset);
   if (object->IsDescriptorArray()) {
     return TransitionArray::cast(object)->back_pointer_storage();
   } else {
     ASSERT(object->IsMap() || object->IsUndefined());
     return object;
   }
 }
 
 
 bool Map::HasElementsTransition() {
   return HasTransitionArray() && transitions()->HasElementsTransition();
 }
 
 
 bool Map::HasTransitionArray() {
-  Object* object = READ_FIELD(this, kTransitionsOrBackPointerOffset);
+  Object* object = Heap::read_field(this, kTransitionsOrBackPointerOffset);
   return object->IsTransitionArray();
 }
 
 
 Map* Map::elements_transition_map() {
   int index = transitions()->Search(GetHeap()->elements_transition_symbol());
   return transitions()->GetTarget(index);
 }
 
 
@@ skipping 40 matching lines @@
 }
 
 
 bool Map::HasPrototypeTransitions() {
   return HasTransitionArray() && transitions()->HasPrototypeTransitions();
 }
 
 
 TransitionArray* Map::transitions() {
   ASSERT(HasTransitionArray());
-  Object* object = READ_FIELD(this, kTransitionsOrBackPointerOffset);
+  Object* object = Heap::read_field(this, kTransitionsOrBackPointerOffset);
   return TransitionArray::cast(object);
 }
 
 
 void Map::set_transitions(TransitionArray* transition_array,
                           WriteBarrierMode mode) {
   // Transition arrays are not shared. When one is replaced, it should not
   // keep referenced objects alive, so we zap it.
   // When there is another reference to the array somewhere (e.g. a handle),
   // not zapping turns from a waste of memory into a source of crashes.
   if (HasTransitionArray()) {
 #ifdef DEBUG
     for (int i = 0; i < transitions()->number_of_transitions(); i++) {
       Map* target = transitions()->GetTarget(i);
       if (target->instance_descriptors() == instance_descriptors()) {
         Name* key = transitions()->GetKey(i);
         int new_target_index = transition_array->Search(key);
         ASSERT(new_target_index != TransitionArray::kNotFound);
         ASSERT(transition_array->GetTarget(new_target_index) == target);
       }
     }
 #endif
     ASSERT(transitions() != transition_array);
     ZapTransitions();
   }
 
-  WRITE_FIELD(this, kTransitionsOrBackPointerOffset, transition_array);
-  CONDITIONAL_WRITE_BARRIER(
-      GetHeap(), this, kTransitionsOrBackPointerOffset, transition_array, mode);
+  Heap::write_field(this,
+                    kTransitionsOrBackPointerOffset,
+                    transition_array,
+                    mode);
 }
 
 
 void Map::init_back_pointer(Object* undefined) {
   ASSERT(undefined->IsUndefined());
-  WRITE_FIELD(this, kTransitionsOrBackPointerOffset, undefined);
+  Heap::write_field(this,
+                    kTransitionsOrBackPointerOffset,
+                    undefined,
+                    SKIP_WRITE_BARRIER);
 }
 
 
 void Map::SetBackPointer(Object* value, WriteBarrierMode mode) {
   ASSERT(instance_type() >= FIRST_JS_RECEIVER_TYPE);
   ASSERT((value->IsUndefined() && GetBackPointer()->IsMap()) ||
          (value->IsMap() && GetBackPointer()->IsUndefined()));
-  Object* object = READ_FIELD(this, kTransitionsOrBackPointerOffset);
+  Object* object = Heap::read_field(this, kTransitionsOrBackPointerOffset);
   if (object->IsTransitionArray()) {
     TransitionArray::cast(object)->set_back_pointer_storage(value);
   } else {
-    WRITE_FIELD(this, kTransitionsOrBackPointerOffset, value);
-    CONDITIONAL_WRITE_BARRIER(
-        GetHeap(), this, kTransitionsOrBackPointerOffset, value, mode);
+    Heap::write_field(this, kTransitionsOrBackPointerOffset, value, mode);
   }
 }
 
 
 ACCESSORS(Map, code_cache, Object, kCodeCacheOffset)
 ACCESSORS(Map, dependent_code, DependentCode, kDependentCodeOffset)
 ACCESSORS(Map, constructor, Object, kConstructorOffset)
 
 ACCESSORS(JSFunction, shared, SharedFunctionInfo, kSharedFunctionInfoOffset)
 ACCESSORS(JSFunction, literals_or_bindings, FixedArray, kLiteralsOffset)
@@ skipping 192 matching lines @@
               kOptCountAndBailoutReasonOffset)
 SMI_ACCESSORS(SharedFunctionInfo, counters, kCountersOffset)
 SMI_ACCESSORS(SharedFunctionInfo, ast_node_count, kAstNodeCountOffset)
 SMI_ACCESSORS(SharedFunctionInfo, profiler_ticks, kProfilerTicksOffset)
 
 #else
 
 #define PSEUDO_SMI_ACCESSORS_LO(holder, name, offset)             \
   STATIC_ASSERT(holder::offset % kPointerSize == 0);              \
   int holder::name() {                                            \
-    int value = READ_INT_FIELD(this, offset);                     \
+    int value = Heap::read_int_field(this, offset);                     \
     ASSERT(kHeapObjectTag == 1);                                  \
     ASSERT((value & kHeapObjectTag) == 0);                        \
     return value >> 1;                                            \
   }                                                               \
   void holder::set_##name(int value) {                            \
     ASSERT(kHeapObjectTag == 1);                                  \
     ASSERT((value & 0xC0000000) == 0xC0000000 ||                  \
            (value & 0xC0000000) == 0x000000000);                  \
-    WRITE_INT_FIELD(this,                                         \
+    Heap::write_int_field(this,                                         \
                     offset,                                       \
                     (value << 1) & ~kHeapObjectTag);              \
   }
 
 #define PSEUDO_SMI_ACCESSORS_HI(holder, name, offset)             \
   STATIC_ASSERT(holder::offset % kPointerSize == kIntSize);       \
   INT_ACCESSORS(holder, name, offset)
 
 
 PSEUDO_SMI_ACCESSORS_LO(SharedFunctionInfo, length, kLengthOffset)
@@ skipping 27 matching lines @@
                         ast_node_count,
                         kAstNodeCountOffset)
 PSEUDO_SMI_ACCESSORS_HI(SharedFunctionInfo,
                         profiler_ticks,
                         kProfilerTicksOffset)
 
 #endif
 
 
 int SharedFunctionInfo::construction_count() {
-  return READ_BYTE_FIELD(this, kConstructionCountOffset);
+  return Heap::read_byte_field(this, kConstructionCountOffset);
 }
 
 
 void SharedFunctionInfo::set_construction_count(int value) {
   ASSERT(0 <= value && value < 256);
-  WRITE_BYTE_FIELD(this, kConstructionCountOffset, static_cast<byte>(value));
+  Heap::write_byte_field(
+      this,
+      kConstructionCountOffset,
+      static_cast<byte>(value));
 }
 
 
 BOOL_ACCESSORS(SharedFunctionInfo,
                compiler_hints,
                live_objects_may_exist,
                kLiveObjectsMayExist)
 
 
 bool SharedFunctionInfo::IsInobjectSlackTrackingInProgress() {
@@ skipping 85 matching lines @@
 }
 
 
 void SharedFunctionInfo::set_start_position(int start_position) {
   set_start_position_and_type((start_position << kStartPositionShift)
     | (start_position_and_type() & ~kStartPositionMask));
 }
 
 
 Code* SharedFunctionInfo::code() {
-  return Code::cast(READ_FIELD(this, kCodeOffset));
+  return Code::cast(Heap::read_field(this, kCodeOffset));
 }
 
 
 void SharedFunctionInfo::set_code(Code* value, WriteBarrierMode mode) {
   ASSERT(value->kind() != Code::OPTIMIZED_FUNCTION);
-  WRITE_FIELD(this, kCodeOffset, value);
-  CONDITIONAL_WRITE_BARRIER(value->GetHeap(), this, kCodeOffset, value, mode);
+  Heap::write_field(this, kCodeOffset, value, mode);
 }
 
 
 void SharedFunctionInfo::ReplaceCode(Code* value) {
   // If the GC metadata field is already used then the function was
   // enqueued as a code flushing candidate and we remove it now.
   if (code()->gc_metadata() != NULL) {
     CodeFlusher* flusher = GetHeap()->mark_compact_collector()->code_flusher();
     flusher->EvictCandidate(this);
   }
 
   ASSERT(code()->gc_metadata() == NULL && value->gc_metadata() == NULL);
   set_code(value);
 }
 
 
 ScopeInfo* SharedFunctionInfo::scope_info() {
-  return reinterpret_cast<ScopeInfo*>(READ_FIELD(this, kScopeInfoOffset));
+  return reinterpret_cast<ScopeInfo*>(Heap::read_field(this, kScopeInfoOffset));
 }
 
 
 void SharedFunctionInfo::set_scope_info(ScopeInfo* value,
                                         WriteBarrierMode mode) {
-  WRITE_FIELD(this, kScopeInfoOffset, reinterpret_cast<Object*>(value));
-  CONDITIONAL_WRITE_BARRIER(GetHeap(),
-                            this,
-                            kScopeInfoOffset,
-                            reinterpret_cast<Object*>(value),
-                            mode);
+  Heap::write_field(this,
+                    kScopeInfoOffset,
+                    reinterpret_cast<Object*>(value),
+                    mode);
 }
 
 
 bool SharedFunctionInfo::is_compiled() {
   return code() !=
       GetIsolate()->builtins()->builtin(Builtins::kCompileUnoptimized);
 }
 
 
 bool SharedFunctionInfo::IsApiFunction() {
@@ skipping 127 matching lines @@
 }
 
 
 bool JSFunction::IsInOptimizationQueue() {
   return code() == GetIsolate()->builtins()->builtin(
       Builtins::kInOptimizationQueue);
 }
 
 
 Code* JSFunction::code() {
-  return Code::cast(
-      Code::GetObjectFromEntryAddress(FIELD_ADDR(this, kCodeEntryOffset)));
+  return Code::cast(Code::GetObjectFromEntryAddress(
+      Heap::get_field_address(this, kCodeEntryOffset)));
 }
 
 
 void JSFunction::set_code(Code* value) {
   ASSERT(!GetHeap()->InNewSpace(value));
   Address entry = value->entry();
-  WRITE_INTPTR_FIELD(this, kCodeEntryOffset, reinterpret_cast<intptr_t>(entry));
+  Heap::write_intptr_field(
+      this,
+      kCodeEntryOffset,
+      reinterpret_cast<intptr_t>(entry));
   GetHeap()->incremental_marking()->RecordWriteOfCodeEntry(
       this,
       HeapObject::RawField(this, kCodeEntryOffset),
       value);
 }
 
 
 void JSFunction::set_code_no_write_barrier(Code* value) {
   ASSERT(!GetHeap()->InNewSpace(value));
   Address entry = value->entry();
-  WRITE_INTPTR_FIELD(this, kCodeEntryOffset, reinterpret_cast<intptr_t>(entry));
+  Heap::write_intptr_field(
+      this,
+      kCodeEntryOffset,
+      reinterpret_cast<intptr_t>(entry));
 }
 
 
 void JSFunction::ReplaceCode(Code* code) {
   bool was_optimized = IsOptimized();
   bool is_optimized = code->kind() == Code::OPTIMIZED_FUNCTION;
 
   if (was_optimized && is_optimized) {
     shared()->EvictFromOptimizedCodeMap(this->code(),
         "Replacing with another optimized code");
   }
 
   set_code(code);
 
   // Add/remove the function from the list of optimized functions for this
   // context based on the state change.
   if (!was_optimized && is_optimized) {
     context()->native_context()->AddOptimizedFunction(this);
   }
   if (was_optimized && !is_optimized) {
     // TODO(titzer): linear in the number of optimized functions; fix!
     context()->native_context()->RemoveOptimizedFunction(this);
   }
 }
 
 
 Context* JSFunction::context() {
-  return Context::cast(READ_FIELD(this, kContextOffset));
+  return Context::cast(Heap::read_field(this, kContextOffset));
 }
 
 
 void JSFunction::set_context(Object* value) {
   ASSERT(value->IsUndefined() || value->IsContext());
-  WRITE_FIELD(this, kContextOffset, value);
-  WRITE_BARRIER(GetHeap(), this, kContextOffset, value);
+  Heap::write_field(this, kContextOffset, value, UPDATE_WRITE_BARRIER);
 }
 
 ACCESSORS(JSFunction, prototype_or_initial_map, Object,
           kPrototypeOrInitialMapOffset)
 
 
 Map* JSFunction::initial_map() {
   return Map::cast(prototype_or_initial_map());
 }
 
@@ skipping 76 matching lines @@
 
 
 int JSFunction::NumberOfLiterals() {
   ASSERT(!shared()->bound());
   return literals()->length();
 }
 
 
 Object* JSBuiltinsObject::javascript_builtin(Builtins::JavaScript id) {
   ASSERT(id < kJSBuiltinsCount);  // id is unsigned.
-  return READ_FIELD(this, OffsetOfFunctionWithId(id));
+  return Heap::read_field(this, OffsetOfFunctionWithId(id));
 }
 
 
 void JSBuiltinsObject::set_javascript_builtin(Builtins::JavaScript id,
                                               Object* value) {
   ASSERT(id < kJSBuiltinsCount);  // id is unsigned.
-  WRITE_FIELD(this, OffsetOfFunctionWithId(id), value);
-  WRITE_BARRIER(GetHeap(), this, OffsetOfFunctionWithId(id), value);
+  Heap::write_field(this,
+                    OffsetOfFunctionWithId(id),
+                    value,
+                    UPDATE_WRITE_BARRIER);
 }
 
 
 Code* JSBuiltinsObject::javascript_builtin_code(Builtins::JavaScript id) {
   ASSERT(id < kJSBuiltinsCount);  // id is unsigned.
-  return Code::cast(READ_FIELD(this, OffsetOfCodeWithId(id)));
+  return Code::cast(Heap::read_field(this, OffsetOfCodeWithId(id)));
 }
 
 
 void JSBuiltinsObject::set_javascript_builtin_code(Builtins::JavaScript id,
                                                    Code* value) {
   ASSERT(id < kJSBuiltinsCount);  // id is unsigned.
-  WRITE_FIELD(this, OffsetOfCodeWithId(id), value);
+  Heap::write_field(this, OffsetOfCodeWithId(id), value, UPDATE_WRITE_BARRIER);
   ASSERT(!GetHeap()->InNewSpace(value));
 }
 
 
 ACCESSORS(JSProxy, handler, Object, kHandlerOffset)
 ACCESSORS(JSProxy, hash, Object, kHashOffset)
 ACCESSORS(JSFunctionProxy, call_trap, Object, kCallTrapOffset)
 ACCESSORS(JSFunctionProxy, construct_trap, Object, kConstructTrapOffset)
 
 
 void JSProxy::InitializeBody(int object_size, Object* value) {
   ASSERT(!value->IsHeapObject() || !GetHeap()->InNewSpace(value));
   for (int offset = kHeaderSize; offset < object_size; offset += kPointerSize) {
-    WRITE_FIELD(this, offset, value);
+    Heap::write_field(this, offset, value, SKIP_WRITE_BARRIER);
   }
 }
 
 
 ACCESSORS(JSSet, table, Object, kTableOffset)
 ACCESSORS(JSMap, table, Object, kTableOffset)
 
 
 #define ORDERED_HASH_TABLE_ITERATOR_ACCESSORS(name, type, offset)    \
   template<class Derived, class TableType>                           \
   type* OrderedHashTableIterator<Derived, TableType>::name() {       \
-    return type::cast(READ_FIELD(this, offset));                     \
+    return type::cast(Heap::read_field(this, offset));               \
   }                                                                  \
   template<class Derived, class TableType>                           \
   void OrderedHashTableIterator<Derived, TableType>::set_##name(     \
       type* value, WriteBarrierMode mode) {                          \
-    WRITE_FIELD(this, offset, value);                                \
-    CONDITIONAL_WRITE_BARRIER(GetHeap(), this, offset, value, mode); \
+    Heap::write_field(this, offset, value, mode);                    \
   }
 
 ORDERED_HASH_TABLE_ITERATOR_ACCESSORS(table, Object, kTableOffset)
 ORDERED_HASH_TABLE_ITERATOR_ACCESSORS(index, Smi, kIndexOffset)
 ORDERED_HASH_TABLE_ITERATOR_ACCESSORS(count, Smi, kCountOffset)
 ORDERED_HASH_TABLE_ITERATOR_ACCESSORS(kind, Smi, kKindOffset)
 ORDERED_HASH_TABLE_ITERATOR_ACCESSORS(next_iterator, Object,
                                       kNextIteratorOffset)
 ORDERED_HASH_TABLE_ITERATOR_ACCESSORS(previous_iterator, Object,
                                       kPreviousIteratorOffset)
 
 #undef ORDERED_HASH_TABLE_ITERATOR_ACCESSORS
 
 
 ACCESSORS(JSWeakCollection, table, Object, kTableOffset)
 ACCESSORS(JSWeakCollection, next, Object, kNextOffset)
 
 
 Address Foreign::foreign_address() {
-  return AddressFrom<Address>(READ_INTPTR_FIELD(this, kForeignAddressOffset));
+  return AddressFrom<Address>(
+      Heap::read_intptr_field(this, kForeignAddressOffset));
 }
 
 
 void Foreign::set_foreign_address(Address value) {
-  WRITE_INTPTR_FIELD(this, kForeignAddressOffset, OffsetFrom(value));
+  Heap::write_intptr_field(this, kForeignAddressOffset, OffsetFrom(value));
 }
 
 
 ACCESSORS(JSGeneratorObject, function, JSFunction, kFunctionOffset)
 ACCESSORS(JSGeneratorObject, context, Context, kContextOffset)
 ACCESSORS(JSGeneratorObject, receiver, Object, kReceiverOffset)
 SMI_ACCESSORS(JSGeneratorObject, continuation, kContinuationOffset)
 ACCESSORS(JSGeneratorObject, operand_stack, FixedArray, kOperandStackOffset)
 SMI_ACCESSORS(JSGeneratorObject, stack_handler_index, kStackHandlerIndexOffset)
 
@@ skipping 62 matching lines @@
 INT_ACCESSORS(Code, instruction_size, kInstructionSizeOffset)
 INT_ACCESSORS(Code, prologue_offset, kPrologueOffset)
 ACCESSORS(Code, relocation_info, ByteArray, kRelocationInfoOffset)
 ACCESSORS(Code, handler_table, FixedArray, kHandlerTableOffset)
 ACCESSORS(Code, deoptimization_data, FixedArray, kDeoptimizationDataOffset)
 ACCESSORS(Code, raw_type_feedback_info, Object, kTypeFeedbackInfoOffset)
 ACCESSORS(Code, next_code_link, Object, kNextCodeLinkOffset)
 
 
 void Code::WipeOutHeader() {
-  WRITE_FIELD(this, kRelocationInfoOffset, NULL);
-  WRITE_FIELD(this, kHandlerTableOffset, NULL);
-  WRITE_FIELD(this, kDeoptimizationDataOffset, NULL);
-  WRITE_FIELD(this, kConstantPoolOffset, NULL);
+  Heap::write_field(this, kRelocationInfoOffset, NULL, SKIP_WRITE_BARRIER);
+  Heap::write_field(this, kHandlerTableOffset, NULL, SKIP_WRITE_BARRIER);
+  Heap::write_field(this, kDeoptimizationDataOffset, NULL, SKIP_WRITE_BARRIER);
+  Heap::write_field(this, kConstantPoolOffset, NULL, SKIP_WRITE_BARRIER);
   // Do not wipe out e.g. a minor key.
-  if (!READ_FIELD(this, kTypeFeedbackInfoOffset)->IsSmi()) {
-    WRITE_FIELD(this, kTypeFeedbackInfoOffset, NULL);
+  if (!Heap::read_field(this, kTypeFeedbackInfoOffset)->IsSmi()) {
+    Heap::write_field(this, kTypeFeedbackInfoOffset, NULL, SKIP_WRITE_BARRIER);
   }
 }
 
 
 Object* Code::type_feedback_info() {
   ASSERT(kind() == FUNCTION);
   return raw_type_feedback_info();
 }
 
 
 void Code::set_type_feedback_info(Object* value, WriteBarrierMode mode) {
   ASSERT(kind() == FUNCTION);
   set_raw_type_feedback_info(value, mode);
-  CONDITIONAL_WRITE_BARRIER(GetHeap(), this, kTypeFeedbackInfoOffset,
-                            value, mode);
 }
 
 
 int Code::stub_info() {
   ASSERT(kind() == COMPARE_IC || kind() == COMPARE_NIL_IC ||
          kind() == BINARY_OP_IC || kind() == LOAD_IC);
   return Smi::cast(raw_type_feedback_info())->value();
 }
 
 
 void Code::set_stub_info(int value) {
   ASSERT(kind() == COMPARE_IC ||
          kind() == COMPARE_NIL_IC ||
          kind() == BINARY_OP_IC ||
          kind() == STUB ||
          kind() == LOAD_IC ||
          kind() == KEYED_LOAD_IC ||
          kind() == STORE_IC ||
          kind() == KEYED_STORE_IC);
   set_raw_type_feedback_info(Smi::FromInt(value));
 }
 
 
 ACCESSORS(Code, gc_metadata, Object, kGCMetadataOffset)
 INT_ACCESSORS(Code, ic_age, kICAgeOffset)
 
 
 byte* Code::instruction_start()  {
-  return FIELD_ADDR(this, kHeaderSize);
+  return Heap::get_field_address(this, kHeaderSize);
 }
 
 
 byte* Code::instruction_end()  {
   return instruction_start() + instruction_size();
 }
 
 
 int Code::body_size() {
   return RoundUp(instruction_size(), kObjectAlignment);
 }
 
 
 ByteArray* Code::unchecked_relocation_info() {
-  return reinterpret_cast<ByteArray*>(READ_FIELD(this, kRelocationInfoOffset));
+  return reinterpret_cast<ByteArray*>(
+      Heap::read_field(this, kRelocationInfoOffset));
 }
 
 
 byte* Code::relocation_start() {
   return unchecked_relocation_info()->GetDataStartAddress();
 }
 
 
 int Code::relocation_size() {
   return unchecked_relocation_info()->length();
 }
 
 
 byte* Code::entry() {
   return instruction_start();
 }
 
 
 bool Code::contains(byte* inner_pointer) {
   return (address() <= inner_pointer) && (inner_pointer <= address() + Size());
 }
 
 
 ACCESSORS(JSArray, length, Object, kLengthOffset)
 
 
 void* JSArrayBuffer::backing_store() {
-  intptr_t ptr = READ_INTPTR_FIELD(this, kBackingStoreOffset);
+  intptr_t ptr = Heap::read_intptr_field(this, kBackingStoreOffset);
   return reinterpret_cast<void*>(ptr);
 }
 
 
 void JSArrayBuffer::set_backing_store(void* value, WriteBarrierMode mode) {
   intptr_t ptr = reinterpret_cast<intptr_t>(value);
-  WRITE_INTPTR_FIELD(this, kBackingStoreOffset, ptr);
+  Heap::write_intptr_field(this, kBackingStoreOffset, ptr);
 }
 
 
 ACCESSORS(JSArrayBuffer, byte_length, Object, kByteLengthOffset)
 ACCESSORS_TO_SMI(JSArrayBuffer, flag, kFlagOffset)
 
 
 bool JSArrayBuffer::is_external() {
   return BooleanBit::get(flag(), kIsExternalBit);
 }
@@ skipping 74 matching lines @@
   ASSERT(TypeTag() != NOT_COMPILED);
   ASSERT(index >= kDataIndex);  // Only implementation data can be set this way.
   FixedArray::cast(data())->set(index, value);
 }
 
 
 ElementsKind JSObject::GetElementsKind() {
   ElementsKind kind = map()->elements_kind();
 #if DEBUG
   FixedArrayBase* fixed_array =
-      reinterpret_cast<FixedArrayBase*>(READ_FIELD(this, kElementsOffset));
+      reinterpret_cast<FixedArrayBase*>(Heap::read_field(this,
+                                                         kElementsOffset));
 
   // If a GC was caused while constructing this object, the elements
   // pointer may point to a one pointer filler map.
   if (ElementsAreSafeToExamine()) {
     Map* map = fixed_array->map();
     ASSERT((IsFastSmiOrObjectElementsKind(kind) &&
             (map == GetHeap()->fixed_array_map() ||
              map == GetHeap()->fixed_cow_array_map())) ||
            (IsFastDoubleElementsKind(kind) &&
             (fixed_array->IsFixedDoubleArray() ||
@@ skipping 590 matching lines @@
   return key;
 }
 
 
 void Map::ClearCodeCache(Heap* heap) {
   // No write barrier is needed since empty_fixed_array is not in new space.
   // Please note this function is used during marking:
   //  - MarkCompactCollector::MarkUnmarkedObject
   //  - IncrementalMarking::Step
   ASSERT(!heap->InNewSpace(heap->empty_fixed_array()));
-  WRITE_FIELD(this, kCodeCacheOffset, heap->empty_fixed_array());
+  Heap::write_field(this,
+                    kCodeCacheOffset,
+                    heap->empty_fixed_array(),
+                    SKIP_WRITE_BARRIER);
 }
 
 
 void JSArray::EnsureSize(Handle<JSArray> array, int required_size) {
   ASSERT(array->HasFastSmiOrObjectElements());
   Handle<FixedArray> elts = handle(FixedArray::cast(array->elements()));
   const int kArraySizeThatFitsComfortablyInNewSpace = 128;
   if (elts->length() < required_size) {
     // Doubling in size would be overkill, but leave some slack to avoid
     // constantly growing.
@@ skipping 52 matching lines @@
   return Handle<Object>(Smi::FromInt(static_cast<int>(elements_kind)), isolate);
 }
 
 
 Object* TypeFeedbackInfo::RawUninitializedSentinel(Heap* heap) {
   return heap->uninitialized_symbol();
 }
 
 
 int TypeFeedbackInfo::ic_total_count() {
-  int current = Smi::cast(READ_FIELD(this, kStorage1Offset))->value();
+  int current = Smi::cast(Heap::read_field(this, kStorage1Offset))->value();
   return ICTotalCountField::decode(current);
 }
 
 
 void TypeFeedbackInfo::set_ic_total_count(int count) {
-  int value = Smi::cast(READ_FIELD(this, kStorage1Offset))->value();
+  int value = Smi::cast(Heap::read_field(this, kStorage1Offset))->value();
   value = ICTotalCountField::update(value,
                                     ICTotalCountField::decode(count));
-  WRITE_FIELD(this, kStorage1Offset, Smi::FromInt(value));
+  Heap::write_field(this,
+                    kStorage1Offset,
+                    Smi::FromInt(value),
+                    SKIP_WRITE_BARRIER);
 }
 
 
 int TypeFeedbackInfo::ic_with_type_info_count() {
-  int current = Smi::cast(READ_FIELD(this, kStorage2Offset))->value();
+  int current = Smi::cast(Heap::read_field(this, kStorage2Offset))->value();
   return ICsWithTypeInfoCountField::decode(current);
 }
 
 
 void TypeFeedbackInfo::change_ic_with_type_info_count(int delta) {
-  int value = Smi::cast(READ_FIELD(this, kStorage2Offset))->value();
+  int value = Smi::cast(Heap::read_field(this, kStorage2Offset))->value();
   int new_count = ICsWithTypeInfoCountField::decode(value) + delta;
   // We can get negative count here when the type-feedback info is
   // shared between two code objects. The can only happen when
   // the debugger made a shallow copy of code object (see Heap::CopyCode).
   // Since we do not optimize when the debugger is active, we can skip
   // this counter update.
   if (new_count >= 0) {
     new_count &= ICsWithTypeInfoCountField::kMask;
     value = ICsWithTypeInfoCountField::update(value, new_count);
-    WRITE_FIELD(this, kStorage2Offset, Smi::FromInt(value));
+    Heap::write_field(this,
+                      kStorage2Offset,
+                      Smi::FromInt(value),
+                      SKIP_WRITE_BARRIER);
   }
 }
 
 
 void TypeFeedbackInfo::initialize_storage() {
-  WRITE_FIELD(this, kStorage1Offset, Smi::FromInt(0));
-  WRITE_FIELD(this, kStorage2Offset, Smi::FromInt(0));
+  Heap::write_field(this, kStorage1Offset, Smi::FromInt(0), SKIP_WRITE_BARRIER);
+  Heap::write_field(this, kStorage2Offset, Smi::FromInt(0), SKIP_WRITE_BARRIER);
 }
 
 
 void TypeFeedbackInfo::change_own_type_change_checksum() {
-  int value = Smi::cast(READ_FIELD(this, kStorage1Offset))->value();
+  int value = Smi::cast(Heap::read_field(this, kStorage1Offset))->value();
   int checksum = OwnTypeChangeChecksum::decode(value);
   checksum = (checksum + 1) % (1 << kTypeChangeChecksumBits);
   value = OwnTypeChangeChecksum::update(value, checksum);
   // Ensure packed bit field is in Smi range.
   if (value > Smi::kMaxValue) value |= Smi::kMinValue;
   if (value < Smi::kMinValue) value &= ~Smi::kMinValue;
-  WRITE_FIELD(this, kStorage1Offset, Smi::FromInt(value));
+  Heap::write_field(this,
+                    kStorage1Offset,
+                    Smi::FromInt(value),
+                    SKIP_WRITE_BARRIER);
 }
 
 
 void TypeFeedbackInfo::set_inlined_type_change_checksum(int checksum) {
-  int value = Smi::cast(READ_FIELD(this, kStorage2Offset))->value();
+  int value = Smi::cast(Heap::read_field(this, kStorage2Offset))->value();
   int mask = (1 << kTypeChangeChecksumBits) - 1;
   value = InlinedTypeChangeChecksum::update(value, checksum & mask);
   // Ensure packed bit field is in Smi range.
   if (value > Smi::kMaxValue) value |= Smi::kMinValue;
   if (value < Smi::kMinValue) value &= ~Smi::kMinValue;
-  WRITE_FIELD(this, kStorage2Offset, Smi::FromInt(value));
+  Heap::write_field(this,
+                    kStorage2Offset,
+                    Smi::FromInt(value),
+                    SKIP_WRITE_BARRIER);
 }
 
 
 int TypeFeedbackInfo::own_type_change_checksum() {
-  int value = Smi::cast(READ_FIELD(this, kStorage1Offset))->value();
+  int value = Smi::cast(Heap::read_field(this, kStorage1Offset))->value();
   return OwnTypeChangeChecksum::decode(value);
 }
 
 
 bool TypeFeedbackInfo::matches_inlined_type_change_checksum(int checksum) {
-  int value = Smi::cast(READ_FIELD(this, kStorage2Offset))->value();
+  int value = Smi::cast(Heap::read_field(this, kStorage2Offset))->value();
   int mask = (1 << kTypeChangeChecksumBits) - 1;
   return InlinedTypeChangeChecksum::decode(value) == (checksum & mask);
 }
 
 
 ACCESSORS(TypeFeedbackInfo, feedback_vector, FixedArray,
           kFeedbackVectorOffset)
 
 
 SMI_ACCESSORS(AliasedArgumentsEntry, aliased_context_slot, kAliasedContextSlot)
@@ skipping 12 matching lines @@
 }
 
 
 int JSObject::BodyDescriptor::SizeOf(Map* map, HeapObject* object) {
   return map->instance_size();
 }
 
 
 void Foreign::ForeignIterateBody(ObjectVisitor* v) {
   v->VisitExternalReference(
-      reinterpret_cast<Address*>(FIELD_ADDR(this, kForeignAddressOffset)));
+      reinterpret_cast<Address*>(
+          Heap::get_field_address(this, kForeignAddressOffset)));
 }
 
 
 template<typename StaticVisitor>
 void Foreign::ForeignIterateBody() {
   StaticVisitor::VisitExternalReference(
-      reinterpret_cast<Address*>(FIELD_ADDR(this, kForeignAddressOffset)));
+      reinterpret_cast<Address*>(
+          Heap::get_field_address(this, kForeignAddressOffset)));
 }
 
 
 void ExternalAsciiString::ExternalAsciiStringIterateBody(ObjectVisitor* v) {
   typedef v8::String::ExternalAsciiStringResource Resource;
-  v->VisitExternalAsciiString(
-      reinterpret_cast<Resource**>(FIELD_ADDR(this, kResourceOffset)));
+  v->VisitExternalAsciiString(reinterpret_cast<Resource**>(
+      Heap::get_field_address(this, kResourceOffset)));
 }
 
 
 template<typename StaticVisitor>
 void ExternalAsciiString::ExternalAsciiStringIterateBody() {
   typedef v8::String::ExternalAsciiStringResource Resource;
-  StaticVisitor::VisitExternalAsciiString(
-      reinterpret_cast<Resource**>(FIELD_ADDR(this, kResourceOffset)));
+  StaticVisitor::VisitExternalAsciiString(reinterpret_cast<Resource**>(
+      Heap::get_field_address(this, kResourceOffset)));
 }
 
 
 void ExternalTwoByteString::ExternalTwoByteStringIterateBody(ObjectVisitor* v) {
   typedef v8::String::ExternalStringResource Resource;
-  v->VisitExternalTwoByteString(
-      reinterpret_cast<Resource**>(FIELD_ADDR(this, kResourceOffset)));
+  v->VisitExternalTwoByteString(reinterpret_cast<Resource**>(
+      Heap::get_field_address(this, kResourceOffset)));
 }
 
 
 template<typename StaticVisitor>
 void ExternalTwoByteString::ExternalTwoByteStringIterateBody() {
   typedef v8::String::ExternalStringResource Resource;
-  StaticVisitor::VisitExternalTwoByteString(
-      reinterpret_cast<Resource**>(FIELD_ADDR(this, kResourceOffset)));
+  StaticVisitor::VisitExternalTwoByteString(reinterpret_cast<Resource**>(
+      Heap::get_field_address(this, kResourceOffset)));
 }
 
 
 template<int start_offset, int end_offset, int size>
 void FixedBodyDescriptor<start_offset, end_offset, size>::IterateBody(
     HeapObject* obj,
     ObjectVisitor* v) {
     v->VisitPointers(HeapObject::RawField(obj, start_offset),
                      HeapObject::RawField(obj, end_offset));
 }
@@ skipping 11 matching lines @@
 #undef TYPE_CHECKER
 #undef CAST_ACCESSOR
 #undef INT_ACCESSORS
 #undef ACCESSORS
 #undef ACCESSORS_TO_SMI
 #undef SMI_ACCESSORS
 #undef SYNCHRONIZED_SMI_ACCESSORS
 #undef NOBARRIER_SMI_ACCESSORS
 #undef BOOL_GETTER
 #undef BOOL_ACCESSORS
-#undef FIELD_ADDR
-#undef READ_FIELD
-#undef NOBARRIER_READ_FIELD
-#undef WRITE_FIELD
-#undef NOBARRIER_WRITE_FIELD
-#undef WRITE_BARRIER
-#undef CONDITIONAL_WRITE_BARRIER
-#undef READ_DOUBLE_FIELD
-#undef WRITE_DOUBLE_FIELD
-#undef READ_INT_FIELD
-#undef WRITE_INT_FIELD
-#undef READ_INTPTR_FIELD
-#undef WRITE_INTPTR_FIELD
-#undef READ_UINT32_FIELD
-#undef WRITE_UINT32_FIELD
-#undef READ_SHORT_FIELD
-#undef WRITE_SHORT_FIELD
-#undef READ_BYTE_FIELD
-#undef WRITE_BYTE_FIELD
-#undef NOBARRIER_READ_BYTE_FIELD
-#undef NOBARRIER_WRITE_BYTE_FIELD
 
 } }  // namespace v8::internal
 
 #endif  // V8_OBJECTS_INL_H_