Write-barrier verification on ARM.

runtime/vm/stub_code_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/code_generator.h"
 #include "vm/cpu.h"
@@ skipping 899 matching lines @@
     // R6: allocation stats address.
     __ str(R1, FieldAddress(R0, Context::num_variables_offset()));
 
     // Setup the parent field.
     // R0: new object.
     // R1: number of context variables.
     // R2: object size.
     // R3: next object start.
     // R6: allocation stats address.
     __ LoadImmediate(R4, reinterpret_cast<intptr_t>(Object::null()));
+    __ StoreIntoObjectNoBarrier(R0, FieldAddress(R0, Context::parent_offset()),
+                                R3);
     __ str(R4, FieldAddress(R0, Context::parent_offset()));
 
     // Initialize the context variables.
     // R0: new object.
     // R1: number of context variables.
     // R2: object size.
     // R3: next object start.
     // R4, R5: raw null.
     // R6: allocation stats address.
     Label loop;
@@ skipping 163 matching lines @@
 
     // Initialize the remaining words of the object.
     __ LoadImmediate(R2, reinterpret_cast<intptr_t>(Object::null()));
 
     // R2: raw null.
     // R0: new object (tagged).
     // R1: next object start.
     // R5: allocation stats table.
     // First try inlining the initialization without a loop.
     if (instance_size < (kInlineInstanceSize * kWordSize)) {
-      // Check if the object contains any non-header fields.
       // Small objects are initialized using a consecutive set of writes.
-      intptr_t current_offset = Instance::NextFieldOffset();
-      // Write two nulls at a time.
-      if (instance_size >= 2 * kWordSize) {
+      intptr_t begin_offset = Instance::NextFieldOffset() - kHeapObjectTag;
+      intptr_t end_offset = instance_size - kHeapObjectTag;
+      // Save one move if less than two fields.
+      if ((end_offset - begin_offset) >= (2 * kWordSize)) {
         __ mov(R3, Operand(R2));
-        while (current_offset + kWordSize < instance_size) {
-          __ StoreToOffset(kWordPair, R2, R0, current_offset - kHeapObjectTag);
-          current_offset += 2 * kWordSize;
-        }
       }
-      // Write remainder.
-      while (current_offset < instance_size) {
-        __ StoreToOffset(kWord, R2, R0, current_offset - kHeapObjectTag);
-        current_offset += kWordSize;
-      }
+      __ InitializeFieldsNoBarrierUnrolled(R0, R0, begin_offset, end_offset,
+                                           R2, R3);
     } else {
       // There are more than kInlineInstanceSize(12) fields
       __ add(R4, R0, Operand(Instance::NextFieldOffset() - kHeapObjectTag));
       __ mov(R3, Operand(R2));
       // Loop until the whole object is initialized.
       // R2: raw null.
       // R3: raw null.
       // R0: new object (tagged).
       // R1: next object start.
       // R4: next word to be initialized.
       // R5: allocation stats table.
       __ InitializeFieldsNoBarrier(R0, R4, R1, R2, R3);
     }
     if (is_cls_parameterized) {
       // Set the type arguments in the new object.
       __ ldr(R4, Address(SP, 0));
-      __ StoreToOffset(kWord, R4,
-                       R0, cls.type_arguments_field_offset() - kHeapObjectTag);
+      FieldAddress type_args(R0, cls.type_arguments_field_offset());
+      __ StoreIntoObjectNoBarrier(R0, type_args, R4);
     }
 
     // Done allocating and initializing the instance.
     // R0: new object (tagged).
     // R5: allocation stats table.
 
     // Update allocation stats.
     __ IncrementAllocationStats(R5, cls.id(), space);
 
     // R0: new object (tagged).
@@ skipping 149 matching lines @@
   __ b(&ok, EQ);
   __ Bind(&error);
   __ Stop("Incorrect IC data");
   __ Bind(&ok);
 #endif
   // Update counter.
   const intptr_t count_offset = ICData::CountIndexFor(num_args) * kWordSize;
   __ LoadFromOffset(kWord, R1, R6, count_offset);
   __ adds(R1, R1, Operand(Smi::RawValue(1)));
   __ LoadImmediate(R1, Smi::RawValue(Smi::kMaxValue), VS);  // Overflow.
-  __ StoreToOffset(kWord, R1, R6, count_offset);
+  __ StoreIntoSmiField(Address(R6, count_offset), R1);
   __ Ret();
 }
 
 
 // Generate inline cache check for 'num_args'.
 //  LR: return address.
 //  R5: inline cache data object.
 // Control flow:
 // - If receiver is null -> jump to IC miss.
 // - If receiver is Smi -> load Smi class.
@@ skipping 123 matching lines @@
   __ Bind(&found);
   // R6: pointer to an IC data check group.
   const intptr_t target_offset = ICData::TargetIndexFor(num_args) * kWordSize;
   const intptr_t count_offset = ICData::CountIndexFor(num_args) * kWordSize;
   __ LoadFromOffset(kWord, R0, R6, target_offset);
 
   // Update counter.
   __ LoadFromOffset(kWord, R1, R6, count_offset);
   __ adds(R1, R1, Operand(Smi::RawValue(1)));
   __ LoadImmediate(R1, Smi::RawValue(Smi::kMaxValue), VS);  // Overflow.
-  __ StoreToOffset(kWord, R1, R6, count_offset);
+  __ StoreIntoSmiField(Address(R6, count_offset), R1);
 
   __ Bind(&call_target_function);
   // R0: target function.
   __ ldr(R2, FieldAddress(R0, Function::instructions_offset()));
   __ AddImmediate(R2, Instructions::HeaderSize() - kHeapObjectTag);
   __ bx(R2);
 
   __ Bind(&stepping);
   __ EnterStubFrame();
   __ Push(R5);  // Preserve IC data.
@@ skipping 112 matching lines @@
   // R6: ic_data_array with entries: target functions and count.
   __ AddImmediate(R6, R6, Array::data_offset() - kHeapObjectTag);
   // R6: points directly to the first ic data array element.
   const intptr_t target_offset = ICData::TargetIndexFor(0) * kWordSize;
   const intptr_t count_offset = ICData::CountIndexFor(0) * kWordSize;
 
   // Increment count for this call.
   __ LoadFromOffset(kWord, R1, R6, count_offset);
   __ adds(R1, R1, Operand(Smi::RawValue(1)));
   __ LoadImmediate(R1, Smi::RawValue(Smi::kMaxValue), VS);  // Overflow.
-  __ StoreToOffset(kWord, R1, R6, count_offset);
+  __ StoreIntoSmiField(Address(R6, count_offset), R1);
 
   // Load arguments descriptor into R4.
   __ ldr(R4, FieldAddress(R5, ICData::arguments_descriptor_offset()));
 
   // Get function and call it, if possible.
   __ LoadFromOffset(kWord, R0, R6, target_offset);
   __ ldr(R2, FieldAddress(R0, Function::instructions_offset()));
 
   // R0: function.
   // R2: target instructions.
@@ skipping 383 matching lines @@
   const Register right = R0;
   __ ldr(left, Address(SP, 1 * kWordSize));
   __ ldr(right, Address(SP, 0 * kWordSize));
   GenerateIdenticalWithNumberCheckStub(assembler, left, right, temp);
   __ Ret();
 }
 
 }  // namespace dart
 
 #endif  // defined TARGET_ARCH_ARM