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

src/heap.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_H_
 #define V8_HEAP_H_
 
 #include <cmath>
 
 #include "allocation.h"
@@ skipping 664 matching lines @@
     return old_pointer_space_->allocation_limit_address();
   }
 
   Address* OldDataSpaceAllocationTopAddress() {
     return old_data_space_->allocation_top_address();
   }
   Address* OldDataSpaceAllocationLimitAddress() {
     return old_data_space_->allocation_limit_address();
   }
 
+  // Heap access methods.
+  static inline Object* read_field(HeapObject* p, int offset);

[Hannes Payer (out of office), 2014/04/30 07:47:25]

Our INLINE macro may force inlining of these functions.

+  static inline intptr_t read_intptr_field(HeapObject* p, int offset);
+  static inline int read_int_field(HeapObject* p, int offset);
+  static inline int32_t read_int32_field(HeapObject* p, int offset);
+  static inline uint32_t read_uint32_field(HeapObject* p, int offset);
+  static inline int64_t read_int64_field(HeapObject* p, int offset);
+  static inline int16_t read_short_field(HeapObject* p, int offset);
+  static inline byte read_byte_field(HeapObject* p, int offset);
+  static inline double read_double_field(HeapObject* p, int offset);
+
+
+  static inline void write_intptr_field(HeapObject* p,
+                                        int offset,
+                                        intptr_t value);
+  static inline void write_int_field(HeapObject* p,
+                                     int offset,
+                                     int value);
+  static inline void write_int32_field(HeapObject* p,
+                                       int offset,
+                                       int32_t value);
+  static inline void write_uint32_field(HeapObject* p,
+                                        int offset,
+                                        uint32_t value);
+  static inline void write_int64_field(HeapObject* p,
+                                       int offset,
+                                       int64_t value);
+  static inline void write_short_field(HeapObject* p,
+                                       int offset,
+                                       int16_t value);
+  static inline void write_byte_field(HeapObject* p,
+                                      int offset,
+                                      byte value);
+  static inline void write_double_field(HeapObject* p,
+                                        int offset,
+                                        double value);
+
+  // TODO(jarin) expose the barrier reason here
+  static inline void write_field(HeapObject* p,
+                                 int offset,
+                                 Object* value,
+                                 WriteBarrierMode mode);
+
+  // TODO(jarin) replace this with variants that do not expose
+  // internal pointers.
+  static inline Address get_field_address(HeapObject* p, int offset);
+
+  // TODO(jarin) synchronized flavors of the field accesses should be
+  // wrapped so that we do not expose the sync.
+  static inline Object* acquire_read_field(HeapObject* p, int offset);
+  static inline Object* nobarrier_read_field(HeapObject* p, int offset);
+  static inline void release_write_field(HeapObject* p,
+                                         int offset,
+                                         Object* value);
+  static inline void nobarrier_write_field(HeapObject* p,
+                                           int offset,
+                                           Object* value);
+  static inline byte nobarrier_read_byte_field(HeapObject* p, int offset);
+  static inline void nobarrier_write_byte_field(HeapObject* p,
+                                                int offset,
+                                                byte value);
+
   // Returns a deep copy of the JavaScript object.
   // Properties and elements are copied too.
   // Returns failure if allocation failed.
   // Optionally takes an AllocationSite to be appended in an AllocationMemento.
   MUST_USE_RESULT MaybeObject* CopyJSObject(JSObject* source,
                                             AllocationSite* site = NULL);
 
   // Clear the Instanceof cache (used when a prototype changes).
   inline void ClearInstanceofCache();
 
@@ skipping 313 matching lines @@
 
   void TracePathToObjectFrom(Object* target, Object* root);
   void TracePathToObject(Object* target);
   void TracePathToGlobal();
 #endif
 
   // Callback function passed to Heap::Iterate etc.  Copies an object if
   // necessary, the object might be promoted to an old space.  The caller must
   // ensure the precondition that the object is (a) a heap object and (b) in
   // the heap's from space.
-  static inline void ScavengePointer(HeapObject** p);
   static inline void ScavengeObject(HeapObject** p, HeapObject* object);
 
   enum ScratchpadSlotMode {
     IGNORE_SCRATCHPAD_SLOT,
     RECORD_SCRATCHPAD_SLOT
   };
 
   // If an object has an AllocationMemento trailing it, return it, otherwise
   // return NULL;
   inline AllocationMemento* FindAllocationMemento(HeapObject* object);
@@ skipping 1781 matching lines @@
   DisallowHeapAllocation no_allocation;  // i.e. no gc allowed.
 
  private:
   DISALLOW_IMPLICIT_CONSTRUCTORS(PathTracer);
 };
 #endif  // DEBUG
 
 } }  // namespace v8::internal
 
 #endif  // V8_HEAP_H_