libv8-node 20.2.0.0-aarch64-linux → 21.7.2.0-aarch64-linux

data/vendor/v8/include/v8-profiler.h

@@ -11,6 +11,7 @@
 #include <unordered_set>
 #include <vector>
 
+#include "cppgc/common.h"          // NOLINT(build/include_directory)
 #include "v8-local-handle.h"       // NOLINT(build/include_directory)
 #include "v8-message.h"            // NOLINT(build/include_directory)
 #include "v8-persistent-handle.h"  // NOLINT(build/include_directory)
@@ -24,7 +25,7 @@ enum class EmbedderStateTag : uint8_t;
 class HeapGraphNode;
 struct HeapStatsUpdate;
 class Object;
-enum StateTag : int;
+enum StateTag : uint16_t;
 
 using NativeObject = void*;
 using SnapshotObjectId = uint32_t;
@@ -596,7 +597,6 @@ class V8_EXPORT HeapGraphNode {
     kBigInt = 13,        // BigInt.
     kObjectShape = 14,   // Internal data used for tracking the shapes (or
                          // "hidden classes") of JS objects.
-    kWasmObject = 15,    // A WasmGC struct or array.
   };
 
   /** Returns node type (see HeapGraphNode::Type). */
@@ -883,6 +883,15 @@ class V8_EXPORT EmbedderGraph {
      */
     virtual Detachedness GetDetachedness() { return Detachedness::kUnknown; }
 
+    /**
+     * Returns the address of the object in the embedder heap, or nullptr to not
+     * specify the address. If this address is provided, then V8 can generate
+     * consistent IDs for objects across subsequent heap snapshots, which allows
+     * devtools to determine which objects were retained from one snapshot to
+     * the next. This value is used only if GetNativeObject returns nullptr.
+     */
+    virtual const void* GetAddress() { return nullptr; }
+
     Node(const Node&) = delete;
     Node& operator=(const Node&) = delete;
   };
@@ -912,12 +921,22 @@ class V8_EXPORT EmbedderGraph {
   virtual ~EmbedderGraph() = default;
 };
 
