Write barrier audit, part 1

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 659 matching lines @@
   cls = Class::NewStringClass(kTwoByteStringCid);
   isolate->object_store()->set_two_byte_string_class(cls);
 
   // Allocate and initialize the empty_array instance.
   {
     uword address = heap->Allocate(Array::InstanceSize(0), Heap::kOld);
     InitializeObject(address, kArrayCid, Array::InstanceSize(0));
     Array::initializeHandle(
         empty_array_,
         reinterpret_cast<RawArray*>(address + kHeapObjectTag));
-    empty_array_->raw_ptr()->length_ = Smi::New(0);
+    empty_array_->StoreSmi(&empty_array_->raw_ptr()->length_, Smi::New(0));
   }
 
   // Allocate and initialize the zero_array instance.
   {
     uword address = heap->Allocate(Array::InstanceSize(1), Heap::kOld);
     InitializeObject(address, kArrayCid, Array::InstanceSize(1));
     Array::initializeHandle(
         zero_array_,
         reinterpret_cast<RawArray*>(address + kHeapObjectTag));
-    zero_array_->raw_ptr()->length_ = Smi::New(1);
-    zero_array_->raw_ptr()->data()[0] = Smi::New(0);
+    zero_array_->StoreSmi(&zero_array_->raw_ptr()->length_, Smi::New(1));
+    zero_array_->StorePointer(&zero_array_->raw_ptr()->data()[0],
+                              static_cast<RawObject*>(Smi::New(0)));
   }
 
   // Allocate and initialize the empty_descriptors instance.
   {
     uword address = heap->Allocate(
         PcDescriptors::InstanceSize(0, RawPcDescriptors::kCompressedRecSize),
         Heap::kOld);
     InitializeObject(address, kPcDescriptorsCid,
         PcDescriptors::InstanceSize(0, RawPcDescriptors::kCompressedRecSize));
     PcDescriptors::initializeHandle(
         empty_descriptors_,
         reinterpret_cast<RawPcDescriptors*>(address + kHeapObjectTag));
-    empty_descriptors_->raw_ptr()->length_ = 0;
+    empty_descriptors_->StoreNonPointer(&empty_descriptors_->raw_ptr()->length_,
+                                        0);
   }
 
   // Allocate and initialize the canonical empty variable descriptor object.
   {
     uword address =
         heap->Allocate(LocalVarDescriptors::InstanceSize(0), Heap::kOld);
     InitializeObject(address,
                      kLocalVarDescriptorsCid,
                      LocalVarDescriptors::InstanceSize(0));
     LocalVarDescriptors::initializeHandle(
@@ skipping 1172 matching lines @@
                    "super classes",
                    String::Handle(cls.Name()).ToCString());
   UNREACHABLE();
 }
 
 
 void Class::set_num_type_arguments(intptr_t value) const {
   if (!Utils::IsInt(16, value)) {
     ReportTooManyTypeArguments(*this);
   }
-  raw_ptr()->num_type_arguments_ = value;
+  StoreNonPointer(&raw_ptr()->num_type_arguments_, value);
 }
 
 
 void Class::set_num_own_type_arguments(intptr_t value) const {
   if (!Utils::IsInt(16, value)) {
     ReportTooManyTypeArguments(*this);
   }
-  raw_ptr()->num_own_type_arguments_ = value;
+  StoreNonPointer(&raw_ptr()->num_own_type_arguments_, value);
 }
 
 
 // Initialize class fields of type Array with empty array.
 void Class::InitEmptyFields() {
   if (Object::empty_array().raw() == Array::null()) {
     // The empty array has not been initialized yet.
     return;
   }
   StorePointer(&raw_ptr()->interfaces_, Object::empty_array().raw());
@@ skipping 322 matching lines @@
 }
 
 
 void Class::set_signature_function(const Function& value) const {
   ASSERT(value.IsClosureFunction() || value.IsSignatureFunction());
   StorePointer(&raw_ptr()->signature_function_, value.raw());
 }
 
 
 void Class::set_state_bits(intptr_t bits) const {
-  raw_ptr()->state_bits_ = static_cast<uint16_t>(bits);
+  StoreNonPointer(&raw_ptr()->state_bits_, static_cast<uint16_t>(bits));
 }
 
 
 void Class::set_library(const Library& value) const {
   StorePointer(&raw_ptr()->library_, value.raw());
 }
 
 
 void Class::set_type_parameters(const TypeArguments& value) const {
   StorePointer(&raw_ptr()->type_parameters_, value.raw());
@@ skipping 1012 matching lines @@
 }
 
 
 void Class::set_script(const Script& value) const {
   StorePointer(&raw_ptr()->script_, value.raw());
 }
 
 
 void Class::set_token_pos(intptr_t token_pos) const {
   ASSERT(token_pos >= 0);
-  raw_ptr()->token_pos_ = token_pos;
+  StoreNonPointer(&raw_ptr()->token_pos_, token_pos);
 }
 
 
 intptr_t Class::ComputeEndTokenPos() const {
   // Return the begin token for synthetic classes.
   if (IsSignatureClass() || IsMixinApplication() || IsTopLevel()) {
     return token_pos();
   }
   const Script& scr = Script::Handle(script());
   ASSERT(!scr.IsNull());
@@ skipping 891 matching lines @@
   ASSERT(Object::unresolved_class_class() != Class::null());
   RawObject* raw = Object::Allocate(UnresolvedClass::kClassId,
                                     UnresolvedClass::InstanceSize(),
                                     Heap::kOld);
   return reinterpret_cast<RawUnresolvedClass*>(raw);
 }
 
 
 void UnresolvedClass::set_token_pos(intptr_t token_pos) const {
   ASSERT(token_pos >= 0);
-  raw_ptr()->token_pos_ = token_pos;
+  StoreNonPointer(&raw_ptr()->token_pos_, token_pos);
 }
 
 
 void UnresolvedClass::set_ident(const String& ident) const {
   StorePointer(&raw_ptr()->ident_, ident.raw());
 }
 
 
 void UnresolvedClass::set_library_prefix(
     const LibraryPrefix& library_prefix) const {
@@ skipping 562 matching lines @@
   // TODO(iposva): Determine if we should throw an exception here.
   ASSERT((index >= 0) && (index < Length()));
   return &raw_ptr()->types()[index];
 }
 
 
 void TypeArguments::SetLength(intptr_t value) const {
   ASSERT(!IsCanonical());
   // This is only safe because we create a new Smi, which does not cause
   // heap allocation.
-  raw_ptr()->length_ = Smi::New(value);
+  StoreSmi(&raw_ptr()->length_, Smi::New(value));
 }
 
 
 static void GrowCanonicalTypeArguments(Isolate* isolate, const Array& table) {
   // Last element of the array is the number of used elements.
   const intptr_t table_size = table.Length() - 1;
   const intptr_t new_table_size = table_size * 2;
   Array& new_table = Array::Handle(isolate, Array::New(new_table_size + 1));
   // Copy all elements from the original table to the newly allocated
   // array.
@@ skipping 673 matching lines @@
 
 void Function::set_is_async_closure(bool value) const {
   set_kind_tag(AsyncClosureBit::update(value, raw_ptr()->kind_tag_));
   // Prohibit inlining as the closure is used for implementing a continuation.
   set_is_inlinable(false);
 }
 
 
 void Function::set_token_pos(intptr_t value) const {
   ASSERT(value >= 0);
-  raw_ptr()->token_pos_ = value;
+  StoreNonPointer(&raw_ptr()->token_pos_, value);
 }
 
 
 void Function::set_kind_tag(intptr_t value) const {
-  raw_ptr()->kind_tag_ = static_cast<uint32_t>(value);
+  StoreNonPointer(&raw_ptr()->kind_tag_, static_cast<uint32_t>(value));
 }
 
 
 void Function::set_num_fixed_parameters(intptr_t value) const {
   ASSERT(value >= 0);
   ASSERT(Utils::IsInt(16, value));
-  raw_ptr()->num_fixed_parameters_ = static_cast<int16_t>(value);
+  StoreNonPointer(&raw_ptr()->num_fixed_parameters_,
+                  static_cast<int16_t>(value));
 }
 
 
 void Function::set_num_optional_parameters(intptr_t value) const {
   // A positive value indicates positional params, a negative one named params.
   ASSERT(Utils::IsInt(16, value));
-  raw_ptr()->num_optional_parameters_ = static_cast<int16_t>(value);
+  StoreNonPointer(&raw_ptr()->num_optional_parameters_,
+                  static_cast<int16_t>(value));
 }
 
 
 void Function::SetNumOptionalParameters(intptr_t num_optional_parameters,
                                         bool are_optional_positional) const {
   ASSERT(num_optional_parameters >= 0);
   set_num_optional_parameters(are_optional_positional ?
                               num_optional_parameters :
                               -num_optional_parameters);
 }
@@ skipping 1526 matching lines @@
   return PrettyName();
 }
 
 
 intptr_t Field::guarded_list_length() const {
   return Smi::Value(raw_ptr()->guarded_list_length_);
 }
 
 
 void Field::set_guarded_list_length(intptr_t list_length) const {
-  raw_ptr()->guarded_list_length_ = Smi::New(list_length);
+  StoreSmi(&raw_ptr()->guarded_list_length_, Smi::New(list_length));
 }
 
 
 intptr_t Field::guarded_list_length_in_object_offset() const {
   return raw_ptr()->guarded_list_length_in_object_offset_ + kHeapObjectTag;
 }
 
 
 void Field::set_guarded_list_length_in_object_offset(
     intptr_t list_length_offset) const {
@@ skipping 1115 matching lines @@
   StorePointer(&raw_ptr()->url_, value.raw());
 }
 
 
 void Script::set_source(const String& value) const {
   StorePointer(&raw_ptr()->source_, value.raw());
 }
 
 
 void Script::set_kind(RawScript::Kind value) const {
-  raw_ptr()->kind_ = value;
+  StoreNonPointer(&raw_ptr()->kind_, value);
 }
 
 
 void Script::set_tokens(const TokenStream& value) const {
   StorePointer(&raw_ptr()->tokens_, value.raw());
 }
 
 
 void Script::Tokenize(const String& private_key) const {
   Isolate* isolate = Isolate::Current();
@@ skipping 13 matching lines @@
   if (FLAG_compiler_stats) {
     CompilerStats::src_length += src.Length();
   }
 }
 
 
 void Script::SetLocationOffset(intptr_t line_offset,
                                intptr_t col_offset) const {
   ASSERT(line_offset >= 0);
   ASSERT(col_offset >= 0);
-  raw_ptr()->line_offset_ = line_offset;
-  raw_ptr()->col_offset_ = col_offset;
+  StoreNonPointer(&raw_ptr()->line_offset_, line_offset);
+  StoreNonPointer(&raw_ptr()->col_offset_, col_offset);
 }
 
 
 void Script::GetTokenLocation(intptr_t token_pos,
                               intptr_t* line,
                               intptr_t* column) const {
   ASSERT(line != NULL);
   const TokenStream& tkns = TokenStream::Handle(tokens());
   if (column == NULL) {
     TokenStream::Iterator tkit(tkns, 0, TokenStream::Iterator::kAllTokens);
@@ skipping 354 matching lines @@
   // Only set name once.
   ASSERT(!Loaded());
   ASSERT(name.IsSymbol());
   StorePointer(&raw_ptr()->name_, name.raw());
 }
 
 
 void Library::SetLoadInProgress() const {
   // Must not already be in the process of being loaded.
   ASSERT(raw_ptr()->load_state_ <= RawLibrary::kLoadRequested);
-  raw_ptr()->load_state_ = RawLibrary::kLoadInProgress;
+  StoreNonPointer(&raw_ptr()->load_state_, RawLibrary::kLoadInProgress);
 }
 
 
 void Library::SetLoadRequested() const {
   // Must not be already loaded.
   ASSERT(raw_ptr()->load_state_ == RawLibrary::kAllocated);
   raw_ptr()->load_state_ = RawLibrary::kLoadRequested;
 }
 
 
 void Library::SetLoaded() const {
   // Should not be already loaded or just allocated.
   ASSERT(LoadInProgress() || LoadRequested());
-  raw_ptr()->load_state_ = RawLibrary::kLoaded;
+  StoreNonPointer(&raw_ptr()->load_state_, RawLibrary::kLoaded);
 }
 
 
 void Library::SetLoadError(const Instance& error) const {
   // Should not be already successfully loaded or just allocated.
   ASSERT(LoadInProgress() || LoadRequested() || LoadFailed());
-  raw_ptr()->load_state_ = RawLibrary::kLoadError;
+  StoreNonPointer(&raw_ptr()->load_state_, RawLibrary::kLoadError);
   StorePointer(&raw_ptr()->load_error_, error.raw());
 }
 
 
 // Traits for looking up Libraries by url in a hash set.
 class LibraryUrlTraits {
  public:
   // Called when growing the table.
   static bool IsMatch(const Object& a, const Object& b) {
     ASSERT(a.IsLibrary() && b.IsLibrary());
@@ skipping 707 matching lines @@
 void Library::AddAnonymousClass(const Class& cls) const {
   intptr_t num_anonymous = this->raw_ptr()->num_anonymous_;
   Array& anon_array = Array::Handle(this->raw_ptr()->anonymous_classes_);
   if (num_anonymous == anon_array.Length()) {
     intptr_t new_len = (num_anonymous == 0) ? 4 : num_anonymous * 2;
     anon_array = Array::Grow(anon_array, new_len);
     StorePointer(&raw_ptr()->anonymous_classes_, anon_array.raw());
   }
   anon_array.SetAt(num_anonymous, cls);
   num_anonymous++;
-  raw_ptr()->num_anonymous_ = num_anonymous;
+  StoreNonPointer(&raw_ptr()->num_anonymous_, num_anonymous);
 }
 
 
 RawLibrary* Library::ImportLibraryAt(intptr_t index) const {
   Namespace& import = Namespace::Handle(ImportAt(index));
   if (import.IsNull()) {
     return Library::null();
   }
   return import.library();
 }
@@ skipping 85 matching lines @@
   // TODO(iposva): Find reasonable initial size.
   const int kInitialElementCount = 16;
   StorePointer(&raw_ptr()->dictionary_, NewDictionary(kInitialElementCount));
 }
 
 
 void Library::InitImportList() const {
   const Array& imports =
       Array::Handle(Array::New(kInitialImportsCapacity, Heap::kOld));
   StorePointer(&raw_ptr()->imports_, imports.raw());
-  raw_ptr()->num_imports_ = 0;
+  StoreNonPointer(&raw_ptr()->num_imports_, 0);
 }
 
 
 RawLibrary* Library::New() {
   ASSERT(Object::library_class() != Class::null());
   RawObject* raw = Object::Allocate(Library::kClassId,
                                     Library::InstanceSize(),
                                     Heap::kOld);
   return reinterpret_cast<RawLibrary*>(raw);
 }
 
 
 RawLibrary* Library::NewLibraryHelper(const String& url,
                                       bool import_core_lib) {
   const Library& result = Library::Handle(Library::New());
   result.StorePointer(&result.raw_ptr()->name_, Symbols::Empty().raw());
   result.StorePointer(&result.raw_ptr()->url_, url.raw());
-  result.raw_ptr()->resolved_names_ = Object::empty_array().raw();
-  result.raw_ptr()->dictionary_ = Object::empty_array().raw();
+  result.StorePointer(&result.raw_ptr()->resolved_names_,
+                      Object::empty_array().raw());
+  result.StorePointer(&result.raw_ptr()->dictionary_,
+                      Object::empty_array().raw());
   result.StorePointer(&result.raw_ptr()->metadata_,
                       GrowableObjectArray::New(4, Heap::kOld));
-  result.raw_ptr()->anonymous_classes_ = Object::empty_array().raw();
-  result.raw_ptr()->num_anonymous_ = 0;
-  result.raw_ptr()->imports_ = Object::empty_array().raw();
-  result.raw_ptr()->exports_ = Object::empty_array().raw();
-  result.raw_ptr()->loaded_scripts_ = Array::null();
+  result.StorePointer(&result.raw_ptr()->anonymous_classes_,
+                      Object::empty_array().raw());
+  result.StoreNonPointer(&result.raw_ptr()->num_anonymous_, 0);
+  result.StorePointer(&result.raw_ptr()->imports_, Object::empty_array().raw());
+  result.StorePointer(&result.raw_ptr()->exports_, Object::empty_array().raw());
+  result.StorePointer(&result.raw_ptr()->loaded_scripts_, Array::null());
   result.raw_ptr()->load_error_ = Instance::null();
   result.set_native_entry_resolver(NULL);
   result.set_native_entry_symbol_resolver(NULL);
-  result.raw_ptr()->corelib_imported_ = true;
+  result.StoreNonPointer(&result.raw_ptr()->corelib_imported_, true);
   result.set_debuggable(false);
   result.set_is_dart_scheme(url.StartsWith(Symbols::DartScheme()));
-  result.raw_ptr()->load_state_ = RawLibrary::kAllocated;
-  result.raw_ptr()->index_ = -1;
+  result.StoreNonPointer(&result.raw_ptr()->load_state_,
+                         RawLibrary::kAllocated);
+  result.StoreNonPointer(&result.raw_ptr()->index_, -1);
   const intptr_t kInitialNameCacheSize = 64;
   result.InitResolvedNamesCache(kInitialNameCacheSize);
   result.InitClassDictionary();
   result.InitImportList();
   result.AllocatePrivateKey();
   if (import_core_lib) {
     const Library& core_lib = Library::Handle(Library::CoreLibrary());
     ASSERT(!core_lib.IsNull());
     const Namespace& ns = Namespace::Handle(
         Namespace::New(core_lib, Object::null_array(), Object::null_array()));
@@ skipping 462 matching lines @@
 RawClass* LibraryPrefix::LookupClass(const String& class_name) const {
   const Object& obj = Object::Handle(LookupObject(class_name));
   if (obj.IsClass()) {
     return Class::Cast(obj).raw();
   }
   return Class::null();
 }
 
 
 void LibraryPrefix::set_is_loaded() const {
-  raw_ptr()->is_loaded_ = true;
+  StoreNonPointer(&raw_ptr()->is_loaded_, true);
 }
 
 
 bool LibraryPrefix::LoadLibrary() const {
   // Non-deferred prefixes are loaded.
   ASSERT(is_deferred_load() || is_loaded());
   if (is_loaded()) {
     return true;  // Load request has already completed.
   }
   ASSERT(is_deferred_load());
@@ skipping 98 matching lines @@
 
 
 RawLibraryPrefix* LibraryPrefix::New(const String& name,
                                      const Namespace& import,
                                      bool deferred_load,
                                      const Library& importer) {
   const LibraryPrefix& result = LibraryPrefix::Handle(LibraryPrefix::New());
   result.set_name(name);
   result.set_num_imports(0);
   result.set_importer(importer);
-  result.raw_ptr()->is_deferred_load_ = deferred_load;
-  result.raw_ptr()->is_loaded_ = !deferred_load;
+  result.StoreNonPointer(&result.raw_ptr()->is_deferred_load_, deferred_load);
+  result.StoreNonPointer(&result.raw_ptr()->is_loaded_, !deferred_load);
   result.set_imports(Array::Handle(Array::New(kInitialSize)));
   result.AddImport(import);
   result.set_dependent_code(Object::null_array());
   return result.raw();
 }
 
 
 void LibraryPrefix::set_name(const String& value) const {
   ASSERT(value.IsSymbol());
   StorePointer(&raw_ptr()->name_, value.raw());
 }
 
 
 void LibraryPrefix::set_imports(const Array& value) const {
   StorePointer(&raw_ptr()->imports_, value.raw());
 }
 
 
 void LibraryPrefix::set_num_imports(intptr_t value) const {
-  raw_ptr()->num_imports_ = value;
+  StoreNonPointer(&raw_ptr()->num_imports_, value);
 }
 
 
 void LibraryPrefix::set_importer(const Library& value) const {
   StorePointer(&raw_ptr()->importer_, value.raw());
 }
 
 
 const char* LibraryPrefix::ToCString() const {
   const char* kFormat = "LibraryPrefix:'%s'";
@@ skipping 335 matching lines @@
   Object::PrintJSONImpl(stream, ref);
 }
 
 
 intptr_t PcDescriptors::Length() const {
   return raw_ptr()->length_;
 }
 
 
 void PcDescriptors::SetLength(intptr_t value) const {
-  raw_ptr()->length_ = value;
+  StoreNonPointer(&raw_ptr()->length_, value);
 }
 
 
 intptr_t PcDescriptors::RecordSizeInBytes() const {
   return raw_ptr()->record_size_in_bytes_;
 }
 
 
 void PcDescriptors::SetRecordSizeInBytes(intptr_t value) const {
   raw_ptr()->record_size_in_bytes_ = value;
@@ skipping 442 matching lines @@
            num_variables, RawLocalVarDescriptors::kMaxIndex);
   }
   LocalVarDescriptors& result = LocalVarDescriptors::Handle();
   {
     uword size = LocalVarDescriptors::InstanceSize(num_variables);
     RawObject* raw = Object::Allocate(LocalVarDescriptors::kClassId,
                                       size,
                                       Heap::kOld);
     NoGCScope no_gc;
     result ^= raw;
-    result.raw_ptr()->num_entries_ = num_variables;
+    result.StoreNonPointer(&result.raw_ptr()->num_entries_, num_variables);
   }
   return result.raw();
 }
 
 
 intptr_t LocalVarDescriptors::Length() const {
   return raw_ptr()->num_entries_;
 }
 
 
@@ skipping 78 matching lines @@
            num_handlers);
   }
   ExceptionHandlers& result = ExceptionHandlers::Handle();
   {
     uword size = ExceptionHandlers::InstanceSize(num_handlers);
     RawObject* raw = Object::Allocate(ExceptionHandlers::kClassId,
                                       size,
                                       Heap::kOld);
     NoGCScope no_gc;
     result ^= raw;
-    result.raw_ptr()->num_entries_ = num_handlers;
+    result.StoreNonPointer(&result.raw_ptr()->num_entries_, num_handlers);
   }
   const Array& handled_types_data = (num_handlers == 0) ?
       Object::empty_array() :
       Array::Handle(Array::New(num_handlers));
   result.set_handled_types_data(handled_types_data);
   return result.raw();
 }
 
 
 const char* ExceptionHandlers::ToCString() const {
@@ skipping 189 matching lines @@
     result ^= raw;
     result.SetLength(num_commands);
   }
   return result.raw();
 }
 
 
 void DeoptInfo::SetLength(intptr_t value) const {
   // This is only safe because we create a new Smi, which does not cause
   // heap allocation.
-  raw_ptr()->length_ = Smi::New(value);
+  StoreSmi(&raw_ptr()->length_, Smi::New(value));
 }
 
 
 void DeoptInfo::SetAt(intptr_t index,
                       intptr_t instr_kind,
                       intptr_t from_index) const {
   *(EntryAddr(index, kInstruction)) = instr_kind;
   *(EntryAddr(index, kFromIndex)) = from_index;
 }
 
