Write barrier audit: const raw_ptr()

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 662 matching lines @@
   // 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_->StoreSmi(&empty_array_->raw_ptr()->length_, Smi::New(0));
   }
 
+  Smi& smi = Smi::Handle();
   // 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_->StoreSmi(&zero_array_->raw_ptr()->length_, Smi::New(1));
-    zero_array_->StorePointer(&zero_array_->raw_ptr()->data()[0],
-                              static_cast<RawObject*>(Smi::New(0)));
+    smi = Smi::New(0);
+    zero_array_->SetAt(0, smi);
   }
 
   // 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_->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(
         empty_var_descriptors_,
         reinterpret_cast<RawLocalVarDescriptors*>(address + kHeapObjectTag));
-    empty_var_descriptors_->raw_ptr()->num_entries_ = 0;
+    empty_var_descriptors_->StoreNonPointer(
+        &empty_var_descriptors_->raw_ptr()->num_entries_, 0);
   }
 
   // Allocate and initialize the canonical empty exception handler info object.
   // The vast majority of all functions do not contain an exception handler
   // and can share this canonical descriptor.
   {
     uword address =
         heap->Allocate(ExceptionHandlers::InstanceSize(0), Heap::kOld);
     InitializeObject(address,
                      kExceptionHandlersCid,
                      ExceptionHandlers::InstanceSize(0));
     ExceptionHandlers::initializeHandle(
         empty_exception_handlers_,
         reinterpret_cast<RawExceptionHandlers*>(address + kHeapObjectTag));
-    empty_exception_handlers_->raw_ptr()->num_entries_ = 0;
+    empty_exception_handlers_->StoreNonPointer(
+        &empty_exception_handlers_->raw_ptr()->num_entries_, 0);
   }
 
   cls = Class::New<Instance>(kDynamicCid);
   cls.set_is_abstract();
   cls.set_num_type_arguments(0);
   cls.set_num_own_type_arguments(0);
   cls.set_is_type_finalized();
   cls.set_is_finalized();
   dynamic_class_ = cls.raw();
 
@@ skipping 4012 matching lines @@
   }
   // The zero array should have been initialized.
   ASSERT(Object::zero_array().raw() != Array::null());
   COMPILE_ASSERT(StubCode::kNoInstantiator == 0);
   result.set_instantiations(Object::zero_array());
   return result.raw();
 }
 
 
 
