Write-barrier verification on ARM.

runtime/vm/intrinsifier_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"  // Needed here to get TARGET_ARCH_ARM.
 #if defined(TARGET_ARCH_ARM)
 
 #include "vm/intrinsifier.h"
 
 #include "vm/assembler.h"
@@ skipping 112 matching lines @@
   // R0: new growable array object start as a tagged pointer.
   // Store the type argument field in the growable array object.
   __ ldr(R1, Address(SP, kTypeArgumentsOffset));  // Type argument.
   __ StoreIntoObjectNoBarrier(
       R0,
       FieldAddress(R0, GrowableObjectArray::type_arguments_offset()),
       R1);
 
   // Set the length field in the growable array object to 0.
   __ LoadImmediate(R1, 0);
-  __ str(R1, FieldAddress(R0, GrowableObjectArray::length_offset()));
+  __ StoreIntoSmiField(FieldAddress(R0, GrowableObjectArray::length_offset()),
+                       R1);
   __ Ret();  // Returns the newly allocated object in R0.
 
   __ Bind(&fall_through);
 }
 
 
 void Intrinsifier::GrowableArrayGetIndexed(Assembler* assembler) {
   Label fall_through;
 
   __ ldr(R0, Address(SP, + 0 * kWordSize));  // Index
@@ skipping 40 matching lines @@
   __ StoreIntoObject(R0, FieldAddress(R1, Array::data_offset()), R2);
   __ Ret();
   __ Bind(&fall_through);
 }
 
 
 // Set length of growable object array. The length cannot
 // be greater than the length of the data container.
 // On stack: growable array (+1), length (+0).
 void Intrinsifier::GrowableArraySetLength(Assembler* assembler) {
+  Label fall_through;
   __ ldr(R0, Address(SP, 1 * kWordSize));  // Growable array.
   __ ldr(R1, Address(SP, 0 * kWordSize));  // Length value.
-  __ tst(R1, Operand(kSmiTagMask));  // Check for Smi.
-  __ str(R1, FieldAddress(R0, GrowableObjectArray::length_offset()), EQ);
-  __ bx(LR, EQ);
-  // Fall through on non-Smi.
+  __ tst(R1, Operand(kSmiTagMask));
+  __ b(&fall_through, NE);  // Non-smi length.
+  __ StoreIntoSmiField(FieldAddress(R0, GrowableObjectArray::length_offset()),
+                       R1);
+  __ Ret();
+  __ Bind(&fall_through);
 }
 
 
 // Set data of growable object array.
 // On stack: growable array (+1), data (+0).
 void Intrinsifier::GrowableArraySetData(Assembler* assembler) {
   if (FLAG_enable_type_checks) {
     return;
   }
   Label fall_through;
@@ skipping 28 matching lines @@
   // R2: data.
   __ ldr(R2, FieldAddress(R0, GrowableObjectArray::data_offset()));
   // R3: capacity.
   __ ldr(R3, FieldAddress(R2, Array::length_offset()));
   // Compare length with capacity.
   __ cmp(R1, Operand(R3));
   __ b(&fall_through, EQ);  // Must grow data.
   const int32_t value_one = reinterpret_cast<int32_t>(Smi::New(1));
   // len = len + 1;
   __ add(R3, R1, Operand(value_one));
-  __ str(R3, FieldAddress(R0, GrowableObjectArray::length_offset()));
+  __ StoreIntoSmiField(FieldAddress(R0, GrowableObjectArray::length_offset()),
+                       R3);
   __ ldr(R0, Address(SP, 0 * kWordSize));  // Value.
   ASSERT(kSmiTagShift == 1);
   __ add(R1, R2, Operand(R1, LSL, 1));
   __ StoreIntoObject(R2, FieldAddress(R1, Array::data_offset()), R0);
   const int32_t raw_null = reinterpret_cast<int32_t>(Object::null());
   __ LoadImmediate(R0, raw_null);
   __ Ret();
   __ Bind(&fall_through);
 }
 
@@ skipping 1471 matching lines @@
   __ eor(R0, R0, Operand(R0, LSR, 11));
   __ add(R0, R0, Operand(R0, LSL, 15));
   // hash_ = hash_ & ((static_cast<intptr_t>(1) << bits) - 1);
   __ LoadImmediate(R2, (static_cast<intptr_t>(1) << String::kHashBits) - 1);
   __ and_(R0, R0, Operand(R2));
   __ cmp(R0, Operand(0));
   // return hash_ == 0 ? 1 : hash_;
   __ Bind(&done);
   __ mov(R0, Operand(1), EQ);
   __ SmiTag(R0);
-  __ str(R0, FieldAddress(R1, String::hash_offset()));
+  __ StoreIntoSmiField(FieldAddress(R1, String::hash_offset()), R0);
   __ Ret();
 }
 
 
 // Allocates one-byte string of length 'end - start'. The content is not
 // initialized.
 // 'length-reg' (R2) contains tagged length.
 // Returns new string as tagged pointer in R0.
 static void TryAllocateOnebyteString(Assembler* assembler,
                                      Label* ok,
@@ skipping 52 matching lines @@
     __ orr(R3, R3, Operand(TMP));
     __ str(R3, FieldAddress(R0, String::tags_offset()));  // Store tags.
   }
 
   // Set the length field using the saved length (R6).
   __ StoreIntoObjectNoBarrier(R0,
                               FieldAddress(R0, String::length_offset()),
                               R6);
   // Clear hash.
   __ LoadImmediate(TMP, 0);
-  __ str(TMP, FieldAddress(R0, String::hash_offset()));
+  __ StoreIntoSmiField(FieldAddress(R0, String::hash_offset()), TMP);
 
   __ IncrementAllocationStatsWithSize(R4, R2, cid, space);
   __ b(ok);
 
   __ Bind(&fail);
   __ b(failure);
 }
 
 
 // Arg0: OneByteString (receiver).
@@ skipping 188 matching lines @@
   Isolate* isolate = Isolate::Current();
   __ LoadImmediate(R1, reinterpret_cast<uword>(isolate));
   // Set return value to Isolate::current_tag_.
   __ ldr(R0, Address(R1, Isolate::current_tag_offset()));
   __ Ret();
 }
 
 }  // namespace dart
 
 #endif  // defined TARGET_ARCH_ARM