Write barrier audit, part 1

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 575 matching lines @@
     *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());
     }
   }
 
+  // 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** addr, RawSmi* value) const {
+    // Can't use Contains, as array length is initialized through this method.
+    ASSERT(reinterpret_cast<uword>(addr) >= RawObject::ToAddr(raw()));
+    *addr = value;
+  }
+
+  // Needs two template arguments to allow assigning enums to fixed-size ints.
+  template<typename FieldType, typename ValueType>
+  void StoreNonPointer(FieldType* addr, ValueType value) const {
+    // Can't use Contains, as it uses tags_, which is set through this method.
+    ASSERT(reinterpret_cast<uword>(addr) >= RawObject::ToAddr(raw()));
+    *addr = value;
+  }
+
+  // Fail at link time if StoreNonPointer is called with an object pointer.
+#define STORE_NON_POINTER_ILLEGAL_TYPE(type)                                   \
+  template<typename ValueType>                                                 \
+  void StoreNonPointer(Raw##type** addr, ValueType value) const {              \
+    UnimplementedMethod();                                                     \
+  }
+  CLASS_LIST(STORE_NON_POINTER_ILLEGAL_TYPE);
+  void UnimplementedMethod() const;
+#undef STORE_NON_POINTER_ILLEGAL_TYPE
+
   RawObject* raw_;  // The raw object reference.
 
  protected:
   virtual void PrintJSONImpl(JSONStream* stream, bool ref) const;
 
  private:
   static intptr_t NextFieldOffset() {
     // Indicates this class cannot be extended by dart code.
     return -kWordSize;
   }
@@ skipping 158 matching lines @@
   intptr_t instance_size() const {
     ASSERT(is_finalized() || is_prefinalized());
     return (raw_ptr()->instance_size_in_words_ * kWordSize);
   }
   void set_instance_size(intptr_t value_in_bytes) const {
     ASSERT(kWordSize != 0);
     set_instance_size_in_words(value_in_bytes / kWordSize);
   }
   void set_instance_size_in_words(intptr_t value) const {
     ASSERT(Utils::IsAligned((value * kWordSize), kObjectAlignment));
-    raw_ptr()->instance_size_in_words_ = value;
+    StoreNonPointer(&raw_ptr()->instance_size_in_words_, value);
   }
 
   intptr_t next_field_offset() const {
     return raw_ptr()->next_field_offset_in_words_ * kWordSize;
   }
   void set_next_field_offset(intptr_t value_in_bytes) const {
     ASSERT(kWordSize != 0);
     set_next_field_offset_in_words(value_in_bytes / kWordSize);
   }
   void set_next_field_offset_in_words(intptr_t value) const {
     ASSERT((value == -1) ||
            (Utils::IsAligned((value * kWordSize), kObjectAlignment) &&
             (value == raw_ptr()->instance_size_in_words_)) ||
            (!Utils::IsAligned((value * kWordSize), kObjectAlignment) &&
             ((value + 1) == raw_ptr()->instance_size_in_words_)));
-    raw_ptr()->next_field_offset_in_words_ = value;
+    StoreNonPointer(&raw_ptr()->next_field_offset_in_words_, value);
   }
 
   cpp_vtable handle_vtable() const { return raw_ptr()->handle_vtable_; }
   void set_handle_vtable(cpp_vtable value) const {
-    raw_ptr()->handle_vtable_ = value;
+    StoreNonPointer(&raw_ptr()->handle_vtable_, value);
   }
 
   static bool is_valid_id(intptr_t value) {
     return RawObject::ClassIdTag::is_valid(value);
   }
   intptr_t id() const { return raw_ptr()->id_; }
   void set_id(intptr_t value) const {
     ASSERT(is_valid_id(value));
-    raw_ptr()->id_ = value;
+    StoreNonPointer(&raw_ptr()->id_, value);
   }
 
   RawString* Name() const;
   RawString* PrettyName() const;
   RawString* UserVisibleName() const;
 
   virtual RawString* DictionaryName() const { return Name(); }
 
   RawScript* script() const { return raw_ptr()->script_; }
   void set_script(const Script& value) const;
