libv8-node 19.9.0.0-aarch64-linux → 20.2.0.0-aarch64-linux

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

@@ -233,7 +233,7 @@ class V8_EXPORT Isolate {
      * Explicitly specify a startup snapshot blob. The embedder owns the blob.
      * The embedder *must* ensure that the snapshot is from a trusted source.
      */
-    StartupData* snapshot_blob = nullptr;
+    const StartupData* snapshot_blob = nullptr;
 
     /**
      * Enables the host application to provide a mechanism for recording
@@ -333,12 +333,9 @@ class V8_EXPORT Isolate {
         const DisallowJavascriptExecutionScope&) = delete;
 
    private:
-    OnFailure on_failure_;
-    v8::Isolate* v8_isolate_;
-
-    bool was_execution_allowed_assert_;
-    bool was_execution_allowed_throws_;
-    bool was_execution_allowed_dump_;
+    v8::Isolate* const v8_isolate_;
+    const OnFailure on_failure_;
+    bool was_execution_allowed_;
   };
 
   /**
@@ -356,7 +353,7 @@ class V8_EXPORT Isolate {
         const AllowJavascriptExecutionScope&) = delete;
 
    private:
-    Isolate* v8_isolate_;
+    Isolate* const v8_isolate_;
     bool was_execution_allowed_assert_;
     bool was_execution_allowed_throws_;
     bool was_execution_allowed_dump_;
@@ -537,6 +534,8 @@ class V8_EXPORT Isolate {
     kTurboFanOsrCompileStarted = 115,
     kAsyncStackTaggingCreateTaskCall = 116,
     kDurationFormat = 117,
+    kInvalidatedNumberStringPrototypeNoReplaceProtector = 118,
+    kRegExpUnicodeSetIncompatibilitiesWithUnicodeMode = 119,  // Unused.
 
     // If you add new values here, you'll also need to update Chromium's:
     // web_feature.mojom, use_counter_callback.cc, and enums.xml. V8 changes to
@@ -924,27 +923,10 @@ class V8_EXPORT Isolate {
   void RemoveGCPrologueCallback(GCCallbackWithData, void* data = nullptr);
   void RemoveGCPrologueCallback(GCCallback callback);
 
-  START_ALLOW_USE_DEPRECATED()
-  /**
-   * Sets the embedder heap tracer for the isolate.
-   * SetEmbedderHeapTracer cannot be used simultaneously with AttachCppHeap.
-   */
-  void SetEmbedderHeapTracer(EmbedderHeapTracer* tracer);
-
-  /*
-   * Gets the currently active heap tracer for the isolate that was set with
-   * SetEmbedderHeapTracer.
-   */
-  EmbedderHeapTracer* GetEmbedderHeapTracer();
-  END_ALLOW_USE_DEPRECATED()
-
   /**
    * Sets an embedder roots handle that V8 should consider when performing
-   * non-unified heap garbage collections.
-   *
-   * Using only EmbedderHeapTracer automatically sets up a default handler.
-   * The intended use case is for setting a custom handler after invoking
-   * `AttachCppHeap()`.
+   * non-unified heap garbage collections. The intended use case is for setting
+   * a custom handler after invoking `AttachCppHeap()`.
    *
    * V8 does not take ownership of the handler.
    */
@@ -954,22 +936,18 @@ class V8_EXPORT Isolate {
    * Attaches a managed C++ heap as an extension to the JavaScript heap. The
    * embedder maintains ownership of the CppHeap. At most one C++ heap can be
    * attached to V8.
-   * AttachCppHeap cannot be used simultaneously with SetEmbedderHeapTracer.
    *
-   * This is an experimental feature and may still change significantly.
+   * Multi-threaded use requires the use of v8::Locker/v8::Unlocker, see
+   * CppHeap.
    */
   void AttachCppHeap(CppHeap*);
 
   /**
    * Detaches a managed C++ heap if one was attached using `AttachCppHeap()`.
-   *
-   * This is an experimental feature and may still change significantly.
    */
   void DetachCppHeap();
 
   /**
-   * This is an experimental feature and may still change significantly.
-
    * \returns the C++ heap managed by V8. Only available if such a heap has been
    *   attached using `AttachCppHeap()`.
    */
@@ -1145,9 +1123,8 @@ class V8_EXPORT Isolate {
    *
    * This should only be used for testing purposes and not to enforce a garbage
    * collection schedule. It has strong negative impact on the garbage
-   * collection performance. Use IdleNotificationDeadline() or
-   * LowMemoryNotification() instead to influence the garbage collection
-   * schedule.
+   * collection performance. Use MemoryPressureNotification() instead to
+   * influence the garbage collection schedule.
    */
   void RequestGarbageCollectionForTesting(GarbageCollectionType type);
 
@@ -1158,9 +1135,8 @@ class V8_EXPORT Isolate {
    *
    * This should only be used for testing purposes and not to enforce a garbage
    * collection schedule. It has strong negative impact on the garbage
-   * collection performance. Use IdleNotificationDeadline() or
-   * LowMemoryNotification() instead to influence the garbage collection
-   * schedule.
+   * collection performance. Use MemoryPressureNotification() instead to
+   * influence the garbage collection schedule.
    */
   void RequestGarbageCollectionForTesting(GarbageCollectionType type,
                                           StackState stack_state);
@@ -1312,6 +1288,8 @@ class V8_EXPORT Isolate {
    * that function. There is no guarantee that the actual work will be done
    * within the time limit.
    */
+  V8_DEPRECATE_SOON(
+      "Use MemoryPressureNotification() to influence the GC schedule.")
   bool IdleNotificationDeadline(double deadline_in_seconds);
 
   /**
@@ -1348,11 +1326,13 @@ class V8_EXPORT Isolate {
    * V8 uses this notification to guide heuristics which may result in a
    * smaller memory footprint at the cost of reduced runtime performance.
    */
+  V8_DEPRECATED("Use IsolateInBackgroundNotification() instead")
   void EnableMemorySavingsMode();
 
   /**
    * Optional notification which will disable the memory savings mode.
    */
+  V8_DEPRECATED("Use IsolateInBackgroundNotification() instead")
   void DisableMemorySavingsMode();
 
   /**
@@ -1526,10 +1506,19 @@ class V8_EXPORT Isolate {
 
   void SetWasmLoadSourceMapCallback(WasmLoadSourceMapCallback callback);
 
+  V8_DEPRECATED("Wasm SIMD is always enabled")
   void SetWasmSimdEnabledCallback(WasmSimdEnabledCallback callback);
 
+  V8_DEPRECATED("Wasm exceptions are always enabled")
   void SetWasmExceptionsEnabledCallback(WasmExceptionsEnabledCallback callback);
 
+  /**
+   * Register callback to control whehter Wasm GC is enabled.
+   * The callback overwrites the value of the flag.
+   * If the callback returns true, it will also enable Wasm stringrefs.
+   */
+  void SetWasmGCEnabledCallback(WasmGCEnabledCallback callback);
+
   void SetSharedArrayBufferConstructorEnabledCallback(
       SharedArrayBufferConstructorEnabledCallback callback);
 
@@ -1684,7 +1673,8 @@ uint32_t Isolate::GetNumberOfDataSlots() {
 
 template <class T>
 MaybeLocal<T> Isolate::GetDataFromSnapshotOnce(size_t index) {
-  T* data = reinterpret_cast<T*>(GetDataFromSnapshotOnce(index));
+  T* data =
+      internal::ValueHelper::SlotAsValue<T>(GetDataFromSnapshotOnce(index));
   if (data) internal::PerformCastCheck(data);
   return Local<T>(data);
 }

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

@@ -50,9 +50,14 @@ class TracedReference;
 class TracedReferenceBase;
 class Utils;
 
+namespace debug {
+class ConsoleCallArguments;
+}
+
 namespace internal {
 template <typename T>
 class CustomArguments;
+class SamplingHeapProfiler;
 }  // namespace internal
 
 namespace api_internal {
@@ -92,6 +97,9 @@ class V8_EXPORT V8_NODISCARD HandleScope {
   HandleScope(const HandleScope&) = delete;
   void operator=(const HandleScope&) = delete;
 
+  static internal::Address* CreateHandleForCurrentIsolate(
+      internal::Address value);
+
  protected:
   V8_INLINE HandleScope() = default;
 
@@ -122,6 +130,33 @@ class V8_EXPORT V8_NODISCARD HandleScope {
   friend class Context;
 };
 
+namespace internal {
+
+/**
+ * Helper functions about handles.
+ */
+class HandleHelper final {
+ public:
+  /**
+   * Checks whether two handles are equal.
+   * They are equal iff they are both empty or they are both non-empty and the
+   * objects to which they refer are physically equal.
+   *
+   * If both handles refer to JS objects, this is the same as strict equality.
+   * For primitives, such as numbers or strings, a `false` return value does not
+   * indicate that the values aren't equal in the JavaScript sense.
+   * Use `Value::StrictEquals()` to check primitives for equality.
+   */
+  template <typename T1, typename T2>
+  V8_INLINE static bool EqualHandles(const T1& lhs, const T2& rhs) {
+    if (lhs.IsEmpty()) return rhs.IsEmpty();
+    if (rhs.IsEmpty()) return false;
+    return lhs.address() == rhs.address();
+  }
+};
+
+}  // namespace internal
+
 /**
  * An object reference managed by the v8 garbage collector.
  *
@@ -154,7 +189,8 @@ class V8_EXPORT V8_NODISCARD HandleScope {
 template <class T>
 class Local {
  public:
-  V8_INLINE Local() : val_(nullptr) {}
+  V8_INLINE Local() : val_(internal::ValueHelper::EmptyValue<T>()) {}
+
   template <class S>
   V8_INLINE Local(Local<S> that) : val_(reinterpret_cast<T*>(*that)) {
     /**
@@ -168,55 +204,40 @@ class Local {
   /**
    * Returns true if the handle is empty.
    */
-  V8_INLINE bool IsEmpty() const { return val_ == nullptr; }
+  V8_INLINE bool IsEmpty() const {
+    return val_ == internal::ValueHelper::EmptyValue<T>();
+  }
 
   /**
    * Sets the handle to be empty. IsEmpty() will then return true.
    */
-  V8_INLINE void Clear() { val_ = nullptr; }
+  V8_INLINE void Clear() { val_ = internal::ValueHelper::EmptyValue<T>(); }
 
   V8_INLINE T* operator->() const { return val_; }
 
   V8_INLINE T* operator*() const { return val_; }
 
   /**
-   * Checks whether two handles are the same.
-   * Returns true if both are empty, or if the objects to which they refer
-   * are identical.
+   * Checks whether two handles are equal or different.
+   * They are equal iff they are both empty or they are both non-empty and the
+   * objects to which they refer are physically equal.
    *
-   * If both handles refer to JS objects, this is the same as strict equality.
-   * For primitives, such as numbers or strings, a `false` return value does not
-   * indicate that the values aren't equal in the JavaScript sense.
-   * Use `Value::StrictEquals()` to check primitives for equality.
+   * If both handles refer to JS objects, this is the same as strict
+   * non-equality. For primitives, such as numbers or strings, a `true` return
+   * value does not indicate that the values aren't equal in the JavaScript
+   * sense. Use `Value::StrictEquals()` to check primitives for equality.
    */
+
   template <class S>
   V8_INLINE bool operator==(const Local<S>& that) const {
-    internal::Address* a = reinterpret_cast<internal::Address*>(this->val_);
-    internal::Address* b = reinterpret_cast<internal::Address*>(that.val_);
-    if (a == nullptr) return b == nullptr;
-    if (b == nullptr) return false;
-    return *a == *b;
+    return internal::HandleHelper::EqualHandles(*this, that);
   }
 
   template <class S>
   V8_INLINE bool operator==(const PersistentBase<S>& that) const {
-    internal::Address* a = reinterpret_cast<internal::Address*>(this->val_);
-    internal::Address* b = reinterpret_cast<internal::Address*>(that.val_);
-    if (a == nullptr) return b == nullptr;
-    if (b == nullptr) return false;
-    return *a == *b;
+    return internal::HandleHelper::EqualHandles(*this, that);
   }
 
-  /**
-   * Checks whether two handles are different.
-   * Returns true if only one of the handles is empty, or if
-   * the objects to which they refer are different.
-   *
-   * If both handles refer to JS objects, this is the same as strict
-   * non-equality. For primitives, such as numbers or strings, a `true` return
-   * value does not indicate that the values aren't equal in the JavaScript
-   * sense. Use `Value::StrictEquals()` to check primitives for equality.
-   */
   template <class S>
   V8_INLINE bool operator!=(const Local<S>& that) const {
     return !operator==(that);
@@ -263,12 +284,12 @@ class Local {
 
   V8_INLINE static Local<T> New(Isolate* isolate,
                                 const PersistentBase<T>& that) {
-    return New(isolate, that.val_);
+    return New(isolate, internal::ValueHelper::SlotAsValue<T>(that.val_));
   }
 
   V8_INLINE static Local<T> New(Isolate* isolate,
                                 const BasicTracedReference<T>& that) {
-    return New(isolate, *that);
+    return New(isolate, internal::ValueHelper::SlotAsValue<T>(*that));
   }
 
  private:
@@ -277,12 +298,6 @@ class Local {
   template <class F>
   friend class Eternal;
   template <class F>
-  friend class PersistentBase;
-  template <class F, class M>
-  friend class Persistent;
-  template <class F>
-  friend class Local;
-  template <class F>
   friend class MaybeLocal;
   template <class F>
   friend class FunctionCallbackInfo;
@@ -309,19 +324,31 @@ class Local {
   friend class ReturnValue;
   template <class F>
   friend class Traced;
-  template <class F>
-  friend class BasicTracedReference;
-  template <class F>
-  friend class TracedReference;
+  friend class internal::SamplingHeapProfiler;
+  friend class internal::HandleHelper;
+  friend class debug::ConsoleCallArguments;
 
   explicit V8_INLINE Local(T* that) : val_(that) {}
+
+  V8_INLINE internal::Address address() const {
+    return internal::ValueHelper::ValueAsAddress(val_);
+  }
+
+  V8_INLINE static Local<T> FromSlot(internal::Address* slot) {
+    return Local<T>(internal::ValueHelper::SlotAsValue<T>(slot));
+  }
+
   V8_INLINE static Local<T> New(Isolate* isolate, T* that) {
+#ifdef V8_ENABLE_CONSERVATIVE_STACK_SCANNING
+    return Local<T>(that);
+#else
     if (that == nullptr) return Local<T>();
-    T* that_ptr = that;
-    internal::Address* p = reinterpret_cast<internal::Address*>(that_ptr);
+    internal::Address* p = reinterpret_cast<internal::Address*>(that);
     return Local<T>(reinterpret_cast<T*>(HandleScope::CreateHandle(
         reinterpret_cast<internal::Isolate*>(isolate), *p)));
+#endif
   }
+
   T* val_;
 };
 
@@ -344,13 +371,15 @@ using Handle = Local<T>;
 template <class T>
 class MaybeLocal {
  public:
-  V8_INLINE MaybeLocal() : val_(nullptr) {}
+  V8_INLINE MaybeLocal() : val_(internal::ValueHelper::EmptyValue<T>()) {}
   template <class S>
   V8_INLINE MaybeLocal(Local<S> that) : val_(reinterpret_cast<T*>(*that)) {
     static_assert(std::is_base_of<T, S>::value, "type check");
   }
 
-  V8_INLINE bool IsEmpty() const { return val_ == nullptr; }
+  V8_INLINE bool IsEmpty() const {
+    return val_ == internal::ValueHelper::EmptyValue<T>();
+  }
 
   /**
    * Converts this MaybeLocal<> to a Local<>. If this MaybeLocal<> is empty,
@@ -358,7 +387,7 @@ class MaybeLocal {
    */
   template <class S>
   V8_WARN_UNUSED_RESULT V8_INLINE bool ToLocal(Local<S>* out) const {
-    out->val_ = IsEmpty() ? nullptr : this->val_;
+    out->val_ = IsEmpty() ? internal::ValueHelper::EmptyValue<T>() : this->val_;
     return !IsEmpty();
   }
 
@@ -367,7 +396,7 @@ class MaybeLocal {
    * V8 will crash the process.
    */
   V8_INLINE Local<T> ToLocalChecked() {
-    if (V8_UNLIKELY(val_ == nullptr)) api_internal::ToLocalEmpty();
+    if (V8_UNLIKELY(IsEmpty())) api_internal::ToLocalEmpty();
     return Local<T>(val_);
   }
 
@@ -399,9 +428,13 @@ class V8_EXPORT V8_NODISCARD EscapableHandleScope : public HandleScope {
    */
   template <class T>
   V8_INLINE Local<T> Escape(Local<T> value) {
+#ifdef V8_ENABLE_CONSERVATIVE_STACK_SCANNING
+    return value;
+#else
     internal::Address* slot =
         Escape(reinterpret_cast<internal::Address*>(*value));
     return Local<T>(reinterpret_cast<T*>(slot));
+#endif
   }
 
   template <class T>

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

@@ -12,6 +12,7 @@
 
 #include "v8-internal.h"      // NOLINT(build/include_directory)
 #include "v8-local-handle.h"  // NOLINT(build/include_directory)
+#include "v8config.h"         // NOLINT(build/include_directory)
 
 namespace v8 {
 
@@ -96,16 +97,42 @@ struct GarbageCollectionYoungCycle {
 };
 
 struct WasmModuleDecoded {
+  WasmModuleDecoded() = default;
+  WasmModuleDecoded(bool async, bool streamed, bool success,
+                    size_t module_size_in_bytes, size_t function_count,
+                    int64_t wall_clock_duration_in_us)
+      : async(async),
+        streamed(streamed),
+        success(success),
+        module_size_in_bytes(module_size_in_bytes),
+        function_count(function_count),
+        wall_clock_duration_in_us(wall_clock_duration_in_us) {}
+
   bool async = false;
   bool streamed = false;
   bool success = false;
   size_t module_size_in_bytes = 0;
   size_t function_count = 0;
   int64_t wall_clock_duration_in_us = -1;
-  int64_t cpu_duration_in_us = -1;
 };
 
 struct WasmModuleCompiled {
+  WasmModuleCompiled() = default;
+
+  WasmModuleCompiled(bool async, bool streamed, bool cached, bool deserialized,
+                     bool lazy, bool success, size_t code_size_in_bytes,
+                     size_t liftoff_bailout_count,
+                     int64_t wall_clock_duration_in_us)
+      : async(async),
+        streamed(streamed),
+        cached(cached),
+        deserialized(deserialized),
+        lazy(lazy),
+        success(success),
+        code_size_in_bytes(code_size_in_bytes),
+        liftoff_bailout_count(liftoff_bailout_count),
+        wall_clock_duration_in_us(wall_clock_duration_in_us) {}
+
   bool async = false;
   bool streamed = false;
   bool cached = false;
@@ -115,7 +142,6 @@ struct WasmModuleCompiled {
   size_t code_size_in_bytes = 0;
   size_t liftoff_bailout_count = 0;
   int64_t wall_clock_duration_in_us = -1;
-  int64_t cpu_duration_in_us = -1;
 };
 
 struct WasmModuleInstantiated {

data/vendor/v8/include/v8-microtask-queue.h

@@ -118,7 +118,12 @@ class V8_EXPORT V8_NODISCARD MicrotasksScope {
  public:
   enum Type { kRunMicrotasks, kDoNotRunMicrotasks };
 
+  V8_DEPRECATE_SOON(
+      "May be incorrect if context was created with non-default microtask "
+      "queue")
   MicrotasksScope(Isolate* isolate, Type type);
+
+  MicrotasksScope(Local<Context> context, Type type);
   MicrotasksScope(Isolate* isolate, MicrotaskQueue* microtask_queue, Type type);
   ~MicrotasksScope();
 

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

@@ -607,6 +607,19 @@ class V8_EXPORT Object : public Value {
     return object.val_->GetCreationContext();
   }
 
+  /**
+   * Gets the context in which the object was created (see GetCreationContext())
+   * and if it's available reads respective embedder field value.
+   * If the context can't be obtained nullptr is returned.
+   * Basically it's a shortcut for
+   *   obj->GetCreationContext().GetAlignedPointerFromEmbedderData(index)
+   * which doesn't create a handle for Context object on the way and doesn't
+   * try to expand the embedder data attached to the context.
+   * In case the Local<Context> is already available because of other reasons,
+   * it's fine to keep using Context::GetAlignedPointerFromEmbedderData().
+   */
+  void* GetAlignedPointerFromEmbedderDataInCreationContext(int index);
+
   /**
    * Checks whether a callback is set by the
    * ObjectTemplate::SetCallAsFunctionHandler method.
@@ -707,7 +720,7 @@ Local<Value> Object::GetInternalField(int index) {
 #ifndef V8_ENABLE_CHECKS
   using A = internal::Address;
   using I = internal::Internals;
-  A obj = *reinterpret_cast<A*>(this);
+  A obj = internal::ValueHelper::ValueAsAddress(this);
   // Fast path: If the object is a plain JSObject, which is the common case, we
   // know where to find the internal fields and can return the value directly.
   int instance_type = I::GetInstanceType(obj);
@@ -717,12 +730,17 @@ Local<Value> Object::GetInternalField(int index) {
 #ifdef V8_COMPRESS_POINTERS
     // We read the full pointer value and then decompress it in order to avoid
     // dealing with potential endiannes issues.
-    value = I::DecompressTaggedAnyField(obj, static_cast<uint32_t>(value));
+    value = I::DecompressTaggedField(obj, static_cast<uint32_t>(value));
 #endif
+
+#ifdef V8_ENABLE_CONSERVATIVE_STACK_SCANNING
+    return Local<Value>(reinterpret_cast<Value*>(value));
+#else
     internal::Isolate* isolate =
         internal::IsolateFromNeverReadOnlySpaceObject(obj);
     A* result = HandleScope::CreateHandle(isolate, value);
     return Local<Value>(reinterpret_cast<Value*>(result));
+#endif
   }
 #endif
   return SlowGetInternalField(index);
@@ -732,7 +750,7 @@ void* Object::GetAlignedPointerFromInternalField(int index) {
 #if !defined(V8_ENABLE_CHECKS)
   using A = internal::Address;
   using I = internal::Internals;
-  A obj = *reinterpret_cast<A*>(this);
+  A obj = internal::ValueHelper::ValueAsAddress(this);
   // Fast path: If the object is a plain JSObject, which is the common case, we
   // know where to find the internal fields and can return the value directly.
   auto instance_type = I::GetInstanceType(obj);

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

@@ -55,7 +55,7 @@ class Eternal {
   V8_INLINE Local<T> Get(Isolate* isolate) const {
     // The eternal handle will never go away, so as with the roots, we don't
     // even need to open a handle.
-    return Local<T>(val_);
+    return Local<T>(internal::ValueHelper::SlotAsValue<T>(val_));
   }
 
   V8_INLINE bool IsEmpty() const { return val_ == nullptr; }
@@ -68,6 +68,10 @@ class Eternal {
   }
 
  private:
+  V8_INLINE internal::Address address() const {
+    return *reinterpret_cast<internal::Address*>(val_);
+  }
+
   T* val_;
 };
 
@@ -122,20 +126,12 @@ class PersistentBase {
 
   template <class S>
   V8_INLINE bool operator==(const PersistentBase<S>& that) const {
-    internal::Address* a = reinterpret_cast<internal::Address*>(this->val_);
-    internal::Address* b = reinterpret_cast<internal::Address*>(that.val_);
-    if (a == nullptr) return b == nullptr;
-    if (b == nullptr) return false;
-    return *a == *b;
+    return internal::HandleHelper::EqualHandles(*this, that);
   }
 
   template <class S>
   V8_INLINE bool operator==(const Local<S>& that) const {
-    internal::Address* a = reinterpret_cast<internal::Address*>(this->val_);
-    internal::Address* b = reinterpret_cast<internal::Address*>(that.val_);
-    if (a == nullptr) return b == nullptr;
-    if (b == nullptr) return false;
-    return *a == *b;
+    return internal::HandleHelper::EqualHandles(*this, that);
   }
 
   template <class S>
@@ -221,8 +217,15 @@ class PersistentBase {
   template <class F1, class F2>
   friend class PersistentValueVector;
   friend class Object;
+  friend class internal::HandleHelper;
 
   explicit V8_INLINE PersistentBase(T* val) : val_(val) {}
+  V8_INLINE T* operator*() const { return this->val_; }
+  V8_INLINE internal::Address address() const {
+    return *reinterpret_cast<internal::Address*>(val_);
+  }
+
+  V8_INLINE static T* New(Isolate* isolate, Local<T> that);
   V8_INLINE static T* New(Isolate* isolate, T* that);
 
   T* val_;
@@ -282,11 +285,13 @@ class Persistent : public PersistentBase<T> {
    * When the Local is non-empty, a new storage cell is created
    * pointing to the same object, and no flags are set.
    */
+
   template <class S>
   V8_INLINE Persistent(Isolate* isolate, Local<S> that)
-      : PersistentBase<T>(PersistentBase<T>::New(isolate, *that)) {
+      : PersistentBase<T>(PersistentBase<T>::New(isolate, that)) {
     static_assert(std::is_base_of<T, S>::value, "type check");
   }
+
   /**
    * Construct a Persistent from a Persistent.
    * When the Persistent is non-empty, a new storage cell is created
@@ -356,7 +361,6 @@ class Persistent : public PersistentBase<T> {
   friend class ReturnValue;
 
   explicit V8_INLINE Persistent(T* that) : PersistentBase<T>(that) {}
-  V8_INLINE T* operator*() const { return this->val_; }
   template <class S, class M2>
   V8_INLINE void Copy(const Persistent<S, M2>& that);
 };
@@ -381,7 +385,7 @@ class Global : public PersistentBase<T> {
    */
   template <class S>
   V8_INLINE Global(Isolate* isolate, Local<S> that)
-      : PersistentBase<T>(PersistentBase<T>::New(isolate, *that)) {
+      : PersistentBase<T>(PersistentBase<T>::New(isolate, that)) {
     static_assert(std::is_base_of<T, S>::value, "type check");
   }
 
@@ -425,7 +429,6 @@ class Global : public PersistentBase<T> {
  private:
   template <class F>
   friend class ReturnValue;
-  V8_INLINE T* operator*() const { return this->val_; }
 };
 
 // UniquePersistent is an alias for Global for historical reason.
@@ -442,6 +445,12 @@ class V8_EXPORT PersistentHandleVisitor {
                                      uint16_t class_id) {}
 };
 
+template <class T>
+T* PersistentBase<T>::New(Isolate* isolate, Local<T> that) {
+  return PersistentBase<T>::New(isolate,
+                                internal::ValueHelper::ValueAsSlot(*that));
+}
+
 template <class T>
 T* PersistentBase<T>::New(Isolate* isolate, T* that) {
   if (that == nullptr) return nullptr;
@@ -486,7 +495,7 @@ void PersistentBase<T>::Reset(Isolate* isolate, const Local<S>& other) {
   static_assert(std::is_base_of<T, S>::value, "type check");
   Reset();
   if (other.IsEmpty()) return;
-  this->val_ = New(isolate, other.val_);
+  this->val_ = New(isolate, internal::ValueHelper::ValueAsSlot(*other));
 }
 
 /**