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

data/vendor/v8/include/cppgc/member.h

@@ -38,9 +38,8 @@ class V8_TRIVIAL_ABI MemberBase {
 
   V8_INLINE MemberBase() = default;
   V8_INLINE explicit MemberBase(const void* value) : raw_(value) {}
-  V8_INLINE MemberBase(const void* value, AtomicInitializerTag) {
-    SetRawAtomic(value);
-  }
+  V8_INLINE MemberBase(const void* value, AtomicInitializerTag)
+      : raw_(value, typename RawStorage::AtomicInitializerTag{}) {}
 
   V8_INLINE explicit MemberBase(RawStorage raw) : raw_(raw) {}
   V8_INLINE explicit MemberBase(std::nullptr_t) : raw_(nullptr) {}
@@ -87,7 +86,7 @@ class V8_TRIVIAL_ABI BasicMember final : private MemberBase<StorageType>,
   V8_INLINE BasicMember(SentinelPointer s) : Base(s) {}  // NOLINT
   V8_INLINE BasicMember(T* raw) : Base(raw) {            // NOLINT
     InitializingWriteBarrier(raw);
-    this->CheckPointer(Get());
+    CheckPointer(raw);
   }
   V8_INLINE BasicMember(T& raw)  // NOLINT
       : BasicMember(&raw) {}
@@ -103,7 +102,7 @@ class V8_TRIVIAL_ABI BasicMember final : private MemberBase<StorageType>,
   V8_INLINE BasicMember(T* raw, AtomicInitializerTag atomic)
       : Base(raw, atomic) {
     InitializingWriteBarrier(raw);
-    this->CheckPointer(Get());
+    CheckPointer(raw);
   }
   V8_INLINE BasicMember(T& raw, AtomicInitializerTag atomic)
       : BasicMember(&raw, atomic) {}
@@ -117,7 +116,7 @@ class V8_TRIVIAL_ABI BasicMember final : private MemberBase<StorageType>,
   // need to be adjusted.
   template <typename U, typename OtherBarrierPolicy, typename OtherWeaknessTag,
             typename OtherCheckingPolicy,
-            std::enable_if_t<internal::IsDecayedSameV<T, U>>* = nullptr>
+            std::enable_if_t<IsDecayedSameV<T, U>>* = nullptr>
   V8_INLINE BasicMember(  // NOLINT
       const BasicMember<U, OtherWeaknessTag, OtherBarrierPolicy,
                         OtherCheckingPolicy, StorageType>& other)
@@ -125,7 +124,7 @@ class V8_TRIVIAL_ABI BasicMember final : private MemberBase<StorageType>,
 
   template <typename U, typename OtherBarrierPolicy, typename OtherWeaknessTag,
             typename OtherCheckingPolicy,
-            std::enable_if_t<internal::IsStrictlyBaseOfV<T, U>>* = nullptr>
+            std::enable_if_t<IsStrictlyBaseOfV<T, U>>* = nullptr>
   V8_INLINE BasicMember(  // NOLINT
       const BasicMember<U, OtherWeaknessTag, OtherBarrierPolicy,
                         OtherCheckingPolicy, StorageType>& other)
@@ -142,7 +141,7 @@ class V8_TRIVIAL_ABI BasicMember final : private MemberBase<StorageType>,
   // need to be adjusted.
   template <typename U, typename OtherBarrierPolicy, typename OtherWeaknessTag,
             typename OtherCheckingPolicy,
-            std::enable_if_t<internal::IsDecayedSameV<T, U>>* = nullptr>
+            std::enable_if_t<IsDecayedSameV<T, U>>* = nullptr>
   V8_INLINE BasicMember(
       BasicMember<U, OtherWeaknessTag, OtherBarrierPolicy, OtherCheckingPolicy,
                   StorageType>&& other) noexcept
@@ -152,7 +151,7 @@ class V8_TRIVIAL_ABI BasicMember final : private MemberBase<StorageType>,
 
   template <typename U, typename OtherBarrierPolicy, typename OtherWeaknessTag,
             typename OtherCheckingPolicy,
-            std::enable_if_t<internal::IsStrictlyBaseOfV<T, U>>* = nullptr>
+            std::enable_if_t<IsStrictlyBaseOfV<T, U>>* = nullptr>
   V8_INLINE BasicMember(
       BasicMember<U, OtherWeaknessTag, OtherBarrierPolicy, OtherCheckingPolicy,
                   StorageType>&& other) noexcept
@@ -183,10 +182,10 @@ class V8_TRIVIAL_ABI BasicMember final : private MemberBase<StorageType>,
   V8_INLINE BasicMember& operator=(
       const BasicMember<U, OtherWeaknessTag, OtherBarrierPolicy,
                         OtherCheckingPolicy, StorageType>& other) {
-    if constexpr (internal::IsDecayedSameV<T, U>) {
+    if constexpr (IsDecayedSameV<T, U>) {
       return operator=(other.GetRawStorage());
     } else {
-      static_assert(internal::IsStrictlyBaseOfV<T, U>);
+      static_assert(IsStrictlyBaseOfV<T, U>);
       return operator=(other.Get());
     }
   }
@@ -206,10 +205,10 @@ class V8_TRIVIAL_ABI BasicMember final : private MemberBase<StorageType>,
   V8_INLINE BasicMember& operator=(
       BasicMember<U, OtherWeaknessTag, OtherBarrierPolicy, OtherCheckingPolicy,
                   StorageType>&& other) noexcept {
-    if constexpr (internal::IsDecayedSameV<T, U>) {
+    if constexpr (IsDecayedSameV<T, U>) {
       operator=(other.GetRawStorage());
     } else {
-      static_assert(internal::IsStrictlyBaseOfV<T, U>);
+      static_assert(IsStrictlyBaseOfV<T, U>);
       operator=(other.Get());
     }
     other.Clear();
@@ -231,7 +230,7 @@ class V8_TRIVIAL_ABI BasicMember final : private MemberBase<StorageType>,
   V8_INLINE BasicMember& operator=(T* other) {
     Base::SetRawAtomic(other);
     AssigningWriteBarrier(other);
-    this->CheckPointer(Get());
+    CheckPointer(other);
     return *this;
   }
 
@@ -270,9 +269,7 @@ class V8_TRIVIAL_ABI BasicMember final : private MemberBase<StorageType>,
     return static_cast<T*>(const_cast<void*>(Base::GetRaw()));
   }
 
-  V8_INLINE void Clear() {
-    Base::SetRawStorageAtomic(RawStorage{});
-  }
+  V8_INLINE void Clear() { Base::SetRawStorageAtomic(RawStorage{}); }
 
   V8_INLINE T* Release() {
     T* result = Get();
@@ -284,20 +281,18 @@ class V8_TRIVIAL_ABI BasicMember final : private MemberBase<StorageType>,
     return reinterpret_cast<const T**>(Base::GetRawSlot());
   }
 
-  V8_INLINE RawStorage GetRawStorage() const {
-    return Base::GetRawStorage();
-  }
+  V8_INLINE RawStorage GetRawStorage() const { return Base::GetRawStorage(); }
 
  private:
   V8_INLINE explicit BasicMember(RawStorage raw) : Base(raw) {
-    InitializingWriteBarrier(Get());
-    this->CheckPointer(Get());
+    InitializingWriteBarrier();
+    CheckPointer();
   }
 
   V8_INLINE BasicMember& operator=(RawStorage other) {
     Base::SetRawStorageAtomic(other);
     AssigningWriteBarrier();
-    this->CheckPointer(Get());
+    CheckPointer();
     return *this;
   }
 
@@ -308,6 +303,10 @@ class V8_TRIVIAL_ABI BasicMember final : private MemberBase<StorageType>,
   V8_INLINE void InitializingWriteBarrier(T* value) const {
     WriteBarrierPolicy::InitializingBarrier(Base::GetRawSlot(), value);
   }
+  V8_INLINE void InitializingWriteBarrier() const {
+    WriteBarrierPolicy::InitializingBarrier(Base::GetRawSlot(),
+                                            Base::GetRawStorage());
+  }
   V8_INLINE void AssigningWriteBarrier(T* value) const {
     WriteBarrierPolicy::template AssigningBarrier<
         StorageType::kWriteBarrierSlotType>(Base::GetRawSlot(), value);
@@ -317,6 +316,12 @@ class V8_TRIVIAL_ABI BasicMember final : private MemberBase<StorageType>,
         StorageType::kWriteBarrierSlotType>(Base::GetRawSlot(),
                                             Base::GetRawStorage());
   }
+  V8_INLINE void CheckPointer(T* value) {
+    CheckingPolicy::template CheckPointer<T>(value);
+  }
+  V8_INLINE void CheckPointer() {
+    CheckingPolicy::template CheckPointer<T>(Base::GetRawStorage());
+  }
 
   V8_INLINE void ClearFromGC() const { Base::ClearFromGC(); }
 
@@ -341,12 +346,11 @@ V8_INLINE bool operator==(
                       StorageType>& member1,
     const BasicMember<T2, WeaknessTag2, WriteBarrierPolicy2, CheckingPolicy2,
                       StorageType>& member2) {
-  if constexpr (internal::IsDecayedSameV<T1, T2>) {
+  if constexpr (IsDecayedSameV<T1, T2>) {
     // Check compressed pointers if types are the same.
     return member1.GetRawStorage() == member2.GetRawStorage();
   } else {
-    static_assert(internal::IsStrictlyBaseOfV<T1, T2> ||
-                  internal::IsStrictlyBaseOfV<T2, T1>);
+    static_assert(IsStrictlyBaseOfV<T1, T2> || IsStrictlyBaseOfV<T2, T1>);
     // Otherwise, check decompressed pointers.
     return member1.Get() == member2.Get();
   }
@@ -372,12 +376,12 @@ V8_INLINE bool operator==(
                       StorageType>& member,
     U* raw) {
   // Never allow comparison with erased pointers.
-  static_assert(!internal::IsDecayedSameV<void, U>);
+  static_assert(!IsDecayedSameV<void, U>);
 
-  if constexpr (internal::IsDecayedSameV<T, U>) {
+  if constexpr (IsDecayedSameV<T, U>) {
     // Check compressed pointers if types are the same.
     return member.GetRawStorage() == StorageType(raw);
-  } else if constexpr (internal::IsStrictlyBaseOfV<T, U>) {
+  } else if constexpr (IsStrictlyBaseOfV<T, U>) {
     // Cast the raw pointer to T, which may adjust the pointer.
     return member.GetRawStorage() == StorageType(static_cast<T*>(raw));
   } else {
@@ -494,7 +498,7 @@ V8_INLINE bool operator<(
     const BasicMember<T2, WeaknessTag2, WriteBarrierPolicy2, CheckingPolicy2,
                       StorageType>& member2) {
   static_assert(
-      internal::IsDecayedSameV<T1, T2>,
+      IsDecayedSameV<T1, T2>,
       "Comparison works only for same pointer type modulo cv-qualifiers");
   return member1.GetRawStorage() < member2.GetRawStorage();
 }
@@ -509,7 +513,7 @@ V8_INLINE bool operator<=(
     const BasicMember<T2, WeaknessTag2, WriteBarrierPolicy2, CheckingPolicy2,
                       StorageType>& member2) {
   static_assert(
-      internal::IsDecayedSameV<T1, T2>,
+      IsDecayedSameV<T1, T2>,
       "Comparison works only for same pointer type modulo cv-qualifiers");
   return member1.GetRawStorage() <= member2.GetRawStorage();
 }
@@ -524,7 +528,7 @@ V8_INLINE bool operator>(
     const BasicMember<T2, WeaknessTag2, WriteBarrierPolicy2, CheckingPolicy2,
                       StorageType>& member2) {
   static_assert(
-      internal::IsDecayedSameV<T1, T2>,
+      IsDecayedSameV<T1, T2>,
       "Comparison works only for same pointer type modulo cv-qualifiers");
   return member1.GetRawStorage() > member2.GetRawStorage();
 }
@@ -539,16 +543,15 @@ V8_INLINE bool operator>=(
     const BasicMember<T2, WeaknessTag2, WriteBarrierPolicy2, CheckingPolicy2,
                       StorageType>& member2) {
   static_assert(
-      internal::IsDecayedSameV<T1, T2>,
+      IsDecayedSameV<T1, T2>,
       "Comparison works only for same pointer type modulo cv-qualifiers");
   return member1.GetRawStorage() >= member2.GetRawStorage();
 }
 
 template <typename T, typename WriteBarrierPolicy, typename CheckingPolicy,
           typename StorageType>
-struct IsWeak<internal::BasicMember<T, WeakMemberTag, WriteBarrierPolicy,
-                                    CheckingPolicy, StorageType>>
-    : std::true_type {};
+struct IsWeak<BasicMember<T, WeakMemberTag, WriteBarrierPolicy, CheckingPolicy,
+                          StorageType>> : std::true_type {};
 
 }  // namespace internal
 
@@ -626,4 +629,35 @@ static constexpr size_t kSizeofCompressedMember =
 
 }  // namespace cppgc
 
+// Mark `BasicMember<T>` and `T*` as having a common reference type of `T*` (the
+// type to which both can be converted or bound). This makes them satisfy
+// `std::equality_comparable`, which allows usage like the following:
+// ```
+//   HeapVector<Member<T>> v;
+//   T* e;
+//   auto it = std::ranges::find(v, e);
+// ```
+// Without this, the `find()` call above would fail to compile with an error
+// about being unable to invoke `std::ranges::equal_to()`.
+template <typename T, typename WeaknessTag, typename WriteBarrierPolicy,
+          typename CheckingPolicy, typename StorageType,
+          template <typename> typename TQ, template <typename> typename UQ>
+struct std::basic_common_reference<
+    cppgc::internal::BasicMember<T, WeaknessTag, WriteBarrierPolicy,
+                                 CheckingPolicy, StorageType>,
+    T*, TQ, UQ> {
+  using type = T*;
+};
+
+template <typename T, typename WeaknessTag, typename WriteBarrierPolicy,
+          typename CheckingPolicy, typename StorageType,
+          template <typename> typename TQ, template <typename> typename UQ>
+struct std::basic_common_reference<
+    T*,
+    cppgc::internal::BasicMember<T, WeaknessTag, WriteBarrierPolicy,
+                                 CheckingPolicy, StorageType>,
+    TQ, UQ> {
+  using type = T*;
+};
+
 #endif  // INCLUDE_CPPGC_MEMBER_H_

data/vendor/v8/include/cppgc/name-provider.h

@@ -55,6 +55,9 @@ class V8_EXPORT NameProvider {
    * Specifies a name for the garbage-collected object. Such names will never
    * be hidden, as they are explicitly specified by the user of this API.
    *
+   * Implementations of this function must not allocate garbage-collected
+   * objects or otherwise modify the cppgc heap.
+   *
    * V8 may call this function while generating a heap snapshot or at other
    * times. If V8 is currently generating a heap snapshot (according to
    * HeapProfiler::IsTakingSnapshot), then the returned string must stay alive

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

@@ -52,6 +52,15 @@ class V8_EXPORT Platform {
    * Foreground task runner that should be used by a Heap.
    */
   virtual std::shared_ptr<TaskRunner> GetForegroundTaskRunner() {
+    return GetForegroundTaskRunner(TaskPriority::kUserBlocking);
+  }
+
+  /**
+   * Returns a TaskRunner with a specific |priority| which can be used to post a
+   * task on the foreground thread.
+   */
+  virtual std::shared_ptr<TaskRunner> GetForegroundTaskRunner(
+      TaskPriority priority) {
     return nullptr;
   }
 
@@ -127,6 +136,8 @@ class V8_EXPORT Platform {
   virtual TracingController* GetTracingController();
 };
 
+V8_EXPORT bool IsInitialized();
+
 /**
  * Process-global initialization of the garbage collector. Must be called before
  * creating a Heap.

data/vendor/v8/include/cppgc/type-traits.h

@@ -9,6 +9,7 @@
 // against Oilpan types without including any other parts.
 #include <cstddef>
 #include <type_traits>
+#include <utility>
 
 namespace cppgc {
 

data/vendor/v8/include/cppgc/visitor.h

@@ -8,12 +8,12 @@
 #include <type_traits>
 
 #include "cppgc/custom-space.h"
-#include "cppgc/ephemeron-pair.h"
 #include "cppgc/garbage-collected.h"
 #include "cppgc/internal/logging.h"
 #include "cppgc/internal/member-storage.h"
 #include "cppgc/internal/pointer-policies.h"
 #include "cppgc/liveness-broker.h"
+#include "cppgc/macros.h"
 #include "cppgc/member.h"
 #include "cppgc/sentinel-pointer.h"
 #include "cppgc/source-location.h"
@@ -36,6 +36,25 @@ class VisitorFactory;
 
 using WeakCallback = void (*)(const LivenessBroker&, const void*);
 
+/**
+ * An ephemeron pair is used to conditionally retain an object.
+ * The `value` will be kept alive only if the `key` is alive.
+ */
+template <typename K, typename V>
+struct EphemeronPair {
+  CPPGC_DISALLOW_NEW();
+
+  EphemeronPair(K* k, V* v) : key(k), value(v) {}
+  WeakMember<K> key;
+  Member<V> value;
+
+  void ClearValueIfKeyIsDead(const LivenessBroker& broker) {
+    if (!broker.IsHeapObjectAlive(key)) value = nullptr;
+  }
+
+  void Trace(Visitor* visitor) const;
+};
+
 /**
  * Visitor passed to trace methods. All managed pointers must have called the
  * Visitor's trace method on them.
@@ -436,6 +455,11 @@ class V8_EXPORT Visitor {
   friend class internal::VisitorBase;
 };
 
+template <typename K, typename V>
+void EphemeronPair<K, V>::Trace(Visitor* visitor) const {
+  visitor->TraceEphemeron(key, value);
+}
+
 namespace internal {
 
 class V8_EXPORT RootVisitor {

data/vendor/v8/include/libplatform/libplatform-export.h

@@ -18,11 +18,11 @@
 #else  // defined(_WIN32)
 
 // Setup for Linux shared library export.
-#ifdef BUILDING_V8_PLATFORM_SHARED
+#if defined(BUILDING_V8_PLATFORM_SHARED) || USING_V8_PLATFORM_SHARED
 #define V8_PLATFORM_EXPORT __attribute__((visibility("default")))
 #else
 #define V8_PLATFORM_EXPORT
-#endif
+#endif  // defined(BUILDING_V8_PLATFORM_SHARED) || ...
 
 #endif  // defined(_WIN32)
 

data/vendor/v8/include/libplatform/v8-tracing.h

@@ -6,7 +6,6 @@
 #define V8_LIBPLATFORM_V8_TRACING_H_
 
 #include <atomic>
-#include <fstream>
 #include <memory>
 #include <unordered_set>
 #include <vector>

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

@@ -10,13 +10,20 @@
 #include <memory>
 
 #include "v8-local-handle.h"  // NOLINT(build/include_directory)
+#include "v8-memory-span.h"   // NOLINT(build/include_directory)
 #include "v8-object.h"        // NOLINT(build/include_directory)
+#include "v8-platform.h"      // NOLINT(build/include_directory)
 #include "v8config.h"         // NOLINT(build/include_directory)
 
 namespace v8 {
 
 class SharedArrayBuffer;
 
+#if defined(V8_COMPRESS_POINTERS) && \
+    !defined(V8_COMPRESS_POINTERS_IN_SHARED_CAGE)
+class IsolateGroup;
+#endif
+
 #ifndef V8_ARRAY_BUFFER_INTERNAL_FIELD_COUNT
 // Defined using gn arg `v8_array_buffer_internal_field_count`.
 #define V8_ARRAY_BUFFER_INTERNAL_FIELD_COUNT 2
@@ -24,6 +31,7 @@ class SharedArrayBuffer;
 
 enum class ArrayBufferCreationMode { kInternalized, kExternalized };
 enum class BackingStoreInitializationMode { kZeroInitialized, kUninitialized };
+enum class BackingStoreOnFailureMode { kReturnNull, kOutOfMemory };
 
 /**
  * A wrapper around the backing store (i.e. the raw memory) of an array buffer.
@@ -83,18 +91,6 @@ class V8_EXPORT BackingStore : public v8::internal::BackingStoreBase {
    */
   void operator delete(void* ptr) { ::operator delete(ptr); }
 
-  /**
-   * Wrapper around ArrayBuffer::Allocator::Reallocate that preserves IsShared.
-   * Assumes that the backing_store was allocated by the ArrayBuffer allocator
-   * of the given isolate.
-   */
-  V8_DEPRECATED(
-      "Reallocate is unsafe, please do not use. Please allocate a new "
-      "BackingStore and copy instead.")
-  static std::unique_ptr<BackingStore> Reallocate(
-      v8::Isolate* isolate, std::unique_ptr<BackingStore> backing_store,
-      size_t byte_length);
-
   /**
    * This callback is used only if the memory block for a BackingStore cannot be
    * allocated with an ArrayBuffer::Allocator. In such cases the destructor of
@@ -172,21 +168,13 @@ class V8_EXPORT ArrayBuffer : public Object {
     virtual void Free(void* data, size_t length) = 0;
 
     /**
-     * Reallocate the memory block of size |old_length| to a memory block of
-     * size |new_length| by expanding, contracting, or copying the existing
-     * memory block. If |new_length| > |old_length|, then the new part of
-     * the memory must be initialized to zeros. Return nullptr if reallocation
-     * is not successful.
-     *
-     * The caller guarantees that the memory block was previously allocated
-     * using Allocate or AllocateUninitialized.
-     *
-     * The default implementation allocates a new block and copies data.
+     * Returns a size_t that determines the largest ArrayBuffer that can be
+     * allocated.  Override if your Allocator is more restrictive than the
+     * default.  Will only be called once, and the value returned will be
+     * cached.
+     * Should not return a value that is larger than kMaxByteLength.
      */
-    V8_DEPRECATED(
-        "Reallocate is unsafe, please do not use. Please allocate new memory "
-        "and copy instead.")
-    virtual void* Reallocate(void* data, size_t old_length, size_t new_length);
+    virtual size_t MaxAllocationSize() const { return kMaxByteLength; }
 
     /**
      * ArrayBuffer allocation mode. kNormal is a malloc/free style allocation,
@@ -195,11 +183,37 @@ class V8_EXPORT ArrayBuffer : public Object {
      */
     enum class AllocationMode { kNormal, kReservation };
 
+    /**
+     * Returns page allocator used by this Allocator instance.
+     *
+     * When the sandbox used by Allocator it is expected that this returns
+     * sandbox's page allocator.
+     * Otherwise, it should return system page allocator.
+     */
+    virtual PageAllocator* GetPageAllocator() { return nullptr; }
+
+#if defined(V8_COMPRESS_POINTERS) && \
+    !defined(V8_COMPRESS_POINTERS_IN_SHARED_CAGE)
     /**
      * Convenience allocator.
      *
      * When the sandbox is enabled, this allocator will allocate its backing
-     * memory inside the sandbox. Otherwise, it will rely on malloc/free.
+     * memory inside the sandbox that belongs to passed isolate group.
+     * Otherwise, it will rely on malloc/free.
+     *
+     * Caller takes ownership, i.e. the returned object needs to be freed using
+     * |delete allocator| once it is no longer in use.
+     */
+    static Allocator* NewDefaultAllocator(const IsolateGroup& group);
+#endif  // defined(V8_COMPRESS_POINTERS) &&
+        // !defined(V8_COMPRESS_POINTERS_IN_SHARED_CAGE)
+
+    /**
+     * Convenience allocator.
+     *
+     * When the sandbox is enabled, this allocator will allocate its backing
+     * memory inside the default global sandbox. Otherwise, it will rely on
+     * malloc/free.
      *
      * Caller takes ownership, i.e. the returned object needs to be freed using
      * |delete allocator| once it is no longer in use.
@@ -217,6 +231,18 @@ class V8_EXPORT ArrayBuffer : public Object {
    */
   size_t MaxByteLength() const;
 
+  /**
+   * Attempt to create a new ArrayBuffer. Allocate |byte_length| bytes.
+   * Allocated memory will be owned by a created ArrayBuffer and
+   * will be deallocated when it is garbage-collected,
+   * unless the object is externalized. If allocation fails, the Maybe
+   * returned will be empty.
+   */
+  static MaybeLocal<ArrayBuffer> MaybeNew(
+      Isolate* isolate, size_t byte_length,
+      BackingStoreInitializationMode initialization_mode =
+          BackingStoreInitializationMode::kZeroInitialized);
+
   /**
    * Create a new ArrayBuffer. Allocate |byte_length| bytes, which are either
    * zero-initialized or uninitialized. Allocated memory will be owned by a
@@ -246,17 +272,25 @@ class V8_EXPORT ArrayBuffer : public Object {
   /**
    * Returns a new standalone BackingStore that is allocated using the array
    * buffer allocator of the isolate. The allocation can either be zero
-   * intialized, or uninitialized. The result can be later passed to
+   * initialized, or uninitialized. The result can be later passed to
    * ArrayBuffer::New.
    *
    * If the allocator returns nullptr, then the function may cause GCs in the
-   * given isolate and re-try the allocation. If GCs do not help, then the
+   * given isolate and re-try the allocation.
+   *
+   * If GCs do not help and on_failure is kOutOfMemory, then the
    * function will crash with an out-of-memory error.
+   *
+   * Otherwise if GCs do not help (or the allocation is too large for GCs to
+   * help) and on_failure is kReturnNull, then a null result is returned.
    */
   static std::unique_ptr<BackingStore> NewBackingStore(
       Isolate* isolate, size_t byte_length,
       BackingStoreInitializationMode initialization_mode =
-          BackingStoreInitializationMode::kZeroInitialized);
+          BackingStoreInitializationMode::kZeroInitialized,
+      BackingStoreOnFailureMode on_failure =
+          BackingStoreOnFailureMode::kOutOfMemory);
+
   /**
    * Returns a new standalone BackingStore that takes over the ownership of
    * the given buffer. The destructor of the BackingStore invokes the given
@@ -354,9 +388,21 @@ class V8_EXPORT ArrayBuffer : public Object {
       V8_ARRAY_BUFFER_INTERNAL_FIELD_COUNT;
   static constexpr int kEmbedderFieldCount = kInternalFieldCount;
 
+#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
+
  private:
   ArrayBuffer();
   static void CheckCast(Value* obj);
+  friend class TypedArray;
 };
 
 #ifndef V8_ARRAY_BUFFER_VIEW_INTERNAL_FIELD_COUNT
@@ -394,6 +440,16 @@ class V8_EXPORT ArrayBufferView : public Object {
    */
   size_t CopyContents(void* dest, size_t byte_length);
 
+  /**
+   * Returns the contents of the ArrayBufferView's buffer as a MemorySpan. If
+   * the contents are on the V8 heap, they get copied into `storage`. Otherwise
+   * a view into the off-heap backing store is returned. The provided storage
+   * should be at least as large as the maximum on-heap size of a TypedArray,
+   * was defined in gn with `typed_array_max_size_in_heap`. The default value is
+   * 64 bytes.
+   */
+  v8::MemorySpan<uint8_t> GetContents(v8::MemorySpan<uint8_t> storage);
+
   /**
    * Returns true if ArrayBufferView's backing ArrayBuffer has already been
    * allocated.
@@ -463,6 +519,18 @@ class V8_EXPORT SharedArrayBuffer : public Object {
       BackingStoreInitializationMode initialization_mode =
           BackingStoreInitializationMode::kZeroInitialized);
 
+  /**
+   * Create a new SharedArrayBuffer. Allocate |byte_length| bytes, which are
+   * either zero-initialized or uninitialized. Allocated memory will be owned by
+   * a created SharedArrayBuffer and will be deallocated when it is
+   * garbage-collected, unless the object is externalized.  If allocation
+   * fails, the Maybe returned will be empty.
+   */
+  static MaybeLocal<SharedArrayBuffer> MaybeNew(
+      Isolate* isolate, size_t byte_length,
+      BackingStoreInitializationMode initialization_mode =
+          BackingStoreInitializationMode::kZeroInitialized);
+
   /**
    * Create a new SharedArrayBuffer with an existing backing store.
    * The created array keeps a reference to the backing store until the array
@@ -481,17 +549,26 @@ class V8_EXPORT SharedArrayBuffer : public Object {
   /**
    * Returns a new standalone BackingStore that is allocated using the array
    * buffer allocator of the isolate. The allocation can either be zero
-   * intialized, or uninitialized. The result can be later passed to
+   * initialized, or uninitialized. The result can be later passed to
    * SharedArrayBuffer::New.
    *
    * If the allocator returns nullptr, then the function may cause GCs in the
-   * given isolate and re-try the allocation. If GCs do not help, then the
-   * function will crash with an out-of-memory error.
+   * given isolate and re-try the allocation.
+   *
+   * If on_failure is kOutOfMemory and GCs do not help, then the function will
+   * crash with an out-of-memory error.
+   *
+   * Otherwise, if on_failure is kReturnNull and GCs do not help (or the
+   * byte_length is so large that the allocation cannot succeed), then a null
+   * result is returned.
    */
   static std::unique_ptr<BackingStore> NewBackingStore(
       Isolate* isolate, size_t byte_length,
       BackingStoreInitializationMode initialization_mode =
-          BackingStoreInitializationMode::kZeroInitialized);
+          BackingStoreInitializationMode::kZeroInitialized,
+      BackingStoreOnFailureMode on_failure =
+          BackingStoreOnFailureMode::kOutOfMemory);
+
   /**
    * Returns a new standalone BackingStore that takes over the ownership of
    * the given buffer. The destructor of the BackingStore invokes the given