Write barrier audit: const raw_ptr()

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 169 matching lines @@
   void operator^=(RawObject* value) {                                          \
     initializeHandle(this, value);                                             \
     ASSERT(IsNull() || Is##object());                                          \
   }                                                                            \
  protected:  /* NOLINT */                                                      \
   object() : super() {}                                                        \
   BASE_OBJECT_IMPLEMENTATION(object, super)                                    \
 
 #define HEAP_OBJECT_IMPLEMENTATION(object, super)                              \
   OBJECT_IMPLEMENTATION(object, super);                                        \
-  Raw##object* raw_ptr() const {                                               \
+  const Raw##object* raw_ptr() const {                                         \
     ASSERT(raw() != null());                                                   \
     return raw()->ptr();                                                       \
   }                                                                            \
   SNAPSHOT_READER_SUPPORT(object)                                              \
   friend class Isolate;                                                        \
   friend class StackFrame;                                                     \
 
 // This macro is used to denote types that do not have a sub-type.
 #define FINAL_HEAP_OBJECT_IMPLEMENTATION(object, super)                        \
  public:  /* NOLINT */                                                         \
   void operator=(Raw##object* value) {                                         \
     raw_ = value;                                                              \
     CHECK_HANDLE();                                                            \
   }                                                                            \
   void operator^=(RawObject* value) {                                          \
     raw_ = value;                                                              \
     CHECK_HANDLE();                                                            \
   }                                                                            \
  private:  /* NOLINT */                                                        \
   object() : super() {}                                                        \
   BASE_OBJECT_IMPLEMENTATION(object, super)                                    \
-  Raw##object* raw_ptr() const {                                               \
+  const Raw##object* raw_ptr() const {                                         \
     ASSERT(raw() != null());                                                   \
     return raw()->ptr();                                                       \
   }                                                                            \
   static intptr_t NextFieldOffset() {                                          \
     return -kWordSize;                                                         \
   }                                                                            \
   SNAPSHOT_READER_SUPPORT(object)                                              \
   friend class Isolate;                                                        \
   friend class StackFrame;                                                     \
 
 class Object {
  public:
   virtual ~Object() { }
 
   RawObject* raw() const { return raw_; }
   void operator=(RawObject* value) {
     initializeHandle(this, value);
   }
 
+  uword CompareAndSwapTags(uword old_tags, uword new_tags) const {
+    return AtomicOperations::CompareAndSwapWord(
+        &raw()->ptr()->tags_, old_tags, new_tags);
+  }
   void set_tags(intptr_t value) const {
     ASSERT(!IsNull());
     // TODO(asiva): Remove the capability of setting tags in general. The mask
     // here only allows for canonical and from_snapshot flags to be set.
     value = value & 0x0000000c;
     uword tags = raw()->ptr()->tags_;
     uword old_tags;
     do {
       old_tags = tags;
       uword new_tags = (old_tags & ~0x0000000c) | value;
-      tags = AtomicOperations::CompareAndSwapWord(
-          &raw()->ptr()->tags_, old_tags, new_tags);
+      tags = CompareAndSwapTags(old_tags, new_tags);
     } while (tags != old_tags);
   }
   void SetCreatedFromSnapshot() const {
     ASSERT(!IsNull());
     raw()->SetCreatedFromSnapshot();
   }
   bool IsCanonical() const {
     ASSERT(!IsNull());
     return raw()->IsCanonical();
   }
@@ skipping 319 matching lines @@
   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));
   }
 
-  template<typename type> void StorePointer(type* addr, type value) const {
+  // 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.
+
+  template<typename type>
+  void StorePointer(const type* addr, type value) const {

[Ivan Posva, 2014/10/10 23:52:11]

type const* addr

to match the untemplated versions below.

[koda, 2014/10/11 00:26:33]

Done.

     // Ensure that this object contains the addr.
     ASSERT(Contains(reinterpret_cast<uword>(addr)));
-    *addr = value;
+    *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());
     }
   }
 
