244 lines
11 KiB
C++
244 lines
11 KiB
C++
/*
|
|
* Copyright (C) 2012-2018 Apple Inc. All rights reserved.
|
|
*
|
|
* Redistribution and use in source and binary forms, with or without
|
|
* modification, are permitted provided that the following conditions
|
|
* are met:
|
|
* 1. Redistributions of source code must retain the above copyright
|
|
* notice, this list of conditions and the following disclaimer.
|
|
* 2. Redistributions in binary form must reproduce the above copyright
|
|
* notice, this list of conditions and the following disclaimer in the
|
|
* documentation and/or other materials provided with the distribution.
|
|
*
|
|
* THIS SOFTWARE IS PROVIDED BY APPLE INC. ``AS IS'' AND ANY
|
|
* EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
|
|
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
|
|
* PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR
|
|
* CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
|
|
* EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
|
|
* PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
|
|
* PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
|
|
* OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
|
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
|
|
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
|
*/
|
|
|
|
#pragma once
|
|
|
|
#include "IndexingHeader.h"
|
|
#include "IndexingType.h"
|
|
#include "PropertyStorage.h"
|
|
#include <wtf/Gigacage.h>
|
|
#include <wtf/Noncopyable.h>
|
|
|
|
namespace JSC {
|
|
|
|
class VM;
|
|
class CopyVisitor;
|
|
class GCDeferralContext;
|
|
struct ArrayStorage;
|
|
|
|
template <typename T>
|
|
struct ContiguousData {
|
|
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
|
|
|
|
private:
|
|
T* m_data { nullptr };
|
|
#if ASSERT_ENABLED
|
|
size_t m_length { 0 };
|
|
#endif
|
|
};
|
|
|
|
using ContiguousDoubles = ContiguousData<double>;
|
|
using ContiguousJSValues = ContiguousData<WriteBarrier<Unknown>>;
|
|
using ConstContiguousDoubles = ContiguousData<const double>;
|
|
using ConstContiguousJSValues = ContiguousData<const WriteBarrier<Unknown>>;
|
|
|
|
class Butterfly {
|
|
WTF_MAKE_NONCOPYABLE(Butterfly);
|
|
private:
|
|
Butterfly() { } // Not instantiable.
|
|
public:
|
|
|
|
static size_t totalSize(size_t preCapacity, size_t propertyCapacity, bool hasIndexingHeader, size_t indexingPayloadSizeInBytes)
|
|
{
|
|
ASSERT(indexingPayloadSizeInBytes ? hasIndexingHeader : true);
|
|
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 ptrdiff_t offsetOfIndexingHeader() { return IndexingHeader::offsetOfIndexingHeader(); }
|
|
static ptrdiff_t offsetOfArrayBuffer() { return offsetOfIndexingHeader() + IndexingHeader::offsetOfArrayBuffer(); }
|
|
static ptrdiff_t offsetOfPublicLength() { return offsetOfIndexingHeader() + IndexingHeader::offsetOfPublicLength(); }
|
|
static 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);
|
|
|
|
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 ptrdiff_t offsetOfPropertyStorage() { return -static_cast<ptrdiff_t>(sizeof(IndexingHeader)); }
|
|
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*);
|
|
|
|
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.
|
|
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);
|
|
};
|
|
|
|
} // namespace JSC
|