-RawAbstractType** TypeArguments::TypeAddr(intptr_t index) const {
+RawAbstractType* const* TypeArguments::TypeAddr(intptr_t index) const {
   // 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.
@@ skipping 2263 matching lines @@
 }
 
 
 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 {
-  raw_ptr()->guarded_list_length_in_object_offset_ =
-      static_cast<int8_t>(list_length_offset - kHeapObjectTag);
+  StoreNonPointer(&raw_ptr()->guarded_list_length_in_object_offset_,
+                  static_cast<int8_t>(list_length_offset - kHeapObjectTag));
   ASSERT(guarded_list_length_in_object_offset() == list_length_offset);
 }
 
 
 bool Field::IsUnboxedField() const {
   bool valid_class = (FlowGraphCompiler::SupportsUnboxedDoubles() &&
                       (guarded_cid() == kDoubleCid)) ||
                      (FlowGraphCompiler::SupportsUnboxedSimd128() &&
                       (guarded_cid() == kFloat32x4Cid)) ||
                      (FlowGraphCompiler::SupportsUnboxedSimd128() &&
@@ skipping 1520 matching lines @@
 void Library::SetLoadInProgress() const {
   // Must not already be in the process of being loaded.
   ASSERT(raw_ptr()->load_state_ <= RawLibrary::kLoadRequested);
   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;
+  StoreNonPointer(&raw_ptr()->load_state_, RawLibrary::kLoadRequested);
 }
 
 
 void Library::SetLoaded() const {
   // Should not be already loaded or just allocated.
   ASSERT(LoadInProgress() || LoadRequested());
   StoreNonPointer(&raw_ptr()->load_state_, RawLibrary::kLoaded);
 }
 
 
@@ skipping 860 matching lines @@
   result.StorePointer(&result.raw_ptr()->dictionary_,
                       Object::empty_array().raw());
   result.StorePointer(&result.raw_ptr()->metadata_,
                       GrowableObjectArray::New(4, Heap::kOld));
   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.StorePointer(&result.raw_ptr()->load_error_, Instance::null());
   result.set_native_entry_resolver(NULL);
   result.set_native_entry_symbol_resolver(NULL);
   result.StoreNonPointer(&result.raw_ptr()->corelib_imported_, true);
   result.set_debuggable(false);
   result.set_is_dart_scheme(url.StartsWith(Symbols::DartScheme()));
   result.StoreNonPointer(&result.raw_ptr()->load_state_,
                          RawLibrary::kAllocated);
   result.StoreNonPointer(&result.raw_ptr()->index_, -1);
   const intptr_t kInitialNameCacheSize = 64;
   result.InitResolvedNamesCache(kInitialNameCacheSize);
@@ skipping 976 matching lines @@
   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;
+  StoreNonPointer(&raw_ptr()->record_size_in_bytes_, value);
 }
 
 
 RawPcDescriptors* PcDescriptors::New(intptr_t num_descriptors,
                                      bool has_try_index) {
   ASSERT(Object::pc_descriptors_class() != Class::null());
   if (num_descriptors < 0 || num_descriptors > kMaxElements) {
     // This should be caught before we reach here.
     FATAL1("Fatal error in PcDescriptors::New: "
            "invalid num_descriptors %" Pd "\n", num_descriptors);
@@ skipping 170 matching lines @@
   uint8_t byte = raw_ptr()->data()[byte_index];
   return (byte & byte_mask);
 }
 
 
 void Stackmap::SetBit(intptr_t bit_index, bool value) const {
   ASSERT(InRange(bit_index));
   int byte_index = bit_index >> kBitsPerByteLog2;
   int bit_remainder = bit_index & (kBitsPerByte - 1);
   uint8_t byte_mask = 1U << bit_remainder;
-  uint8_t* byte_addr = &(raw_ptr()->data()[byte_index]);
+  NoGCScope no_gc;
+  uint8_t* byte_addr = UnsafeMutableNonPointer(&raw_ptr()->data()[byte_index]);
   if (value) {
     *byte_addr |= byte_mask;
   } else {
     *byte_addr &= ~byte_mask;
   }
 }
 
 
 RawStackmap* Stackmap::New(intptr_t pc_offset,
                            BitmapBuilder* bmap,
@@ skipping 263 matching lines @@
   return raw_ptr()->num_entries_;
 }
 
 
 void ExceptionHandlers::SetHandlerInfo(intptr_t try_index,
                                        intptr_t outer_try_index,
                                        intptr_t handler_pc,
                                        bool needs_stacktrace,
                                        bool has_catch_all) const {
   ASSERT((try_index >= 0) && (try_index < num_entries()));
-  RawExceptionHandlers::HandlerInfo* info = &raw_ptr()->data()[try_index];
+  NoGCScope no_gc;
+  RawExceptionHandlers::HandlerInfo* info =
+      UnsafeMutableNonPointer(&raw_ptr()->data()[try_index]);
   info->outer_try_index = outer_try_index;
   info->handler_pc = handler_pc;
   info->needs_stacktrace = needs_stacktrace;
   info->has_catch_all = has_catch_all;
 }
 
 void ExceptionHandlers::GetHandlerInfo(
     intptr_t try_index,
     RawExceptionHandlers::HandlerInfo* info) const {
   ASSERT((try_index >= 0) && (try_index < num_entries()));
@@ skipping 132 matching lines @@
   Object::PrintJSONImpl(stream, ref);
 }
 
 
 intptr_t DeoptInfo::Length() const {
   return Smi::Value(raw_ptr()->length_);
 }
 
 
 intptr_t DeoptInfo::FromIndex(intptr_t index) const {
+  NoGCScope no_gc;
   return *(EntryAddr(index, kFromIndex));
 }
 
 
 intptr_t DeoptInfo::Instruction(intptr_t index) const {
+  NoGCScope no_gc;
   return *(EntryAddr(index, kInstruction));
 }
 
 
 intptr_t DeoptInfo::FrameSize() const {
   return TranslationLength() - NumMaterializations();
 }
 
 
 intptr_t DeoptInfo::TranslationLength() const {
@@ skipping 116 matching lines @@
 void DeoptInfo::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));
 }
 
 
 void DeoptInfo::SetAt(intptr_t index,
                       intptr_t instr_kind,
                       intptr_t from_index) const {
+  NoGCScope no_gc;
   *(EntryAddr(index, kInstruction)) = instr_kind;
   *(EntryAddr(index, kFromIndex)) = from_index;
 }
 
 
 const char* ICData::ToCString() const {
   const char* kFormat = "ICData target:'%s' num-args: %" Pd
                         " num-checks: %" Pd "";
   const String& name = String::Handle(target_name());
   const intptr_t num_args = NumArgsTested();
@@ skipping 35 matching lines @@
 }
 
 
 intptr_t ICData::NumArgsTested() const {
   return NumArgsTestedBits::decode(raw_ptr()->state_bits_);
 }
 
 
 void ICData::SetNumArgsTested(intptr_t value) const {
   ASSERT(Utils::IsUint(2, value));
-  raw_ptr()->state_bits_ =
-      NumArgsTestedBits::update(value, raw_ptr()->state_bits_);
+  StoreNonPointer(&raw_ptr()->state_bits_,
+                  NumArgsTestedBits::update(value, raw_ptr()->state_bits_));
 }
 
 
 uint32_t ICData::DeoptReasons() const {
   return DeoptReasonBits::decode(raw_ptr()->state_bits_);
 }
 
 
 void ICData::SetDeoptReasons(uint32_t reasons) const {
-  raw_ptr()->state_bits_ =
-      DeoptReasonBits::update(reasons, raw_ptr()->state_bits_);
+  StoreNonPointer(&raw_ptr()->state_bits_,
+                  DeoptReasonBits::update(reasons, raw_ptr()->state_bits_));
 }
 
 
 bool ICData::HasDeoptReason(DeoptReasonId reason) const {
   return (DeoptReasons() & (1 << reason)) != 0;
 }
 
 
 void ICData::AddDeoptReason(DeoptReasonId reason) const {
   SetDeoptReasons(DeoptReasons() | (1 << reason));
 }
 
 
 bool ICData::IssuedJSWarning() const {
   return IssuedJSWarningBit::decode(raw_ptr()->state_bits_);
 }
 
 
 void ICData::SetIssuedJSWarning() const {
-  raw_ptr()->state_bits_ =
-      IssuedJSWarningBit::update(true, raw_ptr()->state_bits_);
+  StoreNonPointer(&raw_ptr()->state_bits_,
+                  IssuedJSWarningBit::update(true, raw_ptr()->state_bits_));
 }
 
 
 bool ICData::MayCheckForJSWarning() const {
   const String& name = String::Handle(target_name());
   // Warning issued from native code.
   // Calling sequence is decoded to obtain ic data in order to check if a
   // warning has already been issued.
   if (name.Equals(Library::PrivateCoreLibName(Symbols::_instanceOf())) ||
       name.Equals(Library::PrivateCoreLibName(Symbols::_as()))) {
@@ skipping 803 matching lines @@
     const GrowableObjectArray& object_pool = assembler->object_pool();
     if (object_pool.IsNull()) {
       instrs.set_object_pool(Object::empty_array().raw());
     } else {
       // TODO(regis): Once MakeArray takes a Heap::Space argument, call it here
       // with Heap::kOld and change the ARM and MIPS assemblers to work with a
       // GrowableObjectArray in new space.
       instrs.set_object_pool(Array::MakeArray(object_pool));
     }
     if (FLAG_write_protect_code) {
+      uword address = RawObject::ToAddr(instrs.raw());
       bool status = VirtualMemory::Protect(
-          reinterpret_cast<void*>(instrs.raw_ptr()), instrs.raw()->Size(),
+          reinterpret_cast<void*>(address),
+          instrs.raw()->Size(),
           VirtualMemory::kReadExecute);
       ASSERT(status);
     }
   }
   code.set_comments(assembler->GetCodeComments());
   return code.raw();
 }
 
 
 RawCode* Code::FinalizeCode(const Function& function,
@@ skipping 1258 matching lines @@
     return Integer::Cast(*this).Equals(other);
   }
   if (IsDouble() && other.IsDouble()) {
     return Double::Cast(*this).CanonicalizeEquals(other);
   }
   return false;
 }
 
 
 intptr_t* Instance::NativeFieldsDataAddr() const {
-  NoGCScope no_gc;
+  ASSERT(Isolate::Current()->no_gc_scope_depth() > 0);
   RawTypedData* native_fields =
       reinterpret_cast<RawTypedData*>(*NativeFieldsAddr());
   if (native_fields == TypedData::null()) {
     return NULL;
   }
   return reinterpret_cast<intptr_t*>(native_fields->ptr()->data());
 }
 
 
 void Instance::SetNativeField(int index, intptr_t value) const {
@@ skipping 2698 matching lines @@
   jsobj.AddProperty("valueAsString", ToCString());
 }
 
 
 void Bigint::set_neg(const Bool& value) const {
   StorePointer(&raw_ptr()->neg_, value.raw());
 }
 
 
 void Bigint::set_used(const Smi& value) const {
-  raw_ptr()->used_ = value.raw();
+  StoreSmi(&raw_ptr()->used_, value.raw());
 }
 
 
 void Bigint::set_digits(const TypedData& value) const {
   // The VM expects digits_ to be a Uint32List (not null).
   ASSERT(!value.IsNull() && (value.GetClassId() == kTypedDataUint32ArrayCid));
   StorePointer(&raw_ptr()->digits_, value.raw());
 }
 
 
