deps: update V8 to 8.6.395

PR-URL: https://github.com/nodejs/node/pull/35415
Reviewed-By: Rich Trott <rtrott@gmail.com>
Reviewed-By: Jiawen Geng <technicalcute@gmail.com>
Reviewed-By: Daniel Bevenius <daniel.bevenius@gmail.com>
Reviewed-By: Matteo Collina <matteo.collina@gmail.com>
Reviewed-By: Myles Borins <myles.borins@gmail.com>

1 files changed, 51 insertions, 79 deletions

diff --git a/deps/v8/src/heap/heap-write-barrier-inl.h b/deps/v8/src/heap/heap-write-barrier-inl.h
index 8fec301fe7..cfdbec4f29 100644
--- a/deps/v8/src/heap/heap-write-barrier-inl.h
+++ b/deps/v8/src/heap/heap-write-barrier-inl.h
@@ -26,22 +26,11 @@ V8_EXPORT_PRIVATE bool Heap_PageFlagsAreConsistent(HeapObject object);
 V8_EXPORT_PRIVATE void Heap_GenerationalBarrierSlow(HeapObject object,
                                                     Address slot,
                                                     HeapObject value);
-V8_EXPORT_PRIVATE void Heap_MarkingBarrierSlow(HeapObject object, Address slot,
-                                               HeapObject value);
 V8_EXPORT_PRIVATE void Heap_WriteBarrierForCodeSlow(Code host);
 
-V8_EXPORT_PRIVATE void Heap_MarkingBarrierForArrayBufferExtensionSlow(
-    HeapObject object, ArrayBufferExtension* extension);
-
 V8_EXPORT_PRIVATE void Heap_GenerationalBarrierForCodeSlow(Code host,
                                                            RelocInfo* rinfo,
                                                            HeapObject object);
-V8_EXPORT_PRIVATE void Heap_MarkingBarrierForCodeSlow(Code host,
-                                                      RelocInfo* rinfo,
-                                                      HeapObject object);
-V8_EXPORT_PRIVATE void Heap_MarkingBarrierForDescriptorArraySlow(
-    Heap* heap, HeapObject host, HeapObject descriptor_array,
-    int number_of_own_descriptors);
 
 V8_EXPORT_PRIVATE void Heap_GenerationalEphemeronKeyBarrierSlow(
     Heap* heap, EphemeronHashTable table, Address slot);
