ContiguousData() = default;

ContiguousData(T* data, size_t length)

: m_data(data)

#if ASSERT_ENABLED

, m_length(length)

#endif

{

UNUSED_PARAM(length);

}

struct Data {

Data(T& location, IndexingType indexingMode)

: m_data(location)

#if ASSERT_ENABLED

, m_isWritable(!isCopyOnWrite(indexingMode))

#endif

{

UNUSED_PARAM(indexingMode);

}

explicit operator bool() const { return !!m_data.get(); }

const T& operator=(const T& value)

{

ASSERT(m_isWritable);

m_data = value;

return value;

}

operator const T&() const { return m_data; }

// WriteBarrier forwarded methods.

void set(VM& vm, const JSCell* owner, const JSValue& value)

{

ASSERT(m_isWritable);

m_data.set(vm, owner, value);

}

void setWithoutWriteBarrier(const JSValue& value)

{

ASSERT(m_isWritable);

m_data.setWithoutWriteBarrier(value);

}

void setStartingValue(JSValue value)

{

m_data.setStartingValue(value);

}

void clear()

{

ASSERT(m_isWritable);

m_data.clear();

}

JSValue get() const

{

return m_data.get();

}

T& m_data;

#if ASSERT_ENABLED

bool m_isWritable;

#endif

};

const Data at(const JSCell* owner, size_t index) const;

Data at(const JSCell* owner, size_t index);

T& atUnsafe(size_t index) { ASSERT(index < m_length); return m_data[index]; }

T* data() const { return m_data; }

#if ASSERT_ENABLED

size_t length() const { return m_length; }

#endif

T* m_data { nullptr };

#if ASSERT_ENABLED

size_t m_length { 0 };

#endif

WTF_MAKE_NONCOPYABLE(Butterfly);

Butterfly() { } // Not instantiable.

static size_t totalSize(size_t preCapacity, size_t propertyCapacity, bool hasIndexingHeader, size_t indexingPayloadSizeInBytes)

{

ASSERT(!indexingPayloadSizeInBytes || hasIndexingHeader);

ASSERT(sizeof(EncodedJSValue) == sizeof(IndexingHeader));

return (preCapacity + propertyCapacity) * sizeof(EncodedJSValue) + (hasIndexingHeader ? sizeof(IndexingHeader) : 0) + indexingPayloadSizeInBytes;

}

static Butterfly* fromBase(void* base, size_t preCapacity, size_t propertyCapacity)

{

return reinterpret_cast<Butterfly*>(static_cast<EncodedJSValue*>(base) + preCapacity + propertyCapacity + 1);

}

ALWAYS_INLINE static unsigned availableContiguousVectorLength(size_t propertyCapacity, unsigned vectorLength);

static unsigned availableContiguousVectorLength(Structure*, unsigned vectorLength);

ALWAYS_INLINE static unsigned optimalContiguousVectorLength(size_t propertyCapacity, unsigned vectorLength);

static unsigned optimalContiguousVectorLength(Structure*, unsigned vectorLength);

// This method is here not just because it's handy, but to remind you that

// the whole point of butterflies is to do evil pointer arithmetic.

static Butterfly* fromPointer(char* ptr)

{

return reinterpret_cast<Butterfly*>(ptr);

}

char* pointer() { return reinterpret_cast<char*>(this); }

static constexpr ptrdiff_t offsetOfIndexingHeader() { return IndexingHeader::offsetOfIndexingHeader(); }

static constexpr ptrdiff_t offsetOfArrayBuffer() { return offsetOfIndexingHeader() + IndexingHeader::offsetOfArrayBuffer(); }

static constexpr ptrdiff_t offsetOfPublicLength() { return offsetOfIndexingHeader() + IndexingHeader::offsetOfPublicLength(); }

static constexpr ptrdiff_t offsetOfVectorLength() { return offsetOfIndexingHeader() + IndexingHeader::offsetOfVectorLength(); }

static Butterfly* tryCreateUninitialized(VM&, JSObject* intendedOwner, size_t preCapacity, size_t propertyCapacity, bool hasIndexingHeader, size_t indexingPayloadSizeInBytes, GCDeferralContext* = nullptr);

static Butterfly* createUninitialized(VM&, JSObject* intendedOwner, size_t preCapacity, size_t propertyCapacity, bool hasIndexingHeader, size_t indexingPayloadSizeInBytes);

// FIXME: These return uninitialized indexed storage. Either their names should be updated to reflect this

// and/or they should take some kind of initialization scope.

static Butterfly* tryCreate(VM& vm, JSObject*, size_t preCapacity, size_t propertyCapacity, bool hasIndexingHeader, const IndexingHeader& indexingHeader, size_t indexingPayloadSizeInBytes);

static Butterfly* create(VM&, JSObject* intendedOwner, size_t preCapacity, size_t propertyCapacity, bool hasIndexingHeader, const IndexingHeader&, size_t indexingPayloadSizeInBytes);

static Butterfly* create(VM&, JSObject* intendedOwner, Structure*);

IndexingHeader* indexingHeader() { return IndexingHeader::from(this); }

const IndexingHeader* indexingHeader() const { return IndexingHeader::from(this); }