@@ skipping 79 matching lines @@
     intptr_t value;
     if (value_in_bytes == kNoTypeArguments) {
       value = kNoTypeArguments;
     } else {
       ASSERT(kWordSize != 0);
       value = value_in_bytes / kWordSize;
     }
     set_type_arguments_field_offset_in_words(value);
   }
   void set_type_arguments_field_offset_in_words(intptr_t value) const {
-    raw_ptr()->type_arguments_field_offset_in_words_ = value;
+    StoreNonPointer(&raw_ptr()->type_arguments_field_offset_in_words_, value);
   }
   static intptr_t type_arguments_field_offset_in_words_offset() {
     return OFFSET_OF(RawClass, type_arguments_field_offset_in_words_);
   }
 
   RawType* CanonicalType() const {
     if ((NumTypeArguments() == 0) && !IsSignatureClass()) {
       return reinterpret_cast<RawType*>(raw_ptr()->canonical_types_);
     }
     return reinterpret_cast<RawType*>(Object::null());
@@ skipping 213 matching lines @@
 
   bool is_cycle_free() const {
     return CycleFreeBit::decode(raw_ptr()->state_bits_);
   }
   void set_is_cycle_free() const;
 
   uint16_t num_native_fields() const {
     return raw_ptr()->num_native_fields_;
   }
   void set_num_native_fields(uint16_t value) const {
-    raw_ptr()->num_native_fields_ = value;
+    StoreNonPointer(&raw_ptr()->num_native_fields_, value);
   }
 
   RawCode* allocation_stub() const {
     return raw_ptr()->allocation_stub_;
   }
   void set_allocation_stub(const Code& value) const;
 
   void DisableAllocationStub() const;
 
   RawArray* constants() const;
@@ skipping 648 matching lines @@
         return false;
     }
   }
   bool IsInFactoryScope() const;
 
   intptr_t token_pos() const { return raw_ptr()->token_pos_; }
   void set_token_pos(intptr_t value) const;
 
   intptr_t end_token_pos() const { return raw_ptr()->end_token_pos_; }
   void set_end_token_pos(intptr_t value) const {
-    raw_ptr()->end_token_pos_ = value;
+    StoreNonPointer(&raw_ptr()->end_token_pos_, value);
   }
 
   intptr_t num_fixed_parameters() const {
     return raw_ptr()->num_fixed_parameters_;
   }
   void set_num_fixed_parameters(intptr_t value) const;
 
   bool HasOptionalParameters() const {
     return raw_ptr()->num_optional_parameters_ != 0;
   }
@@ skipping 23 matching lines @@
 
   intptr_t NumImplicitParameters() const;
 
   static intptr_t usage_counter_offset() {
     return OFFSET_OF(RawFunction, usage_counter_);
   }
   intptr_t usage_counter() const {
     return raw_ptr()->usage_counter_;
   }
   void set_usage_counter(intptr_t value) const {
-    raw_ptr()->usage_counter_ = value;
+    StoreNonPointer(&raw_ptr()->usage_counter_, value);
   }
 
   int16_t deoptimization_counter() const {
     return raw_ptr()->deoptimization_counter_;
   }
   void set_deoptimization_counter(int16_t value) const {
-    raw_ptr()->deoptimization_counter_ = value;
+    StoreNonPointer(&raw_ptr()->deoptimization_counter_, value);
   }
 
   static const intptr_t kMaxInstructionCount = (1 << 16) - 1;
   intptr_t optimized_instruction_count() const {
     return raw_ptr()->optimized_instruction_count_;
   }
   void set_optimized_instruction_count(intptr_t value) const {
     ASSERT(value >= 0);
     if (value > kMaxInstructionCount) {
       value = kMaxInstructionCount;
     }
-    raw_ptr()->optimized_instruction_count_ = static_cast<uint16_t>(value);
+    StoreNonPointer(&raw_ptr()->optimized_instruction_count_,
+                    static_cast<uint16_t>(value));
   }
 
   intptr_t optimized_call_site_count() const {
     return raw_ptr()->optimized_call_site_count_;
   }
   void set_optimized_call_site_count(intptr_t value) const {
     ASSERT(value >= 0);
     if (value > kMaxInstructionCount) {
       value = kMaxInstructionCount;
     }
-    raw_ptr()->optimized_call_site_count_ = static_cast<uint16_t>(value);
+    StoreNonPointer(&raw_ptr()->optimized_call_site_count_,
+                    static_cast<uint16_t>(value));
   }
 
   bool IsOptimizable() const;
   bool IsNativeAutoSetupScope() const;
   void SetIsOptimizable(bool value) const;
   void SetIsNativeAutoSetupScope(bool value) const;
 
   bool is_async_closure() const {
     return AsyncClosureBit::decode(raw_ptr()->kind_tag_);
   }