+  // 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** addr, RawSmi* value) const {
+  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()));
-    *addr = value;
+    *const_cast<RawSmi**>(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>
-  void StoreNonPointer(FieldType* addr, ValueType value) const {
+  void StoreNonPointer(const 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;
+    *const_cast<FieldType*>(addr) = value;
   }
 
-  // Fail at link time if StoreNonPointer is called with an object pointer.
+  // Provides non-const access to non-pointer fields within the object. Such
+  // access does not need a write barrier, but it is *not* GC-safe (since the
+  // object might move), hence must be fully contained within a NoGCScope.
+  template<typename FieldType>
+  FieldType* UnsafeMutableNonPointer(const FieldType* addr) const {
+    // Allow pointers at the end of variable-length data, and disallow pointers
+    // within the header word.
+    ASSERT(Contains(reinterpret_cast<uword>(addr) - 1) &&
+           Contains(reinterpret_cast<uword>(addr) - kWordSize));
+    // At least check that there is a NoGCScope, and hope it's big enough.
+    ASSERT(Isolate::Current()->no_gc_scope_depth() > 0);
+    return const_cast<FieldType*>(addr);
+  }
+
+  // Fail at link time if StoreNonPointer or UnsafeMutableNonPointer is
+  // instantiated with an object pointer type.
 #define STORE_NON_POINTER_ILLEGAL_TYPE(type)                                   \
   template<typename ValueType>                                                 \
-  void StoreNonPointer(Raw##type** addr, ValueType value) const {              \
+  void StoreNonPointer(Raw##type* const* addr, ValueType value) const {        \
     UnimplementedMethod();                                                     \
+  }                                                                            \
+  Raw##type** UnsafeMutableNonPointer(Raw##type* const* addr) const {          \
+    UnimplementedMethod();                                                     \
+    return NULL;                                                               \
   }
+
   CLASS_LIST(STORE_NON_POINTER_ILLEGAL_TYPE);
   void UnimplementedMethod() const;
 #undef STORE_NON_POINTER_ILLEGAL_TYPE
 
+  // End of field mutator guards.
+
   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 935 matching lines @@
                 Error* bound_error) const;
 
   // Return the internal or public name of a subvector of this type argument
   // vector, e.g. "<T, dynamic, List<T>, int>".
   RawString* SubvectorName(intptr_t from_index,
                            intptr_t len,
                            NameVisibility name_visibility) const;
 
   RawArray* instantiations() const;
   void set_instantiations(const Array& value) const;
-  RawAbstractType** TypeAddr(intptr_t index) const;
+  RawAbstractType* const* TypeAddr(intptr_t index) const;
   void SetLength(intptr_t value) const;
 
   FINAL_HEAP_OBJECT_IMPLEMENTATION(TypeArguments, Object);
   friend class AbstractType;
   friend class Class;
 };
 
 
 class PatchClass : public Object {
  public:
@@ skipping 1564 matching lines @@
 
 
 class PcDescriptors : public Object {
  public:
   void AddDescriptor(intptr_t index,
                      uword pc,
                      RawPcDescriptors::Kind kind,
                      int64_t deopt_id,
                      int64_t token_pos,  // Or deopt reason.
                      intptr_t try_index) const {  // Or deopt index.
+    NoGCScope no_gc;
     RawPcDescriptors::PcDescriptorRec* rec = recAt(index);
     rec->set_pc(pc);
     rec->set_kind(kind);
     ASSERT(Utils::IsInt(32, deopt_id));
     rec->set_deopt_id(static_cast<int32_t>(deopt_id));
     ASSERT(Utils::IsInt(32, token_pos));
     rec->set_token_pos(static_cast<int32_t>(token_pos),
         RecordSizeInBytes() == RawPcDescriptors::kCompressedRecSize);
     ASSERT(Utils::IsInt(16, try_index));
     rec->set_try_index(try_index);
@@ skipping 45 matching lines @@
     bool MoveNext() {
       if (HasNext()) {
         current_ix_ = next_ix_++;
         MoveToMatching();
         return true;
       } else {
         return false;
       }
     }
 
-    uword Pc() const { return descriptors_.recAt(current_ix_)->pc(); }
+    uword Pc() const {
+      NoGCScope no_gc;
+      return descriptors_.recAt(current_ix_)->pc();
+    }
     intptr_t DeoptId() const {
+      NoGCScope no_gc;
       return descriptors_.recAt(current_ix_)->deopt_id();
     }
     intptr_t TokenPos() const {
+      NoGCScope no_gc;
       return descriptors_.recAt(current_ix_)->token_pos();
     }
     intptr_t TryIndex() const {
+      NoGCScope no_gc;
       return descriptors_.recAt(current_ix_)->try_index();
     }
     RawPcDescriptors::Kind Kind() const {
+      NoGCScope no_gc;
       return descriptors_.recAt(current_ix_)->kind();
     }
 
    private:
     friend class PcDescriptors;
 
     bool HasNext() const { return next_ix_ < descriptors_.Length(); }
 
     // For nested iterations, starting at element after.
     explicit Iterator(const Iterator& iter)
         : ValueObject(),
           descriptors_(iter.descriptors_),
           kind_mask_(iter.kind_mask_),
           next_ix_(iter.next_ix_),
           current_ix_(iter.current_ix_) {}
 
     // Moves to record that matches kind_mask_.
     void MoveToMatching() {
+      NoGCScope no_gc;
       while (next_ix_ < descriptors_.Length()) {
         const RawPcDescriptors::PcDescriptorRec& rec =
             *descriptors_.recAt(next_ix_);
         if ((rec.kind() & kind_mask_) != 0) {
           return;  // Current is valid.
         } else {
           ++next_ix_;
         }
       }
     }
 
     const PcDescriptors& descriptors_;
     const intptr_t kind_mask_;
     intptr_t next_ix_;
     intptr_t current_ix_;
   };
 
  private:
   static const char* KindAsStr(RawPcDescriptors::Kind kind);
 
   intptr_t Length() const;
   void SetLength(intptr_t value) const;
 
   void SetRecordSizeInBytes(intptr_t value) const;
   intptr_t RecordSizeInBytes() const;
 
   RawPcDescriptors::PcDescriptorRec* recAt(intptr_t ix) const {
     ASSERT((0 <= ix) && (ix < Length()));
-    uint8_t* d = raw_ptr()->data() + (ix * RecordSizeInBytes());
+    uint8_t* d = UnsafeMutableNonPointer(raw_ptr()->data()) +
+        (ix * RecordSizeInBytes());
     return reinterpret_cast<RawPcDescriptors::PcDescriptorRec*>(d);
   }
 
   FINAL_HEAP_OBJECT_IMPLEMENTATION(PcDescriptors, Object);
   friend class Class;
   friend class Object;
 };
 
 
 class Stackmap : public Object {
@@ skipping 176 matching lines @@
 
   // Returns true iff decompression yields the same instructions as the
   // original.
   bool VerifyDecompression(const GrowableArray<DeoptInstr*>& original,
                            const Array& deopt_table) const;
 
  private:
   intptr_t* EntryAddr(intptr_t index, intptr_t entry_offset) const {
     ASSERT((index >=0) && (index < Length()));
     intptr_t data_index = (index * kNumberOfEntries) + entry_offset;
-    return &raw_ptr()->data()[data_index];
+    return &UnsafeMutableNonPointer(raw_ptr()->data())[data_index];
   }
 
   void SetLength(intptr_t value) const;
 
   FINAL_HEAP_OBJECT_IMPLEMENTATION(DeoptInfo, Object);
   friend class Class;
 };
 
 
 // Object holding information about an IC: test classes and their
@@ skipping 400 matching lines @@
                                Assembler* assembler,
                                bool optimized = false);
   static RawCode* FinalizeCode(const char* name,
                                Assembler* assembler,
                                bool optimized = false);
   static RawCode* LookupCode(uword pc);
   static RawCode* LookupCodeInVmIsolate(uword pc);
   static RawCode* FindCode(uword pc, int64_t timestamp);
 
   int32_t GetPointerOffsetAt(int index) const {
+    NoGCScope no_gc;
     return *PointerOffsetAddrAt(index);
   }
   intptr_t GetTokenIndexOfPC(uword pc) const;
 
   enum {
     kInvalidPc = -1
   };
 
   // Returns 0 if code is not patchable
   uword GetEntryPatchPc() const;
   uword GetPatchCodePc() const;
 
   uword GetLazyDeoptPc() const;
 
   // Find pc, return 0 if not found.
   uword GetPcForDeoptId(intptr_t deopt_id, RawPcDescriptors::Kind kind) const;
   intptr_t GetDeoptIdForOsr(uword pc) const;
 
   RawString* Name() const;
   RawString* PrettyName() const;
 
   int64_t compile_timestamp() const {
     return raw_ptr()->compile_timestamp_;
   }
 
   intptr_t entry_patch_pc_offset() const {
     return raw_ptr()->entry_patch_pc_offset_;
   }
   void set_entry_patch_pc_offset(intptr_t pc) const {
-    raw_ptr()->entry_patch_pc_offset_ = pc;
+    StoreNonPointer(&raw_ptr()->entry_patch_pc_offset_, pc);
   }
 
 
   intptr_t patch_code_pc_offset() const {
     return raw_ptr()->patch_code_pc_offset_;
   }
   void set_patch_code_pc_offset(intptr_t pc) const {
-    raw_ptr()->patch_code_pc_offset_ = pc;
+    StoreNonPointer(&raw_ptr()->patch_code_pc_offset_, pc);
   }
 
 
   intptr_t lazy_deopt_pc_offset() const {
     return raw_ptr()->lazy_deopt_pc_offset_;
   }
   void set_lazy_deopt_pc_offset(intptr_t pc) const {
-    raw_ptr()->lazy_deopt_pc_offset_ = pc;
+    StoreNonPointer(&raw_ptr()->lazy_deopt_pc_offset_, pc);
   }
 
  private:
   void set_state_bits(intptr_t bits) const;
 
   friend class RawObject;  // For RawObject::SizeFromClass().
   friend class RawCode;
   enum {
     kOptimizedBit = 0,
     kAliveBit = 1,
@@ skipping 37 matching lines @@
 
   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());
     // TODO(iposva): Unit test is missing for this functionality.