+class QueryObjectPredicate {
+ public:
+  virtual ~QueryObjectPredicate() = default;
+  virtual bool Filter(v8::Local<v8::Object> object) = 0;
+};
+
 /**
  * Interface for controlling heap profiling. Instance of the
  * profiler can be retrieved using v8::Isolate::GetHeapProfiler.
  */
 class V8_EXPORT HeapProfiler {
  public:
+  void QueryObjects(v8::Local<v8::Context> context,
+                    QueryObjectPredicate* predicate,
+                    std::vector<v8::Global<v8::Object>>* objects);
+
   enum SamplingFlags {
     kSamplingNoFlags = 0,
     kSamplingForceGC = 1 << 0,
@@ -1045,6 +1064,11 @@ class V8_EXPORT HeapProfiler {
      * Mode for dealing with numeric values, see `NumericsMode`.
      */
     NumericsMode numerics_mode = NumericsMode::kHideNumericValues;
+    /**
+     * Whether stack is considered as a root set.
+     */
+    cppgc::EmbedderStackState stack_state =
+        cppgc::EmbedderStackState::kMayContainHeapPointers;
   };
 
   /**

data/vendor/v8/include/v8-script.h

@@ -9,6 +9,7 @@
 #include <stdint.h>
 
 #include <memory>
+#include <tuple>
 #include <vector>
 
 #include "v8-callbacks.h"     // NOLINT(build/include_directory)
@@ -55,7 +56,7 @@ class V8_EXPORT ScriptOrModule {
 /**
  * A compiled JavaScript script, not yet tied to a Context.
  */
-class V8_EXPORT UnboundScript {
+class V8_EXPORT UnboundScript : public Data {
  public:
   /**
    * Binds the script to the currently entered context.
@@ -142,10 +143,9 @@ class V8_EXPORT ModuleRequest : public Data {
    *
    * All assertions present in the module request will be supplied in this
    * list, regardless of whether they are supported by the host. Per
-   * https://tc39.es/proposal-import-assertions/#sec-hostgetsupportedimportassertions,
-   * hosts are expected to ignore assertions that they do not support (as
-   * opposed to, for example, triggering an error if an unsupported assertion is
-   * present).
+   * https://tc39.es/proposal-import-attributes/#sec-hostgetsupportedimportattributes,
+   * hosts are expected to throw for assertions that they do not support (as
+   * opposed to, for example, ignoring them).
    */
   Local<FixedArray> GetImportAssertions() const;
 
@@ -320,7 +320,7 @@ class V8_EXPORT Module : public Data {
  * A compiled JavaScript script, tied to a Context which was active when the
  * script was compiled.
  */
-class V8_EXPORT Script {
+class V8_EXPORT Script : public Data {
  public:
   /**
    * A shorthand for ScriptCompiler::Compile().
@@ -388,6 +388,27 @@ class V8_EXPORT ScriptCompiler {
     CachedData(const uint8_t* data, int length,
                BufferPolicy buffer_policy = BufferNotOwned);
     ~CachedData();
+
+    enum CompatibilityCheckResult {
+      // Don't change order/existing values of this enum since it keys into the
+      // `code_cache_reject_reason` histogram. Append-only!
+      kSuccess = 0,
+      kMagicNumberMismatch = 1,
+      kVersionMismatch = 2,
+      kSourceMismatch = 3,
+      kFlagsMismatch = 5,
+      kChecksumMismatch = 6,
+      kInvalidHeader = 7,
+      kLengthMismatch = 8,
+      kReadOnlySnapshotChecksumMismatch = 9,
+
+      // This should always point at the last real enum value.
+      kLast = kReadOnlySnapshotChecksumMismatch
+    };
+
+    // Check if the CachedData can be loaded in the given isolate.
+    CompatibilityCheckResult CompatibilityCheck(Isolate* isolate);
+
     // TODO(marja): Async compilation; add constructors which take a callback
     // which will be called when V8 no longer needs the data.
     const uint8_t* data;
@@ -650,7 +671,9 @@ class V8_EXPORT ScriptCompiler {
   static ScriptStreamingTask* StartStreaming(
       Isolate* isolate, StreamedSource* source,
       ScriptType type = ScriptType::kClassic,
-      CompileOptions options = kNoCompileOptions);
+      CompileOptions options = kNoCompileOptions,
+      CompileHintCallback compile_hint_callback = nullptr,
+      void* compile_hint_callback_data = nullptr);
 
   static ConsumeCodeCacheTask* StartConsumingCodeCache(
       Isolate* isolate, std::unique_ptr<CachedData> source);

data/vendor/v8/include/v8-snapshot.h

@@ -88,10 +88,13 @@ class V8_EXPORT SnapshotCreator {
    * \param existing_blob existing snapshot from which to create this one.
    * \param external_references a null-terminated array of external references
    *        that must be equivalent to CreateParams::external_references.
+   * \param owns_isolate whether this SnapshotCreator should call
+   *        v8::Isolate::Dispose() during its destructor.
    */
   SnapshotCreator(Isolate* isolate,
                   const intptr_t* external_references = nullptr,
-                  const StartupData* existing_blob = nullptr);
+                  const StartupData* existing_blob = nullptr,
+                  bool owns_isolate = true);
 
   /**
    * Create and enter an isolate, and set it up for serialization.

data/vendor/v8/include/v8-source-location.h

@@ -0,0 +1,92 @@
+// Copyright 2020 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.
+
+#ifndef INCLUDE_SOURCE_LOCATION_H_
+#define INCLUDE_SOURCE_LOCATION_H_
+
+#include <cstddef>
+#include <string>
+
+#include "v8config.h"  // NOLINT(build/include_directory)
+
+#if defined(__has_builtin)
+#define V8_SUPPORTS_SOURCE_LOCATION                                      \
+  (__has_builtin(__builtin_FUNCTION) && __has_builtin(__builtin_FILE) && \
+   __has_builtin(__builtin_LINE))  // NOLINT
+#elif defined(V8_CC_GNU) && __GNUC__ >= 7
+#define V8_SUPPORTS_SOURCE_LOCATION 1
+#elif defined(V8_CC_INTEL) && __ICC >= 1800
+#define V8_SUPPORTS_SOURCE_LOCATION 1
+#else
+#define V8_SUPPORTS_SOURCE_LOCATION 0
+#endif
+
+namespace v8 {
+
+/**
+ * Encapsulates source location information. Mimics C++20's
+ * `std::source_location`.
+ */
+class V8_EXPORT SourceLocation final {
+ public:
+  /**
+   * Construct source location information corresponding to the location of the
+   * call site.
+   */
+#if V8_SUPPORTS_SOURCE_LOCATION
+  static constexpr SourceLocation Current(
+      const char* function = __builtin_FUNCTION(),
+      const char* file = __builtin_FILE(), size_t line = __builtin_LINE()) {
+    return SourceLocation(function, file, line);
+  }
+#else
+  static constexpr SourceLocation Current() { return SourceLocation(); }
+#endif  // V8_SUPPORTS_SOURCE_LOCATION
+
+  /**
+   * Constructs unspecified source location information.
+   */
+  constexpr SourceLocation() = default;
+
+  /**
+   * Returns the name of the function associated with the position represented
+   * by this object, if any.
+   *
+   * \returns the function name as cstring.
+   */
+  constexpr const char* Function() const { return function_; }
+
+  /**
+   * Returns the name of the current source file represented by this object.
+   *
+   * \returns the file name as cstring.
+   */
+  constexpr const char* FileName() const { return file_; }
+
+  /**
+   * Returns the line number represented by this object.
+   *
+   * \returns the line number.
+   */
+  constexpr size_t Line() const { return line_; }
+
+  /**
+   * Returns a human-readable string representing this object.
+   *
+   * \returns a human-readable string representing source location information.
+   */
+  std::string ToString() const;
+
+ private:
+  constexpr SourceLocation(const char* function, const char* file, size_t line)
+      : function_(function), file_(file), line_(line) {}
+
+  const char* function_ = nullptr;
+  const char* file_ = nullptr;
+  size_t line_ = 0u;
+};
+
+}  // namespace v8
+
+#endif  // INCLUDE_SOURCE_LOCATION_H_

data/vendor/v8/include/v8-statistics.h

@@ -46,6 +46,10 @@ enum class MeasureMemoryExecution { kDefault, kEager, kLazy };
  *
  * It specifies the contexts that need to be measured and gets called when
  * the measurement is completed to report the results.
+ *
+ * Both MeasurementComplete() callbacks will be invoked on completion.
+ * Each implementation of this class should hence implement only one of them,
+ * and leave the other empty.
  */
 class V8_EXPORT MeasureMemoryDelegate {
  public:
@@ -66,10 +70,41 @@ class V8_EXPORT MeasureMemoryDelegate {
    * \param unattributed_size_in_bytes total size of objects that were not
    *   attributed to any context (i.e. are likely shared objects).
    */
+  V8_DEPRECATE_SOON("Please use the version that takes a result struct")
   virtual void MeasurementComplete(
       const std::vector<std::pair<Local<Context>, size_t>>&
           context_sizes_in_bytes,
-      size_t unattributed_size_in_bytes) = 0;
+      size_t unattributed_size_in_bytes) {}
+
+  /** Holds the result of a memory measurement request. */
+  struct Result {
+    /**
+     * a vector of (context, size) pairs that includes each context for
+     * which ShouldMeasure returned true and that was not garbage collected
+     * while the memory measurement was in progress.
+     */
+    const std::vector<std::pair<Local<Context>, size_t>>&
+        context_sizes_in_bytes;
+
+    /**
+     * total size of objects that were not attributed to any context (i.e. are
+     * likely shared objects).
+     */
+    size_t unattributed_size_in_bytes;
+
+    /** total size of generated code for Wasm (shared across contexts). */
+    size_t wasm_code_size_in_bytes;
+
+    /** total size of Wasm metadata (except code; shared across contexts). */
+    size_t wasm_metadata_size_in_bytes;
+  };
+
+  /**
+   * This function is called when memory measurement finishes.
+   *
+   * \param result the result of the measurement.
+   */
+  virtual void MeasurementComplete(Result result) {}
 
   /**
    * Returns a default delegate that resolves the given promise when

data/vendor/v8/include/v8-traced-handle.h

@@ -33,7 +33,7 @@ enum class GlobalHandleStoreMode {
 };
 
 V8_EXPORT internal::Address* GlobalizeTracedReference(
-    internal::Isolate* isolate, internal::Address* handle,
+    internal::Isolate* isolate, internal::Address value,
     internal::Address* slot, GlobalHandleStoreMode store_mode);
 V8_EXPORT void MoveTracedReference(internal::Address** from,
                                    internal::Address** to);
@@ -43,14 +43,12 @@ V8_EXPORT void DisposeTracedReference(internal::Address* global_handle);
 
 }  // namespace internal
 
-class TracedReferenceBase {
+/**
+ * An indirect handle, where the indirect pointer points to a GlobalHandles
+ * node.
+ */
+class TracedReferenceBase : public IndirectHandleBase {
  public:
-  /**
-   * Returns true if the reference is empty, i.e., has not been assigned
-   * object.
-   */
-  bool IsEmpty() const { return val_ == nullptr; }
-
   /**
    * If non-empty, destroy the underlying storage cell. |IsEmpty| will return
    * true after this call.
@@ -60,10 +58,9 @@ class TracedReferenceBase {
   /**
    * Construct a Local<Value> from this handle.
    */
-  V8_INLINE v8::Local<v8::Value> Get(v8::Isolate* isolate) const {
+  V8_INLINE Local<Value> Get(Isolate* isolate) const {
     if (IsEmpty()) return Local<Value>();
-    return Local<Value>::New(isolate,
-                             internal::ValueHelper::SlotAsValue<Value>(val_));
+    return Local<Value>::New(isolate, this->value<Value>());
   }
 
   /**
@@ -86,11 +83,13 @@ class TracedReferenceBase {
   V8_INLINE uint16_t WrapperClassId() const;
 
  protected:
+  V8_INLINE TracedReferenceBase() = default;
+
   /**
    * Update this reference in a thread-safe way.
    */
   void SetSlotThreadSafe(void* new_val) {
-    reinterpret_cast<std::atomic<void*>*>(&val_)->store(
+    reinterpret_cast<std::atomic<void*>*>(&slot())->store(
         new_val, std::memory_order_relaxed);
   }
 
@@ -98,19 +97,13 @@ class TracedReferenceBase {
    * Get this reference in a thread-safe way
    */
   const void* GetSlotThreadSafe() const {
-    return reinterpret_cast<std::atomic<const void*> const*>(&val_)->load(
+    return reinterpret_cast<std::atomic<const void*> const*>(&slot())->load(
         std::memory_order_relaxed);
   }
 
   V8_EXPORT void CheckValue() const;
 
-  V8_INLINE internal::Address address() const { return *val_; }
-
-  // val_ points to a GlobalHandles node.
-  internal::Address* val_ = nullptr;
-
   friend class internal::BasicTracedReferenceExtractor;
-  friend class internal::HandleHelper;
   template <typename F>
   friend class Local;
   template <typename U>
@@ -139,12 +132,7 @@ class BasicTracedReference : public TracedReferenceBase {
   /**
    * Construct a Local<T> from this handle.
    */
-  Local<T> Get(Isolate* isolate) const {
-#ifdef V8_ENABLE_CONSERVATIVE_STACK_SCANNING
-    if (val_ == nullptr) return Local<T>();
-#endif
-    return Local<T>::New(isolate, *this);
-  }
+  Local<T> Get(Isolate* isolate) const { return Local<T>::New(isolate, *this); }
 
   template <class S>
   V8_INLINE BasicTracedReference<S>& As() const {
@@ -152,19 +140,17 @@ class BasicTracedReference : public TracedReferenceBase {
         const_cast<BasicTracedReference<T>&>(*this));
   }
 
-  T* operator->() const {
+  V8_DEPRECATE_SOON("Use Get to convert to Local instead")
+  V8_INLINE T* operator->() const {
 #ifdef V8_ENABLE_CHECKS
     CheckValue();
 #endif  // V8_ENABLE_CHECKS
-    return reinterpret_cast<T*>(val_);
-  }
-  T* operator*() const {
-#ifdef V8_ENABLE_CHECKS
-    CheckValue();
-#endif  // V8_ENABLE_CHECKS
-    return reinterpret_cast<T*>(val_);
+    return this->template value<T>();
   }
 
+  V8_DEPRECATE_SOON("Use Get to convert to Local instead")
+  V8_INLINE T* operator*() const { return this->operator->(); }
+
  private:
   /**
    * An empty BasicTracedReference without storage cell.
@@ -172,7 +158,7 @@ class BasicTracedReference : public TracedReferenceBase {
   BasicTracedReference() = default;
 
   V8_INLINE static internal::Address* New(
-      Isolate* isolate, T* that, void* slot,
+      Isolate* isolate, T* that, internal::Address** slot,
       internal::GlobalHandleStoreMode store_mode);
 
   template <typename F>
@@ -199,7 +185,7 @@ class TracedReference : public BasicTracedReference<T> {
   /**
    * An empty TracedReference without storage cell.
    */
-  TracedReference() : BasicTracedReference<T>() {}
+  V8_INLINE TracedReference() = default;
 
   /**
    * Construct a TracedReference from a Local.
@@ -209,8 +195,9 @@ class TracedReference : public BasicTracedReference<T> {
    */
   template <class S>
   TracedReference(Isolate* isolate, Local<S> that) : BasicTracedReference<T>() {
-    this->val_ = this->New(isolate, *that, &this->val_,
-                           internal::GlobalHandleStoreMode::kInitializingStore);
+    this->slot() =
+        this->New(isolate, *that, &this->slot(),
+                  internal::GlobalHandleStoreMode::kInitializingStore);
     static_assert(std::is_base_of<T, S>::value, "type check");
   }
 
@@ -291,18 +278,18 @@ class TracedReference : public BasicTracedReference<T> {
 // --- Implementation ---
 template <class T>
 internal::Address* BasicTracedReference<T>::New(
-    Isolate* isolate, T* that, void* slot,
+    Isolate* isolate, T* that, internal::Address** slot,
     internal::GlobalHandleStoreMode store_mode) {
-  if (that == internal::ValueHelper::EmptyValue<T>()) return nullptr;
-  internal::Address* p = reinterpret_cast<internal::Address*>(that);
+  if (internal::ValueHelper::IsEmpty(that)) return nullptr;
   return internal::GlobalizeTracedReference(
-      reinterpret_cast<internal::Isolate*>(isolate), p,
+      reinterpret_cast<internal::Isolate*>(isolate),
+      internal::ValueHelper::ValueAsAddress(that),
       reinterpret_cast<internal::Address*>(slot), store_mode);
 }
 
 void TracedReferenceBase::Reset() {
   if (IsEmpty()) return;
-  internal::DisposeTracedReference(reinterpret_cast<internal::Address*>(val_));
+  internal::DisposeTracedReference(slot());
   SetSlotThreadSafe(nullptr);
 }
 
@@ -347,7 +334,7 @@ void TracedReference<T>::Reset(Isolate* isolate, const Local<S>& other) {
   this->Reset();
   if (other.IsEmpty()) return;
   this->SetSlotThreadSafe(
-      this->New(isolate, *other, &this->val_,
+      this->New(isolate, *other, &this->slot(),
                 internal::GlobalHandleStoreMode::kAssigningStore));
 }
 
@@ -373,9 +360,7 @@ template <class T>
 TracedReference<T>& TracedReference<T>::operator=(
     TracedReference&& rhs) noexcept {
   if (this != &rhs) {
-    internal::MoveTracedReference(
-        reinterpret_cast<internal::Address**>(&rhs.val_),
-        reinterpret_cast<internal::Address**>(&this->val_));
+    internal::MoveTracedReference(&rhs.slot(), &this->slot());
   }
   return *this;
 }
@@ -384,10 +369,8 @@ template <class T>
 TracedReference<T>& TracedReference<T>::operator=(const TracedReference& rhs) {
   if (this != &rhs) {
     this->Reset();
-    if (rhs.val_ != nullptr) {
-      internal::CopyTracedReference(
-          reinterpret_cast<const internal::Address* const*>(&rhs.val_),
-          reinterpret_cast<internal::Address**>(&this->val_));
+    if (!rhs.IsEmpty()) {
+      internal::CopyTracedReference(&rhs.slot(), &this->slot());
     }
   }
   return *this;
@@ -396,16 +379,16 @@ TracedReference<T>& TracedReference<T>::operator=(const TracedReference& rhs) {
 void TracedReferenceBase::SetWrapperClassId(uint16_t class_id) {
   using I = internal::Internals;
   if (IsEmpty()) return;
-  internal::Address* obj = reinterpret_cast<internal::Address*>(val_);
-  uint8_t* addr = reinterpret_cast<uint8_t*>(obj) + I::kTracedNodeClassIdOffset;
+  uint8_t* addr =
+      reinterpret_cast<uint8_t*>(slot()) + I::kTracedNodeClassIdOffset;
   *reinterpret_cast<uint16_t*>(addr) = class_id;
 }
 
 uint16_t TracedReferenceBase::WrapperClassId() const {
   using I = internal::Internals;
   if (IsEmpty()) return 0;
-  internal::Address* obj = reinterpret_cast<internal::Address*>(val_);
-  uint8_t* addr = reinterpret_cast<uint8_t*>(obj) + I::kTracedNodeClassIdOffset;
+  uint8_t* addr =
+      reinterpret_cast<uint8_t*>(slot()) + I::kTracedNodeClassIdOffset;
   return *reinterpret_cast<uint16_t*>(addr);
 }
 

data/vendor/v8/include/v8-unwinder.h

@@ -33,7 +33,7 @@ struct V8_EXPORT RegisterState {
 };
 
 // A StateTag represents a possible state of the VM.
-enum StateTag : int {
+enum StateTag : uint16_t {
   JS,
   GC,
   PARSER,

data/vendor/v8/include/v8-util.h

@@ -182,7 +182,7 @@ class PersistentValueMapBase {
    */
   Local<V> Get(const K& key) {
     V* p = FromVal(Traits::Get(&impl_, key));
-#ifdef V8_ENABLE_CONSERVATIVE_STACK_SCANNING
+#ifdef V8_ENABLE_DIRECT_LOCAL
     if (p == nullptr) return Local<V>();
 #endif
     return Local<V>::New(isolate_, p);
@@ -302,13 +302,13 @@ class PersistentValueMapBase {
   }
 
   static PersistentContainerValue ClearAndLeak(Global<V>* persistent) {
-    V* v = persistent->val_;
-    persistent->val_ = nullptr;
-    return reinterpret_cast<PersistentContainerValue>(v);
+    internal::Address* address = persistent->slot();
+    persistent->Clear();
+    return reinterpret_cast<PersistentContainerValue>(address);
   }
 
   static PersistentContainerValue Leak(Global<V>* persistent) {
-    return reinterpret_cast<PersistentContainerValue>(persistent->val_);
+    return reinterpret_cast<PersistentContainerValue>(persistent->slot());
   }
 
   /**
@@ -318,7 +318,7 @@ class PersistentValueMapBase {
    */
   static Global<V> Release(PersistentContainerValue v) {
     Global<V> p;
-    p.val_ = FromVal(v);
+    p.slot() = reinterpret_cast<internal::Address*>(FromVal(v));
     if (Traits::kCallbackType != kNotWeak && p.IsWeak()) {
       Traits::DisposeCallbackData(
           p.template ClearWeak<typename Traits::WeakCallbackDataType>());
@@ -328,7 +328,8 @@ class PersistentValueMapBase {
 
   void RemoveWeak(const K& key) {
     Global<V> p;
-    p.val_ = FromVal(Traits::Remove(&impl_, key));
+    p.slot() = reinterpret_cast<internal::Address*>(
+        FromVal(Traits::Remove(&impl_, key)));
     p.Reset();
   }
 
@@ -396,7 +397,7 @@ class PersistentValueMap : public PersistentValueMapBase<K, V, Traits> {
           Traits::kCallbackType == kWeakWithInternalFields
               ? WeakCallbackType::kInternalFields
               : WeakCallbackType::kParameter;
-      Local<V> value(Local<V>::New(this->isolate(), *persistent));
+      auto value = Local<V>::New(this->isolate(), *persistent);
       persistent->template SetWeak<typename Traits::WeakCallbackDataType>(
           Traits::WeakCallbackParameter(this, key, value), WeakCallback,
           callback_type);
@@ -472,7 +473,7 @@ class GlobalValueMap : public PersistentValueMapBase<K, V, Traits> {
           Traits::kCallbackType == kWeakWithInternalFields
               ? WeakCallbackType::kInternalFields
               : WeakCallbackType::kParameter;
-      Local<V> value(Local<V>::New(this->isolate(), *persistent));
+      auto value = Local<V>::New(this->isolate(), *persistent);
       persistent->template SetWeak<typename Traits::WeakCallbackDataType>(
           Traits::WeakCallbackParameter(this, key, value), OnWeakCallback,
           callback_type);
@@ -629,7 +630,8 @@ class V8_DEPRECATE_SOON("Use std::vector<Global<V>>.") PersistentValueVector {
     size_t length = Traits::Size(&impl_);
     for (size_t i = 0; i < length; i++) {
       Global<V> p;
-      p.val_ = FromVal(Traits::Get(&impl_, i));
+      p.slot() =
+          reinterpret_cast<internal::Address>(FromVal(Traits::Get(&impl_, i)));
     }
     Traits::Clear(&impl_);
   }
@@ -644,9 +646,9 @@ class V8_DEPRECATE_SOON("Use std::vector<Global<V>>.") PersistentValueVector {
 
  private:
   static PersistentContainerValue ClearAndLeak(Global<V>* persistent) {
-    V* v = persistent->val_;
-    persistent->val_ = nullptr;
-    return reinterpret_cast<PersistentContainerValue>(v);
+    auto slot = persistent->slot();
+    persistent->Clear();
+    return reinterpret_cast<PersistentContainerValue>(slot);
   }
 
   static V* FromVal(PersistentContainerValue v) {

data/vendor/v8/include/v8-value-serializer.h

@@ -75,6 +75,20 @@ class V8_EXPORT ValueSerializer {
      */
     virtual void ThrowDataCloneError(Local<String> message) = 0;
 
+    /**
+     * The embedder overrides this method to enable custom host object filter
+     * with Delegate::IsHostObject.
+     *
+     * This method is called at most once per serializer.
+     */
+    virtual bool HasCustomHostObject(Isolate* isolate);
+
+    /**
+     * The embedder overrides this method to determine if an JS object is a
+     * host object and needs to be serialized by the host.
+     */
+    virtual Maybe<bool> IsHostObject(Isolate* isolate, Local<Object> object);
+
     /**
      * The embedder overrides this method to write some kind of host object, if
      * possible. If not, a suitable exception should be thrown and

data/vendor/v8/include/v8-value.h

@@ -16,6 +16,8 @@
  */
 namespace v8 {
 
+class Primiitive;
+class Numeric;
 class BigInt;
 class Int32;
 class Integer;
@@ -354,6 +356,18 @@ class V8_EXPORT Value : public Data {
    */
   bool IsModuleNamespaceObject() const;
 
+  /**
+   * Perform `ToPrimitive(value)` as specified in:
+   * https://tc39.es/ecma262/#sec-toprimitive.
+   */
+  V8_WARN_UNUSED_RESULT MaybeLocal<Primitive> ToPrimitive(
+      Local<Context> context) const;
+  /**
+   * Perform `ToNumeric(value)` as specified in:
+   * https://tc39.es/ecma262/#sec-tonumeric.
+   */
+  V8_WARN_UNUSED_RESULT MaybeLocal<Numeric> ToNumeric(
+      Local<Context> context) const;
   /**
    * Perform the equivalent of `BigInt(value)` in JS.
    */