@@ -52,8 +41,7 @@ namespace heap_internals {
 
 struct MemoryChunk {
   static constexpr uintptr_t kFlagsOffset = kSizetSize;
-  static constexpr uintptr_t kHeapOffset =
-      kSizetSize + kUIntptrSize + kSystemPointerSize;
+  static constexpr uintptr_t kHeapOffset = kSizetSize + kUIntptrSize;
   static constexpr uintptr_t kMarkingBit = uintptr_t{1} << 18;
   static constexpr uintptr_t kFromPageBit = uintptr_t{1} << 3;
   static constexpr uintptr_t kToPageBit = uintptr_t{1} << 4;
@@ -121,17 +109,6 @@ inline void GenerationalEphemeronKeyBarrierInternal(EphemeronHashTable table,
   Heap_GenerationalEphemeronKeyBarrierSlow(table_chunk->GetHeap(), table, slot);
 }
 
-inline void MarkingBarrierInternal(HeapObject object, Address slot,
-                                   HeapObject value) {
-  DCHECK(Heap_PageFlagsAreConsistent(object));
-  heap_internals::MemoryChunk* value_chunk =
-      heap_internals::MemoryChunk::FromHeapObject(value);
-
-  if (!value_chunk->IsMarking()) return;
-
-  Heap_MarkingBarrierSlow(object, slot, value);
-}
-
 }  // namespace heap_internals
 
 inline void WriteBarrierForCode(Code host, RelocInfo* rinfo, Object value) {
@@ -142,21 +119,13 @@ inline void WriteBarrierForCode(Code host, RelocInfo* rinfo, Object value) {
 
 inline void WriteBarrierForCode(Code host, RelocInfo* rinfo, HeapObject value) {
   GenerationalBarrierForCode(host, rinfo, value);
-  MarkingBarrierForCode(host, rinfo, value);
+  WriteBarrier::Marking(host, rinfo, value);
 }
 
 inline void WriteBarrierForCode(Code host) {
   Heap_WriteBarrierForCodeSlow(host);
 }
 
-inline void MarkingBarrierForArrayBufferExtension(
-    HeapObject object, ArrayBufferExtension* extension) {
-  heap_internals::MemoryChunk* object_chunk =
-      heap_internals::MemoryChunk::FromHeapObject(object);
-  if (!extension || !object_chunk->IsMarking()) return;
-  Heap_MarkingBarrierForArrayBufferExtensionSlow(object, extension);
-}
-
 inline void GenerationalBarrier(HeapObject object, ObjectSlot slot,
                                 Object value) {
   if (V8_ENABLE_THIRD_PARTY_HEAP_BOOL) return;
@@ -201,52 +170,6 @@ inline void GenerationalBarrierForCode(Code host, RelocInfo* rinfo,
   Heap_GenerationalBarrierForCodeSlow(host, rinfo, object);
 }
 
-inline void MarkingBarrier(HeapObject object, ObjectSlot slot, Object value) {
-  if (V8_ENABLE_THIRD_PARTY_HEAP_BOOL) return;
-  DCHECK(!HasWeakHeapObjectTag(value));
-  if (!value.IsHeapObject()) return;
-  MarkingBarrier(object, slot, HeapObject::cast(value));
-}
-
-inline void MarkingBarrier(HeapObject object, ObjectSlot slot,
-                           HeapObject value) {
-  if (V8_ENABLE_THIRD_PARTY_HEAP_BOOL) return;
-  DCHECK_IMPLIES(slot.address() != kNullAddress, !HasWeakHeapObjectTag(*slot));
-  heap_internals::MarkingBarrierInternal(object, slot.address(),
-                                         HeapObject::cast(value));
-}
-
-inline void MarkingBarrier(HeapObject object, MaybeObjectSlot slot,
-                           MaybeObject value) {
-  if (V8_ENABLE_THIRD_PARTY_HEAP_BOOL) return;
-  HeapObject value_heap_object;
-  if (!value->GetHeapObject(&value_heap_object)) return;
-  heap_internals::MarkingBarrierInternal(object, slot.address(),
-                                         value_heap_object);
-}
-
-inline void MarkingBarrierForCode(Code host, RelocInfo* rinfo,
-                                  HeapObject object) {
-  if (V8_ENABLE_THIRD_PARTY_HEAP_BOOL) return;
-  DCHECK(!HasWeakHeapObjectTag(object));
-  heap_internals::MemoryChunk* object_chunk =
-      heap_internals::MemoryChunk::FromHeapObject(object);
-  if (!object_chunk->IsMarking()) return;
-  Heap_MarkingBarrierForCodeSlow(host, rinfo, object);
-}
-
-inline void MarkingBarrierForDescriptorArray(Heap* heap, HeapObject host,
-                                             HeapObject descriptor_array,
-                                             int number_of_own_descriptors) {
-  if (V8_ENABLE_THIRD_PARTY_HEAP_BOOL) return;
-  heap_internals::MemoryChunk* chunk =
-      heap_internals::MemoryChunk::FromHeapObject(descriptor_array);
-  if (!chunk->IsMarking()) return;
-
-  Heap_MarkingBarrierForDescriptorArraySlow(heap, host, descriptor_array,
-                                            number_of_own_descriptors);
-}
-
 inline WriteBarrierMode GetWriteBarrierModeForObject(
     HeapObject object, const DisallowHeapAllocation* promise) {
   if (FLAG_disable_write_barriers) return SKIP_WRITE_BARRIER;
@@ -273,6 +196,55 @@ inline bool IsReadOnlyHeapObject(HeapObject object) {
   return chunk->InReadOnlySpace();
 }
 
+base::Optional<Heap*> WriteBarrier::GetHeapIfMarking(HeapObject object) {
+  if (V8_ENABLE_THIRD_PARTY_HEAP_BOOL) return {};
+  heap_internals::MemoryChunk* chunk =
+      heap_internals::MemoryChunk::FromHeapObject(object);
+  if (!chunk->IsMarking()) return {};
+  return chunk->GetHeap();
+}
+
+void WriteBarrier::Marking(HeapObject host, ObjectSlot slot, Object value) {
+  DCHECK(!HasWeakHeapObjectTag(value));
+  if (!value.IsHeapObject()) return;
+  Marking(host, HeapObjectSlot(slot), HeapObject::cast(value));
+}
+
+void WriteBarrier::Marking(HeapObject host, MaybeObjectSlot slot,
+                           MaybeObject value) {
+  HeapObject value_heap_object;
+  if (!value->GetHeapObject(&value_heap_object)) return;
+  Marking(host, HeapObjectSlot(slot), value_heap_object);
+}
+
+void WriteBarrier::Marking(HeapObject host, HeapObjectSlot slot,
+                           HeapObject value) {
+  auto heap = GetHeapIfMarking(host);
+  if (!heap) return;
+  MarkingSlow(*heap, host, slot, value);
+}
+
+void WriteBarrier::Marking(Code host, RelocInfo* reloc_info, HeapObject value) {
+  auto heap = GetHeapIfMarking(host);
+  if (!heap) return;
+  MarkingSlow(*heap, host, reloc_info, value);
+}
+
+void WriteBarrier::Marking(JSArrayBuffer host,
+                           ArrayBufferExtension* extension) {
+  if (!extension) return;
+  auto heap = GetHeapIfMarking(host);
+  if (!heap) return;
+  MarkingSlow(*heap, host, extension);
+}
+
+void WriteBarrier::Marking(Map host, DescriptorArray descriptor_array,
+                           int number_of_own_descriptors) {
+  auto heap = GetHeapIfMarking(host);
+  if (!heap) return;
+  MarkingSlow(*heap, host, descriptor_array, number_of_own_descriptors);
+}
+
 }  // namespace internal
 }  // namespace v8