@@ skipping 783 matching lines @@
   uint32_t hash_;
 };
 
 
 void StringHasher::Add(const String& str, intptr_t begin_index, intptr_t len) {
   ASSERT(begin_index >= 0);
   ASSERT(len >= 0);
   ASSERT((begin_index + len) <= str.Length());
   if (str.IsOneByteString()) {
     for (intptr_t i = 0; i < len; i++) {
+      NoGCScope no_gc;
       Add(*OneByteString::CharAddr(str, i + begin_index));
     }
   } else {
     String::CodePointIterator it(str, begin_index, len);
     while (it.Next()) {
       Add(it.Current());
     }
   }
 }
 
@@ skipping 854 matching lines @@
       Object::MakeUnusedSpaceTraversable(*this, original_size, used_size);
 
       // Update the class information of the object.
       const intptr_t class_id = kExternalOneByteStringCid;
       uword tags = raw_ptr()->tags_;
       uword old_tags;
       do {
         old_tags = tags;
         uword new_tags = RawObject::SizeTag::update(used_size, old_tags);
         new_tags = RawObject::ClassIdTag::update(class_id, new_tags);
-        tags = AtomicOperations::CompareAndSwapWord(
-            &raw_ptr()->tags_, old_tags, new_tags);
+        tags = CompareAndSwapTags(old_tags, new_tags);
       } while (tags != old_tags);
       result = this->raw();
       const uint8_t* ext_array = reinterpret_cast<const uint8_t*>(array);
       ExternalStringData<uint8_t>* ext_data = new ExternalStringData<uint8_t>(
           ext_array, peer, cback);
       ASSERT(result.Length() == str_length);
       ASSERT(!result.HasHash() ||
              (result.Hash() == String::Hash(ext_array, str_length)));
       ExternalOneByteString::SetExternalData(result, ext_data);
       external_data = ext_data;
