Write buffer based write barrier for IA32 and Crankshaft. Currently...

src/ia32/macro-assembler-ia32.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 30 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()) {
 }
 
-#ifdef ENABLE_CARDMARKING_WRITE_BARRIER
 void MacroAssembler::RecordWriteHelper(Register object,
                                        Register addr,
-                                       Register scratch) {
+                                       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);
   }
 
-  // Compute the page start address from the heap object pointer, and reuse
-  // the 'object' register for it.
-  and_(object, ~Page::kPageAlignmentMask);
-
-  // Compute number of region covering addr. See Page::GetRegionNumberForAddress
-  // method for more details.
-  and_(addr, Page::kPageAlignmentMask);
-  shr(addr, Page::kRegionSizeLog2);
-
-  // Set dirty mark for region.
-  bts(Operand(object, Page::kDirtyFlagOffset), addr);
+  // Load write buffer top.
+  ExternalReference write_buffer = ExternalReference::write_buffer_top();
+  mov(scratch, Operand::StaticVariable(write_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(write_buffer), scratch);
+  // Call stub on end of buffer.
+  NearLabel no_overflow;
+  // Check for end of buffer.
+  test(scratch, Immediate(WriteBuffer::kWriteBufferOverflowBit));
+  j(equal, &no_overflow);
+  WriteBufferOverflowStub write_buffer_overflow =
+      WriteBufferOverflowStub(save_fp);
+  CallStub(&write_buffer_overflow);
+  bind(&no_overflow);
 }
 
 
 void MacroAssembler::RecordWrite(Register object,
                                  int offset,
                                  Register value,
-                                 Register scratch) {
+                                 Register scratch,
+                                 SaveFPRegsMode save_fp) {
   // The compiled code assumes that record write doesn't change the
   // context register, so we check that none of the clobbered
   // registers are esi.
   ASSERT(!object.is(esi) && !value.is(esi) && !scratch.is(esi));
 
   // First, check if a write barrier is even needed. The tests below
   // catch stores of Smis and stores into young gen.
   NearLabel done;
 
   // Skip barrier if writing a smi.
@@ skipping 14 matching lines @@
     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);
+  RecordWriteHelper(object, dst, value, save_fp);
 
   bind(&done);
 
   // Clobber all input registers when running with the debug-code flag
   // turned on to provoke errors.
   if (FLAG_debug_code) {
     mov(object, Immediate(BitCast<int32_t>(kZapValue)));
     mov(value, Immediate(BitCast<int32_t>(kZapValue)));
     mov(scratch, Immediate(BitCast<int32_t>(kZapValue)));
   }
 }
 
 
 void MacroAssembler::RecordWrite(Register object,
                                  Register address,
-                                 Register value) {
+                                 Register value,
+                                 SaveFPRegsMode save_fp) {
   // The compiled code assumes that record write doesn't change the
   // context register, so we check that none of the clobbered
   // registers are esi.
   ASSERT(!object.is(esi) && !value.is(esi) && !address.is(esi));
 
   // 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);
 
   InNewSpace(object, value, equal, &done);
 
-  RecordWriteHelper(object, address, value);
+  RecordWriteHelper(object, address, value, save_fp);
 
   bind(&done);
 
   // Clobber all input registers when running with the debug-code flag
   // turned on to provoke errors.
   if (FLAG_debug_code) {
     mov(object, Immediate(BitCast<int32_t>(kZapValue)));
     mov(address, Immediate(BitCast<int32_t>(kZapValue)));
     mov(value, Immediate(BitCast<int32_t>(kZapValue)));
   }
 }
-#endif
+
 
 #ifdef ENABLE_DEBUGGER_SUPPORT
 void MacroAssembler::DebugBreak() {
   Set(eax, Immediate(0));
   mov(ebx, Immediate(ExternalReference(Runtime::kDebugBreak)));
   CEntryStub ces(1);
   call(ces.GetCode(), RelocInfo::DEBUG_BREAK);
 }
 #endif
 
@@ skipping 204 matching lines @@
 void MacroAssembler::EnterApiExitFrame(int argc) {
   EnterExitFramePrologue();
   EnterExitFrameEpilogue(argc, false);
 }
 
 
 void MacroAssembler::LeaveExitFrame(bool save_doubles) {
   // Optionally restore all XMM registers.
   if (save_doubles) {
     CpuFeatures::Scope scope(SSE2);
-    int offset = -2 * kPointerSize;
-    for (int i = 0; i < XMMRegister::kNumRegisters; i++) {
-      XMMRegister reg = XMMRegister::from_code(i);
-      movdbl(reg, Operand(ebp, offset - ((i + 1) * kDoubleSize)));
+    if (save_doubles) {
+      int offset = -2 * kPointerSize;
+      for (int i = 0; i < XMMRegister::kNumRegisters; i++) {
+        XMMRegister reg = XMMRegister::from_code(i);
+        movdbl(reg, Operand(ebp, offset - ((i + 1) * kDoubleSize)));
+      }
+    } else if (FLAG_debug_code) {
+      // Zap all fp registers on a runtime call if we were not asked to preserve
+      // them.
+      push(eax);
+      mov(eax, Factory::nan_value());
+      for (int i = 0; i < XMMRegister::kNumRegisters; i++) {
+        XMMRegister reg = XMMRegister::from_code(i);
+        movdbl(reg, FieldOperand(eax, HeapNumber::kValueOffset));
+      }
+      pop(eax);
     }
   }
 
   // Get the return address from the stack and restore the frame pointer.
   mov(ecx, Operand(ebp, 1 * kPointerSize));
   mov(ebp, Operand(ebp, 0 * kPointerSize));
 
   // Pop the arguments and the receiver from the caller stack.
   lea(esp, Operand(esi, 1 * kPointerSize));
 
@@ skipping 686 matching lines @@
 
 void MacroAssembler::CallRuntime(Runtime::FunctionId id, int num_arguments) {
   CallRuntime(Runtime::FunctionForId(id), num_arguments);
 }
 
 
 void MacroAssembler::CallRuntimeSaveDoubles(Runtime::FunctionId id) {
   Runtime::Function* function = Runtime::FunctionForId(id);
   Set(eax, Immediate(function->nargs));
   mov(ebx, Immediate(ExternalReference(function)));
-  CEntryStub ces(1);
-  ces.SaveDoubles();
+  CEntryStub ces(1, kSaveFPRegs);
   CallStub(&ces);
 }
 
 
 MaybeObject* MacroAssembler::TryCallRuntime(Runtime::FunctionId id,
                                             int num_arguments) {
   return TryCallRuntime(Runtime::FunctionForId(id), num_arguments);
 }
 
 
@@ skipping 784 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