enum class Mode : uint8_t {

Default,

WebAssembly,

};

JS_EXPORT_PRIVATE ~SharedArrayBufferContents();

static Ref<SharedArrayBufferContents> create(std::span<uint8_t> data, std::optional<size_t> maxByteLength, RefPtr<BufferMemoryHandle> memoryHandle, ArrayBufferDestructorFunction&& destructor, Mode mode)

{

return adoptRef(*new SharedArrayBufferContents(data, maxByteLength, WTF::move(memoryHandle), WTF::move(destructor), mode));

}

void* data() const LIFETIME_BOUND { return m_data.getMayBeNull(); }

size_t sizeInBytes(std::memory_order order) const

{

return m_sizeInBytes.load(order);

}

std::optional<size_t> maxByteLength() const

{

if (m_hasMaxByteLength)

return m_maxByteLength;

return std::nullopt;

}

Mode mode() const { return m_mode; }

Expected<int64_t, GrowFailReason> grow(VM&, size_t newByteLength, bool requirePageMultiple);

// One attempt, which cannot collect because it takes no VM. Reports what the caller owes the heap

// once it has released the memory handle's lock: asking for a collection of either kind can run

// finalizers on the calling thread, so neither may be asked for while that lock is held. On

// SyncTryToReclaimMemory the caller must recompute the whole attempt, since the size it was working

// from can move while unlocked.

Expected<int64_t, GrowFailReason> tryGrow(const AbstractLocker&, size_t newByteLength, bool requirePageMultiple, BufferMemoryResult::Kind&);

void updateSize(size_t sizeInBytes, std::memory_order order = std::memory_order_seq_cst)

{

m_sizeInBytes.store(sizeInBytes, order);

}

BufferMemoryHandle* memoryHandle() const { return m_memoryHandle.get(); }

static constexpr ptrdiff_t offsetOfSizeInBytes() { return OBJECT_OFFSETOF(SharedArrayBufferContents, m_sizeInBytes); }

SharedArrayBufferContents(std::span<uint8_t> data, std::optional<size_t> maxByteLength, RefPtr<BufferMemoryHandle> memoryHandle, ArrayBufferDestructorFunction&& destructor, Mode mode)

: m_data(data.data())

, m_destructor(WTF::move(destructor))

, m_memoryHandle(WTF::move(memoryHandle))

, m_sizeInBytes(data.size())

, m_maxByteLength(maxByteLength.value_or(data.size()))

, m_hasMaxByteLength(!!maxByteLength)

, m_mode(mode)

{

RELEASE_ASSERT(m_maxByteLength <= MAX_ARRAY_BUFFER_SIZE);

#if ASSERT_ENABLED

if (m_hasMaxByteLength)

ASSERT(m_memoryHandle);

#endif

}

using DataType = CagedPtr<Gigacage::Primitive, void>;

DataType m_data;

ArrayBufferDestructorFunction m_destructor;

RefPtr<BufferMemoryHandle> m_memoryHandle;

std::atomic<size_t> m_sizeInBytes { 0 };

size_t m_maxByteLength;

bool m_hasMaxByteLength : 1 { false };

Mode m_mode : 1 { Mode::Default };

WTF_MAKE_NONCOPYABLE(ArrayBufferContents);

ArrayBufferContents() = default;

ArrayBufferContents(void* data, size_t sizeInBytes, std::optional<size_t> maxByteLength, ArrayBufferDestructorFunction&&);

ArrayBufferContents(std::span<const uint8_t> data, std::optional<size_t> maxByteLength, ArrayBufferDestructorFunction&&);

ArrayBufferContents(Ref<SharedArrayBufferContents>&&, bool forceFixedLengthIfWasm = true);

ArrayBufferContents(void* data, size_t sizeInBytes, size_t maxByteLength, Ref<BufferMemoryHandle>&&);

JS_EXPORT_PRIVATE static std::optional<ArrayBufferContents> fromSpan(std::span<const uint8_t>);

ArrayBufferContents(ArrayBufferContents&& other)

{

swap(other);

}

ArrayBufferContents& operator=(ArrayBufferContents&& other)

{

ArrayBufferContents moved(WTF::move(other));

swap(moved);

return *this;

}

~ArrayBufferContents()

{

if (RefPtr destructor = m_destructor) {

// FIXME: We shouldn't use getUnsafe here: https://bugs.webkit.org/show_bug.cgi?id=197698

destructor->run(m_data.getUnsafe());

}

}

explicit operator bool() { return !!m_data; }

void* data() const LIFETIME_BOUND { return m_data.getMayBeNull(); }

void* dataWithoutPACValidation() const LIFETIME_BOUND { return m_data.getUnsafe(); }

size_t sizeInBytes(std::memory_order order = std::memory_order_seq_cst) const

{

if (m_hasMaxByteLength) {

if (m_shared)

return m_shared->sizeInBytes(order);

}

return m_sizeInBytes;

}

