Add missing verified write on x64; extend test coverage

runtime/vm/assembler_x64.cc

 // Copyright (c) 2013, 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/globals.h"
 #if defined(TARGET_ARCH_X64)
 
 #include "vm/assembler.h"
 #include "vm/cpu.h"
 #include "vm/heap.h"
@@ skipping 2742 matching lines @@
   }
 }
 
 
 void Assembler::StoreObject(const Address& dst, const Object& object,
                             Register pp) {
   if (CanLoadFromObjectPool(object)) {
     LoadObject(TMP, object, pp);
     movq(dst, TMP);
   } else {
-    LoadImmediate(dst, Immediate(reinterpret_cast<int64_t>(object.raw())), pp);
+    MoveImmediate(dst, Immediate(reinterpret_cast<int64_t>(object.raw())), pp);
   }
 }
 
 
 void Assembler::PushObject(const Object& object, Register pp) {
   if (CanLoadFromObjectPool(object)) {
     LoadObject(TMP, object, pp);
     pushq(TMP);
   } else {
     PushImmediate(Immediate(reinterpret_cast<int64_t>(object.raw())), pp);
@@ skipping 44 matching lines @@
     if (val_smi_tag != 0) {
       // Add back the tag bits.
       orq(reg, Immediate(val_smi_tag));
     }
   } else {
     movq(reg, imm);
   }
 }
 
 
-void Assembler::LoadImmediate(const Address& dst, const Immediate& imm,
+void Assembler::MoveImmediate(const Address& dst, const Immediate& imm,
                               Register pp) {
   if (CanLoadImmediateFromPool(imm, pp)) {
     LoadImmediate(TMP, imm, pp);
     movq(dst, TMP);
   } else {
     movq(dst, imm);
   }
 }
 
 
@@ skipping 106 matching lines @@
   pushq(value);
   StoreIntoObjectFilter(object, value, &done);
   Stop("Store buffer update is required");
   Bind(&done);
   popq(value);
 #endif  // defined(DEBUG)
   // No store buffer update.
 }
 
 
+void Assembler::StoreIntoObjectNoBarrier(Register object,
+                                         const Address& dest,
+                                         const Object& value,
+                                         Register pp) {
+  if (VerifiedMemory::enabled()) {
+    VerifyHeapWord(dest);
+    Register temp = (pp == RCX) ? RDX : RCX;
+    pushq(temp);
+    leaq(temp, dest);
+    StoreObject(Address(temp, 0), value, pp);
+    StoreObject(Address(temp, VerifiedMemory::offset()), value, pp);
+    popq(temp);
+  } else {
+    StoreObject(dest, value, pp);
+  }
+  // TODO(koda): Use 'object', verify that generational barrier's not needed.
+}
+
+
 void Assembler::StoreIntoSmiField(const Address& dest, Register value) {
   VerifiedWrite(dest, value);
 #if defined(DEBUG)
   Label done;
   testq(value, Immediate(kHeapObjectTag));
   j(ZERO, &done);
   Stop("Smi expected");
   Bind(&done);
 #endif  // defined(DEBUG)
 }
@@ skipping 456 matching lines @@
     // next object start and store the class in the class field of object.
     LoadImmediate(TMP, Immediate(heap->TopAddress(space)), pp);
     movq(Address(TMP, 0), instance_reg);
     UpdateAllocationStats(cls.id(), space);
     ASSERT(instance_size >= kHeapObjectTag);
     AddImmediate(instance_reg, Immediate(kHeapObjectTag - instance_size), pp);
     uword tags = 0;
     tags = RawObject::SizeTag::update(instance_size, tags);
     ASSERT(cls.id() != kIllegalCid);
     tags = RawObject::ClassIdTag::update(cls.id(), tags);
-    LoadImmediate(FieldAddress(instance_reg, Object::tags_offset()),
+    MoveImmediate(FieldAddress(instance_reg, Object::tags_offset()),
                   Immediate(tags), pp);
   } else {
     jmp(failure);
   }
 }
 
 
 void Assembler::TryAllocateArray(intptr_t cid,
                                  intptr_t instance_size,
                                  Label* failure,
@@ skipping 313 matching lines @@
 
 
 const char* Assembler::FpuRegisterName(FpuRegister reg) {
   ASSERT((0 <= reg) && (reg < kNumberOfXmmRegisters));
   return xmm_reg_names[reg];
 }
 
 }  // namespace dart
 
 #endif  // defined TARGET_ARCH_X64