Write-barrier verification on ARM.

runtime/vm/assembler_arm.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_ARM)
 
 #include "vm/assembler.h"
 #include "vm/cpu.h"
 #include "vm/longjump.h"
@@ skipping 1623 matching lines @@
   // For the value we are only interested in the new/old bit and the tag bit.
   // And the new bit with the tag bit. The resulting bit will be 0 for a Smi.
   and_(IP, value, Operand(value, LSL, kObjectAlignmentLog2 - 1));
   // And the result with the negated space bit of the object.
   bic(IP, IP, Operand(object));
   tst(IP, Operand(kNewObjectAlignmentOffset));
   b(no_update, EQ);
 }
 
 
+Operand Assembler::GetVerifiedMemoryShadow() {
+  Operand offset;
+  if (!Operand::CanHold(VerifiedMemory::offset(), &offset)) {
+    FATAL1("Offset 0x%" Px " not representable", VerifiedMemory::offset());
+  }
+  return offset;
+}
+
+
+void Assembler::WriteShadowedField(Register base,
+                                   intptr_t offset,
+                                   Register value,
+                                   Condition cond) {
+  if (VerifiedMemory::enabled()) {
+    ASSERT(base != value);
+    Operand shadow(GetVerifiedMemoryShadow());
+    add(base, base, shadow, cond);
+    str(value, Address(base, offset), cond);
+    sub(base, base, shadow, cond);
+  }
+  str(value, Address(base, offset), cond);
+}
+
+
+void Assembler::WriteShadowedFieldPair(Register base,
+                                       intptr_t offset,
+                                       Register value_even,
+                                       Register value_odd,
+                                       Condition cond) {
+  ASSERT(value_odd == value_even + 1);
+  if (VerifiedMemory::enabled()) {
+    ASSERT(base != value_even);
+    ASSERT(base != value_odd);
+    Operand shadow(GetVerifiedMemoryShadow());
+    add(base, base, shadow, cond);
+    strd(value_even, Address(base, offset), cond);
+    sub(base, base, shadow, cond);
+  }
+  strd(value_even, Address(base, offset), cond);
+}
+
+
+Register UseRegister(Register reg, RegList* used) {
+  ASSERT((*used & (1 << reg)) == 0);
+  *used |= (1 << reg);
+  return reg;
+}
+
+
+Register AllocateRegister(RegList* used) {
+  const RegList free = ~*used;
+  return (free == 0) ?
+      kNoRegister :
+      UseRegister(static_cast<Register>(Utils::CountTrailingZeros(free)), used);
+}
+
+
+void Assembler::VerifiedWrite(const Address& address, Register new_value) {
+  if (VerifiedMemory::enabled()) {
+    ASSERT(address.mode() == Address::Offset ||
+           address.mode() == Address::NegOffset);
+    // Allocate temporary registers.
+    RegList used = 0;
+    UseRegister(new_value, &used);
+    Register base = UseRegister(address.rn(), &used);
+    if (address.rm() != kNoRegister) UseRegister(address.rm(), &used);
+    Register old_value = AllocateRegister(&used);

[Ivan Posva, 2014/12/08 19:27:56]

How do you prevent allocating one of the pre-assigned, non-allocatable registers
(e.g. SP) being used here?

Maybe we should not initialize with 0?

[koda, 2014/12/08 22:23:42]

Added assertions to UseRegister. This would only be an issue if the args +
temporaries use more than 13 registers in total.

+    Register shadow_value = AllocateRegister(&used);

[Vyacheslav Egorov (Google), 2014/12/09 11:14:12]

I suggest you merge your custom register allocator with
ParallelMoveResolver::ScratchRegisterScope. It's somewhat bad to have several of
those.

[koda, 2014/12/09 14:38:28]

VerifiedWrite needs to be used in lower-level code like stubs, which is why it's
in Assembler. If more code starts using its "allocator", and especially if it's
non-DEBUG code, then I'll look into refactoring to share what is possible to
share.

+    PushList(used);
+    // Verify old value.
+    ldr(old_value, address);
+    Operand shadow_offset(GetVerifiedMemoryShadow());
+    add(base, base, shadow_offset);
+    ldr(shadow_value, address);
+    cmp(old_value, Operand(shadow_value));
+    Label ok;
+    b(&ok);
+    Stop("Write barrier verification failed");
+    Bind(&ok);
+    // Write new value.
+    str(new_value, address);
+    sub(base, base, shadow_offset);
+    str(new_value, address);
+    PopList(used);
+  } else {
+    str(new_value, address);
+  }
+}
+
+
 void Assembler::StoreIntoObject(Register object,
                                 const Address& dest,
                                 Register value,
                                 bool can_value_be_smi) {
   ASSERT(object != value);
-  str(value, dest);
+  VerifiedWrite(dest, value);
   Label done;
   if (can_value_be_smi) {
     StoreIntoObjectFilter(object, value, &done);
   } else {
     StoreIntoObjectFilterNoSmi(object, value, &done);
   }
   // A store buffer update is required.
   RegList regs = (1 << LR);
   if (value != R0) {
     regs |= (1 << R0);  // Preserve R0.
@@ skipping 20 matching lines @@
   } else {
     AddImmediate(IP, object, offset - kHeapObjectTag);
     StoreIntoObject(object, Address(IP), value, can_value_be_smi);
   }
 }
 
 
 void Assembler::StoreIntoObjectNoBarrier(Register object,
                                          const Address& dest,
                                          Register value) {
-  str(value, dest);
+  VerifiedWrite(dest, value);
 #if defined(DEBUG)
   Label done;
   StoreIntoObjectFilter(object, value, &done);
   Stop("Store buffer update is required");
   Bind(&done);
 #endif  // defined(DEBUG)
   // No store buffer update.
 }
 
 
