[heap] Only visit strong links during scavenge of promoted objects

src/heap/heap.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/heap.h"
 
 #include "src/accessors.h"
 #include "src/api.h"
 #include "src/ast/context-slot-cache.h"
 #include "src/base/bits.h"
@@ skipping 4705 matching lines @@
   if (!new_space_->IsFromSpaceCommitted()) return;
   for (Page* page : NewSpacePageRange(new_space_->FromSpaceStart(),
                                       new_space_->FromSpaceEnd())) {
     for (Address cursor = page->area_start(), limit = page->area_end();
          cursor < limit; cursor += kPointerSize) {
       Memory::Address_at(cursor) = kFromSpaceZapValue;
     }
   }
 }
 
-void Heap::IteratePromotedObjectPointers(HeapObject* object, Address start,
-                                         Address end, bool record_slots,
-                                         ObjectSlotCallback callback) {
-  Address slot_address = start;
-  Page* page = Page::FromAddress(start);
+enum IteratePromotedObjectsMode {
+  RECORD_ONLY,
+  RECORD_AND_SCAVENGE,
+};
 
-  while (slot_address < end) {
-    Object** slot = reinterpret_cast<Object**>(slot_address);
-    Object* target = *slot;
-    if (target->IsHeapObject()) {
-      if (Heap::InFromSpace(target)) {
-        callback(reinterpret_cast<HeapObject**>(slot),
-                 HeapObject::cast(target));
-        Object* new_target = *slot;
-        if (InNewSpace(new_target)) {
-          SLOW_DCHECK(Heap::InToSpace(new_target));
-          SLOW_DCHECK(new_target->IsHeapObject());
-          RememberedSet<OLD_TO_NEW>::Insert(page, slot_address);
-        }
-        SLOW_DCHECK(!MarkCompactCollector::IsOnEvacuationCandidate(new_target));
-      } else if (record_slots &&
-                 MarkCompactCollector::IsOnEvacuationCandidate(target)) {
-        mark_compact_collector()->RecordSlot(object, slot, target);
-      }
-    }
-    slot_address += kPointerSize;
-  }
-}
-
+template <IteratePromotedObjectsMode mode>
 class IteratePromotedObjectsVisitor final : public ObjectVisitor {
  public:
   IteratePromotedObjectsVisitor(Heap* heap, HeapObject* target,
                                 bool record_slots, ObjectSlotCallback callback)

[ulan, 2016/11/15 14:39:31]

Can you rename the "callback" to "scavenge" to make it clear that it works only
for scavenger?

Also maybe add a comment that the visitor cannot be called for the same slot
twice.

[Michael Lippautz, 2016/11/15 14:59:50]

Restructured.

       : heap_(heap),
         target_(target),
         record_slots_(record_slots),
         callback_(callback) {}
 
-  V8_INLINE void VisitPointers(Object** start, Object** end) override {
-    heap_->IteratePromotedObjectPointers(
-        target_, reinterpret_cast<Address>(start),
-        reinterpret_cast<Address>(end), record_slots_, callback_);
+  inline void VisitPointers(Object** start, Object** end) override {
+    Address slot_address = reinterpret_cast<Address>(start);
+    Page* page = Page::FromAddress(slot_address);
+
+    while (slot_address < reinterpret_cast<Address>(end)) {
+      Object** slot = reinterpret_cast<Object**>(slot_address);
+      Object* target = *slot;
+
+      if (mode == RECORD_AND_SCAVENGE && heap_->InNewSpace(target)) {
+        callback_(reinterpret_cast<HeapObject**>(slot),
+                  HeapObject::cast(target));
+        target = *slot;
+        DCHECK(target->IsHeapObject);
+        SLOW_DCHECK(!MarkCompactCollector::IsOnEvacuationCandidate(target));
+      }
+
+      if (heap_->InNewSpace(target)) {
+        SLOW_DCHECK(Heap::InToSpace(new_target));
+        SLOW_DCHECK(new_target->IsHeapObject());
+        RememberedSet<OLD_TO_NEW>::Insert(page, slot_address);
+      } else if (record_slots_ &&
+                 MarkCompactCollector::IsOnEvacuationCandidate(target)) {
+        heap_->mark_compact_collector()->RecordSlot(target_, slot, target);
+      }
+
+      slot_address += kPointerSize;
+    }
   }
 
-  V8_INLINE void VisitCodeEntry(Address code_entry_slot) override {
+  inline void VisitCodeEntry(Address code_entry_slot) override {
     // Black allocation requires us to process objects referenced by
     // promoted objects.
     if (heap_->incremental_marking()->black_allocation()) {
       Code* code = Code::cast(Code::GetObjectFromEntryAddress(code_entry_slot));
       IncrementalMarking::MarkGrey(heap_, code);
     }
   }
 
  private:
   Heap* heap_;
@@ skipping 10 matching lines @@
   // promote objects. But we should not record any slots in non-black
   // objects. Grey object's slots would be rescanned.
   // White object might not survive until the end of collection
   // it would be a violation of the invariant to record it's slots.
   bool record_slots = false;
   if (incremental_marking()->IsCompacting()) {
     MarkBit mark_bit = ObjectMarking::MarkBitFrom(target);
     record_slots = Marking::IsBlack(mark_bit);
   }
 
-  IteratePromotedObjectsVisitor visitor(this, target, record_slots, callback);
-  target->IterateBody(target->map()->instance_type(), size, &visitor);
+  IteratePromotedObjectsVisitor<RECORD_AND_SCAVENGE>
+      record_and_scavenge_visitor(this, target, record_slots, callback);
+  if (target->IsJSFunction()) {
+    // JSFunctions reachable through kNextFunctionLinkOffset are weak and should
+    // only trigger recording, not a scavenge.
+    JSFunction::BodyDescriptorWeakCode::IterateBody(
+        target, size, &record_and_scavenge_visitor);
+    IteratePromotedObjectsVisitor<RECORD_ONLY> record_only_visitor(
+        this, target, record_slots, callback);
+    JSFunction::BodyDescriptorWeakFields::IterateBody(target, size,
+                                                      &record_only_visitor);
+  } else {
+    target->IterateBody(target->map()->instance_type(), size,
+                        &record_and_scavenge_visitor);
+  }
 
   // When black allocations is on, we have to visit not already marked black
   // objects (in new space) promoted to black pages to keep their references
   // alive.
   // TODO(hpayer): Implement a special promotion visitor that incorporates
   // regular visiting and IteratePromotedObjectPointers.
   if (!was_marked_black) {
     if (incremental_marking()->black_allocation()) {
       IncrementalMarking::MarkGrey(this, target->map());
       incremental_marking()->IterateBlackObject(target);
@@ skipping 1653 matching lines @@
 }
 
 
 // static
 int Heap::GetStaticVisitorIdForMap(Map* map) {
   return StaticVisitorBase::GetVisitorId(map);
 }
 
 }  // namespace internal
 }  // namespace v8