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

src/heap-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.
 
 #ifndef V8_HEAP_INL_H_
 #define V8_HEAP_INL_H_
 
 #include <cmath>
 
 #include "heap.h"
@@ skipping 160 matching lines @@
   return CopyFixedDoubleArrayWithMap(src, src->map());
 }
 
 
 MaybeObject* Heap::CopyConstantPoolArray(ConstantPoolArray* src) {
   if (src->length() == 0) return src;
   return CopyConstantPoolArrayWithMap(src, src->map());
 }
 
 
+#define FIELD_ADDR(p, offset) \
+  (reinterpret_cast<byte*>(p) + offset - kHeapObjectTag)
+
+
+inline Object* Heap::read_field(HeapObject* p, int offset) {
+  return *reinterpret_cast<Object**>(FIELD_ADDR(p, offset));
+}
+
+
+inline intptr_t Heap::read_intptr_field(HeapObject* p, int offset) {
+  return *reinterpret_cast<intptr_t*>(FIELD_ADDR(p, offset));
+}
+
+
+inline int Heap::read_int_field(HeapObject* p, int offset) {
+  return *reinterpret_cast<int*>(FIELD_ADDR(p, offset));
+}
+
+
+inline int32_t Heap::read_int32_field(HeapObject* p, int offset) {
+  return *reinterpret_cast<int32_t*>(FIELD_ADDR(p, offset));
+}
+
+
+inline uint32_t Heap::read_uint32_field(HeapObject* p, int offset) {
+  return *reinterpret_cast<uint32_t*>(FIELD_ADDR(p, offset));
+}
+
+
+inline int64_t Heap::read_int64_field(HeapObject* p, int offset) {
+  return *reinterpret_cast<int64_t*>(FIELD_ADDR(p, offset));
+}
+
+
+inline int16_t Heap::read_short_field(HeapObject* p, int offset) {
+  return *reinterpret_cast<int16_t*>(FIELD_ADDR(p, offset));
+}
+
+
+inline byte Heap::read_byte_field(HeapObject* p, int offset) {
+  return *reinterpret_cast<byte*>(FIELD_ADDR(p, offset));
+}
+
+
+inline double Heap::read_double_field(HeapObject* p, int offset) {
+#ifndef V8_TARGET_ARCH_MIPS
+  return *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.
+  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;
+#endif  // V8_TARGET_ARCH_MIPS
+}
+
+
+inline void Heap::write_field(HeapObject* p,
+                              int offset,
+                              Object* value,
+                              WriteBarrierMode mode) {
+  *reinterpret_cast<Object**>(FIELD_ADDR(p, offset)) = value;
+  if (mode == UPDATE_WRITE_BARRIER) {
+    Heap* heap = p->GetHeap();
+    heap->incremental_marking()->RecordWrite(
+      p, HeapObject::RawField(p, offset), value);
+    if (heap->InNewSpace(value)) {
+      heap->RecordWrite(p->address(), offset);
+    }
+  }
+}
+
+inline void Heap::write_intptr_field(HeapObject* p,
+                                     int offset,
+                                     intptr_t value) {
+  *reinterpret_cast<intptr_t*>(FIELD_ADDR(p, offset)) = value;
+}
+
+inline void Heap::write_int_field(HeapObject* p, int offset, int value) {
+  *reinterpret_cast<int*>(FIELD_ADDR(p, offset)) = value;
+}
+
+inline void Heap::write_int32_field(HeapObject* p, int offset, int32_t value) {
+  *reinterpret_cast<int32_t*>(FIELD_ADDR(p, offset)) = value;
+}
+
+inline void Heap::write_uint32_field(HeapObject* p,
+                                     int offset,
+                                     uint32_t value) {
+  *reinterpret_cast<uint32_t*>(FIELD_ADDR(p, offset)) = value;
+}
+
+inline void Heap::write_int64_field(HeapObject* p, int offset, int64_t value) {
+  *reinterpret_cast<int64_t*>(FIELD_ADDR(p, offset)) = value;
+}
+
+inline void Heap::write_short_field(HeapObject* p, int offset, int16_t value) {
+  *reinterpret_cast<int16_t*>(FIELD_ADDR(p, offset)) = value;
+}
+
+inline void Heap::write_byte_field(HeapObject* p, int offset, byte value) {
+  *reinterpret_cast<byte*>(FIELD_ADDR(p, offset)) = value;
+}
+
+inline void Heap::write_double_field(HeapObject* p, int offset, double value) {
+#ifndef V8_TARGET_ARCH_MIPS
+  *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.
+  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];
+#endif  // V8_TARGET_ARCH_MIPS
+}
+
+inline Address Heap::get_field_address(HeapObject* p, int offset) {
+  return reinterpret_cast<Address>(FIELD_ADDR(p, offset));
+}
+
+inline Object* Heap::acquire_read_field(HeapObject* p, int offset) {
+  return reinterpret_cast<Object*>(
+      Acquire_Load(reinterpret_cast<AtomicWord*>(FIELD_ADDR(p, offset))));
+}
+
+inline Object* Heap::nobarrier_read_field(HeapObject* p, int offset) {
+  return reinterpret_cast<Object*>(
+      NoBarrier_Load(reinterpret_cast<AtomicWord*>(FIELD_ADDR(p, offset))));
+}
+
+inline void Heap::release_write_field(HeapObject* p,
+                                      int offset,
+                                      Object* value) {
+  Release_Store(reinterpret_cast<AtomicWord*>(FIELD_ADDR(p, offset)),
+                reinterpret_cast<AtomicWord>(value));
+}
+
+inline void Heap::nobarrier_write_field(HeapObject* p,
+                                        int offset,
+                                        Object* value) {
+  NoBarrier_Store(reinterpret_cast<AtomicWord*>(FIELD_ADDR(p, offset)),
+                  reinterpret_cast<AtomicWord>(value));
+}
+
+inline byte Heap::nobarrier_read_byte_field(HeapObject* p, int offset) {
+  return static_cast<byte>(NoBarrier_Load(
+      reinterpret_cast<Atomic8*>(FIELD_ADDR(p, offset))));
+}
+
+inline void Heap::nobarrier_write_byte_field(HeapObject* p,
+                                                int offset,
+                                                byte value) {
+  NoBarrier_Store(reinterpret_cast<Atomic8*>(FIELD_ADDR(p, offset)),
+                  static_cast<Atomic8>(value));
+}
+
+#undef FIELD_ADDR
+
+
 MaybeObject* Heap::AllocateRaw(int size_in_bytes,
                                AllocationSpace space,
                                AllocationSpace retry_space) {
   ASSERT(AllowHandleAllocation::IsAllowed());
   ASSERT(AllowHeapAllocation::IsAllowed());
   ASSERT(gc_state_ == NOT_IN_GC);
   HeapProfiler* profiler = isolate_->heap_profiler();
 #ifdef DEBUG
   if (FLAG_gc_interval >= 0 &&
       AllowAllocationFailure::IsAllowed(isolate_) &&
@@ skipping 243 matching lines @@
 
     while (src_slot != end_slot) {
       *dst_slot++ = *src_slot++;
     }
   } else {
     OS::MemMove(dst, src, static_cast<size_t>(byte_size));
   }
 }
 
 
-void Heap::ScavengePointer(HeapObject** p) {
-  ScavengeObject(p, *p);
-}
-
-
 AllocationMemento* Heap::FindAllocationMemento(HeapObject* object) {
   // Check if there is potentially a memento behind the object. If
   // the last word of the momento is on another page we return
   // immediately.
   Address object_address = object->address();
   Address memento_address = object_address + object->Size();
   Address last_memento_word_address = memento_address + kPointerSize;
   if (!NewSpacePage::OnSamePage(object_address,
                                 last_memento_word_address)) {
     return NULL;
@@ skipping 318 matching lines @@
 
 
 double GCTracer::SizeOfHeapObjects() {
   return (static_cast<double>(heap_->SizeOfObjects())) / MB;
 }
 
 
 } }  // namespace v8::internal
 
 #endif  // V8_HEAP_INL_H_