node-linux-s390x 21.7.3 → 22.0.0

package/include/node/v8-context.h

@@ -84,6 +84,29 @@ class V8_EXPORT Context : public Data {
    * created by a previous call to Context::New with the same global
    * template. The state of the global object will be completely reset
    * and only object identify will remain.
+   *
+   * \param internal_fields_deserializer An optional callback used
+   * to deserialize fields set by
+   * v8::Object::SetAlignedPointerInInternalField() in wrapper objects
+   * from the default context snapshot. It should match the
+   * SerializeInternalFieldsCallback() used by
+   * v8::SnapshotCreator::SetDefaultContext() when the default context
+   * snapshot is created. It does not need to be configured if the default
+   * context snapshot contains no wrapper objects with pointer internal
+   * fields, or if no custom startup snapshot is configured
+   * in the v8::CreateParams used to create the isolate.
+   *
+   * \param microtask_queue An optional microtask queue used to manage
+   * the microtasks created in this context. If not set the per-isolate
+   * default microtask queue would be used.
+   *
+   * \param context_data_deserializer An optional callback used
+   * to deserialize embedder data set by
+   * v8::Context::SetAlignedPointerInEmbedderData() in the default
+   * context from the default context snapshot. It does not need to be
+   * configured if the default context snapshot contains no pointer embedder
+   * data, or if no custom startup snapshot is configured in the
+   * v8::CreateParams used to create the isolate.
    */
   static Local<Context> New(
       Isolate* isolate, ExtensionConfiguration* extensions = nullptr,
@@ -91,7 +114,9 @@ class V8_EXPORT Context : public Data {
       MaybeLocal<Value> global_object = MaybeLocal<Value>(),
       DeserializeInternalFieldsCallback internal_fields_deserializer =
           DeserializeInternalFieldsCallback(),
-      MicrotaskQueue* microtask_queue = nullptr);
+      MicrotaskQueue* microtask_queue = nullptr,
+      DeserializeContextDataCallback context_data_deserializer =
+          DeserializeContextDataCallback());
 
   /**
    * Create a new context from a (non-default) context snapshot. There
@@ -103,21 +128,37 @@ class V8_EXPORT Context : public Data {
    * \param context_snapshot_index The index of the context snapshot to
    * deserialize from. Use v8::Context::New for the default snapshot.
    *
-   * \param embedder_fields_deserializer Optional callback to deserialize
-   * internal fields. It should match the SerializeInternalFieldCallback used
-   * to serialize.
+   * \param internal_fields_deserializer An optional callback used
+   * to deserialize fields set by
+   * v8::Object::SetAlignedPointerInInternalField() in wrapper objects
+   * from the default context snapshot. It does not need to be
+   * configured if there are no wrapper objects with no internal
+   * pointer fields in the default context snapshot or if no startup
+   * snapshot is configured when the isolate is created.
    *
    * \param extensions See v8::Context::New.
    *
    * \param global_object See v8::Context::New.
+   *
+   * \param internal_fields_deserializer Similar to
+   * internal_fields_deserializer in v8::Context::New but applies to
+   * the context specified by the context_snapshot_index.
+   *
+   * \param microtask_queue  See v8::Context::New.
+   *
+   * \param context_data_deserializer  Similar to
+   * context_data_deserializer in v8::Context::New but applies to
+   * the context specified by the context_snapshot_index.
    */
   static MaybeLocal<Context> FromSnapshot(
       Isolate* isolate, size_t context_snapshot_index,
-      DeserializeInternalFieldsCallback embedder_fields_deserializer =
+      DeserializeInternalFieldsCallback internal_fields_deserializer =
           DeserializeInternalFieldsCallback(),
       ExtensionConfiguration* extensions = nullptr,
       MaybeLocal<Value> global_object = MaybeLocal<Value>(),
-      MicrotaskQueue* microtask_queue = nullptr);
+      MicrotaskQueue* microtask_queue = nullptr,
+      DeserializeContextDataCallback context_data_deserializer =
+          DeserializeContextDataCallback());
 
   /**
    * Returns an global object that isn't backed by an actual context.
@@ -182,7 +223,7 @@ class V8_EXPORT Context : public Data {
      * parameter. Returns true if the operation completed successfully.
      */
     virtual bool FreezeEmbedderObjectAndGetChildren(
-        Local<Object> obj, std::vector<Local<Object>>& children_out) = 0;
+        Local<Object> obj, LocalVector<Object>& children_out) = 0;
   };
 
   /**
@@ -309,18 +350,6 @@ class V8_EXPORT Context : public Data {
                                                 Local<Context> context);
   void SetAbortScriptExecution(AbortScriptExecutionCallback callback);
 
-  /**
-   * Returns the value that was set or restored by
-   * SetContinuationPreservedEmbedderData(), if any.
-   */
-  Local<Value> GetContinuationPreservedEmbedderData() const;
-
-  /**
-   * Sets a value that will be stored on continuations and reset while the
-   * continuation runs.
-   */
-  void SetContinuationPreservedEmbedderData(Local<Value> context);
-
   /**
    * Set or clear hooks to be invoked for promise lifecycle operations.
    * To clear a hook, set it to an empty v8::Function. Each function will
@@ -436,12 +465,12 @@ void* Context::GetAlignedPointerFromEmbedderData(int index) {
 
 template <class T>
 MaybeLocal<T> Context::GetDataFromSnapshotOnce(size_t index) {
-  auto slot = GetDataFromSnapshotOnce(index);
-  if (slot) {
+  if (auto slot = GetDataFromSnapshotOnce(index); slot) {
     internal::PerformCastCheck(
         internal::ValueHelper::SlotAsValue<T, false>(slot));
+    return Local<T>::FromSlot(slot);
   }
-  return Local<T>::FromSlot(slot);
+  return {};
 }
 
 Context* Context::Cast(v8::Data* data) {

package/include/node/v8-embedder-heap.h

@@ -9,6 +9,9 @@
 #include "v8config.h"          // NOLINT(build/include_directory)
 
 namespace v8 {
+namespace internal {
+class TracedHandles;
+}  // namespace internal
 
 class Isolate;
 class Value;
@@ -18,8 +21,17 @@ class Value;
  */
 class V8_EXPORT EmbedderRootsHandler {
  public:
+  enum class RootHandling {
+    kQueryEmbedderForNonDroppableReferences,
+    kDontQueryEmbedderForAnyReference,
+  };
+
   virtual ~EmbedderRootsHandler() = default;
 
+  EmbedderRootsHandler() = default;
+  explicit EmbedderRootsHandler(RootHandling default_traced_reference_handling)
+      : default_traced_reference_handling_(default_traced_reference_handling) {}
+
   /**
    * Returns true if the |TracedReference| handle should be considered as root
    * for the currently running non-tracing garbage collection and false
@@ -31,9 +43,7 @@ class V8_EXPORT EmbedderRootsHandler {
    * |TracedReference|.
    *
    * Note that the `handle` is different from the handle that the embedder holds
-   * for retaining the object. The embedder may use |WrapperClassId()| to
-   * distinguish cases where it wants handles to be treated as roots from not
-   * being treated as roots.
+   * for retaining the object.
    *
    * The concrete implementations must be thread-safe.
    */
@@ -59,6 +69,12 @@ class V8_EXPORT EmbedderRootsHandler {
     ResetRoot(handle);
     return true;
   }
+
+ private:
+  const RootHandling default_traced_reference_handling_ =
+      RootHandling::kQueryEmbedderForNonDroppableReferences;
+
+  friend class internal::TracedHandles;
 };
 
 }  // namespace v8

