Incremental mode now works for x64. The only difference

src/x64/code-stubs-x64.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 280 matching lines @@
   __ bind(&true_result);
   __ Set(rax, 1);
   __ ret(1 * kPointerSize);
   __ bind(&false_result);
   __ Set(rax, 0);
   __ ret(1 * kPointerSize);
 }
 
 
 void StoreBufferOverflowStub::Generate(MacroAssembler* masm) {
-  // We don't allow a GC during a store buffer overflow so there is no need to
-  // store the registers in any particular way, but we do have to store and
-  // restore them.
-  Register saved_regs[] =
-      { rax, rcx, rdx, rbx, rbp, rsi, rdi, r8, r9, r10, r11 };
-  const int kNumberOfSavedRegs = sizeof(saved_regs) / sizeof(Register);
-  for (int i = 0; i < kNumberOfSavedRegs; i++) {
-    __ push(saved_regs[i]);
-  }
-  // R12 to r15 are callee save on all platforms.
-  if (save_doubles_ == kSaveFPRegs) {
-    CpuFeatures::Scope scope(SSE2);
-    __ subq(rsp, Immediate(kDoubleSize * XMMRegister::kNumRegisters));
-    for (int i = 0; i < XMMRegister::kNumRegisters; i++) {
-      XMMRegister reg = XMMRegister::from_code(i);
-      __ movsd(Operand(rsp, i * kDoubleSize), reg);
-    }
-  }
+  __ PushCallerSaved(save_doubles_);
   const int argument_count = 1;
   __ PrepareCallCFunction(argument_count);
 #ifdef _WIN64
   __ LoadAddress(rcx, ExternalReference::isolate_address());
 #else
   __ LoadAddress(rdi, ExternalReference::isolate_address());
 #endif
   __ CallCFunction(
       ExternalReference::store_buffer_overflow_function(masm->isolate()),
       argument_count);
-  if (save_doubles_ == kSaveFPRegs) {
-    CpuFeatures::Scope scope(SSE2);
-    for (int i = 0; i < XMMRegister::kNumRegisters; i++) {
-      XMMRegister reg = XMMRegister::from_code(i);
-      __ movsd(reg, Operand(rsp, i * kDoubleSize));
-    }
-    __ addq(rsp, Immediate(kDoubleSize * XMMRegister::kNumRegisters));
-  }
-  for (int i = kNumberOfSavedRegs - 1; i >= 0; i--) {
-    __ pop(saved_regs[i]);
-  }
+  __ PopCallerSaved(save_doubles_);
   __ ret(0);
 }
 
 
 class FloatingPointHelper : public AllStatic {
  public:
   // Load the operands from rdx and rax into xmm0 and xmm1, as doubles.
   // If the operands are not both numbers, jump to not_numbers.
   // Leaves rdx and rax unchanged.  SmiOperands assumes both are smis.
   // NumberOperands assumes both are smis or heap numbers.
@@ skipping 4849 matching lines @@
   }
 
   if (remembered_set_action_ == EMIT_REMEMBERED_SET) {
     __ RememberedSetHelper(
         address_, value_, save_fp_regs_mode_, MacroAssembler::kReturnAtEnd);
   } else {
     __ ret(0);
   }
 
   __ bind(&skip_non_incremental_part);
-  __ int3();
+  GenerateIncremental(masm);
+}
+
+
+void RecordWriteStub::GenerateIncremental(MacroAssembler* masm) {
+  regs_.Save(masm);
+
+  if (remembered_set_action_ == EMIT_REMEMBERED_SET) {
+    Label dont_need_remembered_set;
+
+    __ movq(regs_.scratch0(), Operand(regs_.address(), 0));
+    __ JumpIfNotInNewSpace(regs_.scratch0(),
+                           regs_.scratch0(),
+                           &dont_need_remembered_set);
+
+    __ CheckPageFlag(regs_.object(),
+                     regs_.scratch0(),
+                     MemoryChunk::SCAN_ON_SCAVENGE,
+                     not_zero,
+                     &dont_need_remembered_set);
+
+    // First notify the incremental marker if necessary, then update the
+    // remembered set.
+    CheckNeedsToInformIncrementalMarker(
+        masm, kRememberedSetOnNoNeedToInformIncrementalMarker);
+    InformIncrementalMarker(masm);
+    regs_.Restore(masm);
+    __ RememberedSetHelper(
+        address_, value_, save_fp_regs_mode_, MacroAssembler::kReturnAtEnd);
+
+    __ bind(&dont_need_remembered_set);
+  }
+
+  CheckNeedsToInformIncrementalMarker(
+      masm, kReturnOnNoNeedToInformIncrementalMarker);
+  InformIncrementalMarker(masm);
+  regs_.Restore(masm);
+  __ ret(0);
+}
+
+
+void RecordWriteStub::InformIncrementalMarker(MacroAssembler* masm) {
+  regs_.SaveCallerSaveRegisters(masm, save_fp_regs_mode_);
+#ifdef _WIN64
+  Register arg3 = r8;
+  Register arg2 = rdx;
+  Register arg1 = rcx;
+#else
+  Register arg3 = rdx;
+  Register arg2 = rsi;
+  Register arg1 = rdi;
+#endif
+  bool save_address = arg1.is(regs_.address());
+  if (save_address) __ push(regs_.address());

[Lasse Reichstein, 2011/06/10 13:55:44]

Put braces around then-block.
Don't trust that __ is a single expression macro (it could be doing coverage
analysis at some point again).

Is there no spare register to use instead of the stack?

[Erik Corry, 2011/06/10 21:57:29]

Done.
Changed to use arg3.

+  __ Move(arg1, regs_.object());
+  if (save_address) {
+    __ pop(arg2);
+    __ movq(arg2, Operand(arg2, 0));
+  } else {
+    __ movq(arg2, Operand(regs_.address(), 0));
+  }
+  __ LoadAddress(arg3, ExternalReference::isolate_address());
+  // TODO(gc): Create a fast version of this C function that does not duplicate
+  // the checks done in the stub.
+  int argument_count = 3;
+  __ PrepareCallCFunction(argument_count);
+  __ CallCFunction(
+      ExternalReference::incremental_marking_record_write_function(
+          masm->isolate()),
+      argument_count);
+  regs_.RestoreCallerSaveRegisters(masm, save_fp_regs_mode_);
+}
+
+
+void RecordWriteStub::CheckNeedsToInformIncrementalMarker(
+    MacroAssembler* masm,
+    RecordWriteStub::OnNoNeedToInformIncrementalMarker on_no_need) {
+  Label object_is_black;
+
+  // Let's look at the color of the object:  If it is not black we don't have
+  // to inform the incremental marker.
+  __ IsBlack(regs_.object(),
+             regs_.scratch0(),
+             regs_.scratch1(),
+             &object_is_black,
+             Label::kNear);
+
+  regs_.Restore(masm);
+  if (on_no_need == kRememberedSetOnNoNeedToInformIncrementalMarker) {
+    __ RememberedSetHelper(
+        address_, value_, save_fp_regs_mode_, MacroAssembler::kReturnAtEnd);
+  } else {
+    __ ret(0);
+  }
+
+  __ bind(&object_is_black);
+
+  // TODO(gc): Add call to EnsureNotWhite here.
+  // Fall through when we need to inform the incremental marker.
 }
 
 
 #undef __
 
 } }  // namespace v8::internal
 
 #endif  // V8_TARGET_ARCH_X64