Make x64 to use the RecordWrite stub. This is a step towards getting

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 2409 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);
-  __ movq(rcx, rbx);
-  __ RecordWrite(rcx,
-                 RegExpImpl::kLastSubjectOffset,
-                 rax,
-                 rdi,
-                 kDontSaveFPRegs);
+  __ RecordWriteField(rbx,
+                      RegExpImpl::kLastSubjectOffset,
+                      rax,
+                      rdi,
+                      kDontSaveFPRegs);
   __ movq(rax, Operand(rsp, kSubjectOffset));
   __ movq(FieldOperand(rbx, RegExpImpl::kLastInputOffset), rax);
-  __ movq(rcx, rbx);
-  __ RecordWrite(rcx, RegExpImpl::kLastInputOffset, rax, rdi, kDontSaveFPRegs);
+  __ RecordWriteField(rbx,
+                      RegExpImpl::kLastInputOffset,
+                      rax,
+                      rdi,
+                      kDontSaveFPRegs);
 
   // Get the static offsets vector filled by the native regexp code.
   __ LoadAddress(rcx,
                  ExternalReference::address_of_static_offsets_vector(isolate));
 
   // rbx: last_match_info backing store (FixedArray)
   // rcx: offsets vector
   // rdx: number of capture registers
   Label next_capture, done;
   // Capture register counter starts from number of capture registers and
@@ skipping 2721 matching lines @@
   __ Drop(1);
   __ ret(2 * kPointerSize);
 
   __ bind(&not_in_dictionary);
   __ movq(scratch, Immediate(0));
   __ Drop(1);
   __ ret(2 * kPointerSize);
 }
 
 
+// Takes the input in 3 registers: address_ value_ and object_.  A pointer to
+// the value has just been written into the object, now this stub makes sure
+// we keep the GC informed.  The word in the object where the value has been
+// written is in the address register.
+void RecordWriteStub::Generate(MacroAssembler* masm) {
+  Label skip_non_incremental_part;
+  __ jmp(&skip_non_incremental_part, Label::kNear);

[Lasse Reichstein, 2011/06/07 14:02:53]

But why overwrite?
Why not just:
  if (!HEAP->incremental_marking()->IsMarking()) {
    __ nop(2);
  } else {
    __ jmp(&....);
  }
And is this even safe? The label is unbound, so won't we be overwriting this
later?

[Erik Corry, 2011/06/08 10:38:55]

We will be ovewriting the opcode every time we start and end an incremental
mark-sweep collection.  The overwrite is only of the offset, not the opcode.

+  if (!HEAP->incremental_marking()->IsMarking()) {

[Lasse Reichstein, 2011/06/07 14:02:53]

HEAP should be replaced by something faster. Maybe you can get the isolate from
the MacroAssembler.

[Erik Corry, 2011/06/08 10:38:55]

Done.

+    ASSERT(masm->get_opcode(-2) == kSkipNonIncrementalPartInstruction);
+    masm->set_opcode(-2, kTwoByteNopInstruction);
+  }
+
+  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();
+}
+
+
 #undef __
 
 } }  // namespace v8::internal
 
 #endif  // V8_TARGET_ARCH_X64