package/include/node/v8-embedder-state-scope.h

@@ -7,12 +7,13 @@
 
 #include <memory>
 
-#include "v8-context.h"       // NOLINT(build/include_directory)
 #include "v8-internal.h"      // NOLINT(build/include_directory)
 #include "v8-local-handle.h"  // NOLINT(build/include_directory)
 
 namespace v8 {
 
+class Context;
+
 namespace internal {
 class EmbedderState;
 }  // namespace internal

package/include/node/v8-exception.h

@@ -30,14 +30,21 @@ class ThreadLocalTop;
  */
 class V8_EXPORT Exception {
  public:
-  static Local<Value> RangeError(Local<String> message);
-  static Local<Value> ReferenceError(Local<String> message);
-  static Local<Value> SyntaxError(Local<String> message);
-  static Local<Value> TypeError(Local<String> message);
-  static Local<Value> WasmCompileError(Local<String> message);
-  static Local<Value> WasmLinkError(Local<String> message);
-  static Local<Value> WasmRuntimeError(Local<String> message);
-  static Local<Value> Error(Local<String> message);
+  static Local<Value> RangeError(Local<String> message,
+                                 Local<Value> options = {});
+  static Local<Value> ReferenceError(Local<String> message,
+                                     Local<Value> options = {});
+  static Local<Value> SyntaxError(Local<String> message,
+                                  Local<Value> options = {});
+  static Local<Value> TypeError(Local<String> message,
+                                Local<Value> options = {});
+  static Local<Value> WasmCompileError(Local<String> message,
+                                       Local<Value> options = {});
+  static Local<Value> WasmLinkError(Local<String> message,
+                                    Local<Value> options = {});
+  static Local<Value> WasmRuntimeError(Local<String> message,
+                                       Local<Value> options = {});
+  static Local<Value> Error(Local<String> message, Local<Value> options = {});
 
   /**
    * Creates an error message for the given exception.
@@ -206,7 +213,6 @@ class V8_EXPORT TryCatch {
   bool can_continue_ : 1;
   bool capture_message_ : 1;
   bool rethrow_ : 1;
-  bool has_terminated_ : 1;
 
   friend class internal::Isolate;
   friend class internal::ThreadLocalTop;

package/include/node/v8-forward.h

@@ -27,6 +27,7 @@ class Context;
 class DataView;
 class Data;
 class Date;
+class DictionaryTemplate;
 class Extension;
 class External;
 class FixedArray;

package/include/node/v8-function-callback.h

@@ -5,6 +5,9 @@
 #ifndef INCLUDE_V8_FUNCTION_CALLBACK_H_
 #define INCLUDE_V8_FUNCTION_CALLBACK_H_
 
+#include <cstdint>
+#include <limits>
+
 #include "v8-local-handle.h"  // NOLINT(build/include_directory)
 #include "v8-primitive.h"     // NOLINT(build/include_directory)
 #include "v8config.h"         // NOLINT(build/include_directory)
@@ -39,14 +42,21 @@ class ReturnValue {
   template <typename S>
   V8_INLINE void Set(const Global<S>& handle);
   template <typename S>
+  V8_INLINE void SetNonEmpty(const Global<S>& handle);
+  template <typename S>
   V8_INLINE void Set(const BasicTracedReference<S>& handle);
   template <typename S>
+  V8_INLINE void SetNonEmpty(const BasicTracedReference<S>& handle);
+  template <typename S>
   V8_INLINE void Set(const Local<S> handle);
+  template <typename S>
+  V8_INLINE void SetNonEmpty(const Local<S> handle);
   // Fast primitive setters
   V8_INLINE void Set(bool value);
   V8_INLINE void Set(double i);
   V8_INLINE void Set(int32_t i);
   V8_INLINE void Set(uint32_t i);
+  V8_INLINE void Set(uint16_t);
   // Fast JS primitive setters
   V8_INLINE void SetNull();
   V8_INLINE void SetUndefined();
@@ -72,8 +82,15 @@ class ReturnValue {
   friend class PropertyCallbackInfo;
   template <class F, class G, class H>
   friend class PersistentValueMapBase;
-  V8_INLINE void SetInternal(internal::Address value) { *value_ = value; }
-  V8_INLINE internal::Address GetDefaultValue();
+  V8_INLINE void SetInternal(internal::Address value);
+  // Setting the hole value has different meanings depending on the usage:
+  //  - for function template callbacks it means that the callback returns
+  //    the undefined value,
+  //  - for property getter callbacks is means that the callback returns
+  //    the undefined value (for property setter callbacks the value returned
+  //    is ignored),
+  //  - for interceptor callbacks it means that the request was not handled.
+  V8_INLINE void SetTheHole();
   V8_INLINE explicit ReturnValue(internal::Address* slot);
 
   // See FunctionCallbackInfo.
@@ -276,44 +293,89 @@ using FunctionCallback = void (*)(const FunctionCallbackInfo<Value>& info);
 template <typename T>
 ReturnValue<T>::ReturnValue(internal::Address* slot) : value_(slot) {}
 
+template <typename T>
+void ReturnValue<T>::SetInternal(internal::Address value) {
+#if V8_STATIC_ROOTS_BOOL
+  using I = internal::Internals;
+  // Ensure that the upper 32-bits are not modified. Compiler should be
+  // able to optimize this to a store of a lower 32-bits of the value.
+  // This is fine since the callback can return only JavaScript values which
+  // are either Smis or heap objects allocated in the main cage.
+  *value_ = I::DecompressTaggedField(*value_, I::CompressTagged(value));
+#else
+  *value_ = value;
+#endif  // V8_STATIC_ROOTS_BOOL
+}
+
 template <typename T>
 template <typename S>
 void ReturnValue<T>::Set(const Global<S>& handle) {
   static_assert(std::is_base_of<T, S>::value, "type check");
   if (V8_UNLIKELY(handle.IsEmpty())) {
-    *value_ = GetDefaultValue();
+    SetTheHole();
   } else {
-    *value_ = handle.ptr();
+    SetInternal(handle.ptr());
   }
 }
 
+template <typename T>
+template <typename S>
+void ReturnValue<T>::SetNonEmpty(const Global<S>& handle) {
+  static_assert(std::is_base_of<T, S>::value, "type check");
+#ifdef V8_ENABLE_CHECKS
+  internal::VerifyHandleIsNonEmpty(handle.IsEmpty());
+#endif  // V8_ENABLE_CHECKS
+  SetInternal(handle.ptr());
+}
+
 template <typename T>
 template <typename S>
 void ReturnValue<T>::Set(const BasicTracedReference<S>& handle) {
   static_assert(std::is_base_of<T, S>::value, "type check");
   if (V8_UNLIKELY(handle.IsEmpty())) {
-    *value_ = GetDefaultValue();
+    SetTheHole();
   } else {
-    *value_ = handle.ptr();
+    SetInternal(handle.ptr());
   }
 }
 
+template <typename T>
+template <typename S>
+void ReturnValue<T>::SetNonEmpty(const BasicTracedReference<S>& handle) {
+  static_assert(std::is_base_of<T, S>::value, "type check");
+#ifdef V8_ENABLE_CHECKS
+  internal::VerifyHandleIsNonEmpty(handle.IsEmpty());
+#endif  // V8_ENABLE_CHECKS
+  SetInternal(handle.ptr());
+}
+
 template <typename T>
 template <typename S>
 void ReturnValue<T>::Set(const Local<S> handle) {
   static_assert(std::is_void<T>::value || std::is_base_of<T, S>::value,
                 "type check");
   if (V8_UNLIKELY(handle.IsEmpty())) {
-    *value_ = GetDefaultValue();
+    SetTheHole();
   } else {
-    *value_ = handle.ptr();
+    SetInternal(handle.ptr());
   }
 }
 
+template <typename T>
+template <typename S>
+void ReturnValue<T>::SetNonEmpty(const Local<S> handle) {
+  static_assert(std::is_void<T>::value || std::is_base_of<T, S>::value,
+                "type check");
+#ifdef V8_ENABLE_CHECKS
+  internal::VerifyHandleIsNonEmpty(handle.IsEmpty());
+#endif  // V8_ENABLE_CHECKS
+  SetInternal(handle.ptr());
+}
+
 template <typename T>
 void ReturnValue<T>::Set(double i) {
   static_assert(std::is_base_of<T, Number>::value, "type check");
-  Set(Number::New(GetIsolate(), i));
+  SetNonEmpty(Number::New(GetIsolate(), i));
 }
 
 template <typename T>
@@ -321,10 +383,10 @@ void ReturnValue<T>::Set(int32_t i) {
   static_assert(std::is_base_of<T, Integer>::value, "type check");
   using I = internal::Internals;
   if (V8_LIKELY(I::IsValidSmi(i))) {
-    *value_ = I::IntToSmi(i);
+    SetInternal(I::IntToSmi(i));
     return;
   }
-  Set(Integer::New(GetIsolate(), i));
+  SetNonEmpty(Integer::New(GetIsolate(), i));
 }
 
 template <typename T>
@@ -336,13 +398,30 @@ void ReturnValue<T>::Set(uint32_t i) {
     Set(static_cast<int32_t>(i));
     return;
   }
-  Set(Integer::NewFromUnsigned(GetIsolate(), i));
+  SetNonEmpty(Integer::NewFromUnsigned(GetIsolate(), i));
+}
+
+template <typename T>
+void ReturnValue<T>::Set(uint16_t i) {
+  static_assert(std::is_base_of<T, Integer>::value, "type check");
+  using I = internal::Internals;
+  static_assert(I::IsValidSmi(std::numeric_limits<uint16_t>::min()));
+  static_assert(I::IsValidSmi(std::numeric_limits<uint16_t>::max()));
+  SetInternal(I::IntToSmi(i));
 }
 
 template <typename T>
 void ReturnValue<T>::Set(bool value) {
   static_assert(std::is_base_of<T, Boolean>::value, "type check");
   using I = internal::Internals;
+#if V8_STATIC_ROOTS_BOOL
+#ifdef V8_ENABLE_CHECKS
+  internal::PerformCastCheck(
+      internal::ValueHelper::SlotAsValue<Value, true>(value_));
+#endif  // V8_ENABLE_CHECKS
+  SetInternal(value ? I::StaticReadOnlyRoot::kTrueValue
+                    : I::StaticReadOnlyRoot::kFalseValue);
+#else
   int root_index;
   if (value) {
     root_index = I::kTrueValueRootIndex;
@@ -350,27 +429,62 @@ void ReturnValue<T>::Set(bool value) {
     root_index = I::kFalseValueRootIndex;
   }
   *value_ = I::GetRoot(GetIsolate(), root_index);
+#endif  // V8_STATIC_ROOTS_BOOL
+}
+
+template <typename T>
+void ReturnValue<T>::SetTheHole() {
+  using I = internal::Internals;
+#if V8_STATIC_ROOTS_BOOL
+  SetInternal(I::StaticReadOnlyRoot::kTheHoleValue);
+#else
+  *value_ = I::GetRoot(GetIsolate(), I::kTheHoleValueRootIndex);
+#endif  // V8_STATIC_ROOTS_BOOL
 }
 
 template <typename T>
 void ReturnValue<T>::SetNull() {
   static_assert(std::is_base_of<T, Primitive>::value, "type check");
   using I = internal::Internals;
+#if V8_STATIC_ROOTS_BOOL
+#ifdef V8_ENABLE_CHECKS
+  internal::PerformCastCheck(
+      internal::ValueHelper::SlotAsValue<Value, true>(value_));
+#endif  // V8_ENABLE_CHECKS
+  SetInternal(I::StaticReadOnlyRoot::kNullValue);
+#else
   *value_ = I::GetRoot(GetIsolate(), I::kNullValueRootIndex);
+#endif  // V8_STATIC_ROOTS_BOOL
 }
 
 template <typename T>
 void ReturnValue<T>::SetUndefined() {
   static_assert(std::is_base_of<T, Primitive>::value, "type check");
   using I = internal::Internals;
+#if V8_STATIC_ROOTS_BOOL
+#ifdef V8_ENABLE_CHECKS
+  internal::PerformCastCheck(
+      internal::ValueHelper::SlotAsValue<Value, true>(value_));
+#endif  // V8_ENABLE_CHECKS
+  SetInternal(I::StaticReadOnlyRoot::kUndefinedValue);
+#else
   *value_ = I::GetRoot(GetIsolate(), I::kUndefinedValueRootIndex);
+#endif  // V8_STATIC_ROOTS_BOOL
 }
 
 template <typename T>
 void ReturnValue<T>::SetEmptyString() {
   static_assert(std::is_base_of<T, String>::value, "type check");
   using I = internal::Internals;
+#if V8_STATIC_ROOTS_BOOL
+#ifdef V8_ENABLE_CHECKS
+  internal::PerformCastCheck(
+      internal::ValueHelper::SlotAsValue<Value, true>(value_));
+#endif  // V8_ENABLE_CHECKS
+  SetInternal(I::StaticReadOnlyRoot::kEmptyString);
+#else
   *value_ = I::GetRoot(GetIsolate(), I::kEmptyStringRootIndex);
+#endif  // V8_STATIC_ROOTS_BOOL
 }
 
 template <typename T>
@@ -385,10 +499,11 @@ Local<Value> ReturnValue<T>::Get() const {
   if (I::is_identical(*value_, I::StaticReadOnlyRoot::kTheHoleValue)) {
 #else
   if (*value_ == I::GetRoot(GetIsolate(), I::kTheHoleValueRootIndex)) {
-#endif
+#endif  // V8_STATIC_ROOTS_BOOL
     return Undefined(GetIsolate());
   }
-  return Local<Value>::New(GetIsolate(), reinterpret_cast<Value*>(value_));
+  return Local<Value>::New(GetIsolate(),
+                           internal::ValueHelper::SlotAsValue<Value>(value_));
 }
 
 template <typename T>
@@ -397,12 +512,6 @@ void ReturnValue<T>::Set(S* whatever) {
   static_assert(sizeof(S) < 0, "incompilable to prevent inadvertent misuse");
 }
 
-template <typename T>
-internal::Address ReturnValue<T>::GetDefaultValue() {
-  using I = internal::Internals;
-  return I::GetRoot(GetIsolate(), I::kTheHoleValueRootIndex);
-}
-
 template <typename T>
 FunctionCallbackInfo<T>::FunctionCallbackInfo(internal::Address* implicit_args,
                                               internal::Address* values,

package/include/node/v8-handle-base.h

@@ -7,92 +7,44 @@
 
 #include "v8-internal.h"  // NOLINT(build/include_directory)
 
-namespace v8 {
+namespace v8::api_internal {
 
-namespace internal {
-
-// Helper functions about values contained in handles.
-// A value is either an indirect pointer or a direct pointer, depending on
-// whether direct local support is enabled.
-class ValueHelper final {
+template <bool check_statically_enabled>
+class StackAllocated {
  public:
-#ifdef V8_ENABLE_DIRECT_LOCAL
-  static constexpr Address kTaggedNullAddress = 1;
-  static constexpr Address kEmpty = kTaggedNullAddress;
-#else
-  static constexpr Address kEmpty = kNullAddress;
-#endif  // V8_ENABLE_DIRECT_LOCAL
-
-  template <typename T>
-  V8_INLINE static bool IsEmpty(T* value) {
-    return reinterpret_cast<Address>(value) == kEmpty;
-  }
-
-  // Returns a handle's "value" for all kinds of abstract handles. For Local,
-  // it is equivalent to `*handle`. The variadic parameters support handle
-  // types with extra type parameters, like `Persistent<T, M>`.
-  template <template <typename T, typename... Ms> typename H, typename T,
-            typename... Ms>
-  V8_INLINE static T* HandleAsValue(const H<T, Ms...>& handle) {
-    return handle.template value<T>();
-  }
-
-#ifdef V8_ENABLE_DIRECT_LOCAL
-
-  template <typename T>
-  V8_INLINE static Address ValueAsAddress(const T* value) {
-    return reinterpret_cast<Address>(value);
-  }
-
-  template <typename T, bool check_null = true, typename S>
-  V8_INLINE static T* SlotAsValue(S* slot) {
-    if (check_null && slot == nullptr) {
-      return reinterpret_cast<T*>(kTaggedNullAddress);
-    }
-    return *reinterpret_cast<T**>(slot);
-  }
+  V8_INLINE StackAllocated() = default;
 
-#else  // !V8_ENABLE_DIRECT_LOCAL
-
-  template <typename T>
-  V8_INLINE static Address ValueAsAddress(const T* value) {
-    return *reinterpret_cast<const Address*>(value);
-  }
+ protected:
+  struct no_checking_tag {};
+  static constexpr no_checking_tag do_not_check{};
 
-  template <typename T, bool check_null = true, typename S>
-  V8_INLINE static T* SlotAsValue(S* slot) {
-    return reinterpret_cast<T*>(slot);
-  }
+  V8_INLINE explicit StackAllocated(no_checking_tag) {}
+  V8_INLINE explicit StackAllocated(const StackAllocated& other,
+                                    no_checking_tag) {}
 
-#endif  // V8_ENABLE_DIRECT_LOCAL
+  V8_INLINE void VerifyOnStack() const {}
 };
 
-/**
- * Helper functions about handles.
- */
-class HandleHelper final {
+template <>
+class V8_TRIVIAL_ABI StackAllocated<true> : public StackAllocated<false> {
  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.ptr() == rhs.ptr();
-  }
+  V8_INLINE StackAllocated() { VerifyOnStack(); }
 
-  static V8_EXPORT void VerifyOnStack(const void* ptr);
-};
+#if V8_HAS_ATTRIBUTE_TRIVIAL_ABI
+  // In this case, StackAllocated becomes not trivially copyable.
+  V8_INLINE StackAllocated(const StackAllocated& other) { VerifyOnStack(); }
+  StackAllocated& operator=(const StackAllocated&) = default;
+#endif
 
-}  // namespace internal
+ protected:
+  V8_INLINE explicit StackAllocated(no_checking_tag tag)
+      : StackAllocated<false>(tag) {}
+  V8_INLINE explicit StackAllocated(const StackAllocated& other,
+                                    no_checking_tag tag)
+      : StackAllocated<false>(other, tag) {}
+
+  V8_EXPORT void VerifyOnStack() const;
+};
 
 /**
  * A base class for abstract handles containing indirect pointers.
@@ -129,9 +81,9 @@ class IndirectHandleBase {
 
   // Returns the handler's "value" (direct or indirect pointer, depending on
   // whether direct local support is enabled).
-  template <typename T>
+  template <typename T, bool check_null = false>
   V8_INLINE T* value() const {
-    return internal::ValueHelper::SlotAsValue<T, false>(slot());
+    return internal::ValueHelper::SlotAsValue<T, check_null>(slot());
   }
 
  private:
@@ -169,7 +121,7 @@ class DirectHandleBase {
 
   // Returns the handler's "value" (direct pointer, as direct local support
   // is guaranteed to be enabled here).
-  template <typename T>
+  template <typename T, bool check_null = false>
   V8_INLINE T* value() const {
     return reinterpret_cast<T*>(ptr_);
   }
@@ -180,6 +132,6 @@ class DirectHandleBase {
 
 #endif  // V8_ENABLE_DIRECT_LOCAL
 
-}  // namespace v8
+}  // namespace v8::api_internal
 
 #endif  // INCLUDE_V8_HANDLE_BASE_H_