@@ skipping 24 matching lines @@
 }
 
 
 void ICData::set_arguments_descriptor(const Array& value) const {
   ASSERT(!value.IsNull());
   StorePointer(&raw_ptr()->args_descriptor_, value.raw());
 }
 
 void ICData::set_deopt_id(intptr_t value) const {
   ASSERT(value <= kMaxInt32);
-  raw_ptr()->deopt_id_ = value;
+  StoreNonPointer(&raw_ptr()->deopt_id_, value);
 }
 
 
 void ICData::set_ic_data(const Array& value) const {
   ASSERT(!value.IsNull());
   StorePointer(&raw_ptr()->ic_data_, value.raw());
 }
 
 
 intptr_t ICData::NumArgsTested() const {
@@ skipping 52 matching lines @@
   // Warning issued in ic miss handler.
   // No decoding necessary, so allow optimization if warning already issued.
   if (name.Equals(Symbols::toString()) && !IssuedJSWarning()) {
     return true;
   }
   return false;
 }
 
 
 void ICData::set_state_bits(uint32_t bits) const {
-  raw_ptr()->state_bits_ = bits;
+  StoreNonPointer(&raw_ptr()->state_bits_, bits);
 }
 
 
 intptr_t ICData::TestEntryLengthFor(intptr_t num_args) {
   return num_args + 1 /* target function*/ + 1 /* frequency */;
 }
 
 
 intptr_t ICData::TestEntryLength() const {
   return TestEntryLengthFor(NumArgsTested());
@@ skipping 503 matching lines @@
   comments_.SetAt(idx * kNumberOfEntries + kCommentEntry, comment);
 }
 
 
 Code::Comments::Comments(const Array& comments)
     : comments_(comments) {
 }
 
 
 void Code::set_state_bits(intptr_t bits) const {
-  raw_ptr()->state_bits_ = bits;
+  StoreNonPointer(&raw_ptr()->state_bits_, bits);
 }
 
 
 void Code::set_is_optimized(bool value) const {
   set_state_bits(OptimizedBit::update(value, raw_ptr()->state_bits_));
 }
 
 
 void Code::set_is_alive(bool value) const {
   set_state_bits(AliveBit::update(value, raw_ptr()->state_bits_));
@@ skipping 759 matching lines @@
 
 // Class IDs in the table are smi-tagged, so we use a smi-tagged mask
 // and target class ID to avoid untagging (on each iteration of the
 // test loop) in generated code.
 intptr_t MegamorphicCache::mask() const {
   return Smi::Value(raw_ptr()->mask_);
 }
 
 
 void MegamorphicCache::set_mask(intptr_t mask) const {
-  raw_ptr()->mask_ = Smi::New(mask);
+  StoreSmi(&raw_ptr()->mask_, Smi::New(mask));
 }
 
 
 intptr_t MegamorphicCache::filled_entry_count() const {
   return raw_ptr()->filled_entry_count_;
 }
 
 
 void MegamorphicCache::set_filled_entry_count(intptr_t count) const {
-  raw_ptr()->filled_entry_count_ = count;
+  StoreNonPointer(&raw_ptr()->filled_entry_count_, count);
 }
 
 
 RawMegamorphicCache* MegamorphicCache::New() {
   MegamorphicCache& result = MegamorphicCache::Handle();
   { RawObject* raw = Object::Allocate(MegamorphicCache::kClassId,
                                       MegamorphicCache::InstanceSize(),
                                       Heap::kOld);
     NoGCScope no_gc;
     result ^= raw;
@@ skipping 288 matching lines @@
 }
 
 
 void LanguageError::set_script(const Script& value) const {
   StorePointer(&raw_ptr()->script_, value.raw());
 }
 
 
 void LanguageError::set_token_pos(intptr_t value) const {
   ASSERT(value >= 0);
-  raw_ptr()->token_pos_ = value;
+  StoreNonPointer(&raw_ptr()->token_pos_, value);
 }
 
 
 void LanguageError::set_kind(uint8_t value) const {
-  raw_ptr()->kind_ = value;
+  StoreNonPointer(&raw_ptr()->kind_, value);
 }
 
 
 void LanguageError::set_message(const String& value) const {
   StorePointer(&raw_ptr()->message_, value.raw());
 }
 
 
 void LanguageError::set_formatted_message(const String& value) const {
   StorePointer(&raw_ptr()->formatted_message_, value.raw());
@@ skipping 1679 matching lines @@
 
 
 RawType* Type::New(const Object& clazz,
                    const TypeArguments& arguments,
                    intptr_t token_pos,
                    Heap::Space space) {
   const Type& result = Type::Handle(Type::New(space));
   result.set_type_class(clazz);
   result.set_arguments(arguments);
   result.set_token_pos(token_pos);
-  result.raw_ptr()->type_state_ = RawType::kAllocated;
+  result.StoreNonPointer(&result.raw_ptr()->type_state_, RawType::kAllocated);
   return result.raw();
 }
 
 
 void Type::set_token_pos(intptr_t token_pos) const {
   ASSERT(token_pos >= 0);
-  raw_ptr()->token_pos_ = token_pos;
+  StoreNonPointer(&raw_ptr()->token_pos_, token_pos);
 }
 
 
 void Type::set_type_state(int8_t state) const {
   ASSERT((state >= RawType::kAllocated) &&
          (state <= RawType::kFinalizedUninstantiated));
-  raw_ptr()->type_state_ = state;
+  StoreNonPointer(&raw_ptr()->type_state_, state);
 }
 
 
 const char* Type::ToCString() const {
   if (IsResolved()) {
     const TypeArguments& type_arguments = TypeArguments::Handle(arguments());
     const char* class_name;
     if (HasResolvedTypeClass()) {
       class_name = String::Handle(
           Class::Handle(type_class()).Name()).ToCString();
@@ skipping 252 matching lines @@
 
 
 void TypeParameter::set_parameterized_class(const Class& value) const {
   // Set value may be null.
   StorePointer(&raw_ptr()->parameterized_class_, value.raw());
 }
 
 
 void TypeParameter::set_index(intptr_t value) const {
   ASSERT(value >= 0);
-  raw_ptr()->index_ = value;
+  StoreNonPointer(&raw_ptr()->index_, value);
 }
 
 
 void TypeParameter::set_name(const String& value) const {
   ASSERT(value.IsSymbol());
   StorePointer(&raw_ptr()->name_, value.raw());
 }
 
 
 void TypeParameter::set_bound(const AbstractType& value) const {
@@ skipping 101 matching lines @@
                                      intptr_t index,
                                      const String& name,
                                      const AbstractType& bound,
                                      intptr_t token_pos) {
   const TypeParameter& result = TypeParameter::Handle(TypeParameter::New());
   result.set_parameterized_class(parameterized_class);
   result.set_index(index);
   result.set_name(name);
   result.set_bound(bound);
   result.set_token_pos(token_pos);
-  result.raw_ptr()->type_state_ = RawTypeParameter::kAllocated;
+  result.StoreNonPointer(&result.raw_ptr()->type_state_,
+                         RawTypeParameter::kAllocated);
   return result.raw();
 }
 
 
 void TypeParameter::set_token_pos(intptr_t token_pos) const {
   ASSERT(token_pos >= 0);
-  raw_ptr()->token_pos_ = token_pos;
+  StoreNonPointer(&raw_ptr()->token_pos_, token_pos);
 }
 
 
 void TypeParameter::set_type_state(int8_t state) const {
   ASSERT((state == RawTypeParameter::kAllocated) ||
          (state == RawTypeParameter::kBeingFinalized) ||
          (state == RawTypeParameter::kFinalizedUninstantiated));
-  raw_ptr()->type_state_ = state;
+  StoreNonPointer(&raw_ptr()->type_state_, state);
 }
 
 
 const char* TypeParameter::ToCString() const {
   const char* format =
       "TypeParameter: name %s; index: %d; class: %s; bound: %s";
   const char* name_cstr = String::Handle(Name()).ToCString();
   const Class& cls = Class::Handle(parameterized_class());
   const char* cls_cstr =
       cls.IsNull() ? " null" : String::Handle(cls.Name()).ToCString();
@@ skipping 760 matching lines @@
   jsobj.AddPropertyF("valueAsString", "%" Pd "", Value());
 }
 
 
 RawClass* Smi::Class() {
   return Isolate::Current()->object_store()->smi_class();
 }
 
 
 void Mint::set_value(int64_t value) const {
-  raw_ptr()->value_ = value;
+  StoreNonPointer(&raw_ptr()->value_, value);
 }
 
 
 RawMint* Mint::New(int64_t val, Heap::Space space) {
   // Do not allocate a Mint if Smi would do.
   ASSERT(!Smi::IsValid(val));
   ASSERT(Isolate::Current()->object_store()->mint_class() != Class::null());
   Mint& result = Mint::Handle();
   {
     RawObject* raw = Object::Allocate(Mint::kClassId,
@@ skipping 100 matching lines @@
   return chars;
 }
 
 
 void Mint::PrintJSONImpl(JSONStream* stream, bool ref) const {
   Integer::PrintJSONImpl(stream, ref);
 }
 
 
 void Double::set_value(double value) const {
-  raw_ptr()->value_ = value;
+  StoreNonPointer(&raw_ptr()->value_, value);
 }
 
 
 bool Double::BitwiseEqualsToDouble(double value) const {
   intptr_t value_offset = Double::value_offset();
   void* this_addr = reinterpret_cast<void*>(
       reinterpret_cast<uword>(this->raw_ptr()) + value_offset);
   void* other_addr = reinterpret_cast<void*>(&value);
   return (memcmp(this_addr, other_addr, sizeof(value)) == 0);
 }
@@ skipping 3195 matching lines @@
   return simd128_value_t().readFrom(&raw_ptr()->value_[0]);
 }
 
 
 void Float32x4::set_value(simd128_value_t value) const {
   value.writeTo(&raw_ptr()->value_[0]);
 }
 
 
 void Float32x4::set_x(float value) const {
-  raw_ptr()->value_[0] = value;
+  StoreNonPointer(&raw_ptr()->value_[0], value);
 }
 
 
 void Float32x4::set_y(float value) const {
-  raw_ptr()->value_[1] = value;
+  StoreNonPointer(&raw_ptr()->value_[1], value);
 }
 
 
 void Float32x4::set_z(float value) const {
-  raw_ptr()->value_[2] = value;
+  StoreNonPointer(&raw_ptr()->value_[2], value);
 }
 
 
 void Float32x4::set_w(float value) const {
-  raw_ptr()->value_[3] = value;
+  StoreNonPointer(&raw_ptr()->value_[3], value);
 }
 
 
 float Float32x4::x() const {
   return raw_ptr()->value_[0];
 }
 
 
 float Float32x4::y() const {
   return raw_ptr()->value_[1];
@@ skipping 59 matching lines @@
                                       space);
     NoGCScope no_gc;
     result ^= raw;
   }
   result.set_value(value);
   return result.raw();
 }
 
 
 void Int32x4::set_x(int32_t value) const {
-  raw_ptr()->value_[0] = value;
+  StoreNonPointer(&raw_ptr()->value_[0], value);
 }
 
 
 void Int32x4::set_y(int32_t value) const {
-  raw_ptr()->value_[1] = value;
+  StoreNonPointer(&raw_ptr()->value_[1], value);
 }
 
 
 void Int32x4::set_z(int32_t value) const {
-  raw_ptr()->value_[2] = value;
+  StoreNonPointer(&raw_ptr()->value_[2], value);
 }
 
 
 void Int32x4::set_w(int32_t value) const {
-  raw_ptr()->value_[3] = value;
+  StoreNonPointer(&raw_ptr()->value_[3], value);
 }
 
 
 int32_t Int32x4::x() const {
   return raw_ptr()->value_[0];
 }
 
 
 int32_t Int32x4::y() const {
   return raw_ptr()->value_[1];
@@ skipping 76 matching lines @@
   return raw_ptr()->value_[0];
 }
 
 
 double Float64x2::y() const {
   return raw_ptr()->value_[1];
 }
 
 
 void Float64x2::set_x(double x) const {
-  raw_ptr()->value_[0] = x;
+  StoreNonPointer(&raw_ptr()->value_[0], x);
 }
 
 
 void Float64x2::set_y(double y) const {
-  raw_ptr()->value_[1] = y;
+  StoreNonPointer(&raw_ptr()->value_[1], y);
 }
 
 
 simd128_value_t Float64x2::value() const {
   return simd128_value_t().readFrom(&raw_ptr()->value_[0]);
 }
 
 
 void Float64x2::set_value(simd128_value_t value) const {
   value.writeTo(&raw_ptr()->value_[0]);
@@ skipping 144 matching lines @@
 
 
 RawCapability* Capability::New(uint64_t id, Heap::Space space) {
   Capability& result = Capability::Handle();
   {
     RawObject* raw = Object::Allocate(Capability::kClassId,
                                       Capability::InstanceSize(),
                                       space);
     NoGCScope no_gc;
     result ^= raw;
-    result.raw_ptr()->id_ = id;
+    result.StoreNonPointer(&result.raw_ptr()->id_, id);
   }
   return result.raw();
 }
 
 
 const char* Capability::ToCString() const {
   return "Capability";
 }
 
 
 void Capability::PrintJSONImpl(JSONStream* stream, bool ref) const {
   Instance::PrintJSONImpl(stream, ref);
 }
 
 
 RawReceivePort* ReceivePort::New(Dart_Port id,
                                  bool is_control_port,
                                  Heap::Space space) {
   Isolate* isolate = Isolate::Current();
   const SendPort& send_port = SendPort::Handle(isolate, SendPort::New(id));
 
   ReceivePort& result = ReceivePort::Handle(isolate);
   {
     RawObject* raw = Object::Allocate(ReceivePort::kClassId,
                                       ReceivePort::InstanceSize(),
                                       space);
     NoGCScope no_gc;
     result ^= raw;
-    result.raw_ptr()->send_port_ = send_port.raw();
+    result.StorePointer(&result.raw_ptr()->send_port_, send_port.raw());
   }
   if (is_control_port) {
     PortMap::SetPortState(id, PortMap::kControlPort);
   } else {
     PortMap::SetPortState(id, PortMap::kLivePort);
   }
   return result.raw();
 }
 
 
 const char* ReceivePort::ToCString() const {
   return "ReceivePort";
 }
 
 
 void ReceivePort::PrintJSONImpl(JSONStream* stream, bool ref) const {
   Instance::PrintJSONImpl(stream, ref);
 }
 
 
 RawSendPort* SendPort::New(Dart_Port id, Heap::Space space) {
   SendPort& result = SendPort::Handle();
   {
     RawObject* raw = Object::Allocate(SendPort::kClassId,
                                       SendPort::InstanceSize(),
                                       space);
     NoGCScope no_gc;
     result ^= raw;
-    result.raw_ptr()->id_ = id;
+    result.StoreNonPointer(&result.raw_ptr()->id_, id);
   }
   return result.raw();
 }
 
 
 const char* SendPort::ToCString() const {
   return "SendPort";
 }
 
 
@@ skipping 88 matching lines @@
   StorePointer(&raw_ptr()->catch_code_array_, code_array.raw());
 }
 
 
 void Stacktrace::set_catch_pc_offset_array(const Array& pc_offset_array) const {
   StorePointer(&raw_ptr()->catch_pc_offset_array_, pc_offset_array.raw());
 }
 
 
 void Stacktrace::set_expand_inlined(bool value) const {
-  raw_ptr()->expand_inlined_ = value;
+  StoreNonPointer(&raw_ptr()->expand_inlined_, value);
 }
 
 
 bool Stacktrace::expand_inlined() const {
   return raw_ptr()->expand_inlined_;
 }
 
 
 RawStacktrace* Stacktrace::New(const Array& code_array,
                                const Array& pc_offset_array,
@@ skipping 195 matching lines @@
   return chars;
 }
 
 
 void JSRegExp::set_pattern(const String& pattern) const {
   StorePointer(&raw_ptr()->pattern_, pattern.raw());
 }
 
 
 void JSRegExp::set_num_bracket_expressions(intptr_t value) const {
-  raw_ptr()->num_bracket_expressions_ = Smi::New(value);
+  StoreSmi(&raw_ptr()->num_bracket_expressions_, Smi::New(value));
 }
 
 
 RawJSRegExp* JSRegExp::New(intptr_t len, Heap::Space space) {
   if (len < 0 || len > kMaxElements) {
     // This should be caught before we reach here.
     FATAL1("Fatal error in JSRegexp::New: invalid len %" Pd "\n", len);
   }
   JSRegExp& result = JSRegExp::Handle();
   {
@@ skipping 314 matching lines @@
   return tag_label.ToCString();
 }
 
 
 void UserTag::PrintJSONImpl(JSONStream* stream, bool ref) const {
   Instance::PrintJSONImpl(stream, ref);
 }
 
 
 }  // namespace dart