[heap] Remove unused field of IterateAndScavengePromotedObjectsVisitor.

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 4794 matching lines @@
        PageRange(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;
     }
   }
 }
 
 class IterateAndScavengePromotedObjectsVisitor final : public ObjectVisitor {
  public:
-  IterateAndScavengePromotedObjectsVisitor(Heap* heap, HeapObject* target,
-                                           bool record_slots)
-      : heap_(heap), target_(target), record_slots_(record_slots) {}
+  IterateAndScavengePromotedObjectsVisitor(Heap* heap, bool record_slots)
+      : heap_(heap), record_slots_(record_slots) {}
 
   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),
                                     HeapObject::cast(target));
           target = *slot;
           if (heap_->InNewSpace(target)) {
             SLOW_DCHECK(heap_->InToSpace(target));
             SLOW_DCHECK(target->IsHeapObject());
             RememberedSet<OLD_TO_NEW>::Insert(page, slot_address);
           }
           SLOW_DCHECK(!MarkCompactCollector::IsOnEvacuationCandidate(
               HeapObject::cast(target)));
         } else if (record_slots_ &&
                    MarkCompactCollector::IsOnEvacuationCandidate(
                        HeapObject::cast(target))) {
-          heap_->mark_compact_collector()->RecordSlot(target_, slot, target);
+          heap_->mark_compact_collector()->RecordSlot(host, slot, target);
         }
       }
 
       slot_address += kPointerSize;
     }
   }
 
   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);
+  IterateAndScavengePromotedObjectsVisitor visitor(this, 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
   // objects (in new space) promoted to black pages to keep their references
@@ skipping 1542 matching lines @@
     case LO_SPACE:
       return "LO_SPACE";
     default:
       UNREACHABLE();
   }
   return NULL;
 }
 
 }  // namespace internal
 }  // namespace v8