Add a host parameter to ObjectVisitor methods.

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/assembler-inl.h"
 #include "src/ast/context-slot-cache.h"
@@ skipping 1119 matching lines @@
   Object** dst_objects = array->data_start() + dst_index;
   MemMove(dst_objects, array->data_start() + src_index, len * kPointerSize);
   FIXED_ARRAY_ELEMENTS_WRITE_BARRIER(this, array, dst_index, len);
 }
 
 
 #ifdef VERIFY_HEAP
 // Helper class for verifying the string table.
 class StringTableVerifier : public ObjectVisitor {
  public:
-  void VisitPointers(Object** start, Object** end) override {
+  void VisitPointers(HeapObject* host, Object** start, Object** end) override {
     // Visit all HeapObject pointers in [start, end).
     for (Object** p = start; p < end; p++) {
       if ((*p)->IsHeapObject()) {
         HeapObject* object = HeapObject::cast(*p);
         Isolate* isolate = object->GetIsolate();
         // Check that the string is actually internalized.
         CHECK(object->IsTheHole(isolate) || object->IsUndefined(isolate) ||
               object->IsInternalizedString());
       }
     }
@@ skipping 595 matching lines @@
   {
     TRACE_GC(tracer(), GCTracer::Scope::SCAVENGER_WEAK);
     IterateEncounteredWeakCollections(&root_scavenge_visitor);
   }
 
   {
     // Copy objects reachable from the code flushing candidates list.
     TRACE_GC(tracer(), GCTracer::Scope::SCAVENGER_CODE_FLUSH_CANDIDATES);
     MarkCompactCollector* collector = mark_compact_collector();
     if (collector->is_code_flushing_enabled()) {
-      collector->code_flusher()->IteratePointersToFromSpace(
-          &root_scavenge_visitor);
+      collector->code_flusher()->VisitListHeads(&root_scavenge_visitor);

[ulan, 2017/04/10 10:59:37]

This is the only non-mechanical change:
we first visit the list heads using the root visitor and the scavenge JSFunction
slots using the static scavenging visitor.

+      collector->code_flusher()
+          ->IteratePointersToFromSpace<StaticScavengeVisitor>();
     }
   }
 
   {
     TRACE_GC(tracer(), GCTracer::Scope::SCAVENGER_SEMISPACE);
     new_space_front = DoScavenge(new_space_front);
   }
 
   isolate()->global_handles()->MarkNewSpaceWeakUnmodifiedObjectsPending(
       &IsUnscavengedHeapObject);
@@ skipping 3046 matching lines @@
     }
   }
 }
 
 class IterateAndScavengePromotedObjectsVisitor final : public ObjectVisitor {
  public:
   IterateAndScavengePromotedObjectsVisitor(Heap* heap, HeapObject* target,
                                            bool record_slots)
       : heap_(heap), target_(target), record_slots_(record_slots) {}
 
-  inline void VisitPointers(Object** start, Object** end) override {
+  inline void VisitPointers(HeapObject* host, Object** start,
+                            Object** end) override {
+    DCHECK_EQ(host, target_);
     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 (target->IsHeapObject()) {
         if (heap_->InFromSpace(target)) {
           Scavenger::ScavengeObject(reinterpret_cast<HeapObject**>(slot),
@@ skipping 10 matching lines @@
                    MarkCompactCollector::IsOnEvacuationCandidate(
                        HeapObject::cast(target))) {
           heap_->mark_compact_collector()->RecordSlot(target_, slot, target);
         }
       }
 
       slot_address += kPointerSize;
     }
   }
 
-  inline void VisitCodeEntry(Address code_entry_slot) override {
+  inline void VisitCodeEntry(JSFunction* host,
+                             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_;
   HeapObject* target_;
   bool record_slots_;
 };
 
 void Heap::IterateAndScavengePromotedObject(HeapObject* target, int size,
                                             bool was_marked_black) {
   // We are not collecting slots on new space objects during mutation
   // thus we have to scan for pointers to evacuation candidates when we
   // 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()) {
     record_slots =
         ObjectMarking::IsBlack(target, MarkingState::Internal(target));
   }
 
+  // TODO(ulan): remove the target, the visitor now gets the host object
+  // in each visit method.
   IterateAndScavengePromotedObjectsVisitor visitor(this, target, record_slots);
   if (target->IsJSFunction()) {
     // JSFunctions reachable through kNextFunctionLinkOffset are weak. Slots for
     // this links are recorded during processing of weak lists.
     JSFunction::BodyDescriptorWeakCode::IterateBody(target, size, &visitor);
   } else {
     target->IterateBody(target->map()->instance_type(), size, &visitor);
   }
 
   // When black allocations is on, we have to visit not already marked black
@@ skipping 1224 matching lines @@
   bool SkipObject(HeapObject* object) {
     if (object->IsFiller()) return true;
     return ObjectMarking::IsWhite(object, MarkingState::Internal(object));
   }
 
  private:
   class MarkingVisitor : public ObjectVisitor, public RootVisitor {
    public:
     MarkingVisitor() : marking_stack_(10) {}
 
-    void VisitPointers(Object** start, Object** end) override {
+    void VisitPointers(HeapObject* host, Object** start,
+                       Object** end) override {
       MarkPointers(start, end);
     }
 
     void VisitRootPointers(Root root, Object** start, Object** end) override {
       MarkPointers(start, end);
     }
 
     void TransitiveClosure() {
       while (!marking_stack_.is_empty()) {
         HeapObject* obj = marking_stack_.RemoveLast();
@@ skipping 276 matching lines @@
 }
 
 
 // static
 int Heap::GetStaticVisitorIdForMap(Map* map) {
   return StaticVisitorBase::GetVisitorId(map);
 }
 
 }  // namespace internal
 }  // namespace v8