@@ skipping 10 matching lines @@
 }
 
 
 void Assembler::StoreIntoObjectNoBarrier(Register object,
                                          const Address& dest,
                                          const Object& value) {
   ASSERT(value.IsSmi() || value.InVMHeap() ||
          (value.IsOld() && value.IsNotTemporaryScopedHandle()));
   // No store buffer update.
   LoadObject(IP, value);
-  str(IP, dest);
+  VerifiedWrite(dest, IP);
 }
 
 
 void Assembler::StoreIntoObjectNoBarrierOffset(Register object,
                                                int32_t offset,
                                                const Object& value) {
   int32_t ignored = 0;
   if (Address::CanHoldStoreOffset(kWord, offset - kHeapObjectTag, &ignored)) {
     StoreIntoObjectNoBarrier(object, FieldAddress(object, offset), value);
   } else {
     AddImmediate(IP, object, offset - kHeapObjectTag);
     StoreIntoObjectNoBarrier(object, Address(IP), value);
   }
 }
 
 
 void Assembler::InitializeFieldsNoBarrier(Register object,
                                           Register begin,
                                           Register end,
                                           Register value_even,
                                           Register value_odd) {
   ASSERT(value_odd == value_even + 1);
   Label init_loop;
   Bind(&init_loop);
   AddImmediate(begin, 2 * kWordSize);
   cmp(begin, Operand(end));
-  strd(value_even, Address(begin, -2 * kWordSize), LS);
+  WriteShadowedFieldPair(begin, -2 * kWordSize, value_even, value_odd, LS);
   b(&init_loop, CC);
-  str(value_even, Address(begin, -2 * kWordSize), HI);
+  WriteShadowedField(begin, -2 * kWordSize, value_even, HI);
 #if defined(DEBUG)
   Label done;
   StoreIntoObjectFilter(object, value_even, &done);
   StoreIntoObjectFilter(object, value_odd, &done);
   Stop("Store buffer update is required");
   Bind(&done);
 #endif  // defined(DEBUG)
   // No store buffer update.
 }
 
 
 void Assembler::InitializeFieldsNoBarrierUnrolled(Register object,
-                                                  Register begin,
-                                                  intptr_t count,
+                                                  Register base,
+                                                  intptr_t begin_offset,
+                                                  intptr_t end_offset,
                                                   Register value_even,
                                                   Register value_odd) {
   ASSERT(value_odd == value_even + 1);
-  intptr_t current_offset = 0;
-  const intptr_t end_offset = count * kWordSize;
+  intptr_t current_offset = begin_offset;
   while (current_offset + kWordSize < end_offset) {
-    strd(value_even, Address(begin, current_offset));
+    WriteShadowedFieldPair(base, current_offset, value_even, value_odd);
     current_offset += 2*kWordSize;
   }
   while (current_offset < end_offset) {
-    str(value_even, Address(begin, current_offset));
+    WriteShadowedField(base, current_offset, value_even);
     current_offset += kWordSize;
   }
 #if defined(DEBUG)
   Label done;
   StoreIntoObjectFilter(object, value_even, &done);
   StoreIntoObjectFilter(object, value_odd, &done);
   Stop("Store buffer update is required");
   Bind(&done);
 #endif  // defined(DEBUG)
   // No store buffer update.
 }
 
 
+void Assembler::StoreIntoSmiField(const Address& dest, Register value) {
+  // TODO(koda): Verify previous value was Smi.
+  VerifiedWrite(dest, value);
+#if defined(DEBUG)
+  Label done;
+  tst(value, Operand(kHeapObjectTag));
+  b(&done, EQ);
+  Stop("Smi expected");
+  Bind(&done);
+#endif  // defined(DEBUG)
+}
+
+
 void Assembler::LoadClassId(Register result, Register object, Condition cond) {
   ASSERT(RawObject::kClassIdTagPos == 16);
   ASSERT(RawObject::kClassIdTagSize == 16);
   const intptr_t class_id_offset = Object::tags_offset() +
       RawObject::kClassIdTagPos / kBitsPerByte;
   ldrh(result, FieldAddress(object, class_id_offset), cond);
 }
 
 
 void Assembler::LoadClassById(Register result, Register class_id) {
@@ skipping 1674 matching lines @@
 
 
 const char* Assembler::FpuRegisterName(FpuRegister reg) {
   ASSERT((0 <= reg) && (reg < kNumberOfFpuRegisters));
   return fpu_reg_names[reg];
 }
 
 }  // namespace dart
 
 #endif  // defined TARGET_ARCH_ARM