std::optional<size_t> maxByteLength() const

{

if (m_hasMaxByteLength)

return m_maxByteLength;

return std::nullopt;

}

std::span<uint8_t> mutableSpan() LIFETIME_BOUND { return { static_cast<uint8_t*>(data()), sizeInBytes() }; }

std::span<const uint8_t> span() const LIFETIME_BOUND { return { static_cast<const uint8_t*>(data()), sizeInBytes() }; }

bool isShared() const { return m_shared; }

bool isResizableOrGrowableShared() const { return m_hasMaxByteLength; }

bool isGrowableShared() const { return isResizableOrGrowableShared() && isShared(); }

bool isResizableNonShared() const { return isResizableOrGrowableShared() && !isShared(); }

void refreshAfterWasmMemoryGrow(Wasm::Memory*);

void swap(ArrayBufferContents& other)

{

using std::swap;

swap(m_data, other.m_data);

swap(m_destructor, other.m_destructor);

swap(m_shared, other.m_shared);

swap(m_memoryHandle, other.m_memoryHandle);

swap(m_sizeInBytes, other.m_sizeInBytes);

swap(m_maxByteLength, other.m_maxByteLength);

swap(m_hasMaxByteLength, other.m_hasMaxByteLength);

}

ArrayBufferContents detach()

{

ArrayBufferContents contents(WTF::move(*this));

m_hasMaxByteLength = contents.m_hasMaxByteLength; // m_maxByteLength needs to be cleared while we need to keep the information that we had m_hasMaxByteLength.

return contents;

}

JS_EXPORT_PRIVATE void shareWith(ArrayBufferContents&);

void reset()

{

m_data = nullptr;

m_destructor = nullptr;

m_shared = nullptr;

m_memoryHandle = nullptr;

m_sizeInBytes = 0;

m_maxByteLength = 0;

m_hasMaxByteLength = false;

}

friend class ArrayBuffer;

enum class InitializationPolicy : uint8_t {

ZeroInitialize,

DontInitialize

};

void tryAllocate(size_t numElements, unsigned elementByteSize, InitializationPolicy);

void makeShared();

void copyTo(ArrayBufferContents&);

using DataType = CagedPtr<Gigacage::Primitive, void>;

DataType m_data { nullptr };

ArrayBufferDestructorFunction m_destructor { nullptr };

RefPtr<SharedArrayBufferContents> m_shared;

RefPtr<BufferMemoryHandle> m_memoryHandle;

size_t m_sizeInBytes { 0 };

size_t m_maxByteLength { 0 };

bool m_hasMaxByteLength { false };

JS_EXPORT_PRIVATE static Ref<ArrayBuffer> create(size_t numElements, unsigned elementByteSize);

JS_EXPORT_PRIVATE static Ref<ArrayBuffer> create(ArrayBuffer&);

JS_EXPORT_PRIVATE static Ref<ArrayBuffer> create(std::span<const uint8_t> = { });

JS_EXPORT_PRIVATE static Ref<ArrayBuffer> create(ArrayBufferContents&&);

JS_EXPORT_PRIVATE static Ref<ArrayBuffer> createAdopted(std::span<const uint8_t>);

JS_EXPORT_PRIVATE static Ref<ArrayBuffer> createFromBytes(std::span<const uint8_t> data, ArrayBufferDestructorFunction&&);

JS_EXPORT_PRIVATE static Ref<ArrayBuffer> createShared(Ref<SharedArrayBufferContents>&&, bool forceFixedLengthIfWasm = true);

JS_EXPORT_PRIVATE static RefPtr<ArrayBuffer> tryCreate(size_t numElements, unsigned elementByteSize, std::optional<size_t> maxByteLength = std::nullopt);

JS_EXPORT_PRIVATE static RefPtr<ArrayBuffer> tryCreate(ArrayBuffer&);

JS_EXPORT_PRIVATE static RefPtr<ArrayBuffer> tryCreate(std::span<const uint8_t> = { });

JS_EXPORT_PRIVATE static RefPtr<ArrayBuffer> tryCreateShared(VM&, size_t numElements, unsigned elementByteSize, size_t maxByteLength);

// Only for use by Uint8ClampedArray::tryCreateUninitialized and FragmentedSharedBuffer::tryCreateArrayBuffer.

JS_EXPORT_PRIVATE static Ref<ArrayBuffer> createUninitialized(size_t numElements, unsigned elementByteSize);

JS_EXPORT_PRIVATE static RefPtr<ArrayBuffer> tryCreateUninitialized(size_t numElements, unsigned elementByteSize);

inline void* data() LIFETIME_BOUND;

inline const void* data() const LIFETIME_BOUND;

inline size_t byteLength(std::memory_order = std::memory_order_relaxed) const;

inline std::optional<size_t> maxByteLength() const;

inline void* dataWithoutPACValidation() LIFETIME_BOUND;

inline const void* dataWithoutPACValidation() const LIFETIME_BOUND;

