libv8-node 21.7.2.0-aarch64-linux → 22.5.1.0-aarch64-linux

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

@@ -27,14 +27,20 @@ namespace internal {
 
 class BasicTracedReferenceExtractor;
 
-enum class GlobalHandleStoreMode {
+enum class TracedReferenceStoreMode {
   kInitializingStore,
   kAssigningStore,
 };
 
+enum class TracedReferenceHandling {
+  kDefault,  // See EmbedderRootsHandler::IsRoot().
+  kDroppable
+};
+
 V8_EXPORT internal::Address* GlobalizeTracedReference(
     internal::Isolate* isolate, internal::Address value,
-    internal::Address* slot, GlobalHandleStoreMode store_mode);
+    internal::Address* slot, TracedReferenceStoreMode store_mode,
+    internal::TracedReferenceHandling reference_handling);
 V8_EXPORT void MoveTracedReference(internal::Address** from,
                                    internal::Address** to);
 V8_EXPORT void CopyTracedReference(const internal::Address* const* from,
@@ -47,7 +53,7 @@ V8_EXPORT void DisposeTracedReference(internal::Address* global_handle);
  * An indirect handle, where the indirect pointer points to a GlobalHandles
  * node.
  */
-class TracedReferenceBase : public IndirectHandleBase {
+class TracedReferenceBase : public api_internal::IndirectHandleBase {
  public:
   /**
    * If non-empty, destroy the underlying storage cell. |IsEmpty| will return
@@ -71,17 +77,6 @@ class TracedReferenceBase : public IndirectHandleBase {
     return this->GetSlotThreadSafe() == nullptr;
   }
 
-  /**
-   * Assigns a wrapper class ID to the handle.
-   */
-  V8_INLINE void SetWrapperClassId(uint16_t class_id);
-
-  /**
-   * Returns the class ID previously assigned to this handle or 0 if no class ID
-   * was previously assigned.
-   */
-  V8_INLINE uint16_t WrapperClassId() const;
-
  protected:
   V8_INLINE TracedReferenceBase() = default;
 
@@ -157,9 +152,10 @@ class BasicTracedReference : public TracedReferenceBase {
    */
   BasicTracedReference() = default;
 
-  V8_INLINE static internal::Address* New(
+  V8_INLINE static internal::Address* NewFromNonEmptyValue(
       Isolate* isolate, T* that, internal::Address** slot,
-      internal::GlobalHandleStoreMode store_mode);
+      internal::TracedReferenceStoreMode store_mode,
+      internal::TracedReferenceHandling reference_handling);
 
   template <typename F>
   friend class Local;
@@ -180,6 +176,8 @@ class BasicTracedReference : public TracedReferenceBase {
 template <typename T>
 class TracedReference : public BasicTracedReference<T> {
  public:
+  struct IsDroppable {};
+
   using BasicTracedReference<T>::Reset;
 
   /**
@@ -195,10 +193,35 @@ class TracedReference : public BasicTracedReference<T> {
    */
   template <class S>
   TracedReference(Isolate* isolate, Local<S> that) : BasicTracedReference<T>() {
-    this->slot() =
-        this->New(isolate, *that, &this->slot(),
-                  internal::GlobalHandleStoreMode::kInitializingStore);
     static_assert(std::is_base_of<T, S>::value, "type check");
+    if (V8_UNLIKELY(that.IsEmpty())) {
+      return;
+    }
+    this->slot() = this->NewFromNonEmptyValue(
+        isolate, *that, &this->slot(),
+        internal::TracedReferenceStoreMode::kInitializingStore,
+        internal::TracedReferenceHandling::kDefault);
+  }
+
+  /**
+   * Construct a droppable TracedReference from a Local. Droppable means that V8
+   * is free to reclaim the pointee if it is unmodified and otherwise
+   * unreachable
+   *
+   * When the Local is non-empty, a new storage cell is created
+   * pointing to the same object.
+   */
+  template <class S>
+  TracedReference(Isolate* isolate, Local<S> that, IsDroppable)
+      : BasicTracedReference<T>() {
+    static_assert(std::is_base_of<T, S>::value, "type check");
+    if (V8_UNLIKELY(that.IsEmpty())) {
+      return;
+    }
+    this->slot() = this->NewFromNonEmptyValue(
+        isolate, *that, &this->slot(),
+        internal::TracedReferenceStoreMode::kInitializingStore,
+        internal::TracedReferenceHandling::kDroppable);
   }
 
   /**
@@ -262,12 +285,19 @@ class TracedReference : public BasicTracedReference<T> {
   V8_INLINE TracedReference& operator=(const TracedReference<S>& rhs);
 
   /**
-   * If non-empty, destroy the underlying storage cell and create a new one with
-   * the contents of other if other is non empty
+   * Always resets the reference. Creates a new reference from `other` if it is
+   * non-empty.
    */
   template <class S>
   V8_INLINE void Reset(Isolate* isolate, const Local<S>& other);
 
+  /**
+   * Always resets the reference. Creates a new reference from `other` if it is
+   * non-empty. The new reference is droppable, see constructor.
+   */
+  template <class S>
+  V8_INLINE void Reset(Isolate* isolate, const Local<S>& other, IsDroppable);
+
   template <class S>
   V8_INLINE TracedReference<S>& As() const {
     return reinterpret_cast<TracedReference<S>&>(
@@ -277,18 +307,21 @@ class TracedReference : public BasicTracedReference<T> {
 
 // --- Implementation ---
 template <class T>
-internal::Address* BasicTracedReference<T>::New(
+internal::Address* BasicTracedReference<T>::NewFromNonEmptyValue(
     Isolate* isolate, T* that, internal::Address** slot,
-    internal::GlobalHandleStoreMode store_mode) {
-  if (internal::ValueHelper::IsEmpty(that)) return nullptr;
+    internal::TracedReferenceStoreMode store_mode,
+    internal::TracedReferenceHandling reference_handling) {
   return internal::GlobalizeTracedReference(
       reinterpret_cast<internal::Isolate*>(isolate),
       internal::ValueHelper::ValueAsAddress(that),
-      reinterpret_cast<internal::Address*>(slot), store_mode);
+      reinterpret_cast<internal::Address*>(slot), store_mode,
+      reference_handling);
 }
 
 void TracedReferenceBase::Reset() {
-  if (IsEmpty()) return;
+  if (V8_UNLIKELY(IsEmpty())) {
+    return;
+  }
   internal::DisposeTracedReference(slot());
   SetSlotThreadSafe(nullptr);
 }
@@ -332,10 +365,28 @@ template <class S>
 void TracedReference<T>::Reset(Isolate* isolate, const Local<S>& other) {
   static_assert(std::is_base_of<T, S>::value, "type check");
   this->Reset();
-  if (other.IsEmpty()) return;
-  this->SetSlotThreadSafe(
-      this->New(isolate, *other, &this->slot(),
-                internal::GlobalHandleStoreMode::kAssigningStore));
+  if (V8_UNLIKELY(other.IsEmpty())) {
+    return;
+  }
+  this->SetSlotThreadSafe(this->NewFromNonEmptyValue(
+      isolate, *other, &this->slot(),
+      internal::TracedReferenceStoreMode::kAssigningStore,
+      internal::TracedReferenceHandling::kDefault));
+}
+
+template <class T>
+template <class S>
+void TracedReference<T>::Reset(Isolate* isolate, const Local<S>& other,
+                               IsDroppable) {
+  static_assert(std::is_base_of<T, S>::value, "type check");
+  this->Reset();
+  if (V8_UNLIKELY(other.IsEmpty())) {
+    return;
+  }
+  this->SetSlotThreadSafe(this->NewFromNonEmptyValue(
+      isolate, *other, &this->slot(),
+      internal::TracedReferenceStoreMode::kAssigningStore,
+      internal::TracedReferenceHandling::kDroppable));
 }
 
 template <class T>
@@ -376,22 +427,6 @@ TracedReference<T>& TracedReference<T>::operator=(const TracedReference& rhs) {
   return *this;
 }
 
-void TracedReferenceBase::SetWrapperClassId(uint16_t class_id) {
-  using I = internal::Internals;
-  if (IsEmpty()) return;
-  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;
-  uint8_t* addr =
-      reinterpret_cast<uint8_t*>(slot()) + I::kTracedNodeClassIdOffset;
-  return *reinterpret_cast<uint16_t*>(addr);
-}
-
 }  // namespace v8
 
 #endif  // INCLUDE_V8_TRACED_HANDLE_H_

data/vendor/v8/include/v8-typed-array.h

@@ -5,14 +5,14 @@
 #ifndef INCLUDE_V8_TYPED_ARRAY_H_
 #define INCLUDE_V8_TYPED_ARRAY_H_
 
+#include <limits>
+
 #include "v8-array-buffer.h"  // NOLINT(build/include_directory)
 #include "v8-local-handle.h"  // NOLINT(build/include_directory)
 #include "v8config.h"         // NOLINT(build/include_directory)
 
 namespace v8 {
 
-class SharedArrayBuffer;
-
 /**
  * A base class for an instance of TypedArray series of constructors
  * (ES6 draft 15.13.6).
@@ -20,12 +20,19 @@ class SharedArrayBuffer;
 class V8_EXPORT TypedArray : public ArrayBufferView {
  public:
   /*
-   * The largest typed array size that can be constructed using New.
+   * The largest supported typed array byte size. Each subclass defines a
+   * type-specific kMaxLength for the maximum length that can be passed to New.
    */
-  static constexpr size_t kMaxLength =
-      internal::kApiSystemPointerSize == 4
-          ? internal::kSmiMaxValue
-          : static_cast<size_t>(uint64_t{1} << 32);
+#if V8_ENABLE_SANDBOX
+  static constexpr size_t kMaxByteLength =
+      internal::kMaxSafeBufferSizeForSandbox;
+#elif V8_HOST_ARCH_32_BIT
+  static constexpr size_t kMaxByteLength = std::numeric_limits<int>::max();
+#else
+  // The maximum safe integer (2^53 - 1).
+  static constexpr size_t kMaxByteLength =
+      static_cast<size_t>((uint64_t{1} << 53) - 1);
+#endif
 
   /**
    * Number of elements in this typed array
@@ -50,6 +57,13 @@ class V8_EXPORT TypedArray : public ArrayBufferView {
  */
 class V8_EXPORT Uint8Array : public TypedArray {
  public:
+  /*
+   * The largest Uint8Array size that can be constructed using New.
+   */
+  static constexpr size_t kMaxLength =
+      TypedArray::kMaxByteLength / sizeof(uint8_t);
+  static_assert(sizeof(uint8_t) == 1);
+
   static Local<Uint8Array> New(Local<ArrayBuffer> array_buffer,
                                size_t byte_offset, size_t length);
   static Local<Uint8Array> New(Local<SharedArrayBuffer> shared_array_buffer,
@@ -71,6 +85,13 @@ class V8_EXPORT Uint8Array : public TypedArray {
  */
 class V8_EXPORT Uint8ClampedArray : public TypedArray {
  public:
+  /*
+   * The largest Uint8ClampedArray size that can be constructed using New.
+   */
+  static constexpr size_t kMaxLength =
+      TypedArray::kMaxByteLength / sizeof(uint8_t);
+  static_assert(sizeof(uint8_t) == 1);
+
   static Local<Uint8ClampedArray> New(Local<ArrayBuffer> array_buffer,
                                       size_t byte_offset, size_t length);
   static Local<Uint8ClampedArray> New(
@@ -93,6 +114,13 @@ class V8_EXPORT Uint8ClampedArray : public TypedArray {
  */
 class V8_EXPORT Int8Array : public TypedArray {
  public:
+  /*
+   * The largest Int8Array size that can be constructed using New.
+   */
+  static constexpr size_t kMaxLength =
+      TypedArray::kMaxByteLength / sizeof(int8_t);
+  static_assert(sizeof(int8_t) == 1);
+
   static Local<Int8Array> New(Local<ArrayBuffer> array_buffer,
                               size_t byte_offset, size_t length);
   static Local<Int8Array> New(Local<SharedArrayBuffer> shared_array_buffer,
@@ -114,6 +142,13 @@ class V8_EXPORT Int8Array : public TypedArray {
  */
 class V8_EXPORT Uint16Array : public TypedArray {
  public:
+  /*
+   * The largest Uint16Array size that can be constructed using New.
+   */
+  static constexpr size_t kMaxLength =
+      TypedArray::kMaxByteLength / sizeof(uint16_t);
+  static_assert(sizeof(uint16_t) == 2);
+
   static Local<Uint16Array> New(Local<ArrayBuffer> array_buffer,
                                 size_t byte_offset, size_t length);
   static Local<Uint16Array> New(Local<SharedArrayBuffer> shared_array_buffer,
@@ -135,6 +170,13 @@ class V8_EXPORT Uint16Array : public TypedArray {
  */
 class V8_EXPORT Int16Array : public TypedArray {
  public:
+  /*
+   * The largest Int16Array size that can be constructed using New.
+   */
+  static constexpr size_t kMaxLength =
+      TypedArray::kMaxByteLength / sizeof(int16_t);
+  static_assert(sizeof(int16_t) == 2);
+
   static Local<Int16Array> New(Local<ArrayBuffer> array_buffer,
                                size_t byte_offset, size_t length);
   static Local<Int16Array> New(Local<SharedArrayBuffer> shared_array_buffer,
@@ -156,6 +198,13 @@ class V8_EXPORT Int16Array : public TypedArray {
  */
 class V8_EXPORT Uint32Array : public TypedArray {
  public:
+  /*
+   * The largest Uint32Array size that can be constructed using New.
+   */
+  static constexpr size_t kMaxLength =
+      TypedArray::kMaxByteLength / sizeof(uint32_t);
+  static_assert(sizeof(uint32_t) == 4);
+
   static Local<Uint32Array> New(Local<ArrayBuffer> array_buffer,
                                 size_t byte_offset, size_t length);
   static Local<Uint32Array> New(Local<SharedArrayBuffer> shared_array_buffer,
@@ -177,6 +226,13 @@ class V8_EXPORT Uint32Array : public TypedArray {
  */
 class V8_EXPORT Int32Array : public TypedArray {
  public:
+  /*
+   * The largest Int32Array size that can be constructed using New.
+   */
+  static constexpr size_t kMaxLength =
+      TypedArray::kMaxByteLength / sizeof(int32_t);
+  static_assert(sizeof(int32_t) == 4);
+
   static Local<Int32Array> New(Local<ArrayBuffer> array_buffer,
                                size_t byte_offset, size_t length);
   static Local<Int32Array> New(Local<SharedArrayBuffer> shared_array_buffer,
@@ -193,11 +249,42 @@ class V8_EXPORT Int32Array : public TypedArray {
   static void CheckCast(Value* obj);
 };
 
+/**
+ * An instance of Float16Array constructor.
+ */
+class V8_EXPORT Float16Array : public TypedArray {
+  static constexpr size_t kMaxLength =
+      TypedArray::kMaxByteLength / sizeof(uint16_t);
+
+ public:
+  static Local<Float16Array> New(Local<ArrayBuffer> array_buffer,
+                                 size_t byte_offset, size_t length);
+  static Local<Float16Array> New(Local<SharedArrayBuffer> shared_array_buffer,
+                                 size_t byte_offset, size_t length);
+  V8_INLINE static Float16Array* Cast(Value* value) {
+#ifdef V8_ENABLE_CHECKS
+    CheckCast(value);
+#endif
+    return static_cast<Float16Array*>(value);
+  }
+
+ private:
+  Float16Array();
+  static void CheckCast(Value* obj);
+};
+
 /**
  * An instance of Float32Array constructor (ES6 draft 15.13.6).
  */
 class V8_EXPORT Float32Array : public TypedArray {
  public:
+  /*
+   * The largest Float32Array size that can be constructed using New.
+   */
+  static constexpr size_t kMaxLength =
+      TypedArray::kMaxByteLength / sizeof(float);
+  static_assert(sizeof(float) == 4);
+
   static Local<Float32Array> New(Local<ArrayBuffer> array_buffer,
                                  size_t byte_offset, size_t length);
   static Local<Float32Array> New(Local<SharedArrayBuffer> shared_array_buffer,
@@ -219,6 +306,13 @@ class V8_EXPORT Float32Array : public TypedArray {
  */
 class V8_EXPORT Float64Array : public TypedArray {
  public:
+  /*
+   * The largest Float64Array size that can be constructed using New.
+   */
+  static constexpr size_t kMaxLength =
+      TypedArray::kMaxByteLength / sizeof(double);
+  static_assert(sizeof(double) == 8);
+
   static Local<Float64Array> New(Local<ArrayBuffer> array_buffer,
                                  size_t byte_offset, size_t length);
   static Local<Float64Array> New(Local<SharedArrayBuffer> shared_array_buffer,
@@ -240,6 +334,13 @@ class V8_EXPORT Float64Array : public TypedArray {
  */
 class V8_EXPORT BigInt64Array : public TypedArray {
  public:
+  /*
+   * The largest BigInt64Array size that can be constructed using New.
+   */
+  static constexpr size_t kMaxLength =
+      TypedArray::kMaxByteLength / sizeof(int64_t);
+  static_assert(sizeof(int64_t) == 8);
+
   static Local<BigInt64Array> New(Local<ArrayBuffer> array_buffer,
                                   size_t byte_offset, size_t length);
   static Local<BigInt64Array> New(Local<SharedArrayBuffer> shared_array_buffer,
@@ -261,6 +362,13 @@ class V8_EXPORT BigInt64Array : public TypedArray {
  */
 class V8_EXPORT BigUint64Array : public TypedArray {
  public:
+  /*
+   * The largest BigUint64Array size that can be constructed using New.
+   */
+  static constexpr size_t kMaxLength =
+      TypedArray::kMaxByteLength / sizeof(uint64_t);
+  static_assert(sizeof(uint64_t) == 8);
+
   static Local<BigUint64Array> New(Local<ArrayBuffer> array_buffer,
                                    size_t byte_offset, size_t length);
   static Local<BigUint64Array> New(Local<SharedArrayBuffer> shared_array_buffer,

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

@@ -240,8 +240,9 @@ class PersistentValueMapBase {
         : value_(other.value_) { }
 
     Local<V> NewLocal(Isolate* isolate) const {
-      return Local<V>::New(
-          isolate, internal::ValueHelper::SlotAsValue<V>(FromVal(value_)));
+      return Local<V>::New(isolate,
+                           internal::ValueHelper::SlotAsValue<V>(
+                               reinterpret_cast<internal::Address*>(value_)));
     }
     bool IsEmpty() const {
       return value_ == kPersistentContainerNotFound;
@@ -298,7 +299,8 @@ class PersistentValueMapBase {
   typename Traits::Impl* impl() { return &impl_; }
 
   static V* FromVal(PersistentContainerValue v) {
-    return reinterpret_cast<V*>(v);
+    return internal::ValueHelper::SlotAsValue<V>(
+        reinterpret_cast<internal::Address*>(v));
   }
 
   static PersistentContainerValue ClearAndLeak(Global<V>* persistent) {
@@ -318,7 +320,7 @@ class PersistentValueMapBase {
    */
   static Global<V> Release(PersistentContainerValue v) {
     Global<V> p;
-    p.slot() = reinterpret_cast<internal::Address*>(FromVal(v));
+    p.slot() = reinterpret_cast<internal::Address*>(v);
     if (Traits::kCallbackType != kNotWeak && p.IsWeak()) {
       Traits::DisposeCallbackData(
           p.template ClearWeak<typename Traits::WeakCallbackDataType>());
@@ -328,8 +330,8 @@ class PersistentValueMapBase {
 
   void RemoveWeak(const K& key) {
     Global<V> p;
-    p.slot() = reinterpret_cast<internal::Address*>(
-        FromVal(Traits::Remove(&impl_, key)));
+    p.slot() =
+        reinterpret_cast<internal::Address*>(Traits::Remove(&impl_, key));
     p.Reset();
   }
 
@@ -345,8 +347,7 @@ class PersistentValueMapBase {
                                     PersistentContainerValue value) {
     bool hasValue = value != kPersistentContainerNotFound;
     if (hasValue) {
-      returnValue->SetInternal(
-          *reinterpret_cast<internal::Address*>(FromVal(value)));
+      returnValue->SetInternal(*reinterpret_cast<internal::Address*>(value));
     }
     return hasValue;
   }
@@ -620,7 +621,7 @@ class V8_DEPRECATE_SOON("Use std::vector<Global<V>>.") PersistentValueVector {
    */
   Local<V> Get(size_t index) const {
     return Local<V>::New(isolate_, internal::ValueHelper::SlotAsValue<V>(
-                                       FromVal(Traits::Get(&impl_, index))));
+                                       Traits::Get(&impl_, index)));
   }
 
   /**
@@ -630,8 +631,7 @@ 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.slot() =
-          reinterpret_cast<internal::Address>(FromVal(Traits::Get(&impl_, i)));
+      p.slot() = reinterpret_cast<internal::Address>(Traits::Get(&impl_, i));
     }
     Traits::Clear(&impl_);
   }
@@ -652,7 +652,8 @@ class V8_DEPRECATE_SOON("Use std::vector<Global<V>>.") PersistentValueVector {
   }
 
   static V* FromVal(PersistentContainerValue v) {
-    return reinterpret_cast<V*>(v);
+    return internal::ValueHelper::SlotAsValue<V>(
+        reinterpret_cast<internal::Address*>(v));
   }
 
   Isolate* isolate_;

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

@@ -16,7 +16,7 @@
  */
 namespace v8 {
 
-class Primiitive;
+class Primitive;
 class Numeric;
 class BigInt;
 class Int32;
@@ -63,7 +63,7 @@ class V8_EXPORT Value : public Data {
    * conversion to boolean, i.e. the result of `Boolean(value)` in JS, whereas
    * this checks `value === true`.
    */
-  bool IsTrue() const;
+  V8_INLINE bool IsTrue() const;
 
   /**
    * Returns true if this value is false.
@@ -72,7 +72,7 @@ class V8_EXPORT Value : public Data {
    * conversion to boolean, i.e. the result of `!Boolean(value)` in JS, whereas
    * this checks `value === false`.
    */
-  bool IsFalse() const;
+  V8_INLINE bool IsFalse() const;
 
   /**
    * Returns true if this value is a symbol or a string.
@@ -301,6 +301,11 @@ class V8_EXPORT Value : public Data {
    */
   bool IsInt32Array() const;
 
+  /**
+   * Returns true if this value is a Float16Array.
+   */
+  bool IsFloat16Array() const;
+
   /**
    * Returns true if this value is a Float32Array.
    */
@@ -391,7 +396,7 @@ class V8_EXPORT Value : public Data {
   V8_WARN_UNUSED_RESULT MaybeLocal<String> ToDetailString(
       Local<Context> context) const;
   /**
-   * Perform the equivalent of `Object(value)` in JS.
+   * Perform the equivalent of `Tagged<Object>(value)` in JS.
    */
   V8_WARN_UNUSED_RESULT MaybeLocal<Object> ToObject(
       Local<Context> context) const;
@@ -461,14 +466,55 @@ class V8_EXPORT Value : public Data {
   V8_INLINE bool QuickIsUndefined() const;
   V8_INLINE bool QuickIsNull() const;
   V8_INLINE bool QuickIsNullOrUndefined() const;
+#if V8_STATIC_ROOTS_BOOL
+  V8_INLINE bool QuickIsTrue() const;
+  V8_INLINE bool QuickIsFalse() const;
+#endif  // V8_STATIC_ROOTS_BOOL
   V8_INLINE bool QuickIsString() const;
   bool FullIsUndefined() const;
   bool FullIsNull() const;
+  bool FullIsTrue() const;
+  bool FullIsFalse() const;
   bool FullIsString() const;
 
   static void CheckCast(Data* that);
 };
 
+/**
+ * Can be used to avoid repeated expensive type checks for groups of objects
+ * that are expected to be similar (e.g. when Blink converts a bunch of
+ * JavaScript objects to "ScriptWrappable" after a "HasInstance" check) by
+ * making use of V8-internal "hidden classes". An object that has passed the
+ * full check can be remembered via {Update}; further objects can be queried
+ * using {Matches}.
+ * Note that the answer will be conservative/"best-effort": when {Matches}
+ * returns true, then the {candidate} can be relied upon to have the same
+ * shape/constructor/prototype/etc. as the {baseline}. Otherwise, no reliable
+ * statement can be made (the objects might still have indistinguishable shapes
+ * for all intents and purposes, but this mechanism, being optimized for speed,
+ * couldn't determine that quickly).
+ */
+class V8_EXPORT TypecheckWitness {
+ public:
+  explicit TypecheckWitness(Isolate* isolate);
+
+  /**
+   * Checks whether {candidate} can cheaply be identified as being "similar"
+   * to the {baseline} that was passed to {Update} earlier.
+   * It's safe to call this on an uninitialized {TypecheckWitness} instance:
+   * it will then return {false} for any input.
+   */
+  V8_INLINE bool Matches(Local<Value> candidate) const;
+
+  /**
+   * Remembers a new baseline for future {Matches} queries.
+   */
+  void Update(Local<Value> baseline);
+
+ private:
+  Local<Data> cached_map_;
+};
+
 template <>
 V8_INLINE Value* Value::Cast(Data* value) {
 #ifdef V8_ENABLE_CHECKS
@@ -541,6 +587,40 @@ bool Value::QuickIsNullOrUndefined() const {
 #endif  // V8_STATIC_ROOTS_BOOL
 }
 
+bool Value::IsTrue() const {
+#if V8_STATIC_ROOTS_BOOL && !defined(V8_ENABLE_CHECKS)
+  return QuickIsTrue();
+#else
+  return FullIsTrue();
+#endif
+}
+
+#if V8_STATIC_ROOTS_BOOL
+bool Value::QuickIsTrue() const {
+  using A = internal::Address;
+  using I = internal::Internals;
+  A obj = internal::ValueHelper::ValueAsAddress(this);
+  return I::is_identical(obj, I::StaticReadOnlyRoot::kTrueValue);
+}
+#endif  // V8_STATIC_ROOTS_BOOL
+
+bool Value::IsFalse() const {
+#if V8_STATIC_ROOTS_BOOL && !defined(V8_ENABLE_CHECKS)
+  return QuickIsFalse();
+#else
+  return FullIsFalse();
+#endif
+}
+
+#if V8_STATIC_ROOTS_BOOL
+bool Value::QuickIsFalse() const {
+  using A = internal::Address;
+  using I = internal::Internals;
+  A obj = internal::ValueHelper::ValueAsAddress(this);
+  return I::is_identical(obj, I::StaticReadOnlyRoot::kFalseValue);
+}
+#endif  // V8_STATIC_ROOTS_BOOL
+
 bool Value::IsString() const {
 #ifdef V8_ENABLE_CHECKS
   return FullIsString();
@@ -562,6 +642,14 @@ bool Value::QuickIsString() const {
 #endif  // V8_STATIC_ROOTS_BOOL
 }
 
+bool TypecheckWitness::Matches(Local<Value> candidate) const {
+  internal::Address obj = internal::ValueHelper::ValueAsAddress(*candidate);
+  internal::Address obj_map = internal::Internals::LoadMap(obj);
+  internal::Address cached =
+      internal::ValueHelper::ValueAsAddress(*cached_map_);
+  return obj_map == cached;
+}
+
 }  // namespace v8
 
 #endif  // INCLUDE_V8_VALUE_H_

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

@@ -8,10 +8,10 @@
 // These macros define the version number for the current version.
 // NOTE these macros are used by some of the tool scripts and the build
 // system so their names cannot be changed without changing the scripts.
-#define V8_MAJOR_VERSION 11
-#define V8_MINOR_VERSION 8
-#define V8_BUILD_NUMBER 172
-#define V8_PATCH_LEVEL 17
+#define V8_MAJOR_VERSION 12
+#define V8_MINOR_VERSION 4
+#define V8_BUILD_NUMBER 254
+#define V8_PATCH_LEVEL 21
 
 // Use 1 for candidates and 0 otherwise.
 // (Boolean macro values are not supported by all preprocessors.)