Support slots recording for compaction during incremental marking.

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 59 matching lines @@
   ASSERT(MemoryChunk::IN_TO_SPACE < 8);
   int mask = (1 << MemoryChunk::IN_FROM_SPACE)
            | (1 << MemoryChunk::IN_TO_SPACE);
   // If non-zero, the page belongs to new-space.
   test_b(Operand(scratch, MemoryChunk::kFlagsOffset),
          static_cast<uint8_t>(mask));
   j(cc, condition_met, condition_met_distance);
 }
 
 
-void MacroAssembler::IncrementalMarkingRecordWriteHelper(
-    Register object,
-    Register value,
-    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()] = 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, address);
-  mov(Operand(esp, 0 * kPointerSize), object);
-  mov(Operand(esp, 1 * kPointerSize), value);
-  CallCFunction(
-      ExternalReference::incremental_marking_record_write_function(isolate()),
-      2);
-
-  for (int i = Register::kNumRegisters - 1; i >= 0; i--) {
-    if (preserve[i]) pop(Register::from_code(i));
-  }
-}
-
-
 void MacroAssembler::RememberedSetHelper(
     Register addr,
     Register scratch,
     SaveFPRegsMode save_fp,
     MacroAssembler::RememberedSetFinalAction and_then) {
   Label done;
   if (FLAG_debug_code) {
     Label ok;
     JumpIfNotInNewSpace(addr, scratch, &ok, Label::kNear);
     int3();
@@ skipping 179 matching lines @@
 
   if (smi_check == INLINE_SMI_CHECK) {
     // Skip barrier if writing a smi.
     ASSERT_EQ(0, kSmiTag);
     test(value, Immediate(kSmiTagMask));
     j(zero, &done, Label::kNear);
   }
 
   CheckPageFlag(value,
                 value,  // Used as scratch.
-                MemoryChunk::POINTERS_TO_HERE_ARE_INTERESTING,
+                MemoryChunk::kPointersToHereAreInterestingMask,
                 zero,
                 &done,
                 Label::kNear);
   CheckPageFlag(object,
                 value,  // Used as scratch.
-                MemoryChunk::POINTERS_FROM_HERE_ARE_INTERESTING,
+                MemoryChunk::kPointersFromHereAreInterestingMask,
                 zero,
                 &done,
                 Label::kNear);
 
   RecordWriteStub stub(object, value, address, remembered_set_action, fp_mode);
   CallStub(&stub);
 
   bind(&done);
 
   // Clobber clobbered registers when running with the debug-code flag
@@ skipping 1929 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);
 }
 
 
 void MacroAssembler::CheckPageFlag(
     Register object,
     Register scratch,
-    MemoryChunk::MemoryChunkFlags flag,
+    int mask,
     Condition cc,
     Label* condition_met,
     Label::Distance condition_met_distance) {
   ASSERT(cc == zero || cc == not_zero);
   if (scratch.is(object)) {
     and_(scratch, Immediate(~Page::kPageAlignmentMask));
   } else {
     mov(scratch, Immediate(~Page::kPageAlignmentMask));
     and_(scratch, Operand(object));
   }
-  if (flag < kBitsPerByte) {
+  if (mask < (1 << kBitsPerByte)) {
     test_b(Operand(scratch, MemoryChunk::kFlagsOffset),
-           static_cast<uint8_t>(1u << flag));
+           static_cast<uint8_t>(mask));
   } else {
-    test(Operand(scratch, MemoryChunk::kFlagsOffset), Immediate(1 << flag));
+    test(Operand(scratch, MemoryChunk::kFlagsOffset), Immediate(mask));
   }
   j(cc, condition_met, condition_met_distance);
 }
 
 
 void MacroAssembler::JumpIfBlack(Register object,
                                  Register scratch0,
                                  Register scratch1,
                                  Label* on_black,
                                  Label::Distance on_black_near) {
@@ skipping 117 matching lines @@
 
   // Value is a data object, and it is white.  Mark it black.  Since we know
   // that the object is white we can make it black by flipping one bit.
   or_(Operand(bitmap_scratch, MemoryChunk::kHeaderSize), mask_scratch);
   bind(&done);
 }
 
 } }  // namespace v8::internal
 
 #endif  // V8_TARGET_ARCH_IA32