@@ skipping 450 matching lines @@
     set_kind_bits(HasInitializerBit::update(has_initializer,
                                             raw_ptr()->kind_bits_));
   }
 
   // Return class id that any non-null value read from this field is guaranteed
   // to have or kDynamicCid if such class id is not known.
   // Stores to this field must update this information hence the name.
   intptr_t guarded_cid() const { return raw_ptr()->guarded_cid_; }
 
   void set_guarded_cid(intptr_t cid) const {
-    raw_ptr()->guarded_cid_ = cid;
+    StoreNonPointer(&raw_ptr()->guarded_cid_, cid);
   }
   static intptr_t guarded_cid_offset() {
     return OFFSET_OF(RawField, guarded_cid_);
   }
   // Return the list length that any list stored in this field is guaranteed
   // to have. If length is kUnknownFixedLength the length has not
   // been determined. If length is kNoFixedLength this field has multiple
   // list lengths associated with it and cannot be predicted.
   intptr_t guarded_list_length() const;
   void set_guarded_list_length(intptr_t list_length) const;
@@ skipping 41 matching lines @@
   };
   // Returns false if any value read from this field is guaranteed to be
   // not null.
   // Internally we is_nullable_ field contains either kNullCid (nullable) or
   // any other value (non-nullable) instead of boolean. This is done to simplify
   // guarding sequence in the generated code.
   bool is_nullable() const {
     return raw_ptr()->is_nullable_ == kNullCid;
   }
   void set_is_nullable(bool val) const {
-    raw_ptr()->is_nullable_ = val ? kNullCid : kIllegalCid;
+    StoreNonPointer(&raw_ptr()->is_nullable_, val ? kNullCid : kIllegalCid);
   }
   static intptr_t is_nullable_offset() {
     return OFFSET_OF(RawField, is_nullable_);
   }
 
   // Record store of the given value into this field. May trigger
   // deoptimization of dependent optimized code.
   void RecordStore(const Object& value) const;
 
   void InitializeGuardedListLengthInObjectOffset() const;
