Use StorePointer instead of direct assignments of objects.

vm/object.h

 // Copyright (c) 2011, 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 "vm/assert.h"
 #include "vm/dart.h"
 #include "vm/globals.h"
@@ skipping 2196 matching lines @@
 class Instance : public Object {
  public:
   virtual bool Equals(const Instance& other) const;
   virtual RawInstance* Canonicalize() const;
 
   RawObject* GetField(const Field& field) const {
     return *FieldAddr(field);
   }
 
   void SetField(const Field& field, const Object& value) const {
-    *FieldAddr(field) = value.raw();
+    StorePointer(FieldAddr(field), value.raw());
   }
 
   RawType* GetType() const;
 
   virtual RawAbstractTypeArguments* GetTypeArguments() const;
   virtual void SetTypeArguments(const AbstractTypeArguments& value) const;
 
   // Check if this instance is an instance of the given type.
   bool IsInstanceOf(const AbstractType& type,
                     const AbstractTypeArguments& type_instantiator) const {
@@ skipping 30 matching lines @@
   RawObject** FieldAddr(const Field& field) const {
     return FieldAddrAtOffset(field.Offset());
   }
   intptr_t* NativeFieldAddr(int index) const {
     ASSERT(IsValidNativeIndex(index));
     return reinterpret_cast<intptr_t*>((raw_value() - kHeapObjectTag)
                                        + (index * kWordSize)
                                        + sizeof(RawObject));
   }
   void SetFieldAtOffset(intptr_t offset, const Object& value) const {
-    *FieldAddrAtOffset(offset) = value.raw();
+    StorePointer(FieldAddrAtOffset(offset), value.raw());
   }
   bool IsValidFieldOffset(int offset) const;
 
   // Check the subtype or assignability relationship between the type of this
   // instance and the given type.
   bool TestType(TypeTestKind test,
                 const AbstractType& type,
                 const AbstractTypeArguments& type_instantiator) const;
 
   // TODO(iposva): Determine if this gets in the way of Smi.
@@ skipping 708 matching lines @@
     return Smi::Value(raw_ptr()->length_);
   }
   static intptr_t length_offset() { return OFFSET_OF(RawArray, length_); }
   static intptr_t data_offset() { return length_offset() + kWordSize; }
 
   RawObject* At(intptr_t index) const {
     return *ObjectAddr(index);
   }
   void SetAt(intptr_t index, const Object& value) const {
     // TODO(iposva): Add storing NoGCScope.
-    *ObjectAddr(index) = value.raw();
+    StorePointer(ObjectAddr(index), value.raw());
   }
 
   virtual RawAbstractTypeArguments* GetTypeArguments() const {
     return raw_ptr()->type_arguments_;
   }
   virtual void SetTypeArguments(const AbstractTypeArguments& value) const {
     raw_ptr()->type_arguments_ = value.Canonicalize();
   }
 
   virtual bool Equals(const Instance& other) const;
@@ skipping 149 matching lines @@
   virtual void SetTypeArguments(const AbstractTypeArguments& value) const {
     raw_ptr()->type_arguments_ = value.Canonicalize();
   }
   static intptr_t type_arguments_offset() {
     return OFFSET_OF(RawClosure, type_arguments_);
   }
 
   // TODO(iposva): Remove smrck support once mapping to arbitrary is available.
   RawInteger* smrck() const { return raw_ptr()->smrck_; }
   void set_smrck(const Integer& smrck) const {
-    raw_ptr()->smrck_ = smrck.raw();
+    StorePointer(&raw_ptr()->smrck_, smrck.raw());
   }
   static intptr_t smrck_offset() { return OFFSET_OF(RawClosure, smrck_); }
 
   static intptr_t InstanceSize() {
     return RoundedAllocationSize(sizeof(RawClosure));
   }
 
   static RawClosure* New(const Function& function,
                          const Context& context,
                          Heap::Space space = Heap::kNew);
@@ skipping 169 matching lines @@
 }
 
 
 void Context::SetAt(intptr_t index, const Instance& value) const {
   StorePointer(InstanceAddr(index), value.raw());
 }
 
 }  // namespace dart
 
 #endif  // VM_OBJECT_H_