1 files changed, 33 insertions, 14 deletions

diff --git a/deps/v8/src/heap/incremental-marking-inl.h b/deps/v8/src/heap/incremental-marking-inl.h
index 7df67d3d27..325fb07182 100644
--- a/deps/v8/src/heap/incremental-marking-inl.h
+++ b/deps/v8/src/heap/incremental-marking-inl.h
@@ -7,10 +7,10 @@
 
 #include "src/heap/incremental-marking.h"
 
+#include "src/execution/isolate.h"
 #include "src/heap/mark-compact-inl.h"
-#include "src/isolate.h"
-#include "src/objects-inl.h"
 #include "src/objects/maybe-object.h"
+#include "src/objects/objects-inl.h"
 
 namespace v8 {
 namespace internal {
@@ -33,24 +33,43 @@ void IncrementalMarking::TransferColor(HeapObject from, HeapObject to) {
   }
 }
 
-void IncrementalMarking::RecordWrite(HeapObject obj, ObjectSlot slot,
-                                     Object value) {
-  DCHECK_IMPLIES(slot.address() != kNullAddress, !HasWeakHeapObjectTag(*slot));
-  DCHECK(!HasWeakHeapObjectTag(value));
-  if (IsMarking() && value->IsHeapObject()) {
-    RecordWriteSlow(obj, HeapObjectSlot(slot), HeapObject::cast(value));
+bool IncrementalMarking::BaseRecordWrite(HeapObject obj, HeapObject value) {
+  DCHECK(!marking_state()->IsImpossible(value));
+  DCHECK(!marking_state()->IsImpossible(obj));
+  // The write barrier stub generated with V8_CONCURRENT_MARKING does not
+  // check the color of the source object.
+  const bool need_recording =
+      V8_CONCURRENT_MARKING_BOOL || marking_state()->IsBlack(obj);
+
+  if (need_recording && WhiteToGreyAndPush(value)) {
+    RestartIfNotMarking();
   }
+  return is_compacting_ && need_recording;
 }
 
-void IncrementalMarking::RecordMaybeWeakWrite(HeapObject obj,
-                                              MaybeObjectSlot slot,
-                                              MaybeObject value) {
+template <typename TSlot>
+void IncrementalMarking::RecordWrite(HeapObject obj, TSlot slot,
+                                     typename TSlot::TObject value) {
+  static_assert(std::is_same<TSlot, ObjectSlot>::value ||
+                    std::is_same<TSlot, MaybeObjectSlot>::value,
+                "Only ObjectSlot and MaybeObjectSlot are expected here");
+  DCHECK_NE(slot.address(), kNullAddress);
+  DCHECK_IMPLIES(!TSlot::kCanBeWeak, !HAS_WEAK_HEAP_OBJECT_TAG((*slot).ptr()));
+  DCHECK_IMPLIES(!TSlot::kCanBeWeak, !HAS_WEAK_HEAP_OBJECT_TAG(value.ptr()));
   // When writing a weak reference, treat it as strong for the purposes of the
   // marking barrier.
-  HeapObject heap_object;
-  if (IsMarking() && value->GetHeapObject(&heap_object)) {
-    RecordWriteSlow(obj, HeapObjectSlot(slot), heap_object);
+  HeapObject value_heap_object;
+  if (IsMarking() && value.GetHeapObject(&value_heap_object)) {
+    RecordWriteSlow(obj, HeapObjectSlot(slot), value_heap_object);
+  }
+}
+
+bool IncrementalMarking::WhiteToGreyAndPush(HeapObject obj) {
+  if (marking_state()->WhiteToGrey(obj)) {
+    marking_worklist()->Push(obj);
+    return true;
   }
+  return false;
 }
 
 void IncrementalMarking::RestartIfNotMarking() {