libv8-node 23.6.1.0-x86_64-linux → 24.1.0.0-x86_64-linux

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

@@ -14,7 +14,7 @@
 #include <string>
 
 #include "v8-source-location.h"  // NOLINT(build/include_directory)
-#include "v8config.h"  // NOLINT(build/include_directory)
+#include "v8config.h"            // NOLINT(build/include_directory)
 
 namespace v8 {
 
@@ -79,9 +79,8 @@ class TaskRunner {
    *
    * Embedders should override PostTaskImpl instead of this.
    */
-  void PostTask(
-      std::unique_ptr<Task> task,
-      const SourceLocation& location = SourceLocation::Current()) {
+  void PostTask(std::unique_ptr<Task> task,
+                const SourceLocation& location = SourceLocation::Current()) {
     PostTaskImpl(std::move(task), location);
   }
 
@@ -553,6 +552,19 @@ class PageAllocator {
    */
   virtual bool DecommitPages(void* address, size_t size) = 0;
 
+  /**
+   * Block any modifications to the given mapping such as changing permissions
+   * or unmapping the pages on supported platforms.
+   * The address space reservation will exist until the process ends, but it's
+   * possible to release the memory using DiscardSystemPages. Note that this
+   * might require write permissions to the page as e.g. on Linux, mseal will
+   * block discarding sealed anonymous memory.
+   */
+  virtual bool SealPages(void* address, size_t length) {
+    // TODO(360048056): make it pure once it's implemented on Chromium side.
+    return false;
+  }
+
   /**
    * INTERNAL ONLY: This interface has not been stabilised and may change
    * without notice from one release to another without being deprecated first.
@@ -1051,7 +1063,7 @@ class Platform {
    * Allows the embedder to manage memory page allocations.
    * Returning nullptr will cause V8 to use the default page allocator.
    */
-  virtual PageAllocator* GetPageAllocator() = 0;
+  virtual PageAllocator* GetPageAllocator() { return nullptr; }
 
   /**
    * Allows the embedder to provide an allocator that uses per-thread memory
@@ -1086,11 +1098,8 @@ class Platform {
    * Returns a TaskRunner which can be used to post a task on the foreground.
    * The TaskRunner's NonNestableTasksEnabled() must be true. This function
    * should only be called from a foreground thread.
-   * TODO(chromium:1448758): Deprecate once |GetForegroundTaskRunner(Isolate*,
-   * TaskPriority)| is ready.
    */
-  virtual std::shared_ptr<v8::TaskRunner> GetForegroundTaskRunner(
-      Isolate* isolate) {
+  std::shared_ptr<v8::TaskRunner> GetForegroundTaskRunner(Isolate* isolate) {
     return GetForegroundTaskRunner(isolate, TaskPriority::kUserBlocking);
   }
 
@@ -1098,18 +1107,16 @@ class Platform {
    * Returns a TaskRunner with a specific |priority| which can be used to post a
    * task on the foreground thread. The TaskRunner's NonNestableTasksEnabled()
    * must be true. This function should only be called from a foreground thread.
-   * TODO(chromium:1448758): Make pure virtual once embedders implement it.
    */
   virtual std::shared_ptr<v8::TaskRunner> GetForegroundTaskRunner(
-      Isolate* isolate, TaskPriority priority) {
-    return nullptr;
-  }
+      Isolate* isolate, TaskPriority priority) = 0;
 
   /**
    * Schedules a task to be invoked on a worker thread.
    * Embedders should override PostTaskOnWorkerThreadImpl() instead of
    * CallOnWorkerThread().
    */
+  V8_DEPRECATE_SOON("Use PostTaskOnWorkerThread instead.")
   void CallOnWorkerThread(
       std::unique_ptr<Task> task,
       const SourceLocation& location = SourceLocation::Current()) {
@@ -1123,6 +1130,7 @@ class Platform {
    * Embedders should override PostTaskOnWorkerThreadImpl() instead of
    * CallBlockingTaskOnWorkerThread().
    */
+  V8_DEPRECATE_SOON("Use PostTaskOnWorkerThread instead.")
   void CallBlockingTaskOnWorkerThread(
       std::unique_ptr<Task> task,
       const SourceLocation& location = SourceLocation::Current()) {
@@ -1137,6 +1145,7 @@ class Platform {
    * Embedders should override PostTaskOnWorkerThreadImpl() instead of
    * CallLowPriorityTaskOnWorkerThread().
    */
+  V8_DEPRECATE_SOON("Use PostTaskOnWorkerThread instead.")
   void CallLowPriorityTaskOnWorkerThread(
       std::unique_ptr<Task> task,
       const SourceLocation& location = SourceLocation::Current()) {
@@ -1152,6 +1161,7 @@ class Platform {
    * Embedders should override PostDelayedTaskOnWorkerThreadImpl() instead of
    * CallDelayedOnWorkerThread().
    */
+  V8_DEPRECATE_SOON("Use PostDelayedTaskOnWorkerThread instead.")
   void CallDelayedOnWorkerThread(
       std::unique_ptr<Task> task, double delay_in_seconds,
       const SourceLocation& location = SourceLocation::Current()) {
@@ -1160,6 +1170,31 @@ class Platform {
                                       location);
   }
 
+  /**
+   * Schedules a task to be invoked on a worker thread.
+   * Embedders should override PostTaskOnWorkerThreadImpl() instead of
+   * PostTaskOnWorkerThread().
+   */
+  void PostTaskOnWorkerThread(
+      TaskPriority priority, std::unique_ptr<Task> task,
+      const SourceLocation& location = SourceLocation::Current()) {
+    PostTaskOnWorkerThreadImpl(priority, std::move(task), location);
+  }
+
+  /**
+   * Schedules a task to be invoked on a worker thread after |delay_in_seconds|
+   * expires.
+   * Embedders should override PostDelayedTaskOnWorkerThreadImpl() instead of
+   * PostDelayedTaskOnWorkerThread().
+   */
+  void PostDelayedTaskOnWorkerThread(
+      TaskPriority priority, std::unique_ptr<Task> task,
+      double delay_in_seconds,
+      const SourceLocation& location = SourceLocation::Current()) {
+    PostDelayedTaskOnWorkerThreadImpl(priority, std::move(task),
+                                      delay_in_seconds, location);
+  }
+
   /**
    * Returns true if idle tasks are enabled for the given |isolate|.
    */

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

@@ -140,8 +140,14 @@ class V8_EXPORT String : public Name {
    * Returns the number of bytes in the UTF-8 encoded
    * representation of this string.
    */
+  V8_DEPRECATED("Use Utf8LengthV2 instead.")
   int Utf8Length(Isolate* isolate) const;
 
+  /**
+   * Returns the number of bytes needed for the Utf8 encoding of this string.
+   */
+  size_t Utf8LengthV2(Isolate* isolate) const;
+
   /**
    * Returns whether this string is known to contain only one byte data,
    * i.e. ISO-8859-1 code points.
@@ -194,15 +200,72 @@ class V8_EXPORT String : public Name {
   };
 
   // 16-bit character codes.
+  V8_DEPRECATED("Use WriteV2 instead.")
   int Write(Isolate* isolate, uint16_t* buffer, int start = 0, int length = -1,
             int options = NO_OPTIONS) const;
   // One byte characters.
+  V8_DEPRECATED("Use WriteOneByteV2 instead.")
   int WriteOneByte(Isolate* isolate, uint8_t* buffer, int start = 0,
                    int length = -1, int options = NO_OPTIONS) const;
   // UTF-8 encoded characters.
+  V8_DEPRECATED("Use WriteUtf8V2 instead.")
   int WriteUtf8(Isolate* isolate, char* buffer, int length = -1,
                 int* nchars_ref = nullptr, int options = NO_OPTIONS) const;
 
+  struct WriteFlags {
+    enum {
+      kNone = 0,
+      // Indicates that the output string should be null-terminated. In that
+      // case, the output buffer must include sufficient space for the
+      // additional null character.
+      kNullTerminate = 1,
+      // Used by WriteUtf8 to replace orphan surrogate code units with the
+      // unicode replacement character. Needs to be set to guarantee valid UTF-8
+      // output.
+      kReplaceInvalidUtf8 = 2
+    };
+  };
+
+  /**
+   * Write the contents of the string to an external buffer.
+   *
+   * Copies length characters into the output buffer starting at offset. The
+   * output buffer must have sufficient space for all characters and the null
+   * terminator if null termination is requested through the flags.
+   *
+   * \param offset The position within the string at which copying begins.
+   * \param length The number of characters to copy from the string.
+   * \param buffer The buffer into which the string will be copied.
+   * \param flags Various flags that influence the behavior of this operation.
+   */
+  void WriteV2(Isolate* isolate, uint32_t offset, uint32_t length,
+               uint16_t* buffer, int flags = WriteFlags::kNone) const;
+  void WriteOneByteV2(Isolate* isolate, uint32_t offset, uint32_t length,
+                      uint8_t* buffer, int flags = WriteFlags::kNone) const;
+
+  /**
+   * Encode the contents of the string as Utf8 into an external buffer.
+   *
+   * Encodes the characters of this string as Utf8 and writes them into the
+   * output buffer until either all characters were encoded or the buffer is
+   * full. Will not write partial UTF-8 sequences, preferring to stop before
+   * the end of the buffer. If null termination is requested, the output buffer
+   * will always be null terminated even if not all characters fit. In that
+   * case, the capacity must be at least one. The required size of the output
+   * buffer can be determined using Utf8Length().
+   *
+   * \param buffer The buffer into which the string will be written.
+   * \param capacity The number of bytes available in the output buffer.
+   * \param flags Various flags that influence the behavior of this operation.
+   * \param processed_characters_return The number of processed characters from
+   * the buffer.
+   * \return The number of bytes copied to the buffer including the null
+   * terminator (if written).
+   */
+  size_t WriteUtf8V2(Isolate* isolate, char* buffer, size_t capacity,
+                     int flags = WriteFlags::kNone,
+                     size_t* processed_characters_return = nullptr) const;
+
   /**
    * A zero length string.
    */
@@ -240,6 +303,44 @@ class V8_EXPORT String : public Name {
      */
     virtual bool IsCacheable() const { return true; }
 
+    /**
+     * Internally V8 will call this Unaccount method when the external string
+     * resource should be unaccounted for. This method can be overridden in
+     * subclasses to control how allocated external bytes are accounted.
+     */
+    virtual void Unaccount(Isolate* isolate) {}
+
+    /**
+     * Returns an estimate of the memory occupied by this external string, to be
+     * used by V8 when producing a heap snapshot. If this function returns
+     * kDefaultMemoryEstimate, then V8 will estimate the external size based on
+     * the string length. This function should return only memory that is
+     * uniquely owned by this resource. If the resource has shared ownership of
+     * a secondary allocation, it can report that memory by implementing
+     * EstimateSharedMemoryUsage.
+     */
+    virtual size_t EstimateMemoryUsage() const {
+      return kDefaultMemoryEstimate;
+    }
+    static constexpr size_t kDefaultMemoryEstimate = static_cast<size_t>(-1);
+
+    class V8_EXPORT SharedMemoryUsageRecorder {
+     public:
+      /**
+       * Record that a shared allocation at the given location has the given
+       * size.
+       */
+      virtual void RecordSharedMemoryUsage(const void* location,
+                                           size_t size) = 0;
+    };
+
+    /**
+     * Estimates memory that this string resource may share with other string
+     * resources, to be used by V8 when producing a heap snapshot.
+     */
+    virtual void EstimateSharedMemoryUsage(
+        SharedMemoryUsageRecorder* recorder) const {}
+
     // Disallow copying and assigning.
     ExternalStringResourceBase(const ExternalStringResourceBase&) = delete;
     void operator=(const ExternalStringResourceBase&) = delete;
@@ -474,8 +575,20 @@ class V8_EXPORT String : public Name {
    * The string is not modified if the operation fails. See NewExternal for
    * information on the lifetime of the resource.
    */
+  V8_DEPRECATE_SOON("Use the version with the isolate argument instead.")
   bool MakeExternal(ExternalStringResource* resource);
 
+  /**
+   * Associate an external string resource with this string by transforming it
+   * in place so that existing references to this string in the JavaScript heap
+   * will use the external string resource. The external string resource's
+   * character contents need to be equivalent to this string.
+   * Returns true if the string has been changed to be an external string.
+   * The string is not modified if the operation fails. See NewExternal for
+   * information on the lifetime of the resource.
+   */
+  bool MakeExternal(Isolate* isolate, ExternalStringResource* resource);
+
   /**
    * Creates a new external string using the one-byte data defined in the given
    * resource. When the external string is no longer live on V8's heap the
@@ -496,8 +609,20 @@ class V8_EXPORT String : public Name {
    * The string is not modified if the operation fails. See NewExternal for
    * information on the lifetime of the resource.
    */
+  V8_DEPRECATE_SOON("Use the version with the isolate argument instead.")
   bool MakeExternal(ExternalOneByteStringResource* resource);
 
+  /**
+   * Associate an external string resource with this string by transforming it
+   * in place so that existing references to this string in the JavaScript heap
+   * will use the external string resource. The external string resource's
+   * character contents need to be equivalent to this string.
+   * Returns true if the string has been changed to be an external string.
+   * The string is not modified if the operation fails. See NewExternal for
+   * information on the lifetime of the resource.
+   */
+  bool MakeExternal(Isolate* isolate, ExternalOneByteStringResource* resource);
+
   /**
    * Returns true if this string can be made external, given the encoding for
    * the external string resource.
@@ -527,7 +652,7 @@ class V8_EXPORT String : public Name {
     ~Utf8Value();
     char* operator*() { return str_; }
     const char* operator*() const { return str_; }
-    int length() const { return length_; }
+    size_t length() const { return length_; }
 
     // Disallow copying and assigning.
     Utf8Value(const Utf8Value&) = delete;
@@ -535,7 +660,7 @@ class V8_EXPORT String : public Name {
 
    private:
     char* str_;
-    int length_;
+    size_t length_;
   };
 
   /**
@@ -557,7 +682,7 @@ class V8_EXPORT String : public Name {
     ~Value();
     uint16_t* operator*() { return str_; }
     const uint16_t* operator*() const { return str_; }
-    int length() const { return length_; }
+    uint32_t length() const { return length_; }
 
     // Disallow copying and assigning.
     Value(const Value&) = delete;
@@ -565,7 +690,7 @@ class V8_EXPORT String : public Name {
 
    private:
     uint16_t* str_;
-    int length_;
+    uint32_t length_;
   };
 
   /**
@@ -594,7 +719,7 @@ class V8_EXPORT String : public Name {
 #endif
       return data16_;
     }
-    int length() const { return length_; }
+    uint32_t length() const { return length_; }
     bool is_one_byte() const { return is_one_byte_; }
 
     // Disallow copying and assigning.
@@ -609,7 +734,7 @@ class V8_EXPORT String : public Name {
       const uint8_t* data8_;
       const uint16_t* data16_;
     };
-    int length_;
+    uint32_t length_;
     bool is_one_byte_;
     // Avoid exposing the internal DisallowGarbageCollection scope.
     alignas(internal::Internals::

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

@@ -418,8 +418,11 @@ class V8_EXPORT CpuProfiler {
    * Synchronously collect current stack sample in all profilers attached to
    * the |isolate|. The call does not affect number of ticks recorded for
    * the current top node.
+   * |trace_id| is an optional identifier set to the collected sample.
+   * this is useful to associate the sample with a trace event.
    */
-  static void CollectSample(Isolate* isolate);
+  static void CollectSample(
+      Isolate* isolate, const std::optional<uint64_t> trace_id = std::nullopt);
 
   /**
    * Disposes the CPU profiler object.
@@ -937,6 +940,15 @@ class V8_EXPORT EmbedderGraph {
    */
   virtual void AddEdge(Node* from, Node* to, const char* name = nullptr) = 0;
 
+  /**
+   * Adds a count of bytes that are not associated with any particular Node.
+   * An embedder may use this to represent the size of nodes which were omitted
+   * from this EmbedderGraph despite being retained by the graph, or other
+   * overhead costs. This number will contribute to the total size in a heap
+   * snapshot, without being represented in the object graph.
+   */
+  virtual void AddNativeSize(size_t size) {}
+
   virtual ~EmbedderGraph() = default;
 };
 

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

@@ -1,4 +1,3 @@
-
 // Copyright 2021 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.

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

@@ -1,4 +1,3 @@
-
 // Copyright 2021 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.

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

@@ -23,15 +23,14 @@ namespace v8 {
  * type check for a supertype must succeed for any subtype.
  *
  * The tag is currently in practice limited to 15 bits since it needs to fit
- * together with a marking bit into the unused parts of a pointer (the top 16
- * bits).
+ * together with a marking bit into the unused parts of a pointer.
  */
 enum class CppHeapPointerTag : uint16_t {
   kFirstTag = 0,
   kNullTag = 0,
 
   /**
-   *  The lower type ids are reserved for the embedder to assign. For that, the
+   * The lower type ids are reserved for the embedder to assign. For that, the
    * main requirement is that all (transitive) child classes of a given parent
    * class have type ids in the same range, and that there are no unrelated
    * types in that range. For example, given the following type hierarchy:
@@ -67,6 +66,7 @@ enum class CppHeapPointerTag : uint16_t {
 // against supertypes, which cover a range of types (their subtypes).
 // Both the lower- and the upper bound are inclusive. In other words, this
 // struct represents the range [lower_bound, upper_bound].
+// TODO(saelo): reuse internal::TagRange here.
 struct CppHeapPointerTagRange {
   constexpr CppHeapPointerTagRange(CppHeapPointerTag lower,
                                    CppHeapPointerTag upper)

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

@@ -129,6 +129,11 @@ class V8_EXPORT ModuleRequest : public Data {
    */
   Local<String> GetSpecifier() const;
 
+  /**
+   * Returns the module import phase for this ModuleRequest.
+   */
+  ModuleImportPhase GetPhase() const;
+
   /**
    * Returns the source code offset of this module request.
    * Use Module::SourceOffsetToLocation to convert this to line/column numbers.
@@ -150,7 +155,7 @@ class V8_EXPORT ModuleRequest : public Data {
    */
   Local<FixedArray> GetImportAttributes() const;
 
-  V8_DEPRECATE_SOON("Use GetImportAttributes instead")
+  V8_DEPRECATED("Use GetImportAttributes instead")
   Local<FixedArray> GetImportAssertions() const {
     return GetImportAttributes();
   }
@@ -211,6 +216,9 @@ class V8_EXPORT Module : public Data {
   using ResolveModuleCallback = MaybeLocal<Module> (*)(
       Local<Context> context, Local<String> specifier,
       Local<FixedArray> import_attributes, Local<Module> referrer);
+  using ResolveSourceCallback = MaybeLocal<Object> (*)(
+      Local<Context> context, Local<String> specifier,
+      Local<FixedArray> import_attributes, Local<Module> referrer);
 
   /**
    * Instantiates the module and its dependencies.
@@ -220,7 +228,8 @@ class V8_EXPORT Module : public Data {
    * exception is propagated.)
    */
   V8_WARN_UNUSED_RESULT Maybe<bool> InstantiateModule(
-      Local<Context> context, ResolveModuleCallback callback);
+      Local<Context> context, ResolveModuleCallback module_callback,
+      ResolveSourceCallback source_callback = nullptr);
 
   /**
    * Evaluates the module and its dependencies.
@@ -264,6 +273,13 @@ class V8_EXPORT Module : public Data {
    */
   bool IsGraphAsync() const;
 
+  /**
+   * Returns whether this module is individually asynchronous (for example,
+   * if it's a Source Text Module Record containing a top-level await).
+   * See [[HasTLA]] in https://tc39.es/ecma262/#sec-cyclic-module-records
+   */
+  bool HasTopLevelAwait() const;
+
   /**
    * Returns whether the module is a SourceTextModule.
    */
@@ -661,6 +677,7 @@ class V8_EXPORT ScriptCompiler {
     kProduceCompileHints = 1 << 2,
     kConsumeCompileHints = 1 << 3,
     kFollowCompileHintsMagicComment = 1 << 4,
+    kFollowCompileHintsPerFunctionMagicComment = 1 << 5,
   };
 
   static inline bool CompileOptionsIsValid(CompileOptions compile_options) {
@@ -701,7 +718,8 @@ class V8_EXPORT ScriptCompiler {
     kNoCacheBecausePacScript,
     kNoCacheBecauseInDocumentWrite,
     kNoCacheBecauseResourceWithNoCacheHandler,
-    kNoCacheBecauseDeferredProduceCodeCache
+    kNoCacheBecauseDeferredProduceCodeCache,
+    kNoCacheBecauseStaticCodeCache,
   };
 
   /**

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

@@ -76,7 +76,12 @@ class V8_EXPORT SourceLocation final {
    *
    * \returns a human-readable string representing source location information.
    */
-  std::string ToString() const;
+  std::string ToString() const {
+    if (!file_) {
+      return {};
+    }
+    return std::string(function_) + "@" + file_ + ":" + std::to_string(line_);
+  }
 
  private:
   constexpr SourceLocation(const char* function, const char* file, size_t line)

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

@@ -72,8 +72,6 @@ class V8_EXPORT Template : public Data {
    * \param name The name of the property for which an accessor is added.
    * \param getter The callback to invoke when getting the property.
    * \param setter The callback to invoke when setting the property.
-   * \param data A piece of data that will be passed to the getter and setter
-   *   callbacks whenever they are invoked.
    * \param attribute The attributes of the property for which an accessor
    *   is added.
    */
@@ -703,6 +701,14 @@ class V8_EXPORT FunctionTemplate : public Template {
    */
   bool IsLeafTemplateForApiObject(v8::Local<v8::Value> value) const;
 
+  /**
+   * Checks if the object can be promoted to read only space, seals it and
+   * prepares for promotion.
+   *
+   * This is an experimental feature and may still change significantly.
+   */
+  void SealAndPrepareForPromotionToReadOnly();
+
   V8_INLINE static FunctionTemplate* Cast(Data* data);
 
  private:

data/vendor/v8/include/v8-trace-categories.h

@@ -0,0 +1,23 @@
+// Copyright 2025 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_V8_TRACE_CATEGORIES_H_
+#define INCLUDE_V8_TRACE_CATEGORIES_H_
+
+#if defined(V8_USE_PERFETTO)
+
+#include "perfetto/tracing/track_event.h"
+#include "v8config.h"
+
+namespace v8 {
+
+// Returns the perfeto TrackEventCategoryRegistry for v8 tracing categories.
+V8_EXPORT const perfetto::internal::TrackEventCategoryRegistry&
+GetTrackEventCategoryRegistry();
+
+}  // namespace v8
+
+#endif  // defined(V8_USE_PERFETTO)
+
+#endif  // INCLUDE_V8_TRACE_CATEGORIES_H_

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

@@ -37,15 +37,13 @@ enum class TracedReferenceHandling {
   kDroppable
 };
 
-V8_EXPORT internal::Address* GlobalizeTracedReference(
-    internal::Isolate* isolate, internal::Address value,
-    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,
-                                   internal::Address** to);
-V8_EXPORT void DisposeTracedReference(internal::Address* global_handle);
+V8_EXPORT Address* GlobalizeTracedReference(
+    Isolate* isolate, Address value, Address* slot,
+    TracedReferenceStoreMode store_mode,
+    TracedReferenceHandling reference_handling);
+V8_EXPORT void MoveTracedReference(Address** from, Address** to);
+V8_EXPORT void CopyTracedReference(const Address* const* from, Address** to);
+V8_EXPORT void DisposeTracedReference(Address* global_handle);
 
 }  // namespace internal
 
@@ -55,6 +53,9 @@ V8_EXPORT void DisposeTracedReference(internal::Address* global_handle);
  */
 class TracedReferenceBase : public api_internal::IndirectHandleBase {
  public:
+  static_assert(sizeof(std::atomic<internal::Address*>) ==
+                sizeof(internal::Address*));
+
   /**
    * If non-empty, destroy the underlying storage cell. |IsEmpty| will return
    * true after this call.
@@ -73,9 +74,7 @@ class TracedReferenceBase : public api_internal::IndirectHandleBase {
    * Returns true if this TracedReference is empty, i.e., has not been
    * assigned an object. This version of IsEmpty is thread-safe.
    */
-  bool IsEmptyThreadSafe() const {
-    return this->GetSlotThreadSafe() == nullptr;
-  }
+  bool IsEmptyThreadSafe() const { return GetSlotThreadSafe() == nullptr; }
 
  protected:
   V8_INLINE TracedReferenceBase() = default;
@@ -83,17 +82,17 @@ class TracedReferenceBase : public api_internal::IndirectHandleBase {
   /**
    * Update this reference in a thread-safe way.
    */
-  void SetSlotThreadSafe(void* new_val) {
-    reinterpret_cast<std::atomic<void*>*>(&slot())->store(
+  void SetSlotThreadSafe(internal::Address* new_val) {
+    reinterpret_cast<std::atomic<internal::Address*>*>(&slot())->store(
         new_val, std::memory_order_relaxed);
   }
 
   /**
    * Get this reference in a thread-safe way
    */
-  const void* GetSlotThreadSafe() const {
-    return reinterpret_cast<std::atomic<const void*> const*>(&slot())->load(
-        std::memory_order_relaxed);
+  const internal::Address* GetSlotThreadSafe() const {
+    return reinterpret_cast<const std::atomic<internal::Address*>*>(&slot())
+        ->load(std::memory_order_relaxed);
   }
 
   V8_EXPORT void CheckValue() const;

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

@@ -23,15 +23,11 @@ class V8_EXPORT TypedArray : public ArrayBufferView {
    * The largest supported typed array byte size. Each subclass defines a
    * type-specific kMaxLength for the maximum length that can be passed to New.
    */
-#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);
+  static constexpr size_t kMaxByteLength = ArrayBuffer::kMaxByteLength;
+
+#ifdef V8_ENABLE_SANDBOX
+  static_assert(v8::TypedArray::kMaxByteLength <=
+                v8::internal::kMaxSafeBufferSizeForSandbox);
 #endif
 
   /**
@@ -253,10 +249,10 @@ class V8_EXPORT Int32Array : public TypedArray {
  * An instance of Float16Array constructor.
  */
 class V8_EXPORT Float16Array : public TypedArray {
+ public:
   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,

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

@@ -18,9 +18,8 @@ struct CalleeSavedRegisters {
   void* arm_r10;
 };
 #elif V8_TARGET_ARCH_X64 || V8_TARGET_ARCH_IA32 || V8_TARGET_ARCH_ARM64 ||     \
-    V8_TARGET_ARCH_MIPS64 || V8_TARGET_ARCH_PPC || V8_TARGET_ARCH_PPC64 ||     \
-    V8_TARGET_ARCH_RISCV64 || V8_TARGET_ARCH_S390 || V8_TARGET_ARCH_LOONG64 || \
-    V8_TARGET_ARCH_RISCV32
+    V8_TARGET_ARCH_MIPS64 || V8_TARGET_ARCH_PPC64 || V8_TARGET_ARCH_RISCV64 || \
+    V8_TARGET_ARCH_S390X || V8_TARGET_ARCH_LOONG64 || V8_TARGET_ARCH_RISCV32
 struct CalleeSavedRegisters {};
 #else
 #error Target architecture was not detected as supported by v8