/*

* Copyright (C) 2019-2021 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.

*/

#include "config.h"

#include "CachedTypes.h"

#include "BaselineJITCode.h"

#include "BuiltinNames.h"

#include "BytecodeCacheError.h"

#include "BytecodeLivenessAnalysis.h"

#include "JSCInlines.h"

#include "JSImmutableButterfly.h"

#include "JSTemplateObjectDescriptor.h"

#include "ScopedArgumentsTable.h"

#include "SourceCodeKey.h"

#include "SourceProvider.h"

#include "UnlinkedEvalCodeBlock.h"

#include "UnlinkedFunctionCodeBlock.h"

#include "UnlinkedMetadataTableInlines.h"

#include "UnlinkedModuleProgramCodeBlock.h"

#include "UnlinkedProgramCodeBlock.h"

#include <wtf/MallocPtr.h>

#include <wtf/Packed.h>

#include <wtf/RobinHoodHashMap.h>

#include <wtf/UUID.h>

#include <wtf/text/AtomStringImpl.h>

namespace JSC {

namespace Yarr {

enum class Flags : uint8_t;

}

template <typename T, typename = void>

struct SourceTypeImpl {

using type = T;

};

template<typename T>

struct SourceTypeImpl<T, std::enable_if_t<!std::is_fundamental<T>::value && !std::is_same<typename T::SourceType_, void>::value>> {

using type = typename T::SourceType_;

};

template<typename T>

using SourceType = typename SourceTypeImpl<T>::type;

static constexpr unsigned jscBytecodeCacheVersion()

{

return StringHasher::computeHash(__TIMESTAMP__);

}

class Encoder {

WTF_MAKE_NONCOPYABLE(Encoder);

WTF_FORBID_HEAP_ALLOCATION;

public:

class Allocation {

friend class Encoder;

public:

uint8_t* buffer() const { return m_buffer; }

ptrdiff_t offset() const { return m_offset; }

private:

Allocation(uint8_t* buffer, ptrdiff_t offset)

: m_buffer(buffer)

, m_offset(offset)

{

}

uint8_t* m_buffer;

ptrdiff_t m_offset;

};

Encoder(VM& vm, FileSystem::PlatformFileHandle fd = FileSystem::invalidPlatformFileHandle)

: m_vm(vm)

, m_fd(fd)

, m_baseOffset(0)

, m_currentPage(nullptr)

{

allocateNewPage();

}

VM& vm() { return m_vm; }

Allocation malloc(unsigned size)

{

RELEASE_ASSERT(size);

ptrdiff_t offset;

if (m_currentPage->malloc(size, offset))

return Allocation { m_currentPage->buffer() + offset, m_baseOffset + offset };

allocateNewPage(size);

return malloc(size);

}

template<typename T, typename... Args>

T* malloc(Args&&... args)

{

return new (malloc(sizeof(T)).buffer()) T(std::forward<Args>(args)...);

}

ptrdiff_t offsetOf(const void* address)

{

ptrdiff_t offset;

ptrdiff_t baseOffset = 0;

for (const auto& page : m_pages) {

if (page.getOffset(address, offset))

return baseOffset + offset;

baseOffset += page.size();

}

RELEASE_ASSERT_NOT_REACHED();

return 0;

}

void cachePtr(const void* ptr, ptrdiff_t offset)

{

m_ptrToOffsetMap.add(ptr, offset);

}

std::optional<ptrdiff_t> cachedOffsetForPtr(const void* ptr)

{

auto it = m_ptrToOffsetMap.find(ptr);

if (it == m_ptrToOffsetMap.end())

return std::nullopt;

return { it->value };

}

void addLeafExecutable(const UnlinkedFunctionExecutable* executable, ptrdiff_t offset)

{

m_leafExecutables.add(executable, offset);

}

RefPtr<CachedBytecode> release(BytecodeCacheError& error)

{

if (!m_currentPage)

return nullptr;

m_currentPage->alignEnd();

if (FileSystem::isHandleValid(m_fd)) {

return releaseMapped(error);

}

size_t size = m_baseOffset + m_currentPage->size();

MallocPtr<uint8_t, VMMalloc> buffer = MallocPtr<uint8_t, VMMalloc>::malloc(size);

unsigned offset = 0;

for (const auto& page : m_pages) {

memcpy(buffer.get() + offset, page.buffer(), page.size());

offset += page.size();

}

RELEASE_ASSERT(offset == size);

return CachedBytecode::create(WTFMove(buffer), size, WTFMove(m_leafExecutables));

}

private:

RefPtr<CachedBytecode> releaseMapped(BytecodeCacheError& error)

{

size_t size = m_baseOffset + m_currentPage->size();

if (!FileSystem::truncateFile(m_fd, size)) {

error = BytecodeCacheError::StandardError(errno);

return nullptr;

}

for (const auto& page : m_pages) {

int bytesWritten = FileSystem::writeToFile(m_fd, page.buffer(), page.size());

if (bytesWritten == -1) {

error = BytecodeCacheError::StandardError(errno);

return nullptr;

}

if (static_cast<size_t>(bytesWritten) != page.size()) {

error = BytecodeCacheError::WriteError(bytesWritten, page.size());

return nullptr;

}

}

bool success;

FileSystem::MappedFileData mappedFileData(m_fd, FileSystem::MappedFileMode::Private, success);

if (!success) {

error = BytecodeCacheError::StandardError(errno);

return nullptr;

}

return CachedBytecode::create(WTFMove(mappedFileData), WTFMove(m_leafExecutables));

}

class Page {

public:

Page(size_t size)

: m_buffer(MallocPtr<uint8_t, VMMalloc>::malloc(size))

, m_capacity(size)

{

}

bool malloc(size_t size, ptrdiff_t& result)

{

size_t alignment = std::min(alignof(std::max_align_t), static_cast<size_t>(WTF::roundUpToPowerOfTwo(size)));

ptrdiff_t offset = roundUpToMultipleOf(alignment, m_offset);

size = roundUpToMultipleOf(alignment, size);

if (static_cast<size_t>(offset + size) > m_capacity)

return false;

result = offset;

m_offset = offset + size;

return true;

}

uint8_t* buffer() const { return m_buffer.get(); }

size_t size() const { return static_cast<size_t>(m_offset); }

bool getOffset(const void* address, ptrdiff_t& result) const

{

const uint8_t* addr = static_cast<const uint8_t*>(address);

if (addr >= m_buffer.get() && addr < m_buffer.get() + m_offset) {

result = addr - m_buffer.get();

return true;

}

return false;

}

void alignEnd()

{

ptrdiff_t size = roundUpToMultipleOf(alignof(std::max_align_t), m_offset);

if (size == m_offset)

return;

RELEASE_ASSERT(static_cast<size_t>(size) <= m_capacity);

m_offset = size;

}

private:

MallocPtr<uint8_t, VMMalloc> m_buffer;

ptrdiff_t m_offset { 0 };

size_t m_capacity;

};

void allocateNewPage(size_t size = 0)

{

static size_t minPageSize = pageSize();

if (m_currentPage) {

m_currentPage->alignEnd();

m_baseOffset += m_currentPage->size();

}

if (size < minPageSize)

size = minPageSize;

else

size = roundUpToMultipleOf(minPageSize, size);

m_pages.append(Page { size });

m_currentPage = &m_pages.last();

}

VM& m_vm;

FileSystem::PlatformFileHandle m_fd;

ptrdiff_t m_baseOffset;

Page* m_currentPage;

Vector<Page> m_pages;

HashMap<const void*, ptrdiff_t> m_ptrToOffsetMap;

LeafExecutableMap m_leafExecutables;

};

Decoder::Decoder(VM& vm, Ref<CachedBytecode> cachedBytecode, RefPtr<SourceProvider> provider)

: m_vm(vm)

, m_cachedBytecode(WTFMove(cachedBytecode))

, m_provider(provider)

{

}

Decoder::~Decoder()

{

for (auto& finalizer : m_finalizers)

finalizer();

}

Ref<Decoder> Decoder::create(VM& vm, Ref<CachedBytecode> cachedBytecode, RefPtr<SourceProvider> provider)

{

return adoptRef(*new Decoder(vm, WTFMove(cachedBytecode), WTFMove(provider)));

}

size_t Decoder::size() const

{

return m_cachedBytecode->size();

}

ptrdiff_t Decoder::offsetOf(const void* ptr)

{

const uint8_t* addr = static_cast<const uint8_t*>(ptr);

ASSERT(addr >= m_cachedBytecode->data() && addr < m_cachedBytecode->data() + m_cachedBytecode->size());

return addr - m_cachedBytecode->data();

}

void Decoder::cacheOffset(ptrdiff_t offset, void* ptr)

{

m_offsetToPtrMap.add(offset, ptr);

}

std::optional<void*> Decoder::cachedPtrForOffset(ptrdiff_t offset)

{

auto it = m_offsetToPtrMap.find(offset);

if (it == m_offsetToPtrMap.end())

return std::nullopt;

return { it->value };

}

const void* Decoder::ptrForOffsetFromBase(ptrdiff_t offset)

{

ASSERT(offset > 0 && static_cast<size_t>(offset) < m_cachedBytecode->size());

return m_cachedBytecode->data() + offset;

}

CompactTDZEnvironmentMap::Handle Decoder::handleForTDZEnvironment(CompactTDZEnvironment* environment) const

{

auto it = m_environmentToHandleMap.find(environment);

RELEASE_ASSERT(it != m_environmentToHandleMap.end());

return it->value;

}

void Decoder::setHandleForTDZEnvironment(CompactTDZEnvironment* environment, const CompactTDZEnvironmentMap::Handle& handle)

{

auto addResult = m_environmentToHandleMap.add(environment, handle);

RELEASE_ASSERT(addResult.isNewEntry);

}

void Decoder::addLeafExecutable(const UnlinkedFunctionExecutable* executable, ptrdiff_t offset)

{

m_cachedBytecode->leafExecutables().add(executable, offset);

}

template<typename Functor>

void Decoder::addFinalizer(const Functor& fn)

{

m_finalizers.append(fn);

}

RefPtr<SourceProvider> Decoder::provider() const

{

return m_provider;

}

template<typename T>

static std::enable_if_t<std::is_same<T, SourceType<T>>::value> encode(Encoder&, T& dst, const SourceType<T>& src)

{

dst = src;

}

template<typename T>

static std::enable_if_t<!std::is_same<T, SourceType<T>>::value> encode(Encoder& encoder, T& dst, const SourceType<T>& src)

{

dst.encode(encoder, src);

}

template<typename T, typename... Args>

static std::enable_if_t<std::is_same<T, SourceType<T>>::value> decode(Decoder&, const T& src, SourceType<T>& dst, Args...)

{

dst = src;

}

template<typename T, typename... Args>

static std::enable_if_t<!std::is_same<T, SourceType<T>>::value> decode(Decoder& decoder, const T& src, SourceType<T>& dst, Args... args)

{

src.decode(decoder, dst, args...);

}

template<typename T>

static std::enable_if_t<std::is_same<T, SourceType<T>>::value, T> decode(Decoder&, T src)

{

return src;

}

template<typename T>

static std::enable_if_t<!std::is_same<T, SourceType<T>>::value, SourceType<T>>&& decode(Decoder& decoder, const T& src)

{

return src.decode(decoder);

}

template<typename Source>

class CachedObject {

WTF_MAKE_NONCOPYABLE(CachedObject);

public:

using SourceType_ = Source;

CachedObject() = default;

inline void* operator new(size_t, void* where) { return where; }

void* operator new[](size_t, void* where) { return where; }

// Copied from WTF_FORBID_HEAP_ALLOCATION, since we only want to allow placement new

void* operator new(size_t) = delete;

void operator delete(void*) = delete;

void* operator new[](size_t size) = delete;

void operator delete[](void*) = delete;

void* operator new(size_t, NotNullTag, void* location) = delete;

};

template<typename Source>

class VariableLengthObject : public CachedObject<Source>, VariableLengthObjectBase {

template<typename, typename>

friend class CachedPtr;

friend struct CachedPtrOffsets;

public:

VariableLengthObject()

: VariableLengthObjectBase(s_invalidOffset)

{

}

bool isEmpty() const

{

return m_offset == s_invalidOffset;

}

protected:

const uint8_t* buffer() const

{

ASSERT(!isEmpty());

return bitwise_cast<const uint8_t*>(this) + m_offset;

}

template<typename T>

const T* buffer() const

{

ASSERT(!(bitwise_cast<uintptr_t>(buffer()) % alignof(T)));

return bitwise_cast<const T*>(buffer());

}

uint8_t* allocate(Encoder& encoder, size_t size)

{

ptrdiff_t offsetOffset = encoder.offsetOf(&m_offset);

auto result = encoder.malloc(size);

m_offset = result.offset() - offsetOffset;

return result.buffer();

}

template<typename T>

#if CPU(ARM64) && CPU(ADDRESS32)

// FIXME: Remove this once it's no longer needed and LLVM doesn't miscompile us:

// <rdar://problem/49792205>

__attribute__((optnone))

#endif

T* allocate(Encoder& encoder, unsigned size = 1)

{

uint8_t* result = allocate(encoder, sizeof(T) * size);

ASSERT(!(bitwise_cast<uintptr_t>(result) % alignof(T)));

return new (result) T[size];

}

private:

constexpr static ptrdiff_t s_invalidOffset = std::numeric_limits<ptrdiff_t>::max();

};

template<typename T, typename Source = SourceType<T>>

class CachedPtr : public VariableLengthObject<Source*> {

template<typename, typename, typename>

friend class CachedRefPtr;

friend struct CachedPtrOffsets;

public:

void encode(Encoder& encoder, const Source* src)

{

if (!src)

return;

if (std::optional<ptrdiff_t> offset = encoder.cachedOffsetForPtr(src)) {

this->m_offset = *offset - encoder.offsetOf(&this->m_offset);

return;

}

T* cachedObject = this->template allocate<T>(encoder);

cachedObject->encode(encoder, *src);

encoder.cachePtr(src, encoder.offsetOf(cachedObject));

}

template<typename... Args>

Source* decode(Decoder& decoder, bool& isNewAllocation, Args&&... args) const

{

if (this->isEmpty()) {

isNewAllocation = false;

return nullptr;

}

ptrdiff_t bufferOffset = decoder.offsetOf(this->buffer());

if (std::optional<void*> ptr = decoder.cachedPtrForOffset(bufferOffset)) {

isNewAllocation = false;

return static_cast<Source*>(*ptr);

}

isNewAllocation = true;

Source* ptr = get()->decode(decoder, std::forward<Args>(args)...);

decoder.cacheOffset(bufferOffset, ptr);

return ptr;

}

template<typename... Args>

Source* decode(Decoder& decoder, Args&&... args) const

{

bool unusedIsNewAllocation;

return decode(decoder, unusedIsNewAllocation, std::forward<Args>(args)...);

}

const T* operator->() const { return get(); }

private:

const T* get() const

{

RELEASE_ASSERT(!this->isEmpty());

return this->template buffer<T>();

}

};

ptrdiff_t CachedPtrOffsets::offsetOffset()

{

return OBJECT_OFFSETOF(CachedPtr<void>, m_offset);

}

template<typename T, typename Source = SourceType<T>, typename PtrTraits = RawPtrTraits<Source>>

class CachedRefPtr : public CachedObject<RefPtr<Source, PtrTraits>> {

public:

void encode(Encoder& encoder, const Source* src)

{

m_ptr.encode(encoder, src);

}

void encode(Encoder& encoder, const RefPtr<Source, PtrTraits> src)

{

encode(encoder, src.get());

}

RefPtr<Source, PtrTraits> decode(Decoder& decoder) const

{

bool isNewAllocation;

Source* decodedPtr = m_ptr.decode(decoder, isNewAllocation);

if (!decodedPtr)

return nullptr;

if (isNewAllocation) {

decoder.addFinalizer([=] {

WTF::DefaultRefDerefTraits<Source>::derefIfNotNull(decodedPtr);

});

}

auto result = adoptRef<Source, PtrTraits>(decodedPtr);

result->ref();

return result;

}

void decode(Decoder& decoder, RefPtr<Source, PtrTraits>& src) const

{

src = decode(decoder);

}

private:

CachedPtr<T, Source> m_ptr;

};

template<typename T, typename Source = SourceType<T>>

class CachedWriteBarrier : public CachedObject<WriteBarrier<Source>> {

friend struct CachedWriteBarrierOffsets;

public:

bool isEmpty() const { return m_ptr.isEmpty(); }

void encode(Encoder& encoder, const WriteBarrier<Source> src)

{

m_ptr.encode(encoder, src.get());

}

void decode(Decoder& decoder, WriteBarrier<Source>& src, const JSCell* owner) const

{

Source* decodedPtr = m_ptr.decode(decoder);

if (decodedPtr)

src.set(decoder.vm(), owner, decodedPtr);

}

private:

CachedPtr<T, Source> m_ptr;

};

ptrdiff_t CachedWriteBarrierOffsets::ptrOffset()

{

return OBJECT_OFFSETOF(CachedWriteBarrier<void>, m_ptr);

}

template<typename T, size_t InlineCapacity = 0, typename OverflowHandler = CrashOnOverflow, typename Malloc = WTF::VectorMalloc>

class CachedVector : public VariableLengthObject<Vector<SourceType<T>, InlineCapacity, OverflowHandler, 16, Malloc>> {

public:

template<typename VectorContainer>

void encode(Encoder& encoder, const VectorContainer& vector)

{

m_size = vector.size();

if (!m_size)

return;

T* buffer = this->template allocate<T>(encoder, m_size);

for (unsigned i = 0; i < m_size; ++i)

::JSC::encode(encoder, buffer[i], vector[i]);

}

template<typename... Args, typename VectorContainer>

void decode(Decoder& decoder, VectorContainer& vector, Args... args) const

{

if (!m_size)

return;

vector = VectorContainer(m_size);

const T* buffer = this->template buffer<T>();

for (unsigned i = 0; i < m_size; ++i)

::JSC::decode(decoder, buffer[i], vector[i], args...);

}

private:

unsigned m_size;

};

template<typename First, typename Second>

class CachedPair : public CachedObject<std::pair<SourceType<First>, SourceType<Second>>> {

public:

void encode(Encoder& encoder, const std::pair<SourceType<First>, SourceType<Second>>& pair)

{

::JSC::encode(encoder, m_first, pair.first);

::JSC::encode(encoder, m_second, pair.second);

}

void decode(Decoder& decoder, std::pair<SourceType<First>, SourceType<Second>>& pair) const

{

::JSC::decode(decoder, m_first, pair.first);

::JSC::decode(decoder, m_second, pair.second);

}

private:

First m_first;

Second m_second;

};

template<typename Key, typename Value, typename HashArg = DefaultHash<SourceType<Key>>, typename KeyTraitsArg = HashTraits<SourceType<Key>>, typename MappedTraitsArg = HashTraits<SourceType<Value>>, typename TableTraits = WTF::HashTableTraits>

class CachedHashMap : public VariableLengthObject<HashMap<SourceType<Key>, SourceType<Value>, HashArg, KeyTraitsArg, MappedTraitsArg, TableTraits>> {

template<typename K, typename V>

using Map = HashMap<K, V, HashArg, KeyTraitsArg, MappedTraitsArg, TableTraits>;

public:

void encode(Encoder& encoder, const Map<SourceType<Key>, SourceType<Value>>& map)

{

SourceType<decltype(m_entries)> entriesVector(map.size());

unsigned i = 0;

for (const auto& it : map)

entriesVector[i++] = { it.key, it.value };

m_entries.encode(encoder, entriesVector);

}

void decode(Decoder& decoder, Map<SourceType<Key>, SourceType<Value>>& map) const

{

SourceType<decltype(m_entries)> decodedEntries;

m_entries.decode(decoder, decodedEntries);

for (const auto& pair : decodedEntries)

map.set(pair.first, pair.second);

}

private:

CachedVector<CachedPair<Key, Value>> m_entries;

};

template<typename Key, typename Value, typename HashArg = DefaultHash<SourceType<Key>>, typename KeyTraitsArg = HashTraits<SourceType<Key>>, typename MappedTraitsArg = HashTraits<SourceType<Value>>>

using CachedMemoryCompactLookupOnlyRobinHoodHashMap = CachedHashMap<Key, Value, HashArg, KeyTraitsArg, MappedTraitsArg, WTF::MemoryCompactLookupOnlyRobinHoodHashTableTraits>;

template<typename T>

class CachedUniquedStringImplBase : public VariableLengthObject<T> {

public:

void encode(Encoder& encoder, const StringImpl& string)

{

m_isAtomic = string.isAtom();

m_isSymbol = string.isSymbol();

m_isRegistered = false;

m_isWellKnownSymbol = false;

m_isPrivate = false;

RefPtr<StringImpl> impl = const_cast<StringImpl*>(&string);

if (m_isSymbol) {

SymbolImpl* symbol = static_cast<SymbolImpl*>(impl.get());

m_isRegistered = symbol->isRegistered();

m_isPrivate = symbol->isPrivate();

if (!symbol->isNullSymbol()) {

// We have special handling for well-known symbols.

if (!m_isPrivate) {

m_isWellKnownSymbol = true;

impl = symbol->substring(strlen("Symbol."));

}

}

}

m_is8Bit = impl->is8Bit();

m_length = impl->length();

if (!m_length)

return;

unsigned size = m_length;

const void* payload;

if (m_is8Bit)

payload = impl->characters8();

else {

payload = impl->characters16();

size *= 2;

}

uint8_t* buffer = this->allocate(encoder, size);

memcpy(buffer, payload, size);

}

UniquedStringImpl* decode(Decoder& decoder) const

{

auto create = [&](const auto* buffer) -> UniquedStringImpl* {

if (!m_isSymbol)

return AtomStringImpl::add(buffer, m_length).leakRef();

SymbolImpl* symbol;

VM& vm = decoder.vm();

if (m_isRegistered) {

String str(buffer, m_length);

if (m_isPrivate)

symbol = static_cast<SymbolImpl*>(&vm.privateSymbolRegistry().symbolForKey(str).leakRef());

else

symbol = static_cast<SymbolImpl*>(&vm.symbolRegistry().symbolForKey(str).leakRef());

} else if (m_isWellKnownSymbol)

symbol = vm.propertyNames->builtinNames().lookUpWellKnownSymbol(buffer, m_length);

else

symbol = vm.propertyNames->builtinNames().lookUpPrivateName(buffer, m_length);

RELEASE_ASSERT(symbol);

String str = symbol;

StringImpl* impl = str.releaseImpl().get();

ASSERT(impl->isSymbol());

if (m_isWellKnownSymbol)

ASSERT(!static_cast<SymbolImpl*>(impl)->isPrivate());

else

ASSERT(static_cast<SymbolImpl*>(impl)->isPrivate());

return static_cast<UniquedStringImpl*>(impl);

};

if (!m_length) {

if (m_isSymbol)

return &SymbolImpl::createNullSymbol().leakRef();

return AtomStringImpl::add("").leakRef();

}

if (m_is8Bit)

return create(this->template buffer<LChar>());

return create(this->template buffer<UChar>());

}

private:

bool m_is8Bit : 1;

bool m_isSymbol : 1;

bool m_isWellKnownSymbol : 1;

bool m_isAtomic : 1;

bool m_isRegistered : 1;

bool m_isPrivate : 1;

unsigned m_length;

};

class CachedUniquedStringImpl : public CachedUniquedStringImplBase<UniquedStringImpl> { };

class CachedStringImpl : public CachedUniquedStringImplBase<StringImpl> { };

class CachedString : public VariableLengthObject<String> {

public:

void encode(Encoder& encoder, const String& string)

{

m_impl.encode(encoder, static_cast<UniquedStringImpl*>(string.impl()));

}

String decode(Decoder& decoder) const

{

return String(static_cast<RefPtr<StringImpl>>(m_impl.decode(decoder)));

}

void decode(Decoder& decoder, String& dst) const

{

dst = decode(decoder);

}

private:

CachedRefPtr<CachedUniquedStringImpl> m_impl;

};

class CachedIdentifier : public VariableLengthObject<Identifier> {

public:

void encode(Encoder& encoder, const Identifier& identifier)

{

m_string.encode(encoder, identifier.string());

}

Identifier decode(Decoder& decoder) const

{

String str = m_string.decode(decoder);

if (str.isNull())

return Identifier();

return Identifier::fromUid(decoder.vm(), (UniquedStringImpl*)str.impl());

}

void decode(Decoder& decoder, Identifier& ident) const

{

ident = decode(decoder);

}

private:

CachedString m_string;

};

template<typename T>

class CachedOptional : public VariableLengthObject<std::optional<SourceType<T>>> {

public:

void encode(Encoder& encoder, const std::optional<SourceType<T>>& source)

{

if (!source)

return;

this->template allocate<T>(encoder)->encode(encoder, *source);

}

std::optional<SourceType<T>> decode(Decoder& decoder) const

{

if (this->isEmpty())

return std::nullopt;

return { this->template buffer<T>()->decode(decoder) };

}

void decode(Decoder& decoder, std::optional<SourceType<T>>& dst) const

{

dst = decode(decoder);

}

void encode(Encoder& encoder, const std::unique_ptr<SourceType<T>>& source)

{

if (!source)

encode(encoder, std::nullopt);

else

encode(encoder, { *source });

}

SourceType<T>* decodeAsPtr(Decoder& decoder) const

{

RELEASE_ASSERT(!this->isEmpty());

return this->template buffer<T>()->decode(decoder);

}

};

class CachedSimpleJumpTable : public CachedObject<UnlinkedSimpleJumpTable> {

public:

void encode(Encoder& encoder, const UnlinkedSimpleJumpTable& jumpTable)

{

m_min = jumpTable.m_min;

m_branchOffsets.encode(encoder, jumpTable.m_branchOffsets);

}

void decode(Decoder& decoder, UnlinkedSimpleJumpTable& jumpTable) const

{

jumpTable.m_min = m_min;

m_branchOffsets.decode(decoder, jumpTable.m_branchOffsets);

}

private:

int32_t m_min;

CachedVector<int32_t> m_branchOffsets;

};

class CachedStringJumpTable : public CachedObject<UnlinkedStringJumpTable> {

public:

void encode(Encoder& encoder, const UnlinkedStringJumpTable& jumpTable)

{

m_offsetTable.encode(encoder, jumpTable.m_offsetTable);

}

void decode(Decoder& decoder, UnlinkedStringJumpTable& jumpTable) const

{

m_offsetTable.decode(decoder, jumpTable.m_offsetTable);

}

private:

CachedMemoryCompactLookupOnlyRobinHoodHashMap<CachedRefPtr<CachedStringImpl>, UnlinkedStringJumpTable::OffsetLocation> m_offsetTable;

};

class CachedBitVector : public VariableLengthObject<BitVector> {

public:

void encode(Encoder& encoder, const BitVector& bitVector)

{

m_numBits = bitVector.size();

if (!m_numBits)

return;

size_t sizeInBytes = BitVector::byteCount(m_numBits);

uint8_t* buffer = this->allocate(encoder, sizeInBytes);

memcpy(buffer, bitVector.bits(), sizeInBytes);

}

void decode(Decoder&, BitVector& bitVector) const

{

if (!m_numBits)

return;

bitVector.ensureSize(m_numBits);

size_t sizeInBytes = BitVector::byteCount(m_numBits);

memcpy(bitVector.bits(), this->buffer(), sizeInBytes);

}

private:

size_t m_numBits;

};

template<typename T, typename HashArg = DefaultHash<T>>

class CachedHashSet : public CachedObject<HashSet<SourceType<T>, HashArg>> {

public:

void encode(Encoder& encoder, const HashSet<SourceType<T>, HashArg>& set)

{

SourceType<decltype(m_entries)> entriesVector(set.size());

unsigned i = 0;

for (const auto& item : set)

entriesVector[i++] = item;

m_entries.encode(encoder, entriesVector);

}

void decode(Decoder& decoder, HashSet<SourceType<T>, HashArg>& set) const

{

SourceType<decltype(m_entries)> entriesVector;

m_entries.decode(decoder, entriesVector);

for (const auto& item : entriesVector)

set.add(item);

}

private:

CachedVector<T> m_entries;

};

class CachedCodeBlockRareData : public CachedObject<UnlinkedCodeBlock::RareData> {

public:

void encode(Encoder& encoder, const UnlinkedCodeBlock::RareData& rareData)

{

m_exceptionHandlers.encode(encoder, rareData.m_exceptionHandlers);

m_unlinkedSwitchJumpTables.encode(encoder, rareData.m_unlinkedSwitchJumpTables);

m_unlinkedStringSwitchJumpTables.encode(encoder, rareData.m_unlinkedStringSwitchJumpTables);

m_expressionInfoFatPositions.encode(encoder, rareData.m_expressionInfoFatPositions);

m_typeProfilerInfoMap.encode(encoder, rareData.m_typeProfilerInfoMap);

m_opProfileControlFlowBytecodeOffsets.encode(encoder, rareData.m_opProfileControlFlowBytecodeOffsets);

m_bitVectors.encode(encoder, rareData.m_bitVectors);

m_constantIdentifierSets.encode(encoder, rareData.m_constantIdentifierSets);

m_needsClassFieldInitializer = rareData.m_needsClassFieldInitializer;

m_privateBrandRequirement = rareData.m_privateBrandRequirement;

}

UnlinkedCodeBlock::RareData* decode(Decoder& decoder) const

{

UnlinkedCodeBlock::RareData* rareData = new UnlinkedCodeBlock::RareData { };

m_exceptionHandlers.decode(decoder, rareData->m_exceptionHandlers);

m_unlinkedSwitchJumpTables.decode(decoder, rareData->m_unlinkedSwitchJumpTables);

m_unlinkedStringSwitchJumpTables.decode(decoder, rareData->m_unlinkedStringSwitchJumpTables);

m_expressionInfoFatPositions.decode(decoder, rareData->m_expressionInfoFatPositions);

m_typeProfilerInfoMap.decode(decoder, rareData->m_typeProfilerInfoMap);

m_opProfileControlFlowBytecodeOffsets.decode(decoder, rareData->m_opProfileControlFlowBytecodeOffsets);

m_bitVectors.decode(decoder, rareData->m_bitVectors);

m_constantIdentifierSets.decode(decoder, rareData->m_constantIdentifierSets);

rareData->m_needsClassFieldInitializer = m_needsClassFieldInitializer;

rareData->m_privateBrandRequirement = m_privateBrandRequirement;

return rareData;

}

private:

CachedVector<UnlinkedHandlerInfo> m_exceptionHandlers;

CachedVector<CachedSimpleJumpTable> m_unlinkedSwitchJumpTables;

CachedVector<CachedStringJumpTable> m_unlinkedStringSwitchJumpTables;

CachedVector<ExpressionRangeInfo::FatPosition> m_expressionInfoFatPositions;

CachedHashMap<unsigned, UnlinkedCodeBlock::RareData::TypeProfilerExpressionRange> m_typeProfilerInfoMap;

CachedVector<InstructionStream::Offset> m_opProfileControlFlowBytecodeOffsets;

CachedVector<CachedBitVector> m_bitVectors;

CachedVector<CachedHashSet<CachedRefPtr<CachedUniquedStringImpl>, IdentifierRepHash>> m_constantIdentifierSets;

unsigned m_needsClassFieldInitializer : 1;

unsigned m_privateBrandRequirement : 1;

};

typedef CachedHashMap<CachedRefPtr<CachedUniquedStringImpl, UniquedStringImpl, WTF::PackedPtrTraits<UniquedStringImpl>>, PrivateNameEntry, IdentifierRepHash, HashTraits<RefPtr<UniquedStringImpl>>, PrivateNameEntryHashTraits> CachedPrivateNameEnvironment;

class CachedVariableEnvironmentRareData : public CachedObject<VariableEnvironment::RareData> {

public:

void encode(Encoder& encoder, const VariableEnvironment::RareData& rareData)

{

m_privateNames.encode(encoder, rareData.m_privateNames);

}