Ensure black and gray objects are kept around by scavenger

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/scopeinfo.h"
 #include "src/base/bits.h"
@@ skipping 1677 matching lines @@
     if (collector->is_code_flushing_enabled()) {
       collector->code_flusher()->IteratePointersToFromSpace(&scavenge_visitor);
     }
   }
 
   {
     TRACE_GC(tracer(), GCTracer::Scope::SCAVENGER_SEMISPACE);
     new_space_front = DoScavenge(&scavenge_visitor, new_space_front);
   }
 
+  {
+    // Copy objects marked black or grey by MarkCompact collector.

[Hannes Payer (out of office), 2016/05/20 07:34:41]

Scavenge objects...

[Marcel Hlopko, 2016/05/20 14:31:41]

Done.

+    TRACE_GC(tracer(),
+             GCTracer::Scope::SCAVENGER_OBJECTS_MARKED_BY_MARK_COMPACT);
+    if (incremental_marking()->IsMarking()) {
+      IterateMarkedForScavenger(&scavenge_visitor);
+      new_space_front = DoScavenge(&scavenge_visitor, new_space_front);
+    }
+  }
+
   if (FLAG_scavenge_reclaim_unmodified_objects) {
     isolate()->global_handles()->MarkNewSpaceWeakUnmodifiedObjectsPending(
         &IsUnscavengedHeapObject);
 
     isolate()->global_handles()->IterateNewSpaceWeakUnmodifiedRoots(
         &scavenge_visitor);
     new_space_front = DoScavenge(&scavenge_visitor, new_space_front);
   } else {
     TRACE_GC(tracer(), GCTracer::Scope::SCAVENGER_OBJECT_GROUPS);
     while (isolate()->global_handles()->IterateObjectGroups(
@@ skipping 1337 matching lines @@
         reinterpret_cast<Map*>(root(kTwoPointerFillerMapRootIndex)));
   } else {
     DCHECK_GT(size, 2 * kPointerSize);
     filler->set_map_no_write_barrier(
         reinterpret_cast<Map*>(root(kFreeSpaceMapRootIndex)));
     FreeSpace::cast(filler)->nobarrier_set_size(size);
   }
   if (mode == ClearRecordedSlots::kYes) {
     ClearRecordedSlotRange(addr, addr + size);
   }
+
   // At this point, we may be deserializing the heap from a snapshot, and
   // none of the maps have been created yet and are NULL.
   DCHECK((filler->map() == NULL && !deserialization_complete_) ||
          filler->map()->IsMap());
 }
 
 
 bool Heap::CanMoveObjectStart(HeapObject* object) {
   if (!FLAG_move_object_start) return false;
 
@@ skipping 1768 matching lines @@
   // Iterate over the partial snapshot cache unless serializing.
   if (mode != VISIT_ONLY_STRONG_FOR_SERIALIZATION) {
     SerializerDeserializer::Iterate(isolate_, v);
   }
   // We don't do a v->Synchronize call here, because in debug mode that will
   // output a flag to the snapshot.  However at this point the serializer and
   // deserializer are deliberately a little unsynchronized (see above) so the
   // checking of the sync flag in the snapshot would fail.
 }
 
+void Heap::IterateMarkedForScavenger(ObjectVisitor* visitor) {
+  NewSpacePageIterator it(new_space_.from_space());
+  while (it.has_next()) {
+    Page* page = it.next();
+    LiveObjectIterator<kAllLiveObjects> it(page);
+    Object* object = nullptr;
+    while ((object = it.Next()) != nullptr) {
+      if (object->IsHeapObject()) {
+        DCHECK(IsUnscavengedHeapObject(this, &object));
+        visitor->VisitPointer(&object);
+      }
+    }
+  }
+}
 
 // TODO(1236194): Since the heap size is configurable on the command line
 // and through the API, we should gracefully handle the case that the heap
 // size is not big enough to fit all the initial objects.
 bool Heap::ConfigureHeap(int max_semi_space_size, int max_old_space_size,
                          int max_executable_size, size_t code_range_size) {
   if (HasBeenSetUp()) return false;
 
   // Overwrite default configuration.
   if (max_semi_space_size > 0) {
@@ skipping 1503 matching lines @@
 }
 
 
 // static
 int Heap::GetStaticVisitorIdForMap(Map* map) {
   return StaticVisitorBase::GetVisitorId(map);
 }
 
 }  // namespace internal
 }  // namespace v8