[heap] Introduce a new remembered set for typed pointers from old to new.

src/heap/mark-compact.cc

 // Copyright 2012 the V8 project authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "src/heap/mark-compact.h"
 
 #include "src/base/atomicops.h"
 #include "src/base/bits.h"
 #include "src/base/sys-info.h"
 #include "src/code-stubs.h"
@@ skipping 2805 matching lines @@
           reinterpret_cast<base::AtomicWord*>(slot),
           reinterpret_cast<base::AtomicWord>(obj),
           reinterpret_cast<base::AtomicWord>(target));
       DCHECK(!heap_obj->GetHeap()->InFromSpace(target) &&
              !MarkCompactCollector::IsOnEvacuationCandidate(target));
     }
   }
   return REMOVE_SLOT;
 }
 
-// Updates a cell slot using an untyped slot callback.
-// The callback accepts (Heap*, Object**) and returns SlotCallbackResult.
-template <typename Callback>
-static SlotCallbackResult UpdateCell(RelocInfo* rinfo, Callback callback) {
-  DCHECK(rinfo->rmode() == RelocInfo::CELL);
-  Object* cell = rinfo->target_cell();
-  Object* old_cell = cell;
-  SlotCallbackResult result = callback(&cell);
-  if (cell != old_cell) {
-    rinfo->set_target_cell(reinterpret_cast<Cell*>(cell));
-  }
-  return result;
-}
-
-// Updates a code entry slot using an untyped slot callback.
-// The callback accepts (Heap*, Object**) and returns SlotCallbackResult.
-template <typename Callback>
-static SlotCallbackResult UpdateCodeEntry(Address entry_address,
-                                          Callback callback) {
-  Object* code = Code::GetObjectFromEntryAddress(entry_address);
-  Object* old_code = code;
-  SlotCallbackResult result = callback(&code);
-  if (code != old_code) {
-    Memory::Address_at(entry_address) = reinterpret_cast<Code*>(code)->entry();
-  }
-  return result;
-}
-
-// Updates a code target slot using an untyped slot callback.
-// The callback accepts (Heap*, Object**) and returns SlotCallbackResult.
-template <typename Callback>
-static SlotCallbackResult UpdateCodeTarget(RelocInfo* rinfo,
-                                           Callback callback) {
-  DCHECK(RelocInfo::IsCodeTarget(rinfo->rmode()));
-  Object* target = Code::GetCodeFromTargetAddress(rinfo->target_address());
-  Object* old_target = target;
-  SlotCallbackResult result = callback(&target);
-  if (target != old_target) {
-    rinfo->set_target_address(Code::cast(target)->instruction_start());
-  }
-  return result;
-}
-
-// Updates an embedded pointer slot using an untyped slot callback.
-// The callback accepts (Heap*, Object**) and returns SlotCallbackResult.
-template <typename Callback>
-static SlotCallbackResult UpdateEmbeddedPointer(RelocInfo* rinfo,
-                                                Callback callback) {
-  DCHECK(rinfo->rmode() == RelocInfo::EMBEDDED_OBJECT);
-  Object* target = rinfo->target_object();
-  Object* old_target = target;
-  SlotCallbackResult result = callback(&target);
-  if (target != old_target) {
-    rinfo->set_target_object(target);
-  }
-  return result;
-}
-
-// Updates a debug target slot using an untyped slot callback.
-// The callback accepts (Heap*, Object**) and returns SlotCallbackResult.
-template <typename Callback>
-static SlotCallbackResult UpdateDebugTarget(RelocInfo* rinfo,
-                                            Callback callback) {
-  DCHECK(RelocInfo::IsDebugBreakSlot(rinfo->rmode()) &&
-         rinfo->IsPatchedDebugBreakSlotSequence());
-  Object* target = Code::GetCodeFromTargetAddress(rinfo->debug_call_address());
-  SlotCallbackResult result = callback(&target);
-  rinfo->set_debug_call_address(Code::cast(target)->instruction_start());
-  return result;
-}
-
-// Updates a typed slot using an untyped slot callback.
-// The callback accepts (Heap*, Object**) and returns SlotCallbackResult.
-template <typename Callback>
-static SlotCallbackResult UpdateTypedSlot(Isolate* isolate, SlotType slot_type,
-                                          Address addr, Callback callback) {
-  switch (slot_type) {
-    case CODE_TARGET_SLOT: {
-      RelocInfo rinfo(isolate, addr, RelocInfo::CODE_TARGET, 0, NULL);
-      return UpdateCodeTarget(&rinfo, callback);
-    }
-    case CELL_TARGET_SLOT: {
-      RelocInfo rinfo(isolate, addr, RelocInfo::CELL, 0, NULL);
-      return UpdateCell(&rinfo, callback);
-    }
-    case CODE_ENTRY_SLOT: {
-      return UpdateCodeEntry(addr, callback);
-    }
-    case DEBUG_TARGET_SLOT: {
-      RelocInfo rinfo(isolate, addr, RelocInfo::DEBUG_BREAK_SLOT_AT_POSITION, 0,
-                      NULL);
-      if (rinfo.IsPatchedDebugBreakSlotSequence()) {
-        return UpdateDebugTarget(&rinfo, callback);
-      }
-      return REMOVE_SLOT;
-    }
-    case EMBEDDED_OBJECT_SLOT: {
-      RelocInfo rinfo(isolate, addr, RelocInfo::EMBEDDED_OBJECT, 0, NULL);
-      return UpdateEmbeddedPointer(&rinfo, callback);
-    }
-    case OBJECT_SLOT: {
-      return callback(reinterpret_cast<Object**>(addr));
-    }
-    case NUMBER_OF_SLOT_TYPES:
-      break;
-  }
-  UNREACHABLE();
-  return REMOVE_SLOT;
-}
-
-
 // Visitor for updating pointers from live objects in old spaces to new space.
 // It does not expect to encounter pointers to dead objects.
 class PointersUpdatingVisitor : public ObjectVisitor {
  public:
   void VisitPointer(Object** p) override { UpdateSlot(p); }
 
   void VisitPointers(Object** start, Object** end) override {
     for (Object** p = start; p < end; p++) UpdateSlot(p);
   }
 
-  void VisitCell(RelocInfo* rinfo) override { UpdateCell(rinfo, UpdateSlot); }
+  void VisitCell(RelocInfo* rinfo) override {
+    UpdateTypedSlotHelper::UpdateCell(rinfo, UpdateSlot);
+  }
 
   void VisitEmbeddedPointer(RelocInfo* rinfo) override {
-    UpdateEmbeddedPointer(rinfo, UpdateSlot);
+    UpdateTypedSlotHelper::UpdateEmbeddedPointer(rinfo, UpdateSlot);
   }
 
   void VisitCodeTarget(RelocInfo* rinfo) override {
-    UpdateCodeTarget(rinfo, UpdateSlot);
+    UpdateTypedSlotHelper::UpdateCodeTarget(rinfo, UpdateSlot);
   }
 
   void VisitCodeEntry(Address entry_address) override {
-    UpdateCodeEntry(entry_address, UpdateSlot);
+    UpdateTypedSlotHelper::UpdateCodeEntry(entry_address, UpdateSlot);
   }
 
   void VisitDebugTarget(RelocInfo* rinfo) override {
-    UpdateDebugTarget(rinfo, UpdateSlot);
+    UpdateTypedSlotHelper::UpdateDebugTarget(rinfo, UpdateSlot);
   }
 };
 
 static String* UpdateReferenceInExternalStringTableEntry(Heap* heap,
                                                          Object** p) {
   MapWord map_word = HeapObject::cast(*p)->map_word();
 
   if (map_word.IsForwardingAddress()) {
     return String::cast(map_word.ToForwardingAddress());
   }
@@ skipping 529 matching lines @@
     MarkBit mark_bit = Marking::MarkBitFrom(code);
     if (Marking::IsWhite(mark_bit)) return;
 
     // Ignore all slots that might have been recorded in the body of the
     // deoptimized code object. Assumption: no slots will be recorded for
     // this object after invalidating it.
     Page* page = Page::FromAddress(code->address());
     Address start = code->instruction_start();
     Address end = code->address() + code->Size();
     RememberedSet<OLD_TO_OLD>::RemoveRangeTyped(page, start, end);
+    RememberedSet<OLD_TO_NEW>::RemoveRangeTyped(page, start, end);
   }
 }
 
 
 // Return true if the given code is deoptimized or will be deoptimized.
 bool MarkCompactCollector::WillBeDeoptimized(Code* code) {
   return code->is_optimized_code() && code->marked_for_deoptimization();
 }
 
 
