Add more missing StorePointer/StoreSmi calls.

runtime/vm/object.h

 // Copyright (c) 2012, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 #ifndef VM_OBJECT_H_
 #define VM_OBJECT_H_
 
 #include "include/dart_api.h"
 #include "platform/assert.h"
 #include "platform/utils.h"
@@ skipping 571 matching lines @@
   void set_vtable(cpp_vtable value) { *vtable_address() = value; }
 
   static RawObject* Allocate(intptr_t cls_id,
                              intptr_t size,
                              Heap::Space space);
 
   static intptr_t RoundedAllocationSize(intptr_t size) {
     return Utils::RoundUp(size, kObjectAlignment);
   }
 
-  bool Contains(uword addr) const {
-    intptr_t this_size = raw()->Size();
-    uword this_addr = RawObject::ToAddr(raw());
-    return (addr >= this_addr) && (addr < (this_addr + this_size));
-  }
+  bool Contains(uword addr) const { return raw()->Contains(addr); }
 
   // Start of field mutator guards.
   //
   // All writes to heap objects should ultimately pass through one of the
-  // methods below, to ensure that the write barrier is correctly applied.
+  // methods below or their counterparts in RawObject, to ensure that the
+  // write barrier is correctly applied.
 
   template<typename type>
   void StorePointer(type const* addr, type value) const {
-    // Ensure that this object contains the addr.
-    ASSERT(Contains(reinterpret_cast<uword>(addr)));
-    *const_cast<type*>(addr) = value;
-    // Filter stores based on source and target.
-    if (!value->IsHeapObject()) return;
-    if (value->IsNewObject() && raw()->IsOldObject() &&
-        !raw()->IsRemembered()) {
-      raw()->SetRememberedBit();
-      Isolate::Current()->store_buffer()->AddObject(raw());
-    }
+    raw()->StorePointer(addr, value);
   }
 
   // Store a range of pointers [from, from + count) into [to, to + count).
   // TODO(koda): Use this to fix Object::Clone's broken store buffer logic.
   void StorePointers(RawObject* const* to,
                      RawObject* const* from,
                      intptr_t count) {
     ASSERT(Contains(reinterpret_cast<uword>(to)));
     if (raw()->IsNewObject()) {
       memmove(const_cast<RawObject**>(to), from, count * kWordSize);
     } else {
       for (intptr_t i = 0; i < count; ++i) {
         StorePointer(&to[i], from[i]);
       }
     }
   }
 
   // Use for storing into an explicitly Smi-typed field of an object
   // (i.e., both the previous and new value are Smis).
   void StoreSmi(RawSmi* const* addr, RawSmi* value) const {
-    // Can't use Contains, as array length is initialized through this method.
-    ASSERT(reinterpret_cast<uword>(addr) >= RawObject::ToAddr(raw()));
-    *const_cast<RawSmi**>(addr) = value;
+    raw()->StoreSmi(addr, value);
   }
 
   template<typename FieldType>
   void StoreSimd128(const FieldType* addr, simd128_value_t value) const {
     ASSERT(Contains(reinterpret_cast<uword>(addr)));
     value.writeTo(const_cast<FieldType*>(addr));
   }
 
   // Needs two template arguments to allow assigning enums to fixed-size ints.
   template<typename FieldType, typename ValueType>
@@ skipping 5830 matching lines @@
                                      Heap::Space space = Heap::kNew);
   static RawGrowableObjectArray* New(const Array& array,
                                      Heap::Space space = Heap::kNew);
 
  private:
   RawArray* DataArray() const { return data()->ptr(); }
   RawObject** ObjectAddr(intptr_t index) const {
     ASSERT((index >= 0) && (index < Length()));
     return &(DataArray()->data()[index]);
   }
-  bool DataContains(uword addr) const {
-    intptr_t data_size = data()->Size();
-    uword data_addr = RawObject::ToAddr(data());
-    return (addr >= data_addr) && (addr < (data_addr + data_size));
-  }
   void DataStorePointer(RawObject** addr, RawObject* value) const {
-    // Ensure that the backing array object contains the addr.
-    ASSERT(DataContains(reinterpret_cast<uword>(addr)));
-    *addr = value;
-    // Filter stores based on source and target.
-    if (!value->IsHeapObject()) return;
-    if (value->IsNewObject() && data()->IsOldObject() &&
-        !data()->IsRemembered()) {
-      data()->SetRememberedBit();
-      Isolate::Current()->store_buffer()->AddObject(data());
-    }
+    data()->StorePointer(addr, value);
   }
 
   static const int kDefaultInitialCapacity = 4;
 
   FINAL_HEAP_OBJECT_IMPLEMENTATION(GrowableObjectArray, Instance);
   friend class Array;
   friend class Class;
 };
 
 
@@ skipping 804 matching lines @@
     StorePointer(&raw_ptr()->value_, value.raw());
   }
 
   static RawWeakProperty* New(Heap::Space space = Heap::kNew);
 
   static intptr_t InstanceSize() {
     return RoundedAllocationSize(sizeof(RawWeakProperty));
   }
 
   static void Clear(RawWeakProperty* raw_weak) {
-    raw_weak->ptr()->key_ = Object::null();
-    raw_weak->ptr()->value_ = Object::null();
+    raw_weak->StorePointer(&(raw_weak->ptr()->key_), Object::null());
+    raw_weak->StorePointer(&(raw_weak->ptr()->value_), Object::null());
   }
 
  private:
   FINAL_HEAP_OBJECT_IMPLEMENTATION(WeakProperty, Instance);
   friend class Class;
 };
 
 
 class MirrorReference : public Instance {
  public:
@@ skipping 211 matching lines @@
 
 
 RawObject* MegamorphicCache::GetTargetFunction(const Array& array,
                                                intptr_t index) {
   return array.At((index * kEntryLength) + kTargetFunctionIndex);
 }
 
 }  // namespace dart
 
 #endif  // VM_OBJECT_H_