@@ skipping 59 matching lines @@
   void set_is_const(bool value) const {
     set_kind_bits(ConstBit::update(value, raw_ptr()->kind_bits_));
   }
   void set_is_synthetic(bool value) const {
     set_kind_bits(SyntheticBit::update(value, raw_ptr()->kind_bits_));
   }
   void set_owner(const Object& value) const {
     StorePointer(&raw_ptr()->owner_, value.raw());
   }
   void set_token_pos(intptr_t token_pos) const {
-    raw_ptr()->token_pos_ = token_pos;
+    StoreNonPointer(&raw_ptr()->token_pos_, token_pos);
   }
   void set_kind_bits(intptr_t value) const {
-    raw_ptr()->kind_bits_ = static_cast<uint8_t>(value);
+    StoreNonPointer(&raw_ptr()->kind_bits_, static_cast<uint8_t>(value));
   }
 
   static RawField* New();
 
   FINAL_HEAP_OBJECT_IMPLEMENTATION(Field, Object);
   friend class Class;
   friend class HeapProfiler;
 };
 
 
 class LiteralToken : public Object {
  public:
   Token::Kind kind() const { return raw_ptr()->kind_; }
   RawString* literal() const { return raw_ptr()->literal_; }
   RawObject* value() const { return raw_ptr()->value_; }
 
   static intptr_t InstanceSize() {
     return RoundedAllocationSize(sizeof(RawLiteralToken));
   }
 
   static RawLiteralToken* New();
   static RawLiteralToken* New(Token::Kind kind, const String& literal);
 
  private:
-  void set_kind(Token::Kind kind) const { raw_ptr()->kind_ = kind; }
+  void set_kind(Token::Kind kind) const {
+    StoreNonPointer(&raw_ptr()->kind_, kind);
+  }
   void set_literal(const String& literal) const;
   void set_value(const Object& value) const;
 
   FINAL_HEAP_OBJECT_IMPLEMENTATION(LiteralToken, Object);
   friend class Class;
 };
 
 
 class TokenStream : public Object {
  public:
@@ skipping 305 matching lines @@
   bool ImportsCorelib() const;
 
   RawFunction* LookupFunctionInScript(const Script& script,
                                       intptr_t token_pos) const;
 
   // Resolving native methods for script loaded in the library.
   Dart_NativeEntryResolver native_entry_resolver() const {
     return raw_ptr()->native_entry_resolver_;
   }
   void set_native_entry_resolver(Dart_NativeEntryResolver value) const {
-    raw_ptr()->native_entry_resolver_ = value;
+    StoreNonPointer(&raw_ptr()->native_entry_resolver_, value);
   }
   Dart_NativeEntrySymbol native_entry_symbol_resolver() const {
     return raw_ptr()->native_entry_symbol_resolver_;
   }
   void set_native_entry_symbol_resolver(
       Dart_NativeEntrySymbol native_symbol_resolver) const {
-    raw_ptr()->native_entry_symbol_resolver_ = native_symbol_resolver;
+    StoreNonPointer(&raw_ptr()->native_entry_symbol_resolver_,
+                    native_symbol_resolver);
   }
 
   RawError* Patch(const Script& script) const;
 
   RawString* PrivateName(const String& name) const;
 
   intptr_t index() const { return raw_ptr()->index_; }
   void set_index(intptr_t value) const {
-    raw_ptr()->index_ = value;
+    StoreNonPointer(&raw_ptr()->index_, value);
   }
 
   void Register() const;
 
   bool IsDebuggable() const {
     return raw_ptr()->debuggable_;
   }
   void set_debuggable(bool value) const {
-    raw_ptr()->debuggable_ = value;
+    StoreNonPointer(&raw_ptr()->debuggable_, value);
   }
 
   bool is_dart_scheme() const {
     return raw_ptr()->is_dart_scheme_;
   }
   void set_is_dart_scheme(bool value) const {
-    raw_ptr()->is_dart_scheme_ = value;
+    StoreNonPointer(&raw_ptr()->is_dart_scheme_, value);
   }
 
   bool IsCoreLibrary() const {
     return raw() == CoreLibrary();
   }
 
   inline intptr_t UrlHash() const;
 
   static RawLibrary* LookupLibrary(const String& url);
   static RawLibrary* GetLibrary(intptr_t index);
@@ skipping 40 matching lines @@
   // the library-specific key.
   static const char kPrivateKeySeparator = '@';
 
  private:
   static const int kInitialImportsCapacity = 4;
   static const int kImportsCapacityIncrement = 8;
 
   static RawLibrary* New();
 
   void set_num_imports(intptr_t value) const {
-    raw_ptr()->num_imports_ = value;
+    StoreNonPointer(&raw_ptr()->num_imports_, value);
   }
   bool HasExports() const;
   RawArray* loaded_scripts() const { return raw_ptr()->loaded_scripts_; }
   RawGrowableObjectArray* metadata() const { return raw_ptr()->metadata_; }
   RawArray* dictionary() const { return raw_ptr()->dictionary_; }
   void InitClassDictionary() const;
 
   RawArray* resolved_names() const { return raw_ptr()->resolved_names_; }
   void InitResolvedNamesCache(intptr_t size) const;
   void GrowResolvedNamesCache() const;
@@ skipping 101 matching lines @@
     return Utils::RoundUp(sizeof(RawInstructions), alignment);
   }
 
   static RawInstructions* FromEntryPoint(uword entry_point) {
     return reinterpret_cast<RawInstructions*>(
         entry_point - HeaderSize() + kHeapObjectTag);
   }
 
  private:
   void set_size(intptr_t size) const {
-    raw_ptr()->size_ = size;
+    StoreNonPointer(&raw_ptr()->size_, size);
   }
   void set_code(RawCode* code) const {
-    raw_ptr()->code_ = code;
+    StorePointer(&raw_ptr()->code_, code);
   }
   void set_object_pool(RawArray* object_pool) const {
     StorePointer(&raw_ptr()->object_pool_, object_pool);
   }
 
   // New is a private method as RawInstruction and RawCode objects should
   // only be created using the Code::FinalizeCode method. This method creates
   // the RawInstruction and RawCode objects, sets up the pointer offsets
   // and links the two in a GC safe manner.
   static RawInstructions* New(intptr_t size);
