Combine the incremental-marking write barrier and the remembered-set...

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 34 matching lines @@
     : 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));
+    Register address) {
+  ASSERT(!object.is(address));
+  ASSERT(!value.is(address));
   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);
+  preserve[object.code()] = true;
+  preserve[value.code()] = true;
+  preserve[address.code()] = true;
 
   for (int i = 0; i < Register::kNumRegisters; i++) {
     if (preserve[i]) push(Register::from_code(i));
   }
 
   // TODO(gc) we are assuming that xmm registers are not modified by
   // the C function we are calling.
-  PrepareCallCFunction(2, scratch);
+  PrepareCallCFunction(2, address);
   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));
   }
 }
 
 
-void MacroAssembler::IncrementalMarkingRecordWrite(Register object,
-                                                   Register value,
-                                                   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);
-    }
-  }
-}
-
-
-void MacroAssembler::RecordWriteHelper(Register object,
-                                       Register addr,
-                                       Register scratch,
-                                       SaveFPRegsMode save_fp) {
+void MacroAssembler::RememberedSetHelper(Register object,
+                                         Register addr,
+                                         Register scratch,
+                                         SaveFPRegsMode save_fp) {
   if (emit_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");
+    Abort("new-space object passed to RememberedSetHelper");
     bind(&not_in_new_space);
   }
 
   // Load store buffer top.
   ExternalReference store_buffer = ExternalReference::store_buffer_top();
   mov(scratch, Operand::StaticVariable(store_buffer));
   // Store pointer to buffer.
   mov(Operand(scratch, 0), addr);
   // Increment buffer top.
   add(Operand(scratch), Immediate(kPointerSize));
   // Write back new top of buffer.
   mov(Operand::StaticVariable(store_buffer), scratch);
   // Call stub on end of buffer.
   NearLabel no_overflow;
   // Check for end of buffer.
   test(scratch, Immediate(StoreBuffer::kStoreBufferOverflowBit));
   j(equal, &no_overflow);
   StoreBufferOverflowStub store_buffer_overflow =
       StoreBufferOverflowStub(save_fp);
   CallStub(&store_buffer_overflow);
   bind(&no_overflow);
 }
 
 
 void MacroAssembler::RecordWrite(Register object,
                                  int offset,
                                  Register value,
-                                 Register scratch,
+                                 Register dst,
                                  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;
+  NearLabel done;
 
   // Skip barrier if writing a smi.
   ASSERT_EQ(0, kSmiTag);
   test(value, Immediate(kSmiTagMask));
   j(zero, &done);
 
-  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;
   if (offset != 0) {
+    // If offset is unspecified, then dst is a scratch register.  We use it
+    // to store the address of the cell that is being stored to.
     lea(dst, Operand(object, offset));
   } else {
     // Array access: calculate the destination address in the same manner as
     // KeyedStoreIC::GenerateGeneric.  Multiply a smi by 2 to get an offset
     // into an array of words.
     ASSERT_EQ(1, kSmiTagSize);
     ASSERT_EQ(0, kSmiTag);
     lea(dst, Operand(object, dst, times_half_pointer_size,
                      FixedArray::kHeaderSize - kHeapObjectTag));
   }
-  RecordWriteHelper(object, dst, value, save_fp);
+
+  RecordWrite(object, dst, value, EMIT_REMEMBERED_SET, save_fp, OMIT_SMI_CHECK);
 
   bind(&done);
 
   // Clobber all input registers when running with the debug-code flag
   // turned on to provoke errors.
   if (emit_debug_code()) {
     mov(object, Immediate(BitCast<int32_t>(kZapValue)));
     mov(value, Immediate(BitCast<int32_t>(kZapValue)));
-    mov(scratch, Immediate(BitCast<int32_t>(kZapValue)));
+    mov(dst, Immediate(BitCast<int32_t>(kZapValue)));
   }
 }
 
 
 void MacroAssembler::RecordWrite(Register object,
                                  Register address,
                                  Register value,
-                                 SaveFPRegsMode save_fp) {
+                                 EmitRememberedSet emit_remembered_set,
+                                 SaveFPRegsMode fp_mode,
+                                 SmiCheck smi_check) {
+  if (emit_remembered_set == OMIT_REMEMBERED_SET &&
+      FLAG_incremental_marking == false) {
+    return;
+  }
   // First, check if a write barrier is even needed. The tests below
   // catch stores of Smis and stores into young gen.
-  Label done;
+  NearLabel done;
 
-  // Skip barrier if writing a smi.
-  ASSERT_EQ(0, kSmiTag);
-  test(value, Immediate(kSmiTagMask));
-  j(zero, &done);
+  if (smi_check == INLINE_SMI_CHECK) {
+    // Skip barrier if writing a smi.
+    ASSERT_EQ(0, kSmiTag);
+    test(value, Immediate(kSmiTagMask));
+    j(zero, &done);
+  }
 
-  IncrementalMarkingRecordWrite(object,
-                                value,
-                                address,
-                                OMIT_SMI_CHECK,
-                                PRESERVE_OBJECT,
-                                DESTROY_VALUE,
-                                PRESERVE_SCRATCH);
+  RecordWriteStub stub(object, value, address, emit_remembered_set, fp_mode);
+  CallStub(&stub);
 
-  InNewSpace(object, value, equal, &done);
-
-  RecordWriteHelper(object, address, value, save_fp);
-
-  bind(&done);
+  if (smi_check == INLINE_SMI_CHECK) {
+    bind(&done);
+  }
 
   // Clobber all input registers when running with the debug-code flag
   // turned on to provoke errors.
   if (emit_debug_code()) {
     mov(object, Immediate(BitCast<int32_t>(kZapValue)));
     mov(address, Immediate(BitCast<int32_t>(kZapValue)));
     mov(value, Immediate(BitCast<int32_t>(kZapValue)));
   }
 }
 
@@ skipping 1870 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