From 5bef74395ddbf849ae01ada0509dbe79ebeb828f Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Micha=C3=ABl=20Zasso?= Date: Mon, 25 Oct 2021 19:33:00 +0200 Subject: [PATCH] deps: patch V8 to 9.5.172.25 Refs: https://github.com/v8/v8/compare/9.5.172.21...9.5.172.25 PR-URL: https://github.com/nodejs/node/pull/40604 Reviewed-By: Jiawen Geng Reviewed-By: Antoine du Hamel --- deps/v8/include/v8-version.h | 2 +- .../backend/ia32/code-generator-ia32.cc | 2 +- deps/v8/src/execution/isolate-inl.h | 2 +- deps/v8/src/heap/cppgc/marker.cc | 1 + deps/v8/src/heap/cppgc/marking-state.h | 23 +++++++--- deps/v8/src/ic/accessor-assembler.cc | 4 +- deps/v8/src/ic/ic.cc | 8 +++- .../heap/cppgc/ephemeron-pair-unittest.cc | 45 +++++++++++++++++++ 8 files changed, 75 insertions(+), 12 deletions(-) diff --git a/deps/v8/include/v8-version.h b/deps/v8/include/v8-version.h index e58f97f9ae8502..b39e2dc20821f5 100644 --- a/deps/v8/include/v8-version.h +++ b/deps/v8/include/v8-version.h @@ -11,7 +11,7 @@ #define V8_MAJOR_VERSION 9 #define V8_MINOR_VERSION 5 #define V8_BUILD_NUMBER 172 -#define V8_PATCH_LEVEL 21 +#define V8_PATCH_LEVEL 25 // Use 1 for candidates and 0 otherwise. // (Boolean macro values are not supported by all preprocessors.) diff --git a/deps/v8/src/compiler/backend/ia32/code-generator-ia32.cc b/deps/v8/src/compiler/backend/ia32/code-generator-ia32.cc index e03f934ba5327c..1cd78b4359aed8 100644 --- a/deps/v8/src/compiler/backend/ia32/code-generator-ia32.cc +++ b/deps/v8/src/compiler/backend/ia32/code-generator-ia32.cc @@ -343,8 +343,8 @@ class OutOfLineRecordWrite final : public OutOfLineCode { __ CallRecordWriteStubSaveRegisters(object_, scratch1_, remembered_set_action, save_fp_mode, StubCallMode::kCallWasmRuntimeStub); - } else { #endif // V8_ENABLE_WEBASSEMBLY + } else { __ CallRecordWriteStubSaveRegisters(object_, scratch1_, remembered_set_action, save_fp_mode); } diff --git a/deps/v8/src/execution/isolate-inl.h b/deps/v8/src/execution/isolate-inl.h index 63f9ea5947c904..48950b673f2227 100644 --- a/deps/v8/src/execution/isolate-inl.h +++ b/deps/v8/src/execution/isolate-inl.h @@ -50,7 +50,7 @@ bool Isolate::has_pending_message() { } Object Isolate::pending_exception() { - DCHECK(has_pending_exception()); + CHECK(has_pending_exception()); DCHECK(!thread_local_top()->pending_exception_.IsException(this)); return thread_local_top()->pending_exception_; } diff --git a/deps/v8/src/heap/cppgc/marker.cc b/deps/v8/src/heap/cppgc/marker.cc index e290787a59b8b3..88f2f3c6085eea 100644 --- a/deps/v8/src/heap/cppgc/marker.cc +++ b/deps/v8/src/heap/cppgc/marker.cc @@ -243,6 +243,7 @@ void MarkerBase::EnterAtomicPause(MarkingConfig::StackState stack_state) { } config_.stack_state = stack_state; config_.marking_type = MarkingConfig::MarkingType::kAtomic; + mutator_marking_state_.set_in_atomic_pause(); // Lock guards against changes to {Weak}CrossThreadPersistent handles, that // may conflict with marking. E.g., a WeakCrossThreadPersistent may be diff --git a/deps/v8/src/heap/cppgc/marking-state.h b/deps/v8/src/heap/cppgc/marking-state.h index 864c8209b7afd3..5f6f0aba3720ea 100644 --- a/deps/v8/src/heap/cppgc/marking-state.h +++ b/deps/v8/src/heap/cppgc/marking-state.h @@ -9,6 +9,7 @@ #include "include/cppgc/trace-trait.h" #include "include/cppgc/visitor.h" +#include "src/base/logging.h" #include "src/heap/cppgc/compaction-worklists.h" #include "src/heap/cppgc/globals.h" #include "src/heap/cppgc/heap-object-header.h" @@ -123,6 +124,8 @@ class MarkingStateBase { discovered_new_ephemeron_pairs_ = false; } + void set_in_atomic_pause() { in_atomic_pause_ = true; } + protected: inline void MarkAndPush(HeapObjectHeader&, TraceDescriptor); @@ -160,6 +163,7 @@ class MarkingStateBase { size_t marked_bytes_ = 0; bool in_ephemeron_processing_ = false; bool discovered_new_ephemeron_pairs_ = false; + bool in_atomic_pause_ = false; }; MarkingStateBase::MarkingStateBase(HeapBase& heap, @@ -300,12 +304,19 @@ void MarkingStateBase::ProcessEphemeron(const void* key, const void* value, // would break the main marking loop. DCHECK(!in_ephemeron_processing_); in_ephemeron_processing_ = true; - // Filter out already marked keys. The write barrier for WeakMember - // ensures that any newly set value after this point is kept alive and does - // not require the callback. - if (!HeapObjectHeader::FromObject(key) - .IsInConstruction() && - HeapObjectHeader::FromObject(key).IsMarked()) { + // Keys are considered live even in incremental/concurrent marking settings + // because the write barrier for WeakMember ensures that any newly set value + // after this point is kept alive and does not require the callback. + const bool key_in_construction = + HeapObjectHeader::FromObject(key).IsInConstruction(); + const bool key_considered_as_live = + key_in_construction + ? in_atomic_pause_ + : HeapObjectHeader::FromObject(key).IsMarked(); + DCHECK_IMPLIES( + key_in_construction && in_atomic_pause_, + HeapObjectHeader::FromObject(key).IsMarked()); + if (key_considered_as_live) { if (value_desc.base_object_payload) { MarkAndPush(value_desc.base_object_payload, value_desc); } else { diff --git a/deps/v8/src/ic/accessor-assembler.cc b/deps/v8/src/ic/accessor-assembler.cc index 64d64cd017c354..f27e3b7f590a76 100644 --- a/deps/v8/src/ic/accessor-assembler.cc +++ b/deps/v8/src/ic/accessor-assembler.cc @@ -846,8 +846,8 @@ void AccessorAssembler::HandleLoadICSmiHandlerLoadNamedCase( Comment("module export"); TNode index = DecodeWord(handler_word); - TNode module = LoadObjectField( - CAST(p->receiver()), JSModuleNamespace::kModuleOffset); + TNode module = + LoadObjectField(CAST(holder), JSModuleNamespace::kModuleOffset); TNode exports = LoadObjectField(module, Module::kExportsOffset); TNode cell = CAST(LoadFixedArrayElement(exports, index)); diff --git a/deps/v8/src/ic/ic.cc b/deps/v8/src/ic/ic.cc index a2b920a09d1bc7..68eee92cef8335 100644 --- a/deps/v8/src/ic/ic.cc +++ b/deps/v8/src/ic/ic.cc @@ -989,7 +989,13 @@ Handle LoadIC::ComputeHandler(LookupIterator* lookup) { // We found the accessor, so the entry must exist. DCHECK(entry.is_found()); int index = ObjectHashTable::EntryToValueIndex(entry); - return LoadHandler::LoadModuleExport(isolate(), index); + Handle smi_handler = + LoadHandler::LoadModuleExport(isolate(), index); + if (holder_is_lookup_start_object) { + return smi_handler; + } + return LoadHandler::LoadFromPrototype(isolate(), map, holder, + smi_handler); } Handle accessors = lookup->GetAccessors(); diff --git a/deps/v8/test/unittests/heap/cppgc/ephemeron-pair-unittest.cc b/deps/v8/test/unittests/heap/cppgc/ephemeron-pair-unittest.cc index 534f744e7ee1ad..b349b591cac540 100644 --- a/deps/v8/test/unittests/heap/cppgc/ephemeron-pair-unittest.cc +++ b/deps/v8/test/unittests/heap/cppgc/ephemeron-pair-unittest.cc @@ -242,5 +242,50 @@ TEST_F(EphemeronPairTest, EphemeronPairWithEmptyMixinValue) { FinishMarking(); } +namespace { + +class KeyWithCallback final : public GarbageCollected { + public: + template + explicit KeyWithCallback(Callback callback) { + callback(this); + } + void Trace(Visitor*) const {} +}; + +class EphemeronHolderForKeyWithCallback final + : public GarbageCollected { + public: + EphemeronHolderForKeyWithCallback(KeyWithCallback* key, GCed* value) + : ephemeron_pair_(key, value) {} + void Trace(cppgc::Visitor* visitor) const { visitor->Trace(ephemeron_pair_); } + + private: + const EphemeronPair ephemeron_pair_; +}; + +} // namespace + +TEST_F(EphemeronPairTest, EphemeronPairWithKeyInConstruction) { + GCed* value = MakeGarbageCollected(GetAllocationHandle()); + Persistent holder; + InitializeMarker(*Heap::From(GetHeap()), GetPlatformHandle().get()); + FinishSteps(); + MakeGarbageCollected( + GetAllocationHandle(), [this, &holder, value](KeyWithCallback* thiz) { + // The test doesn't use conservative stack scanning to retain key to + // avoid retaining value as a side effect. + EXPECT_TRUE(HeapObjectHeader::FromObject(thiz).TryMarkAtomic()); + holder = MakeGarbageCollected( + GetAllocationHandle(), thiz, value); + // Finishing marking at this point will leave an ephemeron pair + // reachable where the key is still in construction. The GC needs to + // mark the value for such pairs as live in the atomic pause as they key + // is considered live. + FinishMarking(); + }); + EXPECT_TRUE(HeapObjectHeader::FromObject(value).IsMarked()); +} + } // namespace internal } // namespace cppgc