@@ skipping 191 matching lines @@
   bool IsObject(intptr_t index) const {
     ASSERT(InRange(index));
     return GetBit(index);
   }
 
   intptr_t Length() const { return raw_ptr()->length_; }
 
   uint32_t PcOffset() const { return raw_ptr()->pc_offset_; }
   void SetPcOffset(uint32_t value) const {
     ASSERT(value <= kMaxUint32);
-    raw_ptr()->pc_offset_ = value;
+    StoreNonPointer(&raw_ptr()->pc_offset_, value);
   }
 
   intptr_t RegisterBitCount() const { return raw_ptr()->register_bit_count_; }
   void SetRegisterBitCount(intptr_t register_bit_count) const {
     ASSERT(register_bit_count < kMaxInt32);
-    raw_ptr()->register_bit_count_ = register_bit_count;
+    StoreNonPointer(&raw_ptr()->register_bit_count_, register_bit_count);
   }
 
   static const intptr_t kMaxLengthInBytes = kSmiMax;
 
   static intptr_t InstanceSize() {
     ASSERT(sizeof(RawStackmap) == OFFSET_OF_RETURNED_VALUE(RawStackmap, data));
     return 0;
   }
   static intptr_t InstanceSize(intptr_t length) {
     ASSERT(length >= 0);
     // The stackmap payload is in an array of bytes.
     intptr_t payload_size =
         Utils::RoundUp(length, kBitsPerByte) / kBitsPerByte;
     return RoundedAllocationSize(sizeof(RawStackmap) + payload_size);
   }
   static RawStackmap* New(intptr_t pc_offset,
                           BitmapBuilder* bmap,
                           intptr_t register_bit_count);
 
  private:
-  void SetLength(intptr_t length) const { raw_ptr()->length_ = length; }
+  void SetLength(intptr_t length) const {
+      StoreNonPointer(&raw_ptr()->length_, length);
+  }
 
   bool InRange(intptr_t index) const { return index < Length(); }
 
   bool GetBit(intptr_t bit_index) const;
   void SetBit(intptr_t bit_index, bool value) const;
 
   FINAL_HEAP_OBJECT_IMPLEMENTATION(Stackmap, Object);
   friend class BitmapBuilder;
   friend class Class;
 };
