Fix/implement new write barrier for x64.

src/x64/code-stubs-x64.cc

 // Copyright 2010 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 237 matching lines @@
   // Return 1/0 for true/false in rax.
   __ bind(&true_result);
   __ movq(rax, Immediate(1));
   __ ret(1 * kPointerSize);
   __ bind(&false_result);
   __ Set(rax, 0);
   __ ret(1 * kPointerSize);
 }
 
 
+void WriteBufferOverflowStub::Generate(MacroAssembler* masm) {
+  // We don't allow a GC during a write buffer overflow so there is no need to
+  // store the registers in any particular way, but we do have to store and
+  // restore them.
+  __ push(rax);

[Vyacheslav Egorov (Chromium), 2011/01/06 12:35:29]

Does it make sense to make something like

static const Register register_to_save[] = {rcx, rdx, ..., r11};

then write two loops for pushing and poping?

+  __ push(rcx);
+  __ push(rdx);
+  __ push(rbx);
+  __ push(rbp);
+  __ push(rsi);
+  __ push(rdi);
+  __ push(r8);
+  __ push(r9);
+  __ push(r10);
+  __ push(r11);
+  // 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);
+    }
+  }
+  const int argument_count = 0;
+  __ PrepareCallCFunction(argument_count);
+  ExternalReference write_buffer_overflow =
+      ExternalReference(Runtime::FunctionForId(Runtime::kWriteBufferOverflow));
+  __ CallCFunction(write_buffer_overflow, 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));
+  }
+  __ pop(r11);
+  __ pop(r10);
+  __ pop(r9);
+  __ pop(r8);
+  __ pop(rdi);
+  __ pop(rsi);
+  __ pop(rbp);
+  __ pop(rbx);
+  __ pop(rdx);
+  __ pop(rcx);
+  __ pop(rax);
+  __ ret(0);
+}
+
+
 const char* GenericBinaryOpStub::GetName() {
   if (name_ != NULL) return name_;
   const int kMaxNameLength = 100;
   name_ = Bootstrapper::AllocateAutoDeletedArray(kMaxNameLength);
   if (name_ == NULL) return "OOM";
   const char* op_name = Token::Name(op_);
   const char* overwrite_name;
   switch (mode_) {
     case NO_OVERWRITE: overwrite_name = "Alloc"; break;
     case OVERWRITE_RIGHT: overwrite_name = "OverwriteRight"; break;
@@ skipping 1696 matching lines @@
 
   // rbx: last_match_info backing store (FixedArray)
   // rdx: number of capture registers
   // Store the capture count.
   __ Integer32ToSmi(kScratchRegister, rdx);
   __ movq(FieldOperand(rbx, RegExpImpl::kLastCaptureCountOffset),
           kScratchRegister);
   // Store last subject and last input.
   __ movq(rax, Operand(rsp, kSubjectOffset));
   __ movq(FieldOperand(rbx, RegExpImpl::kLastSubjectOffset), rax);
-#ifdef ENABLE_CARDMARKING_WRITE_BARRIER
   __ movq(rcx, rbx);
-  __ RecordWrite(rcx, RegExpImpl::kLastSubjectOffset, rax, rdi);
-#endif
+  __ RecordWrite(rcx,
+                 RegExpImpl::kLastSubjectOffset,
+                 rax,
+                 rdi,
+                 kDontSaveFPRegs);
   __ movq(rax, Operand(rsp, kSubjectOffset));
   __ movq(FieldOperand(rbx, RegExpImpl::kLastInputOffset), rax);
-#ifdef ENABLE_CARDMARKING_WRITE_BARRIER
   __ movq(rcx, rbx);
-  __ RecordWrite(rcx, RegExpImpl::kLastInputOffset, rax, rdi);
-#endif
+  __ RecordWrite(rcx, RegExpImpl::kLastInputOffset, rax, rdi, kDontSaveFPRegs);
 
   // Get the static offsets vector filled by the native regexp code.
   __ movq(rcx, ExternalReference::address_of_static_offsets_vector());
 
   // rbx: last_match_info backing store (FixedArray)
   // rcx: offsets vector
   // rdx: number of capture registers
   NearLabel next_capture, done;
   // Capture register counter starts from number of capture registers and
   // counts down until wraping after zero.
@@ skipping 2111 matching lines @@
 
 void ICCompareStub::GenerateMiss(MacroAssembler* masm) {
   UNIMPLEMENTED();
 }
 
 #undef __
 
 } }  // namespace v8::internal
 
 #endif  // V8_TARGET_ARCH_X64