-    return &raw_ptr()->data()[index];
+    return &UnsafeMutableNonPointer(raw_ptr()->data())[index];
   }
   void SetPointerOffsetAt(int index, int32_t offset_in_instructions) {
+    NoGCScope no_gc;
     *PointerOffsetAddrAt(index) = offset_in_instructions;
   }
 
   intptr_t BinarySearchInSCallTable(uword pc) const;
   static RawCode* LookupCodeInIsolate(Isolate* isolate, uword pc);
 
   // 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.
@@ skipping 47 matching lines @@
 
   static intptr_t InstanceSize(intptr_t len) {
     ASSERT(0 <= len && len <= kMaxElements);
     return RoundedAllocationSize(sizeof(RawContext) + (len * kBytesPerElement));
   }
 
   static RawContext* New(intptr_t num_variables,
                          Heap::Space space = Heap::kNew);
 
  private:
-  RawInstance** InstanceAddr(intptr_t context_index) const {
+  RawInstance* const* 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 {
     StoreNonPointer(&raw_ptr()->isolate_, isolate);
   }
 
   void set_num_variables(intptr_t num_variables) const {
     StoreNonPointer(&raw_ptr()->num_variables_, num_variables);
@@ skipping 1710 matching lines @@
   friend class ExternalOneByteString;
   friend class ExternalTwoByteString;
   // So that the MarkingVisitor can print a debug string from a NoHandleScope.
   friend class MarkingVisitor;
 };
 
 
 class OneByteString : public AllStatic {
  public:
   static uint16_t CharAt(const String& str, intptr_t index) {
+    NoGCScope no_gc;
     return *CharAddr(str, index);
   }
 
   static void SetCharAt(const String& str, intptr_t index, uint8_t code_unit) {
+    NoGCScope no_gc;
     *CharAddr(str, index) = code_unit;
   }
   static RawOneByteString* EscapeSpecialCharacters(const String& str);
   // We use the same maximum elements for all strings.
   static const intptr_t kBytesPerElement = 1;
   static const intptr_t kMaxElements = String::kMaxElements;
 
   static intptr_t data_offset() {
     return OFFSET_OF_RETURNED_VALUE(RawOneByteString, data);
   }
@@ skipping 78 matching lines @@
 
   static RawOneByteString* null() {
     return reinterpret_cast<RawOneByteString*>(Object::null());
   }
 
  private:
   static RawOneByteString* raw(const String& str) {
     return reinterpret_cast<RawOneByteString*>(str.raw());
   }
 
-  static RawOneByteString* raw_ptr(const String& str) {
-    return reinterpret_cast<RawOneByteString*>(str.raw_ptr());
+  static const RawOneByteString* raw_ptr(const String& str) {
+    return reinterpret_cast<const RawOneByteString*>(str.raw_ptr());
   }
 
   static uint8_t* CharAddr(const String& str, intptr_t index) {
     ASSERT((index >= 0) && (index < str.Length()));
     ASSERT(str.IsOneByteString());
-    NoGCScope no_gc;
-    return &raw_ptr(str)->data()[index];
+    return &str.UnsafeMutableNonPointer(raw_ptr(str)->data())[index];
   }
 
   static RawOneByteString* ReadFrom(SnapshotReader* reader,
                                     intptr_t object_id,
                                     intptr_t tags,
                                     Snapshot::Kind kind);
 
   friend class Class;
   friend class String;
   friend class ExternalOneByteString;
   friend class SnapshotReader;
   friend class StringHasher;
 };
 
 
 class TwoByteString : public AllStatic {
  public:
   static uint16_t CharAt(const String& str, intptr_t index) {
+    NoGCScope no_gc;
     return *CharAddr(str, index);
   }
 
   static void SetCharAt(const String& str, intptr_t index, uint16_t ch) {
+    NoGCScope no_gc;
     *CharAddr(str, index) = ch;
   }
 
   static RawTwoByteString* EscapeSpecialCharacters(const String& str);
 
   // We use the same maximum elements for all strings.
   static const intptr_t kBytesPerElement = 2;
   static const intptr_t kMaxElements = String::kMaxElements;
 
   static intptr_t data_offset() {
@@ skipping 51 matching lines @@
   }
 
 
   static const ClassId kClassId = kTwoByteStringCid;
 
  private:
   static RawTwoByteString* raw(const String& str) {
     return reinterpret_cast<RawTwoByteString*>(str.raw());
   }
 
-  static RawTwoByteString* raw_ptr(const String& str) {
-    return reinterpret_cast<RawTwoByteString*>(str.raw_ptr());
+  static const RawTwoByteString* raw_ptr(const String& str) {
+    return reinterpret_cast<const RawTwoByteString*>(str.raw_ptr());
   }
 
   static uint16_t* CharAddr(const String& str, intptr_t index) {
     ASSERT((index >= 0) && (index < str.Length()));
     ASSERT(str.IsTwoByteString());
-    NoGCScope no_gc;
-    return &raw_ptr(str)->data()[index];
+    return &str.UnsafeMutableNonPointer(raw_ptr(str)->data())[index];
   }
 
   static RawTwoByteString* ReadFrom(SnapshotReader* reader,
                                     intptr_t object_id,
                                     intptr_t tags,
                                     Snapshot::Kind kind);
 
   friend class Class;
   friend class String;
   friend class SnapshotReader;
 };
 
 
 class ExternalOneByteString : public AllStatic {
  public:
   static uint16_t CharAt(const String& str, intptr_t index) {
+    NoGCScope no_gc;
     return *CharAddr(str, index);
   }
 
   static void* GetPeer(const String& str) {
     return raw_ptr(str)->external_data_->peer();
   }
 
   // We use the same maximum elements for all strings.
   static const intptr_t kBytesPerElement = 1;
   static const intptr_t kMaxElements = String::kMaxElements;
@@ skipping 16 matching lines @@
   static RawOneByteString* EncodeIRI(const String& str);
   static RawOneByteString* DecodeIRI(const String& str);
 
   static const ClassId kClassId = kExternalOneByteStringCid;
 
  private:
   static RawExternalOneByteString* raw(const String& str) {
     return reinterpret_cast<RawExternalOneByteString*>(str.raw());
   }
 
-  static RawExternalOneByteString* raw_ptr(const String& str) {
-    return reinterpret_cast<RawExternalOneByteString*>(str.raw_ptr());
+  static const RawExternalOneByteString* raw_ptr(const String& str) {
+    return reinterpret_cast<const RawExternalOneByteString*>(str.raw_ptr());
   }
 
   static const uint8_t* CharAddr(const String& str, intptr_t index) {
     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;
     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);
 
   static intptr_t NextFieldOffset() {
     // Indicates this class cannot be extended by dart code.
     return -kWordSize;
   }
 
   friend class Class;
   friend class String;
   friend class SnapshotReader;
 };
 
 
 class ExternalTwoByteString : public AllStatic {
  public:
   static uint16_t CharAt(const String& str, intptr_t index) {
+    NoGCScope no_gc;
     return *CharAddr(str, index);
   }
 
   static void* GetPeer(const String& str) {
     return raw_ptr(str)->external_data_->peer();
   }
 
   // We use the same maximum elements for all strings.
   static const intptr_t kBytesPerElement = 2;
   static const intptr_t kMaxElements = String::kMaxElements;
@@ skipping 12 matching lines @@
     return reinterpret_cast<RawExternalTwoByteString*>(Object::null());
   }
 
   static const ClassId kClassId = kExternalTwoByteStringCid;
 
  private:
   static RawExternalTwoByteString* raw(const String& str) {
     return reinterpret_cast<RawExternalTwoByteString*>(str.raw());
   }
 
-  static RawExternalTwoByteString* raw_ptr(const String& str) {
-    return reinterpret_cast<RawExternalTwoByteString*>(str.raw_ptr());
+  static const RawExternalTwoByteString* raw_ptr(const String& str) {
+    return reinterpret_cast<const RawExternalTwoByteString*>(str.raw_ptr());
   }
 
   static const uint16_t* CharAddr(const String& str, intptr_t index) {
     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;
     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,
@@ skipping 134 matching lines @@
   RawArray* Slice(intptr_t start,
                   intptr_t count,
                   bool with_type_argument) const;
 
  protected:
   static RawArray* New(intptr_t class_id,
                        intptr_t len,
                        Heap::Space space = Heap::kNew);
 
  private:
-  RawObject** ObjectAddr(intptr_t index) const {
+  RawObject* const* 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.
     StoreSmi(&raw_ptr()->length_, Smi::New(value));
   }
@@ skipping 319 matching lines @@
   }
 
   intptr_t LengthInBytes() const {
     intptr_t cid = raw()->GetClassId();
     return (ElementSizeInBytes(cid) * Length());
   }
 
   void* DataAddr(intptr_t byte_offset) const {
     ASSERT((byte_offset == 0) ||
            ((byte_offset > 0) && (byte_offset < LengthInBytes())));
-    return reinterpret_cast<void*>(raw_ptr()->data() + byte_offset);
+    return reinterpret_cast<void*>(
+        UnsafeMutableNonPointer(raw_ptr()->data()) + byte_offset);
   }
 
   virtual bool CanonicalizeEquals(const Instance& other) const;
 
 #define TYPED_GETTER_SETTER(name, type)                                        \
   type Get##name(intptr_t byte_offset) const {                                 \
+    NoGCScope no_gc;                                                           \
     return *reinterpret_cast<type*>(DataAddr(byte_offset));                    \
   }                                                                            \
   void Set##name(intptr_t byte_offset, type value) const {                     \
+    NoGCScope no_gc;                                                           \
     *reinterpret_cast<type*>(DataAddr(byte_offset)) = value;                   \
   }
   TYPED_GETTER_SETTER(Int8, int8_t)
   TYPED_GETTER_SETTER(Uint8, uint8_t)
   TYPED_GETTER_SETTER(Int16, int16_t)
   TYPED_GETTER_SETTER(Uint16, uint16_t)
   TYPED_GETTER_SETTER(Int32, int32_t)
   TYPED_GETTER_SETTER(Uint32, uint32_t)
   TYPED_GETTER_SETTER(Int64, int64_t)
   TYPED_GETTER_SETTER(Uint64, uint64_t)
@@ skipping 227 matching lines @@
 class TypedDataView : public AllStatic {
  public:
   static intptr_t ElementSizeInBytes(const Instance& view_obj) {
     ASSERT(!view_obj.IsNull());
     intptr_t cid = view_obj.raw()->GetClassId();
     return ElementSizeInBytes(cid);
   }
 
   static RawInstance* Data(const Instance& view_obj) {
     ASSERT(!view_obj.IsNull());
-    return *reinterpret_cast<RawInstance**>(view_obj.raw_ptr() + kDataOffset);
+    return *reinterpret_cast<RawInstance* const*>(
+        view_obj.raw_ptr() + kDataOffset);
   }
 
   static RawSmi* OffsetInBytes(const Instance& view_obj) {
     ASSERT(!view_obj.IsNull());
-    return *reinterpret_cast<RawSmi**>(
+    return *reinterpret_cast<RawSmi* const*>(
         view_obj.raw_ptr() + kOffsetInBytesOffset);
   }
 
   static RawSmi* Length(const Instance& view_obj) {
     ASSERT(!view_obj.IsNull());
-    return *reinterpret_cast<RawSmi**>(view_obj.raw_ptr() + kLengthOffset);
+    return *reinterpret_cast<RawSmi* const*>(
+        view_obj.raw_ptr() + kLengthOffset);
   }
 
   static bool IsExternalTypedDataView(const Instance& view_obj) {
     const Instance& data = Instance::Handle(Data(view_obj));
     intptr_t cid = data.raw()->GetClassId();
     ASSERT(RawObject::IsTypedDataClassId(cid) ||
            RawObject::IsExternalTypedDataClassId(cid));
     return RawObject::IsExternalTypedDataClassId(cid);
   }
 
@@ skipping 26 matching lines @@
     kOffsetInBytesOffset = 2,
     kLengthOffset = 3,
   };
 };
 
 
 class ByteBuffer : public AllStatic {
  public:
   static RawInstance* Data(const Instance& view_obj) {
     ASSERT(!view_obj.IsNull());
-    return *reinterpret_cast<RawInstance**>(view_obj.raw_ptr() + kDataOffset);
+    return *reinterpret_cast<RawInstance* const*>(
+        view_obj.raw_ptr() + kDataOffset);
   }
 
   static intptr_t NumberOfFields() {
     return kDataOffset;
   }
 
   static intptr_t data_offset() {
     return kWordSize * kDataOffset;
   }
 
@@ skipping 534 matching lines @@
 
 
 RawObject* MegamorphicCache::GetTargetFunction(const Array& array,
                                                intptr_t index) {
   return array.At((index * kEntryLength) + kTargetFunctionIndex);
 }
 
 }  // namespace dart
 
 #endif  // VM_OBJECT_H_