Add missing verified write on x64; extend test coverage

runtime/vm/assembler_x64.h

 // 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.
 
 #ifndef VM_ASSEMBLER_X64_H_
 #define VM_ASSEMBLER_X64_H_
 
 #ifndef VM_ASSEMBLER_H_
 #error Do not include assembler_x64.h directly; use assembler.h instead.
 #endif
@@ skipping 657 matching lines @@
 
   void cmpxchgq(const Address& address, Register reg);
   void lock_cmpxchgq(const Address& address, Register reg) {
     lock();
     cmpxchgq(address, reg);
   }
 
   void cpuid();
 
   // Issue memory to memory move through a TMP register.
+  // TODO(koda): Assert that these are not used for heap objects.
   void MoveMemoryToMemory(const Address& dst, const Address& src) {
     movq(TMP, src);
     movq(dst, TMP);
   }
 
   void Exchange(Register reg, const Address& mem) {
     movq(TMP, mem);
     movq(mem, reg);
     movq(reg, TMP);
   }
@@ skipping 12 matching lines @@
   void CompareRegisters(Register a, Register b);
 
   // Issues a move instruction if 'to' is not the same as 'from'.
   void MoveRegister(Register to, Register from);
   void PopRegister(Register r);
 
   // Macros accepting a pp Register argument may attempt to load values from
   // the object pool when possible. Unless you are sure that the untagged object
   // pool pointer is in another register, or that it is not available at all,
   // PP should be passed for pp.
+  // TODO(koda): Assert that these are not used for heap objects.
   void AddImmediate(Register reg, const Immediate& imm, Register pp);
   void AddImmediate(const Address& address, const Immediate& imm, Register pp);
   void SubImmediate(Register reg, const Immediate& imm, Register pp);
   void SubImmediate(const Address& address, const Immediate& imm, Register pp);
 
   void Drop(intptr_t stack_elements);
 
   enum Patchability {
     kPatchable,
     kNotPatchable,
   };
 
   bool allow_constant_pool() const {
     return allow_constant_pool_;
   }
   void set_allow_constant_pool(bool b) {
     allow_constant_pool_ = b;
   }
 
   bool CanLoadImmediateFromPool(const Immediate& imm, Register pp);
   void LoadImmediate(Register reg, const Immediate& imm, Register pp);
-  void LoadImmediate(const Address& dst, const Immediate& imm, Register pp);
   void LoadIsolate(Register dst);
   void LoadObject(Register dst, const Object& obj, Register pp);
   void JmpPatchable(const ExternalLabel* label, Register pp);
   void Jmp(const ExternalLabel* label, Register pp);
   void J(Condition condition, const ExternalLabel* label, Register pp);
   void CallPatchable(const ExternalLabel* label);
   void Call(const ExternalLabel* label, Register pp);
+  // Unaware of write barrier (use StoreInto* methods for storing to objects).
+  // TODO(koda): Add StackAddress/HeapAddress types to prevent misuse.
   void StoreObject(const Address& dst, const Object& obj, Register pp);
   void PushObject(const Object& object, Register pp);
   void CompareObject(Register reg, const Object& object, Register pp);
 
   // Destroys value.
   void StoreIntoObject(Register object,  // Object we are storing into.
                        const Address& dest,  // Where we are storing into.
                        Register value,  // Value we are storing.
                        bool can_value_be_smi = true);
 
   void StoreIntoObjectNoBarrier(Register object,
                                 const Address& dest,
                                 Register value);
+  void StoreIntoObjectNoBarrier(Register object,
+                                const Address& dest,
+                                const Object& value,
+                                Register pp);
 
   // Stores a Smi value into a heap object field that always contains a Smi.
   void StoreIntoSmiField(const Address& dest, Register value);
   void ZeroSmiField(const Address& dest);
   // Increments a Smi field. Leaves flags in same state as an 'addq'.
   void IncrementSmiField(const Address& dest, int64_t increment);
 
   void DoubleNegate(XmmRegister d);
   void FloatNegate(XmmRegister f);
 
@@ skipping 319 matching lines @@
 
   // Shorter filtering sequence that assumes that value is not a smi.
   void StoreIntoObjectFilterNoSmi(Register object,
                                   Register value,
                                   Label* no_update);
 
   // Analogous to VerifiedMemory::Verify(address, kWordSize).
   void VerifyHeapWord(const Address& address);
   // Analogous to VerifiedMemory::Write.
   void VerifiedWrite(const Address& dest, Register value);
+  // Unaware of write barrier (use StoreInto* methods for storing to objects).
+  void MoveImmediate(const Address& dst, const Immediate& imm, Register pp);
 
   void ComputeCounterAddressesForCid(intptr_t cid,
                                      Heap::Space space,
                                      Address* count_address,
                                      Address* size_address);
   DISALLOW_ALLOCATION();
   DISALLOW_COPY_AND_ASSIGN(Assembler);
 };
 
 
@@ skipping 68 matching lines @@
 }
 
 
 inline void Assembler::EmitOperandSizeOverride() {
   EmitUint8(0x66);
 }
 
 }  // namespace dart
 
 #endif  // VM_ASSEMBLER_X64_H_