void makeShared();

void setSharingMode(ArrayBufferSharingMode);

inline bool isShared() const;

inline ArrayBufferSharingMode sharingMode() const { return isShared() ? ArrayBufferSharingMode::Shared : ArrayBufferSharingMode::Default; }

inline bool isResizableOrGrowableShared() const { return m_contents.isResizableOrGrowableShared(); }

inline bool isFixedLength() const { return !isResizableOrGrowableShared(); }

inline bool isGrowableShared() const { return m_contents.isGrowableShared(); }

inline bool isResizableNonShared() const { return m_contents.isResizableNonShared(); }

inline size_t gcSizeEstimateInBytes() const;

JS_EXPORT_PRIVATE RefPtr<ArrayBuffer> slice(double begin, double end) const;

JS_EXPORT_PRIVATE RefPtr<ArrayBuffer> slice(double begin) const;

JS_EXPORT_PRIVATE RefPtr<ArrayBuffer> sliceWithClampedIndex(size_t begin, size_t end) const;

inline void pin();

inline void unpin();

inline bool isDetachable() const;

// Calling this prevents the backing buffer from ever being detached. This can happen when an

// API user fetched m_contents directly from a TypedArray object, the buffer is backed by a

// WebAssembly.Memory, or is a SharedArrayBuffer.

inline void pinAndLock();

void NODELETE makeWasmMemory();

inline bool isWasmMemory();

// When a resizable buffer is associated with a non-shared Wasm memory, this function is called by the memory's growthSuccessCallback.

void refreshAfterWasmMemoryGrow(Wasm::Memory*);

JS_EXPORT_PRIVATE bool transferTo(VM&, ArrayBufferContents&);

JS_EXPORT_PRIVATE bool shareWith(ArrayBufferContents&);

void detach(VM&);

bool isDetached() { return !m_contents.m_data; }

InlineWatchpointSet& detachingWatchpointSet() LIFETIME_BOUND { return m_detachingWatchpointSet; }

static constexpr ptrdiff_t offsetOfSizeInBytes() { return OBJECT_OFFSETOF(ArrayBuffer, m_contents) + OBJECT_OFFSETOF(ArrayBufferContents, m_sizeInBytes); }

static constexpr ptrdiff_t offsetOfData() { return OBJECT_OFFSETOF(ArrayBuffer, m_contents) + OBJECT_OFFSETOF(ArrayBufferContents, m_data); }

static constexpr ptrdiff_t offsetOfShared() { return OBJECT_OFFSETOF(ArrayBuffer, m_contents) + OBJECT_OFFSETOF(ArrayBufferContents, m_shared); }

JS_EXPORT_PRIVATE ~ArrayBuffer();

JS_EXPORT_PRIVATE static Ref<SharedTask<void(void*)>> primitiveGigacageDestructor();

Expected<int64_t, GrowFailReason> grow(VM&, size_t newByteLength);

Expected<int64_t, GrowFailReason> resize(VM&, size_t newByteLength);

std::span<uint8_t> mutableSpan() LIFETIME_BOUND { return { static_cast<uint8_t*>(data()), byteLength() }; }

std::span<const uint8_t> span() const LIFETIME_BOUND { return { static_cast<const uint8_t*>(data()), byteLength() }; }

Vector<uint8_t> toVector() const { return { span() }; }

static Ref<ArrayBuffer> create(size_t numElements, unsigned elementByteSize, ArrayBufferContents::InitializationPolicy);

static Ref<ArrayBuffer> createInternal(ArrayBufferContents&&, const void*, size_t);

static RefPtr<ArrayBuffer> tryCreate(size_t numElements, unsigned elementByteSize, std::optional<size_t> maxByteLength, ArrayBufferContents::InitializationPolicy);

ArrayBuffer(ArrayBufferContents&&);

inline size_t NODELETE clampIndex(double index) const;

static inline size_t NODELETE clampValue(double x, size_t left, size_t right);

void notifyDetaching(VM&);

ArrayBufferContents m_contents;

InlineWatchpointSet m_detachingWatchpointSet { IsWatched };

Weak<JSArrayBuffer> m_wrapper;

static constexpr unsigned s_lockedFlag = INT32_MIN;

Checked<unsigned> m_pinCount { 0 };

bool m_isWasmMemory { false };

{

// FIXME: We probably want to scale this by the shared ref count or something.

return sizeof(ArrayBuffer) + byteLength();

{

unsigned old = m_pinCount;

m_pinCount--;

m_pinCount |= (old & s_lockedFlag);

WTF_MAKE_TZONE_ALLOCATED_TEMPLATE(IdempotentArrayBufferByteLengthGetter);

IdempotentArrayBufferByteLengthGetter() = default;

size_t operator()(ArrayBuffer& buffer)

{

if (m_byteLength)

return m_byteLength.value();

size_t result = buffer.byteLength(order);

m_byteLength = result;

return result;

}

std::optional<size_t> m_byteLength;