Immediatelly promote marked objects

src/heap/scavenger.cc

 // Copyright 2015 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/scavenger.h"
 
 #include "src/contexts.h"
 #include "src/heap/heap.h"
 #include "src/heap/objects-visiting-inl.h"
 #include "src/heap/scavenger-inl.h"
@@ skipping 190 matching lines @@
   }
 
   template <ObjectContents object_contents, AllocationAlignment alignment>
   static inline void EvacuateObject(Map* map, HeapObject** slot,
                                     HeapObject* object, int object_size,
                                     PromotionMode promotion_mode) {
     SLOW_DCHECK(object_size <= Page::kAllocatableMemory);
     SLOW_DCHECK(object->Size() == object_size);
     Heap* heap = map->GetHeap();
 
-    if (promotion_mode != FORCE_PROMOTION &&
-        !heap->ShouldBePromoted(object->address(), object_size)) {
+    if (!heap->ShouldBePromoted(object->address(), object_size,
+                                promotion_mode)) {
       // A semi-space copy may fail due to fragmentation. In that case, we
       // try to promote the object.
       if (SemiSpaceCopyObject<alignment>(map, slot, object, object_size)) {
         return;
       }
     }
 
     if (PromoteObject<object_contents, alignment>(map, slot, object,
                                                   object_size)) {
       return;
     }
     if (promotion_mode == FORCE_PROMOTION) {
       FatalProcessOutOfMemory("Scavenger: forced promotion\n");
     }
+    if (promotion_mode == PROMOTE_MARKED) {
+      FatalProcessOutOfMemory("Scavenger: promoting marked\n");
+    }
     // If promotion failed, we try to copy the object to the other semi-space
     if (SemiSpaceCopyObject<alignment>(map, slot, object, object_size)) return;
 
     FatalProcessOutOfMemory("Scavenger: semi-space copy\n");
   }
 
   static inline void EvacuateJSFunction(Map* map, HeapObject** slot,
                                         HeapObject* object,
                                         PromotionMode promotion_mode) {
     ObjectEvacuationStrategy<POINTER_OBJECT>::Visit(map, slot, object,
@@ skipping 227 matching lines @@
 
 void ScavengeVisitor::VisitPointers(Object** start, Object** end) {
   // Copy all HeapObject pointers in [start, end)
   for (Object** p = start; p < end; p++) ScavengePointer(p);
 }
 
 
 void ScavengeVisitor::ScavengePointer(Object** p) {
   Object* object = *p;
   if (!heap_->InNewSpace(object)) return;
+  PromotionMode promotion_mode = heap_->incremental_marking()->IsMarking()
+                                     ? PROMOTE_MARKED
+                                     : DEFAULT_PROMOTION;
   Scavenger::ScavengeObject(reinterpret_cast<HeapObject**>(p),
-                            reinterpret_cast<HeapObject*>(object));
+                            reinterpret_cast<HeapObject*>(object),
+                            promotion_mode);
 }
 
 }  // namespace internal
 }  // namespace v8