@@ skipping 17 matching lines @@
       Object::MakeUnusedSpaceTraversable(*this, original_size, used_size);
 
       // Update the class information of the object.
       const intptr_t class_id = kExternalTwoByteStringCid;
       uword tags = raw_ptr()->tags_;
       uword old_tags;
       do {
         old_tags = tags;
         uword new_tags = RawObject::SizeTag::update(used_size, old_tags);
         new_tags = RawObject::ClassIdTag::update(class_id, new_tags);
-        tags = AtomicOperations::CompareAndSwapWord(
-            &raw_ptr()->tags_, old_tags, new_tags);
+        tags = CompareAndSwapTags(old_tags, new_tags);
       } while (tags != old_tags);
       result = this->raw();
       const uint16_t* ext_array = reinterpret_cast<const uint16_t*>(array);
       ExternalStringData<uint16_t>* ext_data = new ExternalStringData<uint16_t>(
           ext_array, peer, cback);
       ASSERT(result.Length() == str_length);
       ASSERT(!result.HasHash() ||
              (result.Hash() == String::Hash(ext_array, str_length)));
       ExternalTwoByteString::SetExternalData(result, ext_data);
       external_data = ext_data;
@@ skipping 188 matching lines @@
   index_ = end_;
   return false;
 }
 
 
 RawOneByteString* OneByteString::EscapeSpecialCharacters(const String& str) {
   intptr_t len = str.Length();
   if (len > 0) {
     intptr_t num_escapes = 0;
     for (intptr_t i = 0; i < len; i++) {
-      num_escapes += EscapeOverhead(*CharAddr(str, i));
+      num_escapes += EscapeOverhead(CharAt(str, i));
     }
     const String& dststr = String::Handle(
         OneByteString::New(len + num_escapes, Heap::kNew));
     intptr_t index = 0;
     for (intptr_t i = 0; i < len; i++) {
       uint8_t ch = CharAt(str, i);
       if (IsSpecialCharacter(ch)) {
         SetCharAt(dststr, index, '\\');
         SetCharAt(dststr, index + 1, SpecialCharacter(ch));
         index += 2;
@@ skipping 13 matching lines @@
   return OneByteString::raw(Symbols::Empty());
 }
 
 
 RawOneByteString* ExternalOneByteString::EscapeSpecialCharacters(
     const String& str) {
   intptr_t len = str.Length();
   if (len > 0) {
     intptr_t num_escapes = 0;
     for (intptr_t i = 0; i < len; i++) {
-      num_escapes += EscapeOverhead(*CharAddr(str, i));
+      num_escapes += EscapeOverhead(CharAt(str, i));
     }
     const String& dststr = String::Handle(
         OneByteString::New(len + num_escapes, Heap::kNew));
     intptr_t index = 0;
     for (intptr_t i = 0; i < len; i++) {
       uint8_t ch = CharAt(str, i);
       if (IsSpecialCharacter(ch)) {
         OneByteString::SetCharAt(dststr, index, '\\');
         OneByteString::SetCharAt(dststr, index + 1, SpecialCharacter(ch));
         index += 2;
       } else if (IsAsciiNonprintable(ch)) {
         OneByteString::SetCharAt(dststr, index, '\\');
         OneByteString::SetCharAt(dststr, index + 1, 'x');
         OneByteString::SetCharAt(dststr, index + 2, GetHexCharacter(ch >> 4));
         OneByteString::SetCharAt(dststr, index + 3, GetHexCharacter(ch & 0xF));
         index += 4;
       } else {
-        *(OneByteString::CharAddr(dststr, index)) = ch;
+        OneByteString::SetCharAt(dststr, index, ch);
         index += 1;
       }
     }
     return OneByteString::raw(dststr);
   }
   return OneByteString::raw(Symbols::Empty());
 }
 
 
 RawOneByteString* OneByteString::New(intptr_t len,
@@ skipping 27 matching lines @@
     memmove(CharAddr(result, 0), characters, len);
   }
   return OneByteString::raw(result);
 }
 
 
 RawOneByteString* OneByteString::New(const uint16_t* characters,
                                      intptr_t len,
                                      Heap::Space space) {
   const String& result =String::Handle(OneByteString::New(len, space));
+  NoGCScope no_gc;
   for (intptr_t i = 0; i < len; ++i) {
     ASSERT(Utf::IsLatin1(characters[i]));
     *CharAddr(result, i) = characters[i];
   }
   return OneByteString::raw(result);
 }
 
 
 RawOneByteString* OneByteString::New(const int32_t* characters,
                                      intptr_t len,
                                      Heap::Space space) {
   const String& result = String::Handle(OneByteString::New(len, space));
+  NoGCScope no_gc;
   for (intptr_t i = 0; i < len; ++i) {
     ASSERT(Utf::IsLatin1(characters[i]));
     *CharAddr(result, i) = characters[i];
   }
   return OneByteString::raw(result);
 }
 
 
 RawOneByteString* OneByteString::New(const String& str,
                                      Heap::Space space) {
@@ skipping 86 matching lines @@
   return OneByteString::raw(result);
 }
 
 
 RawOneByteString* OneByteString::Transform(int32_t (*mapping)(int32_t ch),
                                            const String& str,
                                            Heap::Space space) {
   ASSERT(!str.IsNull());
   intptr_t len = str.Length();
   const String& result = String::Handle(OneByteString::New(len, space));
+  NoGCScope no_gc;
   for (intptr_t i = 0; i < len; ++i) {
     int32_t ch = mapping(str.CharAt(i));
     ASSERT(Utf::IsLatin1(ch));
     *CharAddr(result, i) = ch;
   }
   return OneByteString::raw(result);
 }
 
 
 RawOneByteString* OneByteString::SubStringUnchecked(const String& str,
                                                     intptr_t begin_index,
                                                     intptr_t length,
                                                     Heap::Space space) {
   ASSERT(!str.IsNull() && str.IsOneByteString());
   ASSERT(begin_index >= 0);
   ASSERT(length >= 0);
   if (begin_index <= str.Length() && length == 0) {
     return OneByteString::raw(Symbols::Empty());
   }
   ASSERT(begin_index < str.Length());
   RawOneByteString* result = OneByteString::New(length, space);
   NoGCScope no_gc;
   if (length > 0) {
     uint8_t* dest = &result->ptr()->data()[0];
-    uint8_t* src =  &raw_ptr(str)->data()[begin_index];
+    const uint8_t* src =  &raw_ptr(str)->data()[begin_index];
     memmove(dest, src, length);
   }
   return result;
 }
 
 
 void OneByteString::SetPeer(const String& str,
                             void* peer,
                             Dart_PeerFinalizer cback) {
   ASSERT(!str.IsNull() && str.IsOneByteString());
@@ skipping 10 matching lines @@
                              void* peer) {
   delete reinterpret_cast<ExternalStringData<uint8_t>*>(peer);
 }
 
 
 RawTwoByteString* TwoByteString::EscapeSpecialCharacters(const String& str) {
   intptr_t len = str.Length();
   if (len > 0) {
     intptr_t num_escapes = 0;
     for (intptr_t i = 0; i < len; i++) {
-      num_escapes += EscapeOverhead(*CharAddr(str, i));
+      num_escapes += EscapeOverhead(CharAt(str, i));
     }
     const String& dststr = String::Handle(
         TwoByteString::New(len + num_escapes, Heap::kNew));
     intptr_t index = 0;
     for (intptr_t i = 0; i < len; i++) {
       uint16_t ch = CharAt(str, i);
       if (IsSpecialCharacter(ch)) {
         SetCharAt(dststr, index, '\\');
         SetCharAt(dststr, index + 1, SpecialCharacter(ch));
         index += 2;
@@ skipping 118 matching lines @@
 
 
 RawTwoByteString* TwoByteString::Transform(int32_t (*mapping)(int32_t ch),
                                            const String& str,
                                            Heap::Space space) {
   ASSERT(!str.IsNull());
   intptr_t len = str.Length();
   const String& result = String::Handle(TwoByteString::New(len, space));
   String::CodePointIterator it(str);
   intptr_t i = 0;
+  NoGCScope no_gc;
   while (it.Next()) {
     int32_t src = it.Current();
     int32_t dst = mapping(src);
     ASSERT(dst >= 0 && dst <= 0x10FFFF);
     intptr_t len = Utf16::Length(dst);
     if (len == 1) {
       *CharAddr(result, i) = dst;
     } else {
       ASSERT(len == 2);
       Utf16::Encode(dst, CharAddr(result, i));
@@ skipping 192 matching lines @@
 }
 
 
 RawArray* Array::Slice(intptr_t start,
                        intptr_t count,
                        bool with_type_argument) const {
   // TODO(vegorov) introduce an array allocation method that fills newly
   // allocated array with values from the given source array instead of
   // null-initializing all elements.
   Array& dest = Array::Handle(Array::New(count));
-  if (dest.raw()->IsNewObject()) {
-    NoGCScope no_gc_scope;
-    memmove(dest.ObjectAddr(0), ObjectAddr(start), count * kWordSize);
-  } else {
-    PassiveObject& obj = PassiveObject::Handle();
-    for (intptr_t i = 0; i < count; i++) {
-      obj = At(start + i);
-      dest.SetAt(i, obj);
-    }
-  }
+  dest.StorePointers(dest.ObjectAddr(0), ObjectAddr(start), count);
 
   if (with_type_argument) {
     dest.SetTypeArguments(TypeArguments::Handle(GetTypeArguments()));
   }
 
   return dest.raw();
 }
 
 
 void Array::MakeImmutable() const {
   NoGCScope no_gc;
   uword tags = raw_ptr()->tags_;
   uword old_tags;
   do {
     old_tags = tags;
     uword new_tags = RawObject::ClassIdTag::update(kImmutableArrayCid,
                                                    old_tags);
-    tags = AtomicOperations::CompareAndSwapWord(
-        &raw_ptr()->tags_, old_tags, new_tags);
+    tags = CompareAndSwapTags(old_tags, new_tags);
   } while (tags != old_tags);
 }
 
 
 const char* Array::ToCString() const {
   if (IsNull()) {
     return IsImmutable() ? "_ImmutableList NULL" : "_List NULL";
   }
   const char* format = IsImmutable() ?
       "_ImmutableList len:%" Pd : "_List len:%" Pd;
@@ skipping 74 matching lines @@
   // that it can be traversed over successfully during garbage collection.
   Object::MakeUnusedSpaceTraversable(array, capacity_size, used_size);
 
   // Update the size in the header field and length of the array object.
   uword tags = array.raw_ptr()->tags_;
   ASSERT(kArrayCid == RawObject::ClassIdTag::decode(tags));
   uword old_tags;
   do {
     old_tags = tags;
     uword new_tags = RawObject::SizeTag::update(used_size, old_tags);
-    tags = AtomicOperations::CompareAndSwapWord(
-        &array.raw_ptr()->tags_, old_tags, new_tags);
+    tags = array.CompareAndSwapTags(old_tags, new_tags);
   } while (tags != old_tags);
   array.SetLength(used_len);
 
   // Null the GrowableObjectArray, we are removing it's backing array.
   growable_array.SetLength(0);
   growable_array.SetData(Object::empty_array());
 
   return array.raw();
 }
 
@@ skipping 370 matching lines @@
   return result.raw();
 }
 
 
 simd128_value_t Float32x4::value() const {
   return simd128_value_t().readFrom(&raw_ptr()->value_[0]);
 }
 
 
 void Float32x4::set_value(simd128_value_t value) const {
-  value.writeTo(&raw_ptr()->value_[0]);
+  StoreSimd128(&raw_ptr()->value_[0], value);
 }
 
 
 void Float32x4::set_x(float value) const {
   StoreNonPointer(&raw_ptr()->value_[0], value);
 }
 
 
 void Float32x4::set_y(float value) const {
   StoreNonPointer(&raw_ptr()->value_[1], value);
@@ skipping 124 matching lines @@
   return raw_ptr()->value_[3];
 }
 
 
 simd128_value_t Int32x4::value() const {
   return simd128_value_t().readFrom(&raw_ptr()->value_[0]);
 }
 
 
 void Int32x4::set_value(simd128_value_t value) const {
-  value.writeTo(&raw_ptr()->value_[0]);
+  StoreSimd128(&raw_ptr()->value_[0], value);
 }
 
 
 const char* Int32x4::ToCString() const {
   const char* kFormat = "[%08x, %08x, %08x, %08x]";
   int32_t _x = x();
   int32_t _y = y();
   int32_t _z = z();
   int32_t _w = w();
   // Calculate the size of the string.
@@ skipping 61 matching lines @@
   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]);
+  StoreSimd128(&raw_ptr()->value_[0], value);
 }
 
 
 const char* Float64x2::ToCString() const {
   const char* kFormat = "[%f, %f]";
   double _x = x();
   double _y = y();
   // Calculate the size of the string.
   intptr_t len = OS::SNPrint(NULL, 0, kFormat, _x, _y) + 1;
   char* chars = Isolate::Current()->current_zone()->Alloc<char>(len);
@@ skipping 38 matching lines @@
   const TypedData& other_typed_data = TypedData::Cast(other);
 
   if (this->ElementType() != other_typed_data.ElementType()) {
     return false;
   }
 
   const intptr_t len = this->LengthInBytes();
   if (len != other_typed_data.LengthInBytes()) {
     return false;
   }
-
+  NoGCScope no_gc;
   return (len == 0) ||
       (memcmp(DataAddr(0), other_typed_data.DataAddr(0), len) == 0);
 }
 
 
 RawTypedData* TypedData::New(intptr_t class_id,
                              intptr_t len,
                              Heap::Space space) {
   if (len < 0 || len > TypedData::MaxElements(class_id)) {
     FATAL1("Fatal error in TypedData::New: invalid len %" Pd "\n", len);
@@ skipping 793 matching lines @@
   return tag_label.ToCString();
 }
 
 
 void UserTag::PrintJSONImpl(JSONStream* stream, bool ref) const {
   Instance::PrintJSONImpl(stream, ref);
 }
 
 
 }  // namespace dart