Move IncrementalRecordWrite to a stub.

src/ia32/macro-assembler-ia32.cc

 // 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 31 matching lines @@
 // MacroAssembler implementation.
 
 MacroAssembler::MacroAssembler(void* buffer, int size)
     : Assembler(buffer, size),
       generating_stub_(false),
       allow_stub_calls_(true),
       code_object_(Heap::undefined_value()) {
 }
 
 
+void MacroAssembler::IncrementalMarkingRecordWriteHelper(Register object,
+                                                         Register value,
+                                                         Register scratch,
+                                                         ObjectMode object_mode,
+                                                         ValueMode value_mode,
+                                                         ScratchMode scratch_mode) {
+  ASSERT(!object.is(scratch));
+  ASSERT(!value.is(scratch));
+  ASSERT(!value.is(object));
+
+  bool preserve[Register::kNumRegisters];
+
+  for (int i = 0; i < Register::kNumRegisters; i++) preserve[i] = false;
+
+  preserve[eax.code()] = true;
+  preserve[ecx.code()] = true;
+  preserve[edx.code()] = true;
+  preserve[object.code()] = (object_mode == PRESERVE_OBJECT);
+  preserve[value.code()] = (value_mode == PRESERVE_VALUE);
+  preserve[scratch.code()] = (scratch_mode == PRESERVE_SCRATCH);
+
+  for (int i = 0; i < Register::kNumRegisters; i++) {
+    if (preserve[i]) push(Register::from_code(i));

[Erik Corry, 2011/03/02 12:34:06]

SSE2 registers?

+  }
+
+  PrepareCallCFunction(2, scratch);
+  mov(Operand(esp, 0 * kPointerSize), object);
+  mov(Operand(esp, 1 * kPointerSize), value);
+  CallCFunction(
+      ExternalReference::incremental_marking_record_write_function(), 2);
+
+  for (int i = Register::kNumRegisters - 1; i >= 0; i--) {
+    if (preserve[i]) pop(Register::from_code(i));
+  }
+

[Erik Corry, 2011/03/02 12:34:06]

Extra blank line.

[Vyacheslav Egorov (Chromium), 2011/03/02 15:11:32]

Done.

+}
+
+
 void MacroAssembler::IncrementalMarkingRecordWrite(Register object,
                                                    Register value,
-                                                   Register scratch) {
-  ASSERT(!object.is(scratch));
-  ASSERT(!value.is(scratch));
-  push(eax);
-  push(ecx);
-  push(edx);
-  PrepareCallCFunction(2, scratch);
-  mov(Operand(esp, 0 * kPointerSize), object);
-  mov(Operand(esp, 1 * kPointerSize), value);
-  CallCFunction(
-      ExternalReference::incremental_marking_record_write_function(), 2);
-  pop(edx);
-  pop(ecx);
-  pop(eax);
+                                                   Register scratch,
+                                                   SmiCheck smi_check,
+                                                   ObjectMode object_mode,
+                                                   ValueMode value_mode,
+                                                   ScratchMode scratch_mode) {
+  if (FLAG_incremental_marking) {
+    Label done;
+
+    if (smi_check == INLINE_SMI_CHECK) {
+      ASSERT_EQ(0, kSmiTag);
+      test(value, Immediate(kSmiTagMask));
+      j(zero, &done);
+    }
+
+    IncrementalMarkingRecordWriteStub stub(
+        object, value, scratch, object_mode, value_mode, scratch_mode);
+    CallStub(&stub);
+
+    if (smi_check == INLINE_SMI_CHECK) {
+      bind(&done);
+    }
+  }
 }
 

[Erik Corry, 2011/03/02 12:34:06]

Extra blank line.

[Vyacheslav Egorov (Chromium), 2011/03/02 15:11:32]

Done.

 
+
 void MacroAssembler::RecordWriteHelper(Register object,
                                        Register addr,
                                        Register scratch,
                                        SaveFPRegsMode save_fp) {
   if (FLAG_debug_code) {
     // Check that the object is not in new space.
     Label not_in_new_space;
     InNewSpace(object, scratch, not_equal, &not_in_new_space);
     Abort("new-space object passed to RecordWriteHelper");
     bind(&not_in_new_space);
@@ skipping 27 matching lines @@
                                  SaveFPRegsMode save_fp) {
   // First, check if a write barrier is even needed. The tests below
   // catch stores of Smis and stores into young gen.
   Label done;
 
   // Skip barrier if writing a smi.
   ASSERT_EQ(0, kSmiTag);
   test(value, Immediate(kSmiTagMask));
   j(zero, &done);
 
-  IncrementalMarkingRecordWrite(object, value, scratch);
+  IncrementalMarkingRecordWrite(object,
+                                value,
+                                scratch,
+                                OMIT_SMI_CHECK,
+                                PRESERVE_OBJECT,
+                                DESTROY_VALUE,
+                                (offset == 0) ? PRESERVE_SCRATCH : DESTROY_SCRATCH);
 
   InNewSpace(object, value, equal, &done);
 
   // The offset is relative to a tagged or untagged HeapObject pointer,
   // so either offset or offset + kHeapObjectTag must be a
   // multiple of kPointerSize.
   ASSERT(IsAligned(offset, kPointerSize) ||
          IsAligned(offset + kHeapObjectTag, kPointerSize));
 
   Register dst = scratch;
@@ skipping 1901 matching lines @@
 
   // Check that the code was patched as expected.
   ASSERT(masm_.pc_ == address_ + size_);
   ASSERT(masm_.reloc_info_writer.pos() == address_ + size_ + Assembler::kGap);
 }
 
 
 } }  // namespace v8::internal
 
 #endif  // V8_TARGET_ARCH_IA32