Call a stub for the write barrier on ARM. This is a step

src/arm/macro-assembler-arm.h

 // Copyright 2011 the V8 project authors. All rights reserved.
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 //
 //     * Redistributions of source code must retain the above copyright
 //       notice, this list of conditions and the following disclaimer.
 //     * Redistributions in binary form must reproduce the above
 //       copyright notice, this list of conditions and the following
 //       disclaimer in the documentation and/or other materials provided
@@ skipping 63 matching lines @@
   NO_OBJECT_TO_DOUBLE_FLAGS = 0,
   // Object is known to be a non smi.
   OBJECT_NOT_SMI = 1 << 0,
   // Don't load NaNs or infinities, branch to the non number case instead.
   AVOID_NANS_AND_INFINITIES = 1 << 1
 };
 
 
 enum RememberedSetAction { EMIT_REMEMBERED_SET, OMIT_REMEMBERED_SET };
 enum SmiCheck { INLINE_SMI_CHECK, OMIT_SMI_CHECK };
+enum LinkRegisterStatus { kLRHasNotBeenSaved, kLRHasBeenSaved };
 
 
 bool Aliasing(Register r1, Register r2, Register r3, Register r4);
 
 
 // MacroAssembler implements a collection of frequently used macros.
 class MacroAssembler: public Assembler {
  public:
   // The isolate parameter can be NULL if the macro assembler should
   // not use isolate-dependent functionality. In this case, it's the
@@ skipping 63 matching lines @@
   void SmiJumpTable(Register index, Vector<Label*> targets);
   // Load an object from the root table.
   void LoadRoot(Register destination,
                 Heap::RootListIndex index,
                 Condition cond = al);
   // Store an object to the root table.
   void StoreRoot(Register source,
                  Heap::RootListIndex index,
                  Condition cond = al);
 
-  // Enters the address into the store buffer.  RememberedSetHelper only works
-  // if the address is not in new space.
-  void RememberedSetHelper(Register address,
+  // ---------------------------------------------------------------------------
+  // GC Support
+
+  void IncrementalMarkingRecordWriteHelper(Register object,
+                                           Register value,
+                                           Register address);
+
+  enum RememberedSetFinalAction {
+    kReturnAtEnd,
+    kFallThroughAtEnd
+  };
+
+  // For page containing |object| mark region covering |addr| dirty.
+  // RememberedSetHelper only works if the object is not in new
+  // space.
+  void RememberedSetHelper(Register addr,
                            Register scratch,
-                           SaveFPRegsMode save_fp);
+                           SaveFPRegsMode save_fp,
+                           RememberedSetFinalAction and_then);
+
+  void CheckPageFlag(Register object,
+                     Register scratch,
+                     MemoryChunk::MemoryChunkFlags flag,
+                     Condition cc,
+                     Label* condition_met);
 
   // Check if object is in new space.
   // scratch can be object itself, but it will be clobbered.
   void InNewSpace(Register object,
                   Register scratch,
                   Condition cond,  // eq for new space, ne otherwise.
                   Label* branch);
 
-  void CheckPageFlag(Register object,
-                     Register scratch,
-                     MemoryChunk::MemoryChunkFlags flag,
-                     Condition cc,
-                     Label* condition_met);
+  // Check if an object has a given incremental marking color.  Also uses ecx!
+  // The color bits are found by splitting the address at the bit offset
+  // indicated by the mask: bits that are zero in the mask are used for the
+  // address of the bitmap, and bits that are one in the mask are used for the
+  // index of the bit.
+  void HasColor(Register object,
+                Register scratch0,
+                Register scratch1,
+                Label* has_color,
+                int first_bit,
+                int second_bit);
+
+  void IsBlack(Register object,
+               Register scratch0,
+               Register scratch1,
+               Label* is_black);
+
+  // Checks the color of an object.  If the object is already grey or black
+  // then we just fall through, since it is already live.  If it is white and
+  // we can determine that it doesn't need to be scanned, then we just mark it
+  // black and fall through.  For the rest we jump to the label so the
+  // incremental marker can fix its assumptions.
+  void EnsureNotWhite(Register object,
+                      Register scratch1,
+                      Register scratch2,
+                      Label* object_is_white_and_not_data,
+                      Label::Distance distance);
+
+  // Checks whether an object is data-only, ie it does need to be scanned by the
+  // garbage collector.
+  void IsDataObject(Register value,
+                    Register scratch,
+                    Label* not_data_object,
+                    Label::Distance not_data_object_distance);
 
   // Notify the garbage collector that we wrote a pointer into an object.
   // |object| is the object being stored into, |value| is the object being
   // stored.  All registers are clobbered by the operation.  RecordWriteField
   // filters out smis so it does not update the write barrier if the value is a
   // smi.  The offset is the offset from the start of the object, not the offset
   // from the tagged HeapObject pointer.  For use with
   // FieldMemOperand(reg, off)
   void RecordWriteField(
       Register object,
       int offset,
       Register value,
       Register scratch,
+      LinkRegisterStatus lr_status,
       SaveFPRegsMode save_fp,
       RememberedSetAction remembered_set_action = EMIT_REMEMBERED_SET,
       SmiCheck smi_check = INLINE_SMI_CHECK);
 
   // As above, but the offset has the tag presubtracted.  For use with
   // MemOperand(reg, off).
   inline void RecordWriteContextSlot(
       Register context,
       int offset,
       Register value,
       Register scratch,
+      LinkRegisterStatus lr_status,
       SaveFPRegsMode save_fp,
       RememberedSetAction remembered_set_action = EMIT_REMEMBERED_SET,
       SmiCheck smi_check = INLINE_SMI_CHECK) {
     RecordWriteField(context,
                      offset + kHeapObjectTag,
                      value,
                      scratch,
+                     lr_status,
                      save_fp,
                      remembered_set_action,
                      smi_check);
   }
 
   // For a given |object| notify the garbage collector that the slot |address|
   // has been written.  |value| is the object being stored. The value and
   // address registers are clobbered by the operation.
   void RecordWrite(
       Register object,
       Register address,
       Register value,
+      LinkRegisterStatus lr_status,
       SaveFPRegsMode save_fp,
       RememberedSetAction remembered_set_action = EMIT_REMEMBERED_SET,
       SmiCheck smi_check = INLINE_SMI_CHECK);
 
   // Push two registers.  Pushes leftmost register first (to highest address).
   void Push(Register src1, Register src2, Condition cond = al) {
     ASSERT(!src1.is(src2));
     if (src1.code() > src2.code()) {
       stm(db_w, sp, src1.bit() | src2.bit(), cond);
     } else {
@@ skipping 841 matching lines @@
   // Activation support.
   void EnterFrame(StackFrame::Type type);
   void LeaveFrame(StackFrame::Type type);
 
   void InitializeNewString(Register string,
                            Register length,
                            Heap::RootListIndex map_index,
                            Register scratch1,
                            Register scratch2);
 
+  // Helper for finding the mark bits for an address.  Afterwards, the
+  // bitmap register points at the word with the mark bits and the mask
+  // the position of the first bit.  Uses ecx as scratch and leaves addr_reg
+  // unchanged.
+  inline void GetMarkBits(Register addr_reg,
+                          Register bitmap_reg,
+                          Register mask_reg);
+
   // Compute memory operands for safepoint stack slots.
   static int SafepointRegisterStackIndex(int reg_code);
   MemOperand SafepointRegisterSlot(Register reg);
   MemOperand SafepointRegistersAndDoublesSlot(Register reg);
 
   bool generating_stub_;
   bool allow_stub_calls_;
   // This handle will be patched with the code object on installation.
   Handle<Object> code_object_;
 
@@ skipping 55 matching lines @@
 #define __FILE_LINE__ __FILE__ ":" CODE_COVERAGE_TOSTRING(__LINE__)
 #define ACCESS_MASM(masm) masm->stop(__FILE_LINE__); masm->
 #else
 #define ACCESS_MASM(masm) masm->
 #endif
 
 
 } }  // namespace v8::internal
 
 #endif  // V8_ARM_MACRO_ASSEMBLER_ARM_H_