Add more missing StorePointer/StoreSmi calls.

runtime/vm/object.cc

 // 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.
 
 #include "vm/object.h"
 
 #include "include/dart_api.h"
 #include "platform/assert.h"
 #include "vm/assembler.h"
 #include "vm/cpu.h"
@@ skipping 924 matching lines @@
       uword old_tags;
       // TODO(iposva): Investigate whether CompareAndSwapWord is necessary.
       do {
         old_tags = tags;
         tags = AtomicOperations::CompareAndSwapWord(
             &raw->ptr()->tags_, old_tags, new_tags);
       } while (tags != old_tags);
 
       intptr_t leftover_len = (leftover_size - TypedData::InstanceSize(0));
       ASSERT(TypedData::InstanceSize(leftover_len) == leftover_size);
-      raw->ptr()->length_ = Smi::New(leftover_len);
+      raw->StoreSmi(&(raw->ptr()->length_), Smi::New(leftover_len));
     } else {
       // Update the leftover space as a basic object.
       ASSERT(leftover_size == Object::InstanceSize());
       RawObject* raw = reinterpret_cast<RawObject*>(RawObject::FromAddr(addr));
       uword new_tags = RawObject::ClassIdTag::update(kInstanceCid, 0);
       new_tags = RawObject::SizeTag::update(leftover_size, new_tags);
       uword tags = raw->ptr()->tags_;
       uword old_tags;
       // TODO(iposva): Investigate whether CompareAndSwapWord is necessary.
       do {
@@ skipping 11184 matching lines @@
     const ZoneGrowableArray<intptr_t>& pointer_offsets =
         assembler->GetPointerOffsets();
     ASSERT(pointer_offsets.length() == pointer_offset_count);
     ASSERT(code.pointer_offsets_length() == pointer_offsets.length());
 
     // Set pointer offsets list in Code object and resolve all handles in
     // the instruction stream to raw objects.
     for (intptr_t i = 0; i < pointer_offsets.length(); i++) {
       intptr_t offset_in_instrs = pointer_offsets[i];
       code.SetPointerOffsetAt(i, offset_in_instrs);
-      const Object* object = region.Load<const Object*>(offset_in_instrs);
-      region.Store<RawObject*>(offset_in_instrs, object->raw());
+      uword addr = region.start() + offset_in_instrs;
+      const Object* object = *reinterpret_cast<Object**>(addr);
+      instrs.raw()->StorePointer(reinterpret_cast<RawObject**>(addr),
+                                 object->raw());
     }
 
     // Hook up Code and Instructions objects.
     instrs.set_code(code.raw());
     code.set_instructions(instrs.raw());
     code.set_is_alive(true);
 
     // Set object pool in Instructions object.
     const GrowableObjectArray& object_pool = assembler->object_pool();
     if (object_pool.IsNull()) {
@@ skipping 6000 matching lines @@
   if (len < 0 || len > kMaxElements) {
     // This should be caught before we reach here.
     FATAL1("Fatal error in OneByteString::New: invalid len %" Pd "\n", len);
   }
   {
     RawObject* raw = Object::Allocate(OneByteString::kClassId,
                                       OneByteString::InstanceSize(len),
                                       space);
     NoGCScope no_gc;
     RawOneByteString* result = reinterpret_cast<RawOneByteString*>(raw);
-    result->ptr()->length_ = Smi::New(len);
-    result->ptr()->hash_ = 0;
+    result->StoreSmi(&(result->ptr()->length_), Smi::New(len));
+    result->StoreSmi(&(result->ptr()->hash_), Smi::New(0));
     return result;
   }
 }
 
 
 RawOneByteString* OneByteString::New(const uint8_t* characters,
                                      intptr_t len,
                                      Heap::Space space) {
   const String& result = String::Handle(OneByteString::New(len, space));
   if (len > 0) {
@@ skipping 516 matching lines @@
   if ((len < 0) || (len > Array::kMaxElements)) {
     // This should be caught before we reach here.
     FATAL1("Fatal error in Array::New: invalid len %" Pd "\n", len);
   }
   {
     RawArray* raw = reinterpret_cast<RawArray*>(
         Object::Allocate(class_id,
                          Array::InstanceSize(len),
                          space));
     NoGCScope no_gc;
-    raw->ptr()->length_ = Smi::New(len);
+    raw->StoreSmi(&(raw->ptr()->length_), Smi::New(len));
     return raw;
   }
 }
 
 
 RawArray* Array::Slice(intptr_t start,
                        intptr_t count,
                        bool with_type_argument) const {
   // TODO(vegorov) introduce an array allocation method that fills newly
   // allocated array with values from the given source array instead of
@@ skipping 1593 matching lines @@
   return tag_label.ToCString();
 }
 
 
 void UserTag::PrintJSONImpl(JSONStream* stream, bool ref) const {
   Instance::PrintJSONImpl(stream, ref);
 }
 
 
 }  // namespace dart