@@ skipping 628 matching lines @@
 
    private:
     const uword pc_;
 
     DISALLOW_COPY_AND_ASSIGN(FindRawCodeVisitor);
   };
 
   static const intptr_t kEntrySize = sizeof(int32_t);  // NOLINT
 
   void set_compile_timestamp(int64_t timestamp) const {
-    raw_ptr()->compile_timestamp_ = timestamp;
+    StoreNonPointer(&raw_ptr()->compile_timestamp_, timestamp);
   }
 
   void set_instructions(RawInstructions* instructions) {
     // RawInstructions are never allocated in New space and hence a
     // store buffer update is not needed here.
-    raw_ptr()->instructions_ = instructions;
+    StorePointer(&raw_ptr()->instructions_, instructions);
   }
 
   void set_pointer_offsets_length(intptr_t value) {
     // The number of fixups is limited to 1-billion.
     ASSERT(Utils::IsUint(30, value));
     set_state_bits(PtrOffBits::update(value, raw_ptr()->state_bits_));
   }
   int32_t* PointerOffsetAddrAt(int index) const {
     ASSERT(index >= 0);
     ASSERT(index < pointer_offsets_length());
@@ skipping 67 matching lines @@
   static RawContext* New(intptr_t num_variables,
                          Heap::Space space = Heap::kNew);
 
  private:
   RawInstance** InstanceAddr(intptr_t context_index) const {
     ASSERT((context_index >= 0) && (context_index < num_variables()));
     return &raw_ptr()->data()[context_index];
   }
 
   void set_isolate(Isolate* isolate) const {
-    raw_ptr()->isolate_ = isolate;
+    StoreNonPointer(&raw_ptr()->isolate_, isolate);
   }
 
   void set_num_variables(intptr_t num_variables) const {
-    raw_ptr()->num_variables_ = num_variables;
+    StoreNonPointer(&raw_ptr()->num_variables_, num_variables);
   }
 
   FINAL_HEAP_OBJECT_IMPLEMENTATION(Context, Object);
   friend class Class;
 };
 
 
 // The ContextScope class makes it possible to delay the compilation of a local
 // function until it is invoked. A ContextScope instance collects the local
 // variables that are referenced by the local function to be compiled and that
@@ skipping 44 matching lines @@
   static intptr_t InstanceSize(intptr_t len) {
     ASSERT(0 <= len && len <= kMaxElements);
     return RoundedAllocationSize(
         sizeof(RawContextScope) + (len * kBytesPerElement));
   }
 
   static RawContextScope* New(intptr_t num_variables);
 
  private:
   void set_num_variables(intptr_t num_variables) const {
-    raw_ptr()->num_variables_ = num_variables;
+    StoreNonPointer(&raw_ptr()->num_variables_, num_variables);
   }
 
   RawContextScope::VariableDesc* VariableDescAddr(intptr_t index) const {
     ASSERT((index >= 0) && (index < num_variables()));
     uword raw_addr = reinterpret_cast<uword>(raw_ptr());
     raw_addr += sizeof(RawContextScope) +
         (index * sizeof(RawContextScope::VariableDesc));
     return reinterpret_cast<RawContextScope::VariableDesc*>(raw_addr);
   }
 
@@ skipping 1599 matching lines @@
  protected:
   // These two operate on an array of Latin-1 encoded characters.
   // They are protected to avoid mistaking Latin-1 for UTF-8, but used
   // by friendly templated code (e.g., Symbols).
   bool Equals(const uint8_t* characters, intptr_t len) const;
   static intptr_t Hash(const uint8_t* characters, intptr_t len);
 
   void 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 SetHash(intptr_t value) const {
     // This is only safe because we create a new Smi, which does not cause
     // heap allocation.
-    raw_ptr()->hash_ = Smi::New(value);
+    StoreSmi(&raw_ptr()->hash_, Smi::New(value));
   }
 
   template<typename HandleType, typename ElementType, typename CallbackType>
   static void ReadFromImpl(SnapshotReader* reader,
                            String* str_obj,
                            intptr_t len,
                            intptr_t tags,
                            CallbackType new_symbol,
                            Snapshot::Kind kind);
 
@@ skipping 289 matching lines @@
     ASSERT((index >= 0) && (index < str.Length()));
     ASSERT(str.IsExternalOneByteString());
     NoGCScope no_gc;
     return &(raw_ptr(str)->external_data_->data()[index]);
   }
 
   static void SetExternalData(const String& str,
                               ExternalStringData<uint8_t>* data) {
     ASSERT(str.IsExternalOneByteString());
     NoGCScope no_gc;
-    raw_ptr(str)->external_data_ = data;
+    str.StoreNonPointer(&raw_ptr(str)->external_data_, data);
   }
 
   static void Finalize(void* isolate_callback_data,
                        Dart_WeakPersistentHandle handle,
                        void* peer);
 
   static RawExternalOneByteString* ReadFrom(SnapshotReader* reader,
                                             intptr_t object_id,
                                             intptr_t tags,
                                             Snapshot::Kind kind);
