ARM port of r42723.

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"  // NOLINT
 #if defined(TARGET_ARCH_ARM)
 
 #include "vm/assembler.h"
 #include "vm/cpu.h"
 #include "vm/longjump.h"
@@ skipping 1682 matching lines @@
 
 
 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) {
+void Assembler::VerifiedWrite(const Address& address,
+                              Register new_value,
+                              FieldContent old_content) {
+#if defined(DEBUG)
+  ASSERT(address.mode() == Address::Offset ||
+         address.mode() == Address::NegOffset);
+  // Allocate temporary registers (and check for register collisions).
+  RegList used = 0;
+  UseRegister(new_value, &used);
+  Register base = UseRegister(address.rn(), &used);
+  if (address.rm() != kNoRegister) UseRegister(address.rm(), &used);

[Ivan Posva, 2015/01/16 06:34:48]

{

}

[koda, 2015/01/16 16:24:32]

Done.

+  Register old_value = AllocateRegister(&used);
+  Register temp = AllocateRegister(&used);
+  PushList(used);
+  ldr(old_value, address);
+  // First check that 'old_value' contains 'old_content'.
+  // Smi test.
+  tst(old_value, Operand(kHeapObjectTag));
+  Label ok;
+  switch (old_content) {
+    case kOnlySmi:
+      b(&ok, EQ);  // Smi is OK.
+      Stop("Expected smi.");
+      break;
+    case kHeapObjectOrSmi:
+      b(&ok, EQ);  // Smi is OK.
+      // Non-smi case: Verify object pointer is word-aligned when untagged.
+      COMPILE_ASSERT(kHeapObjectTag == 1);
+      tst(old_value, Operand((kWordSize - 1) - kHeapObjectTag));
+      b(&ok, EQ);
+      Stop("Expected heap object or Smi");
+      break;
+    case kEmptyOrSmiOrNull:
+      b(&ok, EQ);  // Smi is OK.
+      // Non-smi case: Check for the special zap word or null.
+      // Note: Cannot use CompareImmediate, since IP may be in use.
+      LoadImmediate(temp, Heap::kZap32Bits);
+      cmp(old_value, Operand(temp));
+      b(&ok, EQ);
+      LoadImmediate(temp, reinterpret_cast<uint32_t>(Object::null()));
+      cmp(old_value, Operand(temp));
+      b(&ok, EQ);
+      Stop("Expected zapped, Smi or null");
+      break;
+    default:
+      UNREACHABLE();
+  }
+  Bind(&ok);
   if (VerifiedMemory::enabled()) {
-    ASSERT(address.mode() == Address::Offset ||
-           address.mode() == Address::NegOffset);
-    // Allocate temporary registers (and check for register collisions).
-    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);
-    Register shadow_value = AllocateRegister(&used);
-    PushList(used);
-    // Verify old value.
-    ldr(old_value, address);
     Operand shadow_offset(GetVerifiedMemoryShadow());
+    // Adjust the address to shadow.
     add(base, base, shadow_offset);
-    ldr(shadow_value, address);
-    cmp(old_value, Operand(shadow_value));
-    Label ok;
-    b(&ok);
+    ldr(temp, address);
+    cmp(old_value, Operand(temp));
+    Label match;
+    b(&match, EQ);
     Stop("Write barrier verification failed");
-    Bind(&ok);
-    // Write new value.
+    Bind(&match);
+    // Write new value in shadow.
     str(new_value, address);
+    // Restore original address.
     sub(base, base, shadow_offset);
-    str(new_value, address);
-    PopList(used);
-  } else {
-    str(new_value, address);
   }
+  str(new_value, address);
+  PopList(used);
+#else
+  str(new_value, address);
+#endif  // DEBUG
 }
 
 
 void Assembler::StoreIntoObject(Register object,
                                 const Address& dest,
                                 Register value,
                                 bool can_value_be_smi) {
   ASSERT(object != value);
-  VerifiedWrite(dest, value);
+  VerifiedWrite(dest, value, kHeapObjectOrSmi);
   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 19 matching lines @@
         object, FieldAddress(object, offset), value, can_value_be_smi);
   } 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) {
-  VerifiedWrite(dest, value);
+                                         Register value,
+                                         FieldContent old_content) {
+  VerifiedWrite(dest, value, old_content);
 #if defined(DEBUG)
   Label done;
   StoreIntoObjectFilter(object, value, &done);
   Stop("Store buffer update is required");
   Bind(&done);
 #endif  // defined(DEBUG)
   // No store buffer update.
 }
 
 
 void Assembler::StoreIntoObjectNoBarrierOffset(Register object,
                                                int32_t offset,
-                                               Register value) {
+                                               Register value,
+                                               FieldContent old_content) {
   int32_t ignored = 0;
   if (Address::CanHoldStoreOffset(kWord, offset - kHeapObjectTag, &ignored)) {
-    StoreIntoObjectNoBarrier(object, FieldAddress(object, offset), value);
+    StoreIntoObjectNoBarrier(object, FieldAddress(object, offset), value,
+                             old_content);
   } else {
     AddImmediate(IP, object, offset - kHeapObjectTag);
-    StoreIntoObjectNoBarrier(object, Address(IP), value);
+    StoreIntoObjectNoBarrier(object, Address(IP), value, old_content);
   }
 }
 
 
 void Assembler::StoreIntoObjectNoBarrier(Register object,
                                          const Address& dest,
-                                         const Object& value) {
+                                         const Object& value,
+                                         FieldContent old_content) {
   ASSERT(value.IsSmi() || value.InVMHeap() ||
          (value.IsOld() && value.IsNotTemporaryScopedHandle()));
   // No store buffer update.
   LoadObject(IP, value);
-  VerifiedWrite(dest, IP);
+  VerifiedWrite(dest, IP, old_content);
 }
 
 
 void Assembler::StoreIntoObjectNoBarrierOffset(Register object,
                                                int32_t offset,
-                                               const Object& value) {
+                                               const Object& value,
+                                               FieldContent old_content) {
   int32_t ignored = 0;
   if (Address::CanHoldStoreOffset(kWord, offset - kHeapObjectTag, &ignored)) {
-    StoreIntoObjectNoBarrier(object, FieldAddress(object, offset), value);
+    StoreIntoObjectNoBarrier(object, FieldAddress(object, offset), value,
+                             old_content);
   } else {
     AddImmediate(IP, object, offset - kHeapObjectTag);
-    StoreIntoObjectNoBarrier(object, Address(IP), value);
+    StoreIntoObjectNoBarrier(object, Address(IP), value, old_content);
   }
 }
 
 
 void Assembler::InitializeFieldsNoBarrier(Register object,
                                           Register begin,
                                           Register end,
                                           Register value_even,
                                           Register value_odd) {
   ASSERT(value_odd == value_even + 1);
@@ skipping 36 matching lines @@
   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");
+  Stop("New value must be Smi.");
   Bind(&done);
 #endif  // defined(DEBUG)
+  VerifiedWrite(dest, value, kOnlySmi);
 }
 
 
 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);
 }
@@ skipping 1720 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