CachedTypes.h

/*

 * Copyright (C) 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 "BytecodeLivenessAnalysis.h"

#include "JSCast.h"

#include "JSImmutableButterfly.h"

#include "ScopedArgumentsTable.h"

#include "SourceCodeKey.h"

#include "UnlinkedEvalCodeBlock.h"

#include "UnlinkedFunctionCodeBlock.h"

#include "UnlinkedMetadataTableInlines.h"

#include "UnlinkedModuleProgramCodeBlock.h"

#include "UnlinkedProgramCodeBlock.h"

#include <wtf/FastMalloc.h>

#include <wtf/Forward.h>

#include <wtf/Optional.h>

#include <wtf/text/AtomicStringImpl.h>

namespace JSC {

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;

class Encoder {

    WTF_MAKE_NONCOPYABLE(Encoder);

public:

    Encoder(VM& vm)

        : m_vm(vm)

        , m_offset(0)

    {

        m_buffer = (uint8_t*)fastZeroedMalloc(s_maxSize);

    }

    ~Encoder()

    {

        if (m_buffer)

            fastFree(m_buffer);

    }

    VM& vm() { return m_vm; }

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

    size_t size() const { return m_offset; }

    ptrdiff_t mallocOffset(unsigned size)

    {

        m_offset = WTF::roundUpToMultipleOf(sizeof(void*), m_offset);

        ASSERT(static_cast<size_t>(m_offset + size) < s_maxSize);

        ptrdiff_t result = m_offset;

        m_offset += size;

        return result;

    }

    uint8_t* malloc(unsigned size)

    {

        ptrdiff_t offset = mallocOffset(size);

        return m_buffer + offset;

    }

    template<typename T>

    T* malloc()

    {

        return reinterpret_cast<T*>(malloc(sizeof(T)));

    }

    ptrdiff_t offsetOf(const void* address)

    {

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

        ASSERT(addr >= m_buffer && addr < m_buffer + m_offset);

        return addr - m_buffer;

    }

    void cachePtr(const void* ptr, ptrdiff_t offset)

    {

        m_ptrToOffsetMap.add(ptr, offset);

    }

    WTF::Optional<ptrdiff_t> offsetForPtr(const void* ptr)

    {

        auto it = m_ptrToOffsetMap.find(ptr);

        if (it == m_ptrToOffsetMap.end())

            return WTF::nullopt;

        return { it->value };

    }

private:

    unsigned s_maxSize = 10 * MB;

    VM& m_vm;

    uint8_t* m_buffer;

    ptrdiff_t m_offset;

    HashMap<const void*, ptrdiff_t> m_ptrToOffsetMap;

};

class Decoder {

    WTF_MAKE_NONCOPYABLE(Decoder);

public:

    Decoder(VM& vm, const void* baseAddress, size_t size)

        : m_vm(vm)

        , m_baseAddress(reinterpret_cast<const uint8_t*>(baseAddress))

#ifndef NDEBUG

        , m_size(size)

#endif

    {

        UNUSED_PARAM(size);

    }

    ~Decoder()

    {

        for (auto& pair : m_finalizers)

            pair.value();

    }

    VM& vm() { return m_vm; }

    ptrdiff_t offsetOf(const void* ptr)

    {

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

        ASSERT(addr >= m_baseAddress && addr < m_baseAddress + m_size);

        return addr - m_baseAddress;

    }

    void cacheOffset(ptrdiff_t offset, void* ptr)

    {

        m_offsetToPtrMap.add(offset, ptr);

    }

    WTF::Optional<void*> ptrForOffset(ptrdiff_t offset)

    {

        auto it = m_offsetToPtrMap.find(offset);

        if (it == m_offsetToPtrMap.end())

            return WTF::nullopt;

        return { it->value };

    }

    template<typename Functor>

    void addFinalizer(ptrdiff_t offset, const Functor& fn)

    {

        m_finalizers.add(offset, fn);

    }

private:

    VM& m_vm;

    const uint8_t* m_baseAddress;

#ifndef NDEBUG

    size_t m_size;

#endif

    HashMap<ptrdiff_t, void*> m_offsetToPtrMap;

    HashMap<ptrdiff_t, std::function<void()>> m_finalizers;

};

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, typename Dst>

struct CachedObject {

    using SourceType = Source;

    static unsigned sizeOf(const Source& source)

    {

        unsigned size = 0;

        computeOutOfLineSize(size, source);

        return size;

    }

    template<typename T>

    static T& cast(T* source)

    {

        return *source;

    }

    template<typename T, typename = std::enable_if_t<!std::is_pointer<T>::value>>

    static T& cast(T& source)

    {

        return source;

    }

    template<typename T>

    static const T& cast(const T* const source)

    {

        return *source;

    }

    template<typename T, typename = std::enable_if_t<!std::is_pointer<T>::value>>

    static const T& cast(const T& source)

    {

        return source;

    }

};

template<typename Source, typename Dst>

struct VariableLengthObject : public CachedObject<Source, Dst> {

private:

    constexpr static ptrdiff_t s_invalidOffset = PTRDIFF_MAX;

public:

    ptrdiff_t offset { s_invalidOffset };

    const uint8_t* buffer() const

    {

        ASSERT(offset != s_invalidOffset);

        return reinterpret_cast<const uint8_t*>(this) + offset;

    }

    uint8_t* buffer()

    {

        ASSERT(offset != s_invalidOffset);

        return reinterpret_cast<uint8_t*>(this) + offset;

    }

    template<typename T>

    const T* buffer() const

    {

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

    }

    template<typename T>

    T* buffer()

    {

        return reinterpret_cast<T*>(buffer());

    }

    uint8_t* allocate(Encoder& encoder, size_t size)

    {

        ptrdiff_t offsetOffset = encoder.offsetOf(&offset);

        ptrdiff_t allocationOffset = encoder.mallocOffset(size);

        offset = allocationOffset - offsetOffset;

        return buffer();

    }

    template<typename T>

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

    {

        allocate(encoder, sizeof(T[size]));

        return buffer<T>();

    }

};

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

struct CachedPtr : public VariableLengthObject<SourceType*, CachedPtr<T>> {

    bool isEmpty;

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

    {

        isEmpty = !src;

        if (isEmpty)

            return;

        if (WTF::Optional<ptrdiff_t> offset = encoder.offsetForPtr(src)) {

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

            return;

        }

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

        cachedObject->encode(encoder, *src);

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

    }

    template<typename... Args>

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

    {

        if (isEmpty)

            return nullptr;

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

        if (WTF::Optional<void*> ptr = decoder.ptrForOffset(bufferOffset))

            return reinterpret_cast<SourceType*>(*ptr);

        SourceType* ptr = operator->()->decode(decoder, args...);

        decoder.cacheOffset(bufferOffset, ptr);

        return ptr;

    }

    T* operator->()

    {

        if (isEmpty)

            return nullptr;

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

    }

    const T* operator->() const

    {

        if (isEmpty)

            return nullptr;

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

    }

};

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

struct CachedRefPtr : public CachedObject<RefPtr<SourceType>, CachedRefPtr<T>> {

    CachedPtr<T, SourceType> ptr;

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

    {

        ptr.encode(encoder, src);

    }

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

    {

        encode(encoder, src.get());

    }

    RefPtr<SourceType> decode(Decoder& decoder) const

    {

        SourceType* decodedPtr = ptr.decode(decoder);

        decoder.addFinalizer(decoder.offsetOf(ptr.buffer()), [=] { derefIfNotNull(decodedPtr); });

        refIfNotNull(decodedPtr);

        return adoptRef(decodedPtr);

    }

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

    {

        src = decode(decoder);

    }

};

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

struct CachedWriteBarrier : public CachedObject<WriteBarrier<SourceType>, CachedWriteBarrier<T>> {

    CachedPtr<T, SourceType> ptr;

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

    {

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

    }

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

    {

        SourceType* decodedPtr = ptr.decode(decoder);

        if (decodedPtr)

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

    }

};

template<typename T, size_t IC = 0, typename OH = CrashOnOverflow>

struct CachedVector : public VariableLengthObject<Vector<SourceType<T>, IC, OH>, CachedVector<T, IC, OH>> {

    unsigned size;

    void encode(Encoder& encoder, const Vector<SourceType<T>, IC, OH>& vector)

    {

        size = vector.size();

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

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

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

    }

    template<typename... Args>

    void decode(Decoder& decoder, Vector<SourceType<T>, IC, OH>& vector, Args... args) const

    {

        vector.resizeToFit(size);

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

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

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

    }

};

template<typename Fst, typename Snd>

struct CachedPair : public CachedObject<std::pair<SourceType<Fst>, SourceType<Snd>>, CachedPair<Fst, Snd>> {

    Fst fst;

    Snd snd;

    void encode(Encoder& encoder, const std::pair<SourceType<Fst>, SourceType<Snd>>& pair)

    {

        ::JSC::encode(encoder, fst, std::get<0>(pair));

        ::JSC::encode(encoder, snd, std::get<1>(pair));

    }

    void decode(Decoder& decoder, std::pair<SourceType<Fst>, SourceType<Snd>>& pair) const

    {

        ::JSC::decode(decoder, fst, std::get<0>(pair));

        ::JSC::decode(decoder, snd, std::get<1>(pair));

    }

};

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

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

    CachedVector<CachedPair<Key, Value>> entries;

    template<typename K, typename V>

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

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

    {

        entries.size = map.size();

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

        unsigned i = 0;

        for (const auto& it : map)

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

        entries.encode(encoder, entriesVector);

    }

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

    {

        SourceType<decltype(entries)> decodedEntries;

        entries.decode(decoder, decodedEntries);

        for (const auto& pair : decodedEntries)

            map.set(std::get<0>(pair), std::get<1>(pair));

    }

};

struct CachedUniquedStringImpl : public VariableLengthObject<UniquedStringImpl, CachedUniquedStringImpl> {

    bool is8Bit : 1;

    bool isSymbol : 1;

    bool isAtomic : 1;

    unsigned length;

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

    {

        isAtomic = string.isAtomic();

        isSymbol = string.isSymbol();

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

        if (isSymbol) {

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

            if (!symbol->isNullSymbol()) {

                Identifier uid = Identifier::fromUid(&encoder.vm(), symbol);

                impl = encoder.vm().propertyNames->lookUpPublicName(uid).string().impl();

            }

        }

        is8Bit = impl->is8Bit();

        length = impl->length();

        if (!length)

            return;

        unsigned size = length;

        const void* payload;

        if (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 (!isSymbol)

                return AtomicStringImpl::add(buffer, length).leakRef();

            if (!length)

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

            Identifier ident = Identifier::fromString(&decoder.vm(), buffer, length);

            String str = decoder.vm().propertyNames->lookUpPrivateName(ident)->string();

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

            ASSERT(impl->isSymbol());

            return static_cast<UniquedStringImpl*>(impl);

        };

        if (is8Bit)

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

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

    }

};

struct CachedStringImpl : public VariableLengthObject<StringImpl, CachedStringImpl> {

    CachedUniquedStringImpl uniquedStringImpl;

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

    {

        uniquedStringImpl.encode(encoder, impl);

    }

    StringImpl* decode(Decoder& decoder) const

    {

        return uniquedStringImpl.decode(decoder);

    }

};

struct CachedString : public VariableLengthObject<String, CachedString> {

    CachedRefPtr<CachedUniquedStringImpl> impl;

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

    {

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

    }

    String decode(Decoder& decoder) const

    {

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

    }

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

    {

        dst = decode(decoder);

    }

};

struct CachedIdentifier : public VariableLengthObject<Identifier, CachedIdentifier> {

    CachedString string;

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

    {

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

    }

    Identifier decode(Decoder& decoder) const

    {

        String str = 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);

    }

};

template<typename T>

struct CachedOptional : public VariableLengthObject<WTF::Optional<SourceType<T>>, CachedOptional<T>> {

    bool isEmpty;

    void encode(Encoder& encoder, const WTF::Optional<SourceType<T>>& source)

    {

        isEmpty = !source;

        if (isEmpty)

            return;

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

    }

    WTF::Optional<SourceType<T>> decode(Decoder& decoder) const

    {

        if (isEmpty)

            return WTF::nullopt;

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

    }

    void decode(Decoder& decoder, WTF::Optional<SourceType<T>>& dst) const

    {

        dst = decode(decoder);

    }

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

    {

        if (!source)

            encode(encoder, WTF::nullopt);

        else

            encode(encoder, { *source });

    }

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

    {

        if (isEmpty)

            return nullptr;

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

    }

};

struct CachedSimpleJumpTable : public CachedObject<UnlinkedSimpleJumpTable, CachedSimpleJumpTable> {

    int32_t min;

    CachedVector<int32_t> branchOffsets;

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

    {

        min = jumpTable.min;

        branchOffsets.encode(encoder, jumpTable.branchOffsets);

    }

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

    {

        jumpTable.min = min;

        branchOffsets.decode(decoder, jumpTable.branchOffsets);

    }

};

struct CachedStringJumpTable : public CachedObject<UnlinkedStringJumpTable, CachedStringJumpTable> {

    CachedHashMap<CachedRefPtr<CachedStringImpl>, UnlinkedStringJumpTable:: OffsetLocation> offsetTable;

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

    {

        offsetTable.encode(encoder, jumpTable.offsetTable);

    }

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

    {

        offsetTable.decode(decoder, jumpTable.offsetTable);

    }

};

struct CachedRareData : public CachedObject<UnlinkedCodeBlock::RareData, CachedRareData> {

    CachedVector<UnlinkedHandlerInfo> exceptionHandlers;

    // Jump Tables

    CachedVector<CachedSimpleJumpTable> switchJumpTables;

    CachedVector<CachedStringJumpTable> stringSwitchJumpTables;

    CachedVector<ExpressionRangeInfo::FatPosition> expressionInfoFatPositions;

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

    CachedVector<InstructionStream::Offset> opProfileControlFlowBytecodeOffsets;

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

    {

        exceptionHandlers.encode(encoder, rareData.m_exceptionHandlers);

        switchJumpTables.encode(encoder, rareData.m_switchJumpTables);

        stringSwitchJumpTables.encode(encoder, rareData.m_stringSwitchJumpTables);

        expressionInfoFatPositions.encode(encoder, rareData.m_expressionInfoFatPositions);

        typeProfilerInfoMap.encode(encoder, rareData.m_typeProfilerInfoMap);

        opProfileControlFlowBytecodeOffsets.encode(encoder, rareData.m_opProfileControlFlowBytecodeOffsets);

    }

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

    {

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

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

        switchJumpTables.decode(decoder, rareData->m_switchJumpTables);

        stringSwitchJumpTables.decode(decoder, rareData->m_stringSwitchJumpTables);

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

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

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

        return rareData;

    }

};

struct CachedBitVector : public VariableLengthObject<BitVector, CachedBitVector> {

    unsigned size;

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

    {

        size = bitVector.size();

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

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

    }

    void decode(Decoder&, BitVector& bitVector) const

    {

        bitVector.ensureSize(size);

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

    }

};

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

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

    CachedVector<T> entries;

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

    {

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

        unsigned i = 0;

        for (const auto& item : set)

            entriesVector[i++] = item;

        entries.encode(encoder, entriesVector);

    }

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

    {

        SourceType<decltype(entries)> entriesVector;

        entries.decode(decoder, entriesVector);

        for (const auto& item : entriesVector)

            set.add(item);

    }

};

struct CachedConstantIdentifierSetEntry : public VariableLengthObject<ConstantIdentifierSetEntry, CachedConstantIdentifierSetEntry> {

    unsigned constant;

    CachedHashSet<CachedRefPtr<CachedUniquedStringImpl>, IdentifierRepHash> set;

    void encode(Encoder& encoder, const ConstantIdentifierSetEntry& entry)

    {

        constant = std::get<1>(entry);

        set.encode(encoder, std::get<0>(entry));

    }

    void decode(Decoder& decoder, ConstantIdentifierSetEntry& entry) const

    {

        std::get<1>(entry) = constant;

        set.decode(decoder, std::get<0>(entry));

    }

};

struct CachedVariableEnvironment : public CachedObject<VariableEnvironment, CachedVariableEnvironment> {

    bool isEverythingCaptured;

    CachedHashMap<CachedRefPtr<CachedUniquedStringImpl>, VariableEnvironmentEntry, IdentifierRepHash, HashTraits<RefPtr<UniquedStringImpl>>, VariableEnvironmentEntryHashTraits> map;

    void encode(Encoder& encoder, const VariableEnvironment& env)

    {

        isEverythingCaptured = env.m_isEverythingCaptured;

        map.encode(encoder, env.m_map);

    }

    void decode(Decoder& decoder, VariableEnvironment& env) const

    {

        env.m_isEverythingCaptured = isEverythingCaptured;

        map.decode(decoder, env.m_map);

    }

};

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

struct CachedArray : public VariableLengthObject<SourceType*, CachedArray<T, SourceType>> {

    void encode(Encoder& encoder, const SourceType* array, unsigned size)

    {

        T* dst = this->template allocate<T>(encoder, size);

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

            ::JSC::encode(encoder, dst[i], array[i]);

    }

    template<typename... Args>

    void decode(Decoder& decoder, SourceType* array, unsigned size, Args... args) const

    {

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

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

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

    }

};

struct CachedScopedArgumentsTable : public CachedObject<ScopedArgumentsTable, CachedScopedArgumentsTable> {

    uint32_t length;

    CachedArray<ScopeOffset> arguments;

    void encode(Encoder& encoder, const ScopedArgumentsTable& scopedArgumentsTable)

    {

        length = scopedArgumentsTable.m_length;

        arguments.encode(encoder, scopedArgumentsTable.m_arguments.get(), length);

    }

    ScopedArgumentsTable* decode(Decoder& decoder) const

    {

        ScopedArgumentsTable* scopedArgumentsTable = ScopedArgumentsTable::create(decoder.vm(), length);

        arguments.decode(decoder, scopedArgumentsTable->m_arguments.get(), length);

        return scopedArgumentsTable;

    }

};

struct CachedSymbolTableEntry : public CachedObject<SymbolTableEntry, CachedSymbolTableEntry> {

    intptr_t bits;

    void encode(Encoder&, const SymbolTableEntry& symbolTableEntry)

    {

        bits = symbolTableEntry.m_bits | SymbolTableEntry::SlimFlag;

    }

    void decode(Decoder&, SymbolTableEntry& symbolTableEntry) const

    {

        symbolTableEntry.m_bits = bits;

    }

};

struct CachedSymbolTable : public CachedObject<SymbolTable, CachedSymbolTable> {

    CachedHashMap<CachedRefPtr<CachedUniquedStringImpl>, CachedSymbolTableEntry, IdentifierRepHash, HashTraits<RefPtr<UniquedStringImpl>>, SymbolTableIndexHashTraits> map;

    ScopeOffset maxScopeOffset;

    unsigned usesNonStrictEval : 1;

    unsigned nestedLexicalScope : 1;

    unsigned scopeType : 3;

    // FIXME: do we need to cached this eventually?

    // CachedPtr<SymbolTableRareData> rareData;

    CachedPtr<CachedScopedArgumentsTable> arguments;

    void encode(Encoder& encoder, const SymbolTable& symbolTable)

    {

        ASSERT(!symbolTable.m_rareData);

        map.encode(encoder, symbolTable.m_map);

        maxScopeOffset = symbolTable.m_maxScopeOffset;

        usesNonStrictEval = symbolTable.m_usesNonStrictEval;

        nestedLexicalScope = symbolTable.m_nestedLexicalScope;

        scopeType = symbolTable.m_scopeType;

        arguments.encode(encoder, symbolTable.m_arguments.get());

    }

    SymbolTable* decode(Decoder& decoder) const

    {

        SymbolTable* symbolTable = SymbolTable::create(decoder.vm());

        map.decode(decoder, symbolTable->m_map);

        symbolTable->m_maxScopeOffset = maxScopeOffset;

        symbolTable->m_usesNonStrictEval = usesNonStrictEval;

        symbolTable->m_nestedLexicalScope = nestedLexicalScope;

        symbolTable->m_scopeType = scopeType;

        ScopedArgumentsTable* scopedArgumentsTable = arguments.decode(decoder);

        if (scopedArgumentsTable)

            symbolTable->m_arguments.set(decoder.vm(), symbolTable, scopedArgumentsTable);

        return symbolTable;

    }

};

struct CachedJSValue;

struct CachedImmutableButterfly : public CachedObject<JSImmutableButterfly, CachedImmutableButterfly> {

    IndexingType indexingType;

    unsigned length;

    union {

        CachedArray<double> cachedDoubles;

        CachedArray<CachedJSValue, WriteBarrier<Unknown>> cachedValues;

    };

    void encode(Encoder& encoder, JSImmutableButterfly& immutableButterfly)

    {

        length = immutableButterfly.length();

        indexingType = immutableButterfly.indexingMode(); // this is confusing, not sure why we have to use indexingMode vs indexingType

        if (hasDouble(indexingType))

            cachedDoubles.encode(encoder, immutableButterfly.toButterfly()->contiguousDouble().data(), length);

        else

            cachedValues.encode(encoder, immutableButterfly.toButterfly()->contiguous().data(), length);

    }

    JSImmutableButterfly* decode(Decoder& decoder) const

    {

        JSImmutableButterfly* immutableButterfly = JSImmutableButterfly::create(decoder.vm(), indexingType, length);

        if (hasDouble(indexingType))

            cachedDoubles.decode(decoder, immutableButterfly->toButterfly()->contiguousDouble().data(), length, immutableButterfly);

        else

            cachedValues.decode(decoder, immutableButterfly->toButterfly()->contiguous().data(), length, immutableButterfly);

        return immutableButterfly;

    }

};

struct CachedRegExp : public CachedObject<RegExp, CachedRegExp> {

    CachedString patternString;

    RegExpFlags flags;

    void encode(Encoder& encoder, const RegExp& regExp)

    {

        patternString.encode(encoder, regExp.m_patternString);

        flags = regExp.m_flags;

    }

    RegExp* decode(Decoder& decoder) const

    {

        String pattern { patternString.decode(decoder) };

        return RegExp::create(decoder.vm(), pattern, flags);

    }

};

struct CachedTemplateObjectDescriptor : public CachedObject<TemplateObjectDescriptor, CachedTemplateObjectDescriptor> {

    CachedVector<CachedString, 4> rawStrings;

    CachedVector<CachedOptional<CachedString>, 4> cookedStrings;

    void encode(Encoder& encoder, const TemplateObjectDescriptor& templateObjectDescriptor)

    {

        rawStrings.encode(encoder, templateObjectDescriptor.rawStrings());

        cookedStrings.encode(encoder, templateObjectDescriptor.cookedStrings());

    }

    Ref<TemplateObjectDescriptor> decode(Decoder& decoder) const

    {

        TemplateObjectDescriptor::StringVector decodedRawStrings;

        TemplateObjectDescriptor::OptionalStringVector decodedCookedStrings;

        rawStrings.decode(decoder, decodedRawStrings);

        cookedStrings.decode(decoder, decodedCookedStrings);

        return TemplateObjectDescriptor::create(WTFMove(decodedRawStrings), WTFMove(decodedCookedStrings));

    }

};

struct CachedBigInt : public VariableLengthObject<JSBigInt, CachedBigInt> {

    unsigned length;

    bool sign;

    void encode(Encoder& encoder, JSBigInt& bigInt)

    {

        length = bigInt.length();

        sign = bigInt.sign();

        if (!length)

            return;

        unsigned size = sizeof(JSBigInt::Digit[length]);

        this->allocate(encoder, size);

        memcpy(this->buffer(), bigInt.dataStorage(), size);

    }

    JSBigInt* decode(Decoder& decoder) const

    {

        JSBigInt* bigInt = JSBigInt::createWithLengthUnchecked(decoder.vm(), length);

        bigInt->setSign(sign);

        memcpy(bigInt->dataStorage(), this->buffer(), sizeof(JSBigInt::Digit[length]));

        return bigInt;

    }

};

struct CachedJSValue : public VariableLengthObject<WriteBarrier<Unknown>, CachedJSValue> {

    enum class EncodedType : uint8_t {

        JSValue,

        SymbolTable,

        String,

        ImmutableButterfly,

        RegExp,

        TemplateObjectDescriptor,

        BigInt,

    };

    EncodedType type;

    void encode(Encoder& encoder, const WriteBarrier<Unknown> value)

    {

        JSValue v = value.get();

        if (!v.isCell() || v.isEmpty()) {

            type = EncodedType::JSValue;

            *this->allocate<EncodedJSValue>(encoder) = JSValue::encode(v);

            return;

        }

        JSCell* cell = v.asCell();

        const ClassInfo* classInfo = cell->classInfo(encoder.vm());

        if (classInfo == SymbolTable::info()) {

            type = EncodedType::SymbolTable;

            this->allocate<CachedSymbolTable>(encoder)->encode(encoder, *jsCast<SymbolTable*>(cell));

            return;

        }

        if (classInfo == JSString::info()) {

            type = EncodedType::String;

            StringImpl* impl = asString(cell)->tryGetValue().impl();

            ASSERT(!impl || !impl->isSymbol());

            this->allocate<CachedUniquedStringImpl>(encoder)->encode(encoder, *impl);

            return;

        }

        if (classInfo == JSImmutableButterfly::info()) {

            type = EncodedType::ImmutableButterfly;

            this->allocate<CachedImmutableButterfly>(encoder)->encode(encoder, *jsCast<JSImmutableButterfly*>(cell));

            return;

        }

        if (classInfo == RegExp::info()) {

            type = EncodedType::RegExp;

            this->allocate<CachedRegExp>(encoder)->encode(encoder, *jsCast<RegExp*>(cell));

            return;

        }

        if (classInfo == JSTemplateObjectDescriptor::info()) {

            type = EncodedType::TemplateObjectDescriptor;

            this->allocate<CachedTemplateObjectDescriptor>(encoder)->encode(encoder, jsCast<JSTemplateObjectDescriptor*>(cell)->descriptor());

            return;

        }

        if (classInfo == JSBigInt::info()) {

            type = EncodedType::BigInt;

            this->allocate<CachedBigInt>(encoder)->encode(encoder, *jsCast<JSBigInt*>(cell));

            return;

        }

        RELEASE_ASSERT_NOT_REACHED();

    }

    void decode(Decoder& decoder, WriteBarrier<Unknown>& value, const JSCell* owner) const

    {

        JSValue v;

        switch (type) {

        case EncodedType::JSValue:

            v = JSValue::decode(*this->buffer<EncodedJSValue>());

            break;

        case EncodedType::SymbolTable:

            v = this->buffer<CachedSymbolTable>()->decode(decoder);

            break;

        case EncodedType::String: {

            UniquedStringImpl* impl = this->buffer<CachedUniquedStringImpl>()->decode(decoder);

            v = JSString::create(decoder.vm(), adoptRef(*impl));

            break;

        }

        case EncodedType::ImmutableButterfly:

            v = this->buffer<CachedImmutableButterfly>()->decode(decoder);

            break;

        case EncodedType::RegExp:

            v = this->buffer<CachedRegExp>()->decode(decoder);

            break;

        case EncodedType::TemplateObjectDescriptor:

            v = JSTemplateObjectDescriptor::create(decoder.vm(), this->buffer<CachedTemplateObjectDescriptor>()->decode(decoder));

            break;

        case EncodedType::BigInt:

            v = this->buffer<CachedBigInt>()->decode(decoder);

            break;

        default:

            RELEASE_ASSERT_NOT_REACHED();

        }

        value.set(decoder.vm(), owner, v);

    }

};

struct CachedInstructionStream : public CachedObject<InstructionStream, CachedInstructionStream> {

    CachedVector<uint8_t, 0, UnsafeVectorOverflow> instructions;

    void encode(Encoder& encoder, const InstructionStream& stream)

    {

        instructions.encode(encoder, stream.m_instructions);

    }

    InstructionStream* decode(Decoder& decoder) const

    {

        Vector<uint8_t, 0, UnsafeVectorOverflow> instructionsVector;

        instructions.decode(decoder, instructionsVector);

        return new InstructionStream(WTFMove(instructionsVector));

    }

};

struct CachedMetadataTable : public CachedObject<UnlinkedMetadataTable, CachedMetadataTable> {

    bool hasMetadata;

    std::array<unsigned, UnlinkedMetadataTable::s_offsetTableEntries> metadata;

    void encode(Encoder&, const UnlinkedMetadataTable& metadataTable)

    {

        ASSERT(metadataTable.m_isFinalized);

        hasMetadata = metadataTable.m_hasMetadata;

        if (!hasMetadata)

            return;

        for (unsigned i = UnlinkedMetadataTable::s_offsetTableEntries; i--;)

            metadata[i] = metadataTable.buffer()[i];

    }

    void decode(Decoder&, UnlinkedMetadataTable& metadataTable) const

    {

        metadataTable.m_isFinalized = true;

        metadataTable.m_isLinked = false;

        metadataTable.m_hasMetadata = hasMetadata;

        for (unsigned i = UnlinkedMetadataTable::s_offsetTableEntries; i--;)

            metadataTable.buffer()[i] = metadata[i];

    }

};

struct CachedSourceOrigin : public CachedObject<SourceOrigin, CachedSourceOrigin> {

    CachedString string;

    void encode(Encoder& encoder, const SourceOrigin& sourceOrigin)

    {

        string.encode(encoder, sourceOrigin.string());

    }

    SourceOrigin decode(Decoder& decoder) const

    {

        return SourceOrigin { string.decode(decoder) };

    }

};

struct CachedTextPosition : public CachedObject<TextPosition, CachedTextPosition> {

    int line;

    int column;

    void encode(Encoder&, TextPosition textPosition)

    {

        line = textPosition.m_line.zeroBasedInt();

        column = textPosition.m_column.zeroBasedInt();

    }

    TextPosition decode(Decoder&) const

    {

        return TextPosition { OrdinalNumber::fromZeroBasedInt(line), OrdinalNumber::fromZeroBasedInt(column) };

    }

};

template <typename SourceType, typename CachedType>

struct CachedSourceProviderShape : public CachedObject<SourceType, CachedType> {

    bool validated : 1;

    CachedSourceOrigin sourceOrigin;

    CachedString url;

    CachedString sourceURLDirective;

    CachedString sourceMappingURLDirective;

    CachedTextPosition startPosition;

    void encode(Encoder& encoder, const SourceProvider& sourceProvider)

    {

        validated = sourceProvider.isValid();

        sourceOrigin.encode(encoder, sourceProvider.sourceOrigin());

        url.encode(encoder, sourceProvider.url());

        sourceURLDirective.encode(encoder, sourceProvider.sourceURL());

        sourceMappingURLDirective.encode(encoder, sourceProvider.sourceMappingURL());

        startPosition.encode(encoder, sourceProvider.startPosition());

    }

    void decode(Decoder& decoder, SourceProvider& sourceProvider) const

    {

        if (validated)

            sourceProvider.setValid();

        sourceProvider.setSourceURLDirective(sourceURLDirective.decode(decoder));

        sourceProvider.setSourceMappingURLDirective(sourceMappingURLDirective.decode(decoder));

    }

};

struct CachedStringSourceProvider : public CachedSourceProviderShape<StringSourceProvider, CachedStringSourceProvider> {

    using Base = CachedSourceProviderShape<StringSourceProvider, CachedStringSourceProvider>;

    CachedString source;

    void encode(Encoder& encoder, const StringSourceProvider& sourceProvider)

    {

        Base::encode(encoder, sourceProvider);

        source.encode(encoder, sourceProvider.source().toString());

    }

    StringSourceProvider* decode(Decoder& decoder, SourceProviderSourceType sourceType) const

    {

        String decodedSource = source.decode(decoder);

        SourceOrigin decodedSourceOrigin = sourceOrigin.decode(decoder);

        String decodedURL = url.decode(decoder);

        TextPosition decodedStartPosition = startPosition.decode(decoder);

        Ref<StringSourceProvider> sourceProvider = StringSourceProvider::create(decodedSource, decodedSourceOrigin, decodedURL, decodedStartPosition, sourceType);

        Base::decode(decoder, sourceProvider.get());

        return &sourceProvider.leakRef();

    }

};

#if ENABLE(WEBASSEMBLY)

struct CachedWebAssemblySourceProvider : public CachedSourceProviderShape<WebAssemblySourceProvider, CachedWebAssemblySourceProvider> {

    using Base = CachedSourceProviderShape<WebAssemblySourceProvider, CachedWebAssemblySourceProvider>;

    CachedVector<uint8_t> data;

    void encode(Encoder& encoder, const WebAssemblySourceProvider& sourceProvider)

    {

        Base::encode(encoder, sourceProvider);

        data.encode(encoder, sourceProvider.data());

    }

    WebAssemblySourceProvider* decode(Decoder& decoder) const

    {

        Vector<uint8_t> decodedData;

        SourceOrigin decodedSourceOrigin = sourceOrigin.decode(decoder);

        String decodedURL = url.decode(decoder);

        data.decode(decoder, decodedData);

        Ref<WebAssemblySourceProvider> sourceProvider = WebAssemblySourceProvider::create(WTFMove(decodedData), decodedSourceOrigin, decodedURL);

        Base::decode(decoder, sourceProvider.get());

        return &sourceProvider.leakRef();

    }

};

#endif

struct CachedSourceProvider : public VariableLengthObject<SourceProvider, CachedSourceProvider> {

    SourceProviderSourceType sourceType;

    void encode(Encoder& encoder, const SourceProvider& sourceProvider)

    {

        sourceType = sourceProvider.sourceType();

        switch (sourceType) {

        case SourceProviderSourceType::Program:

        case SourceProviderSourceType::Module:

            this->allocate<CachedStringSourceProvider>(encoder)->encode(encoder, reinterpret_cast<const StringSourceProvider&>(sourceProvider));

            break;

#if ENABLE(WEBASSEMBLY)

        case SourceProviderSourceType::WebAssembly:

            this->allocate<CachedWebAssemblySourceProvider>(encoder)->encode(encoder, reinterpret_cast<const WebAssemblySourceProvider&>(sourceProvider));

            break;

#endif

        default:

            RELEASE_ASSERT_NOT_REACHED();

        }

    }

    SourceProvider* decode(Decoder& decoder) const

    {

        switch (sourceType) {

        case SourceProviderSourceType::Program:

        case SourceProviderSourceType::Module:

            return this->buffer<CachedStringSourceProvider>()->decode(decoder, sourceType);

#if ENABLE(WEBASSEMBLY)

        case SourceProviderSourceType::WebAssembly:

            return this->buffer<CachedWebAssemblySourceProvider>()->decode(decoder);

#endif

        default:

            RELEASE_ASSERT_NOT_REACHED();

        }

    }

};

template<typename SourceType, typename CacheType>

struct CachedUnlinkedSourceCodeShape : public CachedObject<SourceType,  CacheType> {

    CachedPtr<CachedSourceProvider> provider;

    int startOffset;

    int endOffset;

    void encode(Encoder& encoder, const UnlinkedSourceCode& sourceCode)

    {

        provider.encode(encoder, sourceCode.m_provider.get());

        startOffset = sourceCode.startOffset();

        endOffset = sourceCode.endOffset();

    }

    void decode(Decoder& decoder, UnlinkedSourceCode& sourceCode) const

    {

        sourceCode.m_provider = provider.decode(decoder);

        sourceCode.m_startOffset = startOffset;

        sourceCode.m_endOffset = endOffset;

    }

};

struct CachedUnlinkedSourceCode : public CachedUnlinkedSourceCodeShape<UnlinkedSourceCode, CachedUnlinkedSourceCode> { };

struct CachedSourceCode : public CachedUnlinkedSourceCodeShape<SourceCode, CachedSourceCode> {

    using Base = CachedUnlinkedSourceCodeShape<SourceCode, CachedSourceCode>;

    int firstLine;

    int startColumn;

    void encode(Encoder& encoder, const SourceCode& sourceCode)

    {

        Base::encode(encoder, sourceCode);

        firstLine = sourceCode.firstLine().zeroBasedInt();

        startColumn = sourceCode.startColumn().zeroBasedInt();

    }

    void decode(Decoder& decoder, SourceCode& sourceCode) const

    {

        Base::decode(decoder, sourceCode);

        sourceCode.m_firstLine = OrdinalNumber::fromZeroBasedInt(firstLine);

        sourceCode.m_startColumn = OrdinalNumber::fromZeroBasedInt(startColumn);

    }

};

struct CachedFunctionExecutable : public CachedObject<UnlinkedFunctionExecutable, CachedFunctionExecutable> {

    void encode(Encoder&, const UnlinkedFunctionExecutable&);

    UnlinkedFunctionExecutable* decode(Decoder&) const;

    unsigned firstLineOffset;

    unsigned lineCount;

    unsigned unlinkedFunctionNameStart;

    unsigned unlinkedBodyStartColumn;

    unsigned unlinkedBodyEndColumn;

    unsigned startOffset;

    unsigned sourceLength;

    unsigned parametersStartOffset;

    unsigned typeProfilingStartOffset;

    unsigned typeProfilingEndOffset;

    unsigned parameterCount;

    CodeFeatures features;

    SourceParseMode sourceParseMode;

    unsigned isInStrictContext : 1;

    unsigned hasCapturedVariables : 1;

    unsigned isBuiltinFunction : 1;

    unsigned isBuiltinDefaultClassConstructor : 1;

    unsigned constructAbility: 1;

    unsigned constructorKind : 2;

    unsigned functionMode : 2; // FunctionMode

    unsigned scriptMode: 1; // JSParserScriptMode

    unsigned superBinding : 1;

    unsigned derivedContextType: 2;

    CachedSourceCode classSource;

    CachedIdentifier name;

    CachedIdentifier ecmaName;

    CachedIdentifier inferredName;

    CachedVariableEnvironment parentScopeTDZVariables;

    CachedWriteBarrier<CachedFunctionCodeBlock, UnlinkedFunctionCodeBlock> unlinkedCodeBlockForCall;

    CachedWriteBarrier<CachedFunctionCodeBlock, UnlinkedFunctionCodeBlock> unlinkedCodeBlockForConstruct;

};

template<typename CodeBlockType, typename CachedCodeBlockType>

struct CachedCodeBlock : public CachedObject<CodeBlockType, CachedCodeBlockType> {

    void encode(Encoder&, const UnlinkedCodeBlock&);

    void decode(Decoder&, UnlinkedCodeBlock&) const;

    VirtualRegister thisRegister;

    VirtualRegister scopeRegister;

    VirtualRegister globalObjectRegister;

    unsigned usesEval : 1;

    unsigned isStrictMode : 1;

    unsigned isConstructor : 1;

    unsigned hasCapturedVariables : 1;

    unsigned isBuiltinFunction : 1;

    unsigned superBinding : 1;

    unsigned scriptMode: 1;

    unsigned isArrowFunctionContext : 1;

    unsigned isClassContext : 1;

    unsigned wasCompiledWithDebuggingOpcodes : 1;

    unsigned constructorKind : 2;

    unsigned derivedContextType : 2;

    unsigned evalContextType : 2;

    unsigned hasTailCalls : 1;

    unsigned lineCount;

    unsigned endColumn;

    int numVars;

    int numCalleeLocals;

    int numParameters;

    CodeFeatures features;

    SourceParseMode parseMode;

    CodeType codeType;

    std::array<unsigned, LinkTimeConstantCount> linkTimeConstants;

    CachedMetadataTable metadata;

    CachedOptional<CachedRareData> rareData;

    CachedString sourceURLDirective;

    CachedString sourceMappingURLDirective;

    CachedPtr<CachedInstructionStream> instructions;

    CachedVector<InstructionStream::Offset> jumpTargets;

    CachedVector<InstructionStream::Offset> propertyAccessInstructions;

    CachedVector<CachedJSValue> constantRegisters;

    CachedVector<SourceCodeRepresentation> constantsSourceCodeRepresentation;

    CachedVector<ExpressionRangeInfo> expressionInfo;

    CachedHashMap<InstructionStream::Offset, int> outOfLineJumpTargets;

    CachedVector<CachedConstantIdentifierSetEntry> constantIdentifierSets;

    CachedVector<CachedIdentifier> identifiers;

    CachedVector<CachedBitVector> bitVectors;

    CachedVector<CachedWriteBarrier<CachedFunctionExecutable>> functionDecls;

    CachedVector<CachedWriteBarrier<CachedFunctionExecutable>> functionExprs;

};

struct CachedProgramCodeBlock : public CachedCodeBlock<UnlinkedProgramCodeBlock, CachedProgramCodeBlock> {

    using Base = CachedCodeBlock<UnlinkedProgramCodeBlock, CachedProgramCodeBlock>;

    using Base::encode;

    CachedVariableEnvironment varDeclarations;

    CachedVariableEnvironment lexicalDeclarations;

    void encode(Encoder& encoder, const UnlinkedProgramCodeBlock& codeBlock)

    {

        Base::encode(encoder, codeBlock);

        varDeclarations.encode(encoder, codeBlock.m_varDeclarations);

        lexicalDeclarations.encode(encoder, codeBlock.m_lexicalDeclarations);

    }

    UnlinkedProgramCodeBlock* decode(Decoder& decoder) const

    {

        UnlinkedProgramCodeBlock* codeBlock = new (NotNull, allocateCell<UnlinkedProgramCodeBlock>(decoder.vm().heap)) UnlinkedProgramCodeBlock(decoder, *this);

        codeBlock->finishCreation(decoder.vm());

        Base::decode(decoder, *codeBlock);

        varDeclarations.decode(decoder, codeBlock->m_varDeclarations);

        lexicalDeclarations.decode(decoder, codeBlock->m_lexicalDeclarations);

        return codeBlock;

    }

};

struct CachedModuleCodeBlock : public CachedCodeBlock<UnlinkedModuleProgramCodeBlock, CachedModuleCodeBlock> {

    using Base = CachedCodeBlock<UnlinkedModuleProgramCodeBlock, CachedModuleCodeBlock>;

    using Base::encode;

    int moduleEnvironmentSymbolTableConstantRegisterOffset;

    void encode(Encoder& encoder, const UnlinkedModuleProgramCodeBlock& codeBlock)

    {

        Base::encode(encoder, codeBlock);

        moduleEnvironmentSymbolTableConstantRegisterOffset = codeBlock.m_moduleEnvironmentSymbolTableConstantRegisterOffset;

    }

    UnlinkedModuleProgramCodeBlock* decode(Decoder& decoder) const

    {

        UnlinkedModuleProgramCodeBlock* codeBlock = new (NotNull, allocateCell<UnlinkedModuleProgramCodeBlock>(decoder.vm().heap)) UnlinkedModuleProgramCodeBlock(decoder, *this);

        codeBlock->finishCreation(decoder.vm());

        Base::decode(decoder, *codeBlock);

        codeBlock->m_moduleEnvironmentSymbolTableConstantRegisterOffset = moduleEnvironmentSymbolTableConstantRegisterOffset;

        return codeBlock;

    }

};

struct CachedEvalCodeBlock : public CachedCodeBlock<UnlinkedEvalCodeBlock, CachedEvalCodeBlock> {

    using Base = CachedCodeBlock<UnlinkedEvalCodeBlock, CachedEvalCodeBlock>;

    using Base::encode;

    CachedVector<CachedIdentifier, 0, UnsafeVectorOverflow> variables;

    CachedVector<CachedIdentifier, 0, UnsafeVectorOverflow> functionHoistingCandidates;

    void encode(Encoder& encoder, const UnlinkedEvalCodeBlock& codeBlock)

    {

        Base::encode(encoder, codeBlock);

        variables.encode(encoder, codeBlock.m_variables);

        functionHoistingCandidates.encode(encoder, codeBlock.m_functionHoistingCandidates);

    }

    UnlinkedEvalCodeBlock* decode(Decoder& decoder) const

    {

        UnlinkedEvalCodeBlock* codeBlock = new (NotNull, allocateCell<UnlinkedEvalCodeBlock>(decoder.vm().heap)) UnlinkedEvalCodeBlock(decoder, *this);

        codeBlock->finishCreation(decoder.vm());

        Base::decode(decoder, *codeBlock);

        variables.decode(decoder, codeBlock->m_variables);

        functionHoistingCandidates.decode(decoder, codeBlock->m_functionHoistingCandidates);

        return codeBlock;

    }

};

struct CachedFunctionCodeBlock : public CachedCodeBlock<UnlinkedFunctionCodeBlock, CachedFunctionCodeBlock> {

    using Base = CachedCodeBlock<UnlinkedFunctionCodeBlock, CachedFunctionCodeBlock>;

    void encode(Encoder& encoder, const UnlinkedFunctionCodeBlock& codeBlock)

    {

        Base::encode(encoder, codeBlock);

    }

    UnlinkedFunctionCodeBlock* decode(Decoder& decoder) const

    {

        UnlinkedFunctionCodeBlock* codeBlock = new (NotNull, allocateCell<UnlinkedFunctionCodeBlock>(decoder.vm().heap)) UnlinkedFunctionCodeBlock(decoder, *this);

        codeBlock->finishCreation(decoder.vm());

        Base::decode(decoder, *codeBlock);

        return codeBlock;

    }

};

ALWAYS_INLINE UnlinkedFunctionCodeBlock::UnlinkedFunctionCodeBlock(Decoder& decoder, const CachedFunctionCodeBlock& cachedCodeBlock)

    : Base(decoder, decoder.vm().unlinkedFunctionCodeBlockStructure.get(), cachedCodeBlock)

{

}

template<typename T>

struct CachedCodeBlockTypeImpl;

template<>

struct CachedCodeBlockTypeImpl<UnlinkedProgramCodeBlock> {

    using type = CachedProgramCodeBlock;

};

template<>

struct CachedCodeBlockTypeImpl<UnlinkedModuleProgramCodeBlock> {

    using type = CachedModuleCodeBlock;

};

template<>

struct CachedCodeBlockTypeImpl<UnlinkedEvalCodeBlock> {

    using type = CachedEvalCodeBlock;

};

template<typename T>

using CachedCodeBlockType = typename CachedCodeBlockTypeImpl<T>::type;

template<typename CodeBlockType, typename CachedCodeBlockType>

ALWAYS_INLINE UnlinkedCodeBlock::UnlinkedCodeBlock(Decoder& decoder, Structure* structure, const CachedCodeBlock<CodeBlockType, CachedCodeBlockType>& cachedCodeBlock)

    : Base(decoder.vm(), structure)

    , m_instructions(cachedCodeBlock.instructions.decode(decoder))

    , m_liveness(nullptr)

    , m_thisRegister(cachedCodeBlock.thisRegister)

    , m_scopeRegister(cachedCodeBlock.scopeRegister)

    , m_globalObjectRegister(cachedCodeBlock.globalObjectRegister)

    , m_sourceURLDirective(cachedCodeBlock.sourceURLDirective.decode(decoder))

    , m_sourceMappingURLDirective(cachedCodeBlock.sourceMappingURLDirective.decode(decoder))

    , m_usesEval(cachedCodeBlock.usesEval)

    , m_isStrictMode(cachedCodeBlock.isStrictMode)

    , m_isConstructor(cachedCodeBlock.isConstructor)

    , m_hasCapturedVariables(cachedCodeBlock.hasCapturedVariables)

    , m_isBuiltinFunction(cachedCodeBlock.isBuiltinFunction)

    , m_superBinding(cachedCodeBlock.superBinding)

    , m_scriptMode(cachedCodeBlock.scriptMode)

    , m_isArrowFunctionContext(cachedCodeBlock.isArrowFunctionContext)

    , m_isClassContext(cachedCodeBlock.isClassContext)

    , m_wasCompiledWithDebuggingOpcodes(cachedCodeBlock.wasCompiledWithDebuggingOpcodes)

    , m_constructorKind(cachedCodeBlock.constructorKind)

    , m_derivedContextType(cachedCodeBlock.derivedContextType)

    , m_evalContextType(cachedCodeBlock.evalContextType)

    , m_hasTailCalls(cachedCodeBlock.hasTailCalls)

    , m_lineCount(cachedCodeBlock.lineCount)

    , m_endColumn(cachedCodeBlock.endColumn)

    , m_numVars(cachedCodeBlock.numVars)

    , m_numCalleeLocals(cachedCodeBlock.numCalleeLocals)

    , m_numParameters(cachedCodeBlock.numParameters)

    , m_features(cachedCodeBlock.features)

    , m_parseMode(cachedCodeBlock.parseMode)

    , m_codeType(cachedCodeBlock.codeType)

    , m_rareData(cachedCodeBlock.rareData.decodeAsPtr(decoder))

{

}

template<typename CodeBlockType, typename CachedCodeBlockType>

ALWAYS_INLINE void CachedCodeBlock<CodeBlockType, CachedCodeBlockType>::decode(Decoder& decoder, UnlinkedCodeBlock& codeBlock) const

{

    for (unsigned i = LinkTimeConstantCount; i--;)

        codeBlock.m_linkTimeConstants[i] = linkTimeConstants[i];

    metadata.decode(decoder, codeBlock.m_metadata);

    propertyAccessInstructions.decode(decoder, codeBlock.m_propertyAccessInstructions);

    constantRegisters.decode(decoder, codeBlock.m_constantRegisters, &codeBlock);

    constantsSourceCodeRepresentation.decode(decoder, codeBlock.m_constantsSourceCodeRepresentation);

    expressionInfo.decode(decoder, codeBlock.m_expressionInfo);

    outOfLineJumpTargets.decode(decoder, codeBlock.m_outOfLineJumpTargets);

    jumpTargets.decode(decoder, codeBlock.m_jumpTargets);

    constantIdentifierSets.decode(decoder, codeBlock.m_constantIdentifierSets);

    identifiers.decode(decoder, codeBlock.m_identifiers);

    bitVectors.decode(decoder, codeBlock.m_bitVectors);

    functionDecls.decode(decoder, codeBlock.m_functionDecls, &codeBlock);

    functionExprs.decode(decoder, codeBlock.m_functionExprs, &codeBlock);

}

ALWAYS_INLINE UnlinkedProgramCodeBlock::UnlinkedProgramCodeBlock(Decoder& decoder, const CachedProgramCodeBlock& cachedCodeBlock)

    : Base(decoder, decoder.vm().unlinkedProgramCodeBlockStructure.get(), cachedCodeBlock)

{

}

ALWAYS_INLINE UnlinkedModuleProgramCodeBlock::UnlinkedModuleProgramCodeBlock(Decoder& decoder, const CachedModuleCodeBlock& cachedCodeBlock)

    : Base(decoder, decoder.vm().unlinkedModuleProgramCodeBlockStructure.get(), cachedCodeBlock)

{

}

ALWAYS_INLINE UnlinkedEvalCodeBlock::UnlinkedEvalCodeBlock(Decoder& decoder, const CachedEvalCodeBlock& cachedCodeBlock)

    : Base(decoder, decoder.vm().unlinkedEvalCodeBlockStructure.get(), cachedCodeBlock)

{

}

ALWAYS_INLINE void CachedFunctionExecutable::encode(Encoder& encoder, const UnlinkedFunctionExecutable& executable)

{

    firstLineOffset = executable.m_firstLineOffset;

    lineCount = executable.m_lineCount;

    unlinkedFunctionNameStart = executable.m_unlinkedFunctionNameStart;

    unlinkedBodyStartColumn = executable.m_unlinkedBodyStartColumn;

    unlinkedBodyEndColumn = executable.m_unlinkedBodyEndColumn;

    startOffset = executable.m_startOffset;

    sourceLength = executable.m_sourceLength;

    parametersStartOffset = executable.m_parametersStartOffset;

    typeProfilingStartOffset = executable.m_typeProfilingStartOffset;

    typeProfilingEndOffset = executable.m_typeProfilingEndOffset;

    parameterCount = executable.m_parameterCount;

    features = executable.m_features;

    sourceParseMode = executable.m_sourceParseMode;

    isInStrictContext = executable.m_isInStrictContext;

    hasCapturedVariables = executable.m_hasCapturedVariables;

    isBuiltinFunction = executable.m_isBuiltinFunction;

    isBuiltinDefaultClassConstructor = executable.m_isBuiltinDefaultClassConstructor;

    constructAbility = executable.m_constructAbility;

    constructorKind = executable.m_constructorKind;

    functionMode = executable.m_functionMode;

    scriptMode = executable.m_scriptMode;

    superBinding = executable.m_superBinding;

    derivedContextType = executable.m_derivedContextType;

    classSource.encode(encoder, executable.m_classSource);

    name.encode(encoder, executable.name());

    ecmaName.encode(encoder, executable.ecmaName());

    inferredName.encode(encoder, executable.inferredName());

    parentScopeTDZVariables.encode(encoder, executable.parentScopeTDZVariables());

    unlinkedCodeBlockForCall.encode(encoder, executable.m_unlinkedCodeBlockForCall);

    unlinkedCodeBlockForConstruct.encode(encoder, executable.m_unlinkedCodeBlockForConstruct);

}

ALWAYS_INLINE UnlinkedFunctionExecutable* CachedFunctionExecutable::decode(Decoder& decoder) const

{

    VariableEnvironment env;

    parentScopeTDZVariables.decode(decoder, env);

    UnlinkedFunctionExecutable* executable = new (NotNull, allocateCell<UnlinkedFunctionExecutable>(decoder.vm().heap)) UnlinkedFunctionExecutable(decoder, env, *this);

    executable->finishCreation(decoder.vm());

    classSource.decode(decoder, executable->m_classSource);

    unlinkedCodeBlockForCall.decode(decoder, executable->m_unlinkedCodeBlockForCall, executable);

    unlinkedCodeBlockForConstruct.decode(decoder, executable->m_unlinkedCodeBlockForConstruct, executable);

    return executable;

}

ALWAYS_INLINE UnlinkedFunctionExecutable::UnlinkedFunctionExecutable(Decoder& decoder, VariableEnvironment& parentScopeTDZVariables, const CachedFunctionExecutable& cachedExecutable)

    : Base(decoder.vm(), decoder.vm().unlinkedFunctionExecutableStructure.get())

    , m_firstLineOffset(cachedExecutable.firstLineOffset)

    , m_lineCount(cachedExecutable.lineCount)

    , m_unlinkedFunctionNameStart(cachedExecutable.unlinkedFunctionNameStart)

    , m_unlinkedBodyStartColumn(cachedExecutable.unlinkedBodyStartColumn)

    , m_unlinkedBodyEndColumn(cachedExecutable.unlinkedBodyEndColumn)

    , m_startOffset(cachedExecutable.startOffset)

    , m_sourceLength(cachedExecutable.sourceLength)

    , m_parametersStartOffset(cachedExecutable.parametersStartOffset)

    , m_typeProfilingStartOffset(cachedExecutable.typeProfilingStartOffset)

    , m_typeProfilingEndOffset(cachedExecutable.typeProfilingEndOffset)

    , m_parameterCount(cachedExecutable.parameterCount)

    , m_features(cachedExecutable.features)

    , m_sourceParseMode(cachedExecutable.sourceParseMode)

    , m_isInStrictContext(cachedExecutable.isInStrictContext)

    , m_hasCapturedVariables(cachedExecutable.hasCapturedVariables)

    , m_isBuiltinFunction(cachedExecutable.isBuiltinFunction)

    , m_isBuiltinDefaultClassConstructor(cachedExecutable.isBuiltinDefaultClassConstructor)

    , m_constructAbility(cachedExecutable.constructAbility)

    , m_constructorKind(cachedExecutable.constructorKind)

    , m_functionMode(cachedExecutable.functionMode)

    , m_scriptMode(cachedExecutable.scriptMode)

    , m_superBinding(cachedExecutable.superBinding)

    , m_derivedContextType(cachedExecutable.derivedContextType)

    , m_name(cachedExecutable.name.decode(decoder))

    , m_ecmaName(cachedExecutable.ecmaName.decode(decoder))

    , m_inferredName(cachedExecutable.inferredName.decode(decoder))

    , m_parentScopeTDZVariables(decoder.vm().m_compactVariableMap->get(parentScopeTDZVariables))

{

}

template<typename CodeBlockType, typename CachedCodeBlockType>

ALWAYS_INLINE void CachedCodeBlock<CodeBlockType, CachedCodeBlockType>::encode(Encoder& encoder, const UnlinkedCodeBlock& codeBlock)

{

    thisRegister = codeBlock.m_thisRegister;

    scopeRegister = codeBlock.m_scopeRegister;

    globalObjectRegister = codeBlock.m_globalObjectRegister;

    usesEval = codeBlock.m_usesEval;

    isStrictMode = codeBlock.m_isStrictMode;

    isConstructor = codeBlock.m_isConstructor;

    hasCapturedVariables = codeBlock.m_hasCapturedVariables;

    isBuiltinFunction = codeBlock.m_isBuiltinFunction;

    superBinding = codeBlock.m_superBinding;

    scriptMode = codeBlock.m_scriptMode;

    isArrowFunctionContext = codeBlock.m_isArrowFunctionContext;

    isClassContext = codeBlock.m_isClassContext;

    wasCompiledWithDebuggingOpcodes = codeBlock.m_wasCompiledWithDebuggingOpcodes;

    constructorKind = codeBlock.m_constructorKind;

    derivedContextType = codeBlock.m_derivedContextType;

    evalContextType = codeBlock.m_evalContextType;

    hasTailCalls = codeBlock.m_hasTailCalls;

    lineCount = codeBlock.m_lineCount;

    endColumn = codeBlock.m_endColumn;

    numVars = codeBlock.m_numVars;

    numCalleeLocals = codeBlock.m_numCalleeLocals;

    numParameters = codeBlock.m_numParameters;

    features = codeBlock.m_features;

    parseMode = codeBlock.m_parseMode;

    codeType = codeBlock.m_codeType;

    for (unsigned i = LinkTimeConstantCount; i--;)

        linkTimeConstants[i] = codeBlock.m_linkTimeConstants[i];

    metadata.encode(encoder, codeBlock.m_metadata);

    rareData.encode(encoder, codeBlock.m_rareData);

    sourceURLDirective.encode(encoder, codeBlock.m_sourceURLDirective.impl());

    sourceMappingURLDirective.encode(encoder, codeBlock.m_sourceURLDirective.impl());

    instructions.encode(encoder, codeBlock.m_instructions.get());

    propertyAccessInstructions.encode(encoder, codeBlock.m_propertyAccessInstructions);

    constantRegisters.encode(encoder, codeBlock.m_constantRegisters);

    constantsSourceCodeRepresentation.encode(encoder, codeBlock.m_constantsSourceCodeRepresentation);

    expressionInfo.encode(encoder, codeBlock.m_expressionInfo);

    jumpTargets.encode(encoder, codeBlock.m_jumpTargets);

    outOfLineJumpTargets.encode(encoder, codeBlock.m_outOfLineJumpTargets);

    constantIdentifierSets.encode(encoder, codeBlock.m_constantIdentifierSets);

    identifiers.encode(encoder, codeBlock.m_identifiers);

    bitVectors.encode(encoder, codeBlock.m_bitVectors);

    functionDecls.encode(encoder, codeBlock.m_functionDecls);

    functionExprs.encode(encoder, codeBlock.m_functionExprs);

}

struct CachedSourceCodeKey : public CachedObject<SourceCodeKey, CachedSourceCodeKey> {

    CachedUnlinkedSourceCode sourceCode;

    CachedString name;

    unsigned flags;

    unsigned hash;

    int functionConstructorParametersEndPosition;

    void encode(Encoder& encoder, const SourceCodeKey& key)

    {

        sourceCode.encode(encoder, key.m_sourceCode);

        name.encode(encoder, key.m_name);

        flags = key.m_flags.m_flags;

        hash = key.hash();

        functionConstructorParametersEndPosition = key.m_functionConstructorParametersEndPosition;

    }

    void decode(Decoder& decoder, SourceCodeKey& key) const

    {

        sourceCode.decode(decoder, key.m_sourceCode);

        name.decode(decoder, key.m_name);

        key.m_flags.m_flags = flags;

        key.m_hash = hash;

        key.m_functionConstructorParametersEndPosition = functionConstructorParametersEndPosition;

    }

};

template<typename UnlinkedCodeBlockType>

struct CacheEntry {

    CachedSourceCodeKey key;

    CachedPtr<CachedCodeBlockType<UnlinkedCodeBlockType>> codeBlock;

    void encode(Encoder& encoder, std::pair<SourceCodeKey, const UnlinkedCodeBlockType*> pair)

    {

        key.encode(encoder, pair.first);

        codeBlock.encode(encoder, pair.second);

    }

    std::pair<SourceCodeKey, UnlinkedCodeBlockType*> decode(Decoder& decoder) const

    {

        SourceCodeKey decodedKey;

        key.decode(decoder, decodedKey);

        return { WTFMove(decodedKey), codeBlock.decode(decoder) };

    }

};

template<typename UnlinkedCodeBlockType>

ALWAYS_INLINE void encodeCodeBlock(Encoder& encoder, SourceCodeKey key, const UnlinkedCodeBlock* codeBlock)

{

    auto* entry = encoder.template malloc<CacheEntry<UnlinkedCodeBlockType>>();

    entry->encode(encoder,  { key, jsCast<const UnlinkedCodeBlockType*>(codeBlock) });

}

ALWAYS_INLINE void encodeCodeBlock(Encoder& encoder, SourceCodeKey key, const UnlinkedCodeBlock* codeBlock)

{

    const ClassInfo* classInfo = codeBlock->classInfo(encoder.vm());

    if (classInfo == UnlinkedProgramCodeBlock::info()) {

        encodeCodeBlock<UnlinkedProgramCodeBlock>(encoder, key, codeBlock);

        return;

    }

    if (classInfo == UnlinkedModuleProgramCodeBlock::info()) {

        encodeCodeBlock<UnlinkedModuleProgramCodeBlock>(encoder, key, codeBlock);

        return;

    }

    ASSERT(classInfo == UnlinkedEvalCodeBlock::info());

}

} // namespace JSC
Source/JavaScriptCore/ChangeLog

Source/WTF/ChangeLog

Source/JavaScriptCore/JavaScriptCore.xcodeproj/project.pbxproj

Source/JavaScriptCore/builtins/BuiltinNames.cpp

Source/JavaScriptCore/builtins/BuiltinNames.h

Source/JavaScriptCore/bytecode/CodeBlock.cpp

Source/JavaScriptCore/bytecode/CodeBlock.h

Source/JavaScriptCore/bytecode/HandlerInfo.h

Source/JavaScriptCore/bytecode/InstructionStream.h

Source/JavaScriptCore/bytecode/UnlinkedCodeBlock.h

Source/JavaScriptCore/bytecode/UnlinkedEvalCodeBlock.h

Source/JavaScriptCore/bytecode/UnlinkedFunctionCodeBlock.h

Source/JavaScriptCore/bytecode/UnlinkedFunctionExecutable.h

Source/JavaScriptCore/bytecode/UnlinkedGlobalCodeBlock.h

Source/JavaScriptCore/bytecode/UnlinkedMetadataTable.h

Source/JavaScriptCore/bytecode/UnlinkedModuleProgramCodeBlock.h

Source/JavaScriptCore/bytecode/UnlinkedProgramCodeBlock.h

Source/JavaScriptCore/interpreter/Interpreter.cpp

Source/JavaScriptCore/jsc.cpp

Source/JavaScriptCore/parser/SourceCode.h

Source/JavaScriptCore/parser/SourceCodeKey.h

Source/JavaScriptCore/parser/UnlinkedSourceCode.h

Source/JavaScriptCore/parser/VariableEnvironment.h

Source/JavaScriptCore/runtime/CachedTypes.h

Source/JavaScriptCore/runtime/CodeCache.cpp

Source/JavaScriptCore/runtime/CodeCache.h

Source/JavaScriptCore/runtime/JSBigInt.cpp

Source/JavaScriptCore/runtime/JSBigInt.h

Source/JavaScriptCore/runtime/Options.cpp

Source/JavaScriptCore/runtime/Options.h

Source/JavaScriptCore/runtime/RegExp.h

Source/JavaScriptCore/runtime/ScopedArgumentsTable.h

Source/JavaScriptCore/runtime/SymbolTable.h

Source/WTF/wtf/BitVector.h

Tools/ChangeLog

Tools/Scripts/jsc-stress-test-helpers/bytecode-cache-test-helper

Tools/Scripts/run-jsc-stress-tests