@@ skipping 52 matching lines @@
     ASSERT((index >= 0) && (index < str.Length()));
     ASSERT(str.IsExternalTwoByteString());
     NoGCScope no_gc;
     return &(raw_ptr(str)->external_data_->data()[index]);
   }
 
   static void SetExternalData(const String& str,
                               ExternalStringData<uint16_t>* data) {
     ASSERT(str.IsExternalTwoByteString());
     NoGCScope no_gc;
-    raw_ptr(str)->external_data_ = data;
+    str.StoreNonPointer(&raw_ptr(str)->external_data_, data);
   }
 
   static void Finalize(void* isolate_callback_data,
                        Dart_WeakPersistentHandle handle,
                        void* peer);
 
   static RawExternalTwoByteString* ReadFrom(SnapshotReader* reader,
                                             intptr_t object_id,
                                             intptr_t tags,
                                             Snapshot::Kind kind);
@@ skipping 26 matching lines @@
 
   static const Bool& False() {
     return Object::bool_false();
   }
 
   static const Bool& Get(bool value) {
     return value ? Bool::True() : Bool::False();
   }
 
  private:
-  void set_value(bool value) const { raw_ptr()->value_ = value; }
+  void set_value(bool value) const {
+    StoreNonPointer(&raw_ptr()->value_, value);
+  }
 
   // New should only be called to initialize the two legal bool values.
   static RawBool* New(bool value);
 
   FINAL_HEAP_OBJECT_IMPLEMENTATION(Bool, Instance);
   friend class Class;
   friend class Object;  // To initialize the true and false values.
 };
 
 
@@ skipping 93 matching lines @@
  private:
   RawObject** ObjectAddr(intptr_t index) const {
     // TODO(iposva): Determine if we should throw an exception here.
     ASSERT((index >= 0) && (index < Length()));
     return &raw_ptr()->data()[index];
   }
 
   void 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));
   }
 
   FINAL_HEAP_OBJECT_IMPLEMENTATION(Array, Instance);
   friend class Class;
   friend class ImmutableArray;
   friend class Object;
   friend class String;
 };
 
 
@@ skipping 37 matching lines @@
     ASSERT(!IsNull());
     return Smi::Value(DataArray()->length_);
   }
   intptr_t Length() const {
     ASSERT(!IsNull());
     return Smi::Value(raw_ptr()->length_);
   }
   void 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));
   }
 
   RawArray* data() const { return raw_ptr()->data_; }
   void SetData(const Array& value) const {
     StorePointer(&raw_ptr()->data_, value.raw());
   }
 
   RawObject* At(intptr_t index) const {
     NoGCScope no_gc;
     ASSERT(!IsNull());
@@ skipping 378 matching lines @@
   static bool IsTypedData(const Instance& obj) {
     ASSERT(!obj.IsNull());
     intptr_t cid = obj.raw()->GetClassId();
     return RawObject::IsTypedDataClassId(cid);
   }
 
   static RawTypedData* EmptyUint32Array(Isolate* isolate);
 
  protected:
   void SetLength(intptr_t value) const {
-    raw_ptr()->length_ = Smi::New(value);
+    StoreSmi(&raw_ptr()->length_, Smi::New(value));
   }
 
  private:
   static const intptr_t element_size[];
 
   FINAL_HEAP_OBJECT_IMPLEMENTATION(TypedData, Instance);
   friend class Class;
   friend class ExternalTypedData;
   friend class TypedDataView;
 };
