Write barrier audit: Verify previous value in generated code.

runtime/vm/assembler_ia32.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_IA32)
 
 #include "vm/assembler.h"
 #include "vm/code_generator.h"
 #include "vm/cpu.h"
@@ skipping 1927 matching lines @@
 
 
 void Assembler::hlt() {
   AssemblerBuffer::EnsureCapacity ensured(&buffer_);
   EmitUint8(0xF4);
 }
 
 
 void Assembler::j(Condition condition, Label* label, bool near) {
   AssemblerBuffer::EnsureCapacity ensured(&buffer_);
+  if (VerifiedMemory::enabled()) {
+    near = Assembler::kFarJump;
+  }
   if (label->IsBound()) {
     static const int kShortSize = 2;
     static const int kLongSize = 6;
     intptr_t offset = label->Position() - buffer_.Size();
     ASSERT(offset <= 0);
     if (Utils::IsInt(8, offset - kShortSize)) {
       EmitUint8(0x70 + condition);
       EmitUint8((offset - kShortSize) & 0xFF);
     } else {
       EmitUint8(0x0F);
@@ skipping 22 matching lines @@
 
 void Assembler::jmp(Register reg) {
   AssemblerBuffer::EnsureCapacity ensured(&buffer_);
   EmitUint8(0xFF);
   EmitRegisterOperand(4, reg);
 }
 
 
 void Assembler::jmp(Label* label, bool near) {
   AssemblerBuffer::EnsureCapacity ensured(&buffer_);
+  if (VerifiedMemory::enabled()) {
+    near = Assembler::kFarJump;
+  }
   if (label->IsBound()) {
     static const int kShortSize = 2;
     static const int kLongSize = 5;
     intptr_t offset = label->Position() - buffer_.Size();
     ASSERT(offset <= 0);
     if (Utils::IsInt(8, offset - kShortSize)) {
       EmitUint8(0xEB);
       EmitUint8((offset - kShortSize) & 0xFF);
     } else {
       EmitUint8(0xE9);
@@ skipping 192 matching lines @@
   // Mask out higher, uninteresting bits which were polluted by dest.
   andl(value, Immediate(kObjectAlignment - 1));
   // Compare with the expected bit pattern.
   cmpl(value, Immediate(
       (kNewObjectAlignmentOffset >> 1) + kHeapObjectTag +
       kOldObjectAlignmentOffset + kHeapObjectTag));
   j(NOT_ZERO, no_update, Assembler::kNearJump);
 }
 
 
+void Assembler::Verify(const Address& dest) {

[Ivan Posva, 2014/11/14 22:09:11]

Verify is a bit too generic a name for this functionality.

[koda, 2014/11/17 16:17:11]

Renamed to VerifyHeapWord.

+  if (VerifiedMemory::enabled()) {
+    Register dest_addr = EDX;
+    Register old_value = EBX;
+    pushl(dest_addr);

[Ivan Posva, 2014/11/14 22:09:11]

Some comments explaining what is going on here would be helpful.

[koda, 2014/11/17 16:17:11]

Done. Also improved naming of vars/params.

+    pushl(old_value);
+    leal(dest_addr, dest);
+    movl(old_value, Address(dest_addr, 0));
+    cmpl(old_value, Address(dest_addr, VerifiedMemory::offset()));
+    Label ok;
+    j(EQUAL, &ok, Assembler::kNearJump);
+    Stop("Write barrier verification failed");
+    Bind(&ok);
+    popl(old_value);
+    popl(dest_addr);
+  }
+}
+
+
 void Assembler::VerifiedWrite(const Address& dest, Register value) {
-  // TODO(koda): Verify previous value.
+  Verify(dest);
   movl(dest, value);
   if (VerifiedMemory::enabled()) {
     Register temp = (value == EDX) ? ECX : EDX;
     pushl(temp);
     leal(temp, dest);
     movl(Address(temp, VerifiedMemory::offset()), value);
     popl(temp);
   }
 }
 
@@ skipping 50 matching lines @@
   AssemblerBuffer::EnsureCapacity ensured(&buffer_);
   EmitUint8(0xC7);
   EmitOperand(0, dest);
   buffer_.EmitObject(value);
 }
 
 
 void Assembler::StoreIntoObjectNoBarrier(Register object,
                                          const Address& dest,
                                          const Object& value) {
+  Verify(dest);
   if (value.IsSmi() || value.InVMHeap()) {
-    // TODO(koda): Verify previous value.
     Immediate imm_value(reinterpret_cast<int32_t>(value.raw()));
     movl(dest, imm_value);
     if (VerifiedMemory::enabled()) {
       Register temp = ECX;
       pushl(temp);
       leal(temp, dest);
       movl(Address(temp, VerifiedMemory::offset()), imm_value);
       popl(temp);
     }
   } else {
@@ skipping 16 matching lines @@
   Label done;
   testl(value, Immediate(kHeapObjectTag));
   j(ZERO, &done);
   Stop("Smi expected");
   Bind(&done);
 #endif  // defined(DEBUG)
 }
 
 
 void Assembler::ZeroSmiField(const Address& dest) {
+  Verify(dest);  // TODO(koda): Add VerifySmi once we distinguish initalization.
   Immediate zero(Smi::RawValue(0));
-  // TODO(koda): Verify previous value.
   movl(dest, zero);
   if (VerifiedMemory::enabled()) {
     Register temp = ECX;
     pushl(temp);
     leal(temp, dest);
     movl(Address(temp, VerifiedMemory::offset()), zero);
     popl(temp);
   }
 }
 
 
 void Assembler::IncrementSmiField(const Address& dest, int32_t increment) {
   // Note: FlowGraphCompiler::EdgeCounterIncrementSizeInBytes depends on
   // the length of this instruction sequence.
-  //
-  // TODO(koda): Implement testl for addresses and check that dest is a smi.
+  Verify(dest);  // TODO(koda): Add VerifySmi once we distinguish initalization.
   Immediate inc_imm(Smi::RawValue(increment));
   addl(dest, inc_imm);
   if (VerifiedMemory::enabled()) {
     Register temp = ECX;
     pushl(temp);
     leal(temp, dest);
     addl(Address(temp, VerifiedMemory::offset()), inc_imm);
     popl(temp);
   }
 }
@@ skipping 618 matching lines @@
 
 const char* Assembler::FpuRegisterName(FpuRegister reg) {
   ASSERT((0 <= reg) && (reg < kNumberOfXmmRegisters));
   return xmm_reg_names[reg];
 }
 
 
 }  // namespace dart
 
 #endif  // defined TARGET_ARCH_IA32