PropertyStorage propertyStorage() { return indexingHeader()->propertyStorage(); }

ConstPropertyStorage propertyStorage() const { return indexingHeader()->propertyStorage(); }

uint32_t publicLength() const { return indexingHeader()->publicLength(); }

uint32_t vectorLength() const { return indexingHeader()->vectorLength(); }

void setPublicLength(uint32_t value) { indexingHeader()->setPublicLength(value); }

void setVectorLength(uint32_t value) { indexingHeader()->setVectorLength(value); }

template<typename T>

T* indexingPayload() { return reinterpret_cast_ptr<T*>(this); }

ArrayStorage* arrayStorage() { return indexingPayload<ArrayStorage>(); }

ContiguousJSValues contiguousInt32() { return ContiguousJSValues(indexingPayload<WriteBarrier<Unknown>>(), vectorLength()); }

ContiguousDoubles contiguousDouble() { return ContiguousDoubles(indexingPayload<double>(), vectorLength()); }

ContiguousJSValues contiguous() { return ContiguousJSValues(indexingPayload<WriteBarrier<Unknown>>(), vectorLength()); }

template<typename T>

const T* indexingPayload() const { return reinterpret_cast_ptr<const T*>(this); }

const ArrayStorage* arrayStorage() const { return indexingPayload<ArrayStorage>(); }

ConstContiguousJSValues contiguousInt32() const { return ConstContiguousJSValues(indexingPayload<WriteBarrier<Unknown>>(), vectorLength()); }

ConstContiguousDoubles contiguousDouble() const { return ConstContiguousDoubles(indexingPayload<double>(), vectorLength()); }

ConstContiguousJSValues contiguous() const { return ConstContiguousJSValues(indexingPayload<WriteBarrier<Unknown>>(), vectorLength()); }

static Butterfly* fromContiguous(WriteBarrier<Unknown>* contiguous)

{

return reinterpret_cast<Butterfly*>(contiguous);

}

static Butterfly* fromContiguous(double* contiguous)

{

return reinterpret_cast<Butterfly*>(contiguous);

}

static constexpr ptrdiff_t offsetOfPropertyStorage() { return -static_cast<ptrdiff_t>(sizeof(IndexingHeader)); }

constexpr static int indexOfPropertyStorage()

{

ASSERT(sizeof(IndexingHeader) == sizeof(EncodedJSValue));

return -1;

}

void* base(size_t preCapacity, size_t propertyCapacity) { return propertyStorage() - propertyCapacity - preCapacity; }

void* base(Structure*);

// FIXME: This returns uninitialized indexed storage. Either their names should be updated to reflect this

// and/or they should take some kind of initialization scope.

static Butterfly* createOrGrowArrayRight(

Butterfly*, VM&, JSObject* intendedOwner, Structure* oldStructure,

size_t propertyCapacity, bool hadIndexingHeader,

size_t oldIndexingPayloadSizeInBytes, size_t newIndexingPayloadSizeInBytes);

// The butterfly reallocation methods perform the reallocation itself but do not change any

// of the meta-data to reflect that the reallocation occurred. Note that this set of

// methods is not exhaustive and is not intended to encapsulate all possible allocation

// modes of butterflies - there are code paths that allocate butterflies by calling

// directly into Heap::tryAllocateStorage.

// FIXME: These return uninitialized indexed storage. Either their names should be updated to reflect this

// and/or they should take some kind of initialization scope.

static Butterfly* createOrGrowPropertyStorage(Butterfly*, VM&, JSObject* intendedOwner, Structure*, size_t oldPropertyCapacity, size_t newPropertyCapacity);

Butterfly* growArrayRight(VM&, JSObject* intendedOwner, Structure* oldStructure, size_t propertyCapacity, bool hadIndexingHeader, size_t oldIndexingPayloadSizeInBytes, size_t newIndexingPayloadSizeInBytes); // Assumes that preCapacity is zero, and asserts as much.

Butterfly* growArrayRight(VM&, JSObject* intendedOwner, Structure*, size_t newIndexingPayloadSizeInBytes);

Butterfly* reallocArrayRightIfPossible(VM&, GCDeferralContext&, JSObject* intendedOwner, Structure* oldStructure, size_t propertyCapacity, bool hadIndexingHeader, size_t oldIndexingPayloadSizeInBytes, size_t newIndexingPayloadSizeInBytes); // Assumes that preCapacity is zero, and asserts as much.

Butterfly* resizeArray(VM&, JSObject* intendedOwner, size_t propertyCapacity, bool oldHasIndexingHeader, size_t oldIndexingPayloadSizeInBytes, size_t newPreCapacity, bool newHasIndexingHeader, size_t newIndexingPayloadSizeInBytes);

Butterfly* resizeArray(VM&, JSObject* intendedOwner, Structure*, size_t newPreCapacity, size_t newIndexingPayloadSizeInBytes); // Assumes that you're not changing whether or not the object has an indexing header.

Butterfly* unshift(Structure*, size_t numberOfSlots);

Butterfly* shift(Structure*, size_t numberOfSlots);

// FIXME: This should either not be static or take a span.

ALWAYS_INLINE static void clearRange(IndexingType, Butterfly*, unsigned start, unsigned end);