ARM port of r42723.

runtime/vm/assembler_arm.h

 // 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.
 
 #ifndef VM_ASSEMBLER_ARM_H_
 #define VM_ASSEMBLER_ARM_H_
 
 #ifndef VM_ASSEMBLER_H_
 #error Do not include assembler_arm.h directly; use assembler.h instead.
 #endif
@@ skipping 624 matching lines @@
   void IntegerDivide(Register result, Register left, Register right,
                      DRegister tmpl, DRegister tmpr);
 
   // If we aren't on ARMv7, there is no smull.
   void CheckMultSignedOverflow(Register left,
                                Register right,
                                Register tmp,
                                DRegister dtmp0, DRegister dtmp1,
                                Label* overflow);
 
-  // Load and Store. May clobber IP.
+  // Load and Store.
+  // These three do not clobber IP.
   void LoadPatchableImmediate(Register rd, int32_t value, Condition cond = AL);
   void LoadDecodableImmediate(Register rd, int32_t value, Condition cond = AL);
   void LoadImmediate(Register rd, int32_t value, Condition cond = AL);
+  // These two may clobber IP.
   void LoadSImmediate(SRegister sd, float value, Condition cond = AL);
   void LoadDImmediate(DRegister dd, double value,
                       Register scratch, Condition cond = AL);
 
   void MarkExceptionHandler(Label* label);
 
   void Drop(intptr_t stack_elements);
 
   void LoadPoolPointer();
 
   void LoadIsolate(Register rd);
 
   void LoadObject(Register rd, const Object& object, Condition cond = AL);
   void PushObject(const Object& object);
   void CompareObject(Register rn, const Object& object);
 
+  // When storing into a heap object field, knowledge of the previous content
+  // is expressed through these constants.
+  enum FieldContent {
+    kEmptyOrSmiOrNull,  // Empty = garbage/zapped in release/debug mode.
+    kHeapObjectOrSmi,
+    kOnlySmi,
+  };
+
   void StoreIntoObject(Register object,  // Object we are storing into.
                        const Address& dest,  // Where we are storing into.
                        Register value,  // Value we are storing.
                        bool can_value_be_smi = true);
   void StoreIntoObjectOffset(Register object,
                              int32_t offset,
                              Register value,
                              bool can_value_be_smi = true);
 
   void StoreIntoObjectNoBarrier(Register object,
                                 const Address& dest,
-                                Register value);
-  void StoreIntoObjectNoBarrierOffset(Register object,
-                                      int32_t offset,
-                                      Register value);
+                                Register value,
+                                FieldContent old_content = kHeapObjectOrSmi);
+  void InitializeFieldNoBarrier(Register object,
+                                const Address& dest,
+                                Register value) {
+    StoreIntoObjectNoBarrier(object, dest, value, kEmptyOrSmiOrNull);
+  }
+  void StoreIntoObjectNoBarrierOffset(
+      Register object,
+      int32_t offset,
+      Register value,
+      FieldContent old_content = kHeapObjectOrSmi);
   void StoreIntoObjectNoBarrier(Register object,
                                 const Address& dest,
-                                const Object& value);
-  void StoreIntoObjectNoBarrierOffset(Register object,
-                                      int32_t offset,
-                                      const Object& value);
+                                const Object& value,
+                                FieldContent old_content = kHeapObjectOrSmi);
+  void StoreIntoObjectNoBarrierOffset(
+      Register object,
+      int32_t offset,
+      const Object& value,
+      FieldContent old_content = kHeapObjectOrSmi);
 
   // Store value_even, value_odd, value_even, ... into the words in the address
   // range [begin, end), assumed to be uninitialized fields in object (tagged).
   // The stores must not need a generational store barrier (e.g., smi/null),
   // and (value_even, value_odd) must be a valid register pair.
   // Destroys register 'begin'.
   void InitializeFieldsNoBarrier(Register object,
                                  Register begin,
                                  Register end,
                                  Register value_even,
@@ skipping 393 matching lines @@
                           intptr_t offset,
                           Register value,
                           Condition cond = AL);
   void WriteShadowedFieldPair(Register base,
                               intptr_t offset,
                               Register value_even,
                               Register value_odd,
                               Condition cond = AL);
   // Writes new_value to address and its shadow location, if enabled, after
   // verifying that its old value matches its shadow.
-  void VerifiedWrite(const Address& address, Register new_value);
+  void VerifiedWrite(const Address& address,
+                     Register new_value,
+                     FieldContent old_content);
 
   DISALLOW_ALLOCATION();
   DISALLOW_COPY_AND_ASSIGN(Assembler);
 };
 
 }  // namespace dart
 
 #endif  // VM_ASSEMBLER_ARM_H_