@@ skipping 87 matching lines @@
                                    Heap::Space space = Heap::kNew);
 
   static bool IsExternalTypedData(const Instance& obj) {
     ASSERT(!obj.IsNull());
     intptr_t cid = obj.raw()->GetClassId();
     return RawObject::IsExternalTypedDataClassId(cid);
   }
 
  protected:
   void SetLength(intptr_t value) const {
-    raw_ptr()->length_ = Smi::New(value);
+    StoreSmi(&raw_ptr()->length_, Smi::New(value));
   }
 
   void SetData(uint8_t* data) const {
-    raw_ptr()->data_ = data;
+    StoreNonPointer(&raw_ptr()->data_, data);
   }
 
  private:
   FINAL_HEAP_OBJECT_IMPLEMENTATION(ExternalTypedData, Instance);
   friend class Class;
 };
 
 
 class TypedDataView : public AllStatic {
  public:
@@ skipping 327 matching lines @@
   static intptr_t InstanceSize(intptr_t len) {
     ASSERT(0 <= len && len <= kMaxElements);
     return RoundedAllocationSize(
         sizeof(RawJSRegExp) + (len * kBytesPerElement));
   }
 
   static RawJSRegExp* New(intptr_t length, Heap::Space space = Heap::kNew);
 
  private:
   void set_type(RegExType type) const {
-    raw_ptr()->type_flags_ = TypeBits::update(type, raw_ptr()->type_flags_);
+    StoreNonPointer(&raw_ptr()->type_flags_,
+                    TypeBits::update(type, raw_ptr()->type_flags_));
   }
   void set_flags(intptr_t value) const {
-    raw_ptr()->type_flags_ = FlagsBits::update(value, raw_ptr()->type_flags_);
+    StoreNonPointer(&raw_ptr()->type_flags_,
+                    FlagsBits::update(value, raw_ptr()->type_flags_));
   }
 
   RegExType type() const {
     return TypeBits::decode(raw_ptr()->type_flags_);
   }
   intptr_t flags() const {
     return FlagsBits::decode(raw_ptr()->type_flags_);
   }
 
   void SetLength(intptr_t value) const {
     // This is only safe because we create a new Smi, which does not cause
     // heap allocation.
-    raw_ptr()->data_length_ = Smi::New(value);
+    StoreSmi(&raw_ptr()->data_length_, Smi::New(value));
   }
 
   FINAL_HEAP_OBJECT_IMPLEMENTATION(JSRegExp, Instance);
   friend class Class;
 };
 
 
 class WeakProperty : public Instance {
  public:
   RawObject* key() const {
@@ skipping 63 matching lines @@
   friend class Class;
 };
 
 
 class UserTag : public Instance {
  public:
   uword tag() const { return raw_ptr()->tag(); }
   void set_tag(uword t) const {
     ASSERT(t >= UserTags::kUserTagIdOffset);
     ASSERT(t < UserTags::kUserTagIdOffset + UserTags::kMaxUserTags);
-    raw_ptr()->tag_ = t;
+    StoreNonPointer(&raw_ptr()->tag_, t);
   }
   static intptr_t tag_offset() { return OFFSET_OF(RawUserTag, tag_); }
 
   RawString* label() const {
     return raw_ptr()->label_;
   }
 
   void MakeActive() const;
 
   static intptr_t InstanceSize() {
@@ skipping 61 matching lines @@
 intptr_t Field::Offset() const {
   ASSERT(!is_static());  // Offset is valid only for instance fields.
   intptr_t value = Smi::Value(reinterpret_cast<RawSmi*>(raw_ptr()->value_));
   return (value * kWordSize);
 }
 
 
 void Field::SetOffset(intptr_t value_in_bytes) const {
   ASSERT(!is_static());  // SetOffset is valid only for instance fields.
   ASSERT(kWordSize != 0);
-  raw_ptr()->value_ = Smi::New(value_in_bytes / kWordSize);
+  StorePointer(&raw_ptr()->value_,
+               static_cast<RawInstance*>(Smi::New(value_in_bytes / kWordSize)));
 }
 
 
 void Context::SetAt(intptr_t index, const Instance& value) const {
   StorePointer(InstanceAddr(index), value.raw());
 }
 
 
 intptr_t Instance::GetNativeField(int index) const {
   ASSERT(IsValidNativeIndex(index));
@@ skipping 78 matching lines @@
 
 
 RawObject* MegamorphicCache::GetTargetFunction(const Array& array,
                                                intptr_t index) {
   return array.At((index * kEntryLength) + kTargetFunctionIndex);
 }
 
 }  // namespace dart
 
 #endif  // VM_OBJECT_H_