@@ skipping 152 matching lines @@
         return UpdateSlot(reinterpret_cast<Object**>(slot));
       });
     }
   }
 
   static void UpdateTypedPointers(Heap* heap, MemoryChunk* chunk) {
     if (direction == OLD_TO_OLD) {
       Isolate* isolate = heap->isolate();
       RememberedSet<OLD_TO_OLD>::IterateTyped(
           chunk, [isolate](SlotType type, Address slot) {
-            return UpdateTypedSlot(isolate, type, slot, UpdateSlot);
+            return UpdateTypedSlotHelper::UpdateTypedSlot(isolate, type, slot,
+                                                          UpdateSlot);
+          });
+    } else {
+      Isolate* isolate = heap->isolate();
+      RememberedSet<OLD_TO_NEW>::IterateTyped(
+          chunk, [isolate, heap](SlotType type, Address slot) {
+            return UpdateTypedSlotHelper::UpdateTypedSlot(
+                isolate, type, slot, [heap](Object** slot) {
+                  return CheckAndUpdateOldToNewSlot(

[ulan, 2016/05/23 08:40:08]

For separate CL: We would need to force promotion of all new space objects
referenced by code. Otherwise, we would have to clear old_to_new slots in dying
code objects, which would be expensive.
Let's discuss details offline.

+                      heap, reinterpret_cast<Address>(slot));
+                });
           });
     }
   }
 
   static SlotCallbackResult CheckAndUpdateOldToNewSlot(Heap* heap,
                                                        Address slot_address) {
     Object** slot = reinterpret_cast<Object**>(slot_address);
     if (heap->InFromSpace(*slot)) {
       HeapObject* heap_object = reinterpret_cast<HeapObject*>(*slot);
       DCHECK(heap_object->IsHeapObject());
@@ skipping 338 matching lines @@
     MarkBit mark_bit = Marking::MarkBitFrom(host);
     if (Marking::IsBlack(mark_bit)) {
       RelocInfo rinfo(isolate(), pc, RelocInfo::CODE_TARGET, 0, host);
       RecordRelocSlot(host, &rinfo, target);
     }
   }
 }
 
 }  // namespace internal
 }  // namespace v8