2018-12-17  Tadeu Zagallo  <tzagallo@apple.com>

        Cache bytecode to disk

        https://bugs.webkit.org/show_bug.cgi?id=192782

        <rdar://problem/46084932>

        Reviewed by NOBODY (OOPS!).

        * JavaScriptCore.xcodeproj/project.pbxproj:

        * builtins/BuiltinNames.cpp:

        (JSC::BuiltinNames::BuiltinNames):

        * builtins/BuiltinNames.h:

        * bytecode/CodeBlock.cpp:

        (JSC::CodeBlock::setConstantIdentifierSetRegisters):

        * bytecode/CodeBlock.h:

        * bytecode/HandlerInfo.h:

        (JSC::UnlinkedHandlerInfo::UnlinkedHandlerInfo):

        * bytecode/InstructionStream.h:

        * bytecode/UnlinkedCodeBlock.h:

        (JSC::UnlinkedCodeBlock::addSetConstant):

        (JSC::UnlinkedCodeBlock::constantIdentifierSets):

        * bytecode/UnlinkedEvalCodeBlock.h:

        * bytecode/UnlinkedFunctionCodeBlock.h:

        * bytecode/UnlinkedFunctionExecutable.h:

        * bytecode/UnlinkedGlobalCodeBlock.h:

        (JSC::UnlinkedGlobalCodeBlock::UnlinkedGlobalCodeBlock):

        * bytecode/UnlinkedMetadataTable.h:

        * bytecode/UnlinkedModuleProgramCodeBlock.h:

        * bytecode/UnlinkedProgramCodeBlock.h:

        * interpreter/Interpreter.cpp:

        (JSC::Interpreter::executeProgram):

        * parser/SourceCode.h:

        * parser/SourceCodeKey.h:

        (JSC::SourceCodeKey::operator!= const):

        * parser/UnlinkedSourceCode.h:

        * parser/VariableEnvironment.h:

        * runtime/CachedTypes.h: Added.

        (JSC::Encoder::Encoder):

        (JSC::Encoder::~Encoder):

        (JSC::Encoder::vm):

        (JSC::Encoder::buffer const):

        (JSC::Encoder::size const):

        (JSC::Encoder::mallocOffset):

        (JSC::Encoder::malloc):

        (JSC::Encoder::offsetOf):

        (JSC::Encoder::cachePtr):

        (JSC::Encoder::offsetForPtr):

        (JSC::Decoder::Decoder):

        (JSC::Decoder::~Decoder):

        (JSC::Decoder::vm):

        (JSC::Decoder::offsetOf):

        (JSC::Decoder::cacheOffset):

        (JSC::Decoder::addFinalizer):

        (JSC::encode):

        (JSC::decode):

        (JSC::CachedObject::sizeOf):

        (JSC::CachedObject::cast):

        (JSC::VariableLengthObject::buffer const):

        (JSC::VariableLengthObject::buffer):

        (JSC::VariableLengthObject::allocate):

        (JSC::CachedPtr::encode):

        (JSC::CachedPtr::decode const):

        (JSC::CachedPtr::operator->):

        (JSC::CachedPtr::operator-> const):

        (JSC::CachedRefPtr::encode):

        (JSC::CachedRefPtr::decode const):

        (JSC::CachedWriteBarrier::encode):

        (JSC::CachedWriteBarrier::decode const):

        (JSC::CachedVector::encode):

        (JSC::CachedVector::decode const):

        (JSC::CachedPair::encode):

        (JSC::CachedPair::decode const):

        (JSC::CachedHashMap::encode):

        (JSC::CachedHashMap::decode const):

        (JSC::CachedUniquedStringImpl::encode):

        (JSC::CachedUniquedStringImpl::decode const):

        (JSC::CachedStringImpl::encode):

        (JSC::CachedStringImpl::decode const):

        (JSC::CachedString::encode):

        (JSC::CachedString::decode const):

        (JSC::CachedIdentifier::encode):

        (JSC::CachedIdentifier::decode const):

        (JSC::CachedOptional::encode):

        (JSC::CachedOptional::decode const):

        (JSC::CachedOptional::decodeAsPtr const):

        (JSC::CachedSimpleJumpTable::encode):

        (JSC::CachedSimpleJumpTable::decode const):

        (JSC::CachedStringJumpTable::encode):

        (JSC::CachedStringJumpTable::decode const):

        (JSC::CachedRareData::encode):

        (JSC::CachedRareData::decode const):

        (JSC::CachedBitVector::encode):

        (JSC::CachedBitVector::decode const):

        (JSC::CachedHashSet::encode):

        (JSC::CachedHashSet::decode const):

        (JSC::CachedConstantIdentifierSetEntry::encode):

        (JSC::CachedConstantIdentifierSetEntry::decode const):

        (JSC::CachedVariableEnvironment::encode):

        (JSC::CachedVariableEnvironment::decode const):

        (JSC::CachedArray::encode):

        (JSC::CachedArray::decode const):

        (JSC::CachedScopedArgumentsTable::encode):

        (JSC::CachedScopedArgumentsTable::decode const):

        (JSC::CachedSymbolTableEntry::encode):

        (JSC::CachedSymbolTableEntry::decode const):

        (JSC::CachedSymbolTable::encode):

        (JSC::CachedSymbolTable::decode const):

        (JSC::CachedImmutableButterfly::encode):

        (JSC::CachedImmutableButterfly::decode const):

        (JSC::CachedRegExp::encode):

        (JSC::CachedRegExp::decode const):

        (JSC::CachedTemplateObjectDescriptor::encode):

        (JSC::CachedTemplateObjectDescriptor::decode const):

        (JSC::CachedBigInt::encode):

        (JSC::CachedBigInt::decode const):

        (JSC::CachedJSValue::encode):

        (JSC::CachedJSValue::decode const):

        (JSC::CachedInstructionStream::encode):

        (JSC::CachedInstructionStream::decode const):

        (JSC::CachedMetadataTable::encode):

        (JSC::CachedMetadataTable::decode const):

        (JSC::CachedSourceOrigin::encode):

        (JSC::CachedSourceOrigin::decode const):

        (JSC::CachedTextPosition::encode):

        (JSC::CachedTextPosition::decode const):

        (JSC::CachedSourceProviderShape::encode):

        (JSC::CachedSourceProviderShape::decode const):

        (JSC::CachedStringSourceProvider::encode):

        (JSC::CachedStringSourceProvider::decode const):

        (JSC::CachedWebAssemblySourceProvider::encode):

        (JSC::CachedWebAssemblySourceProvider::decode const):

        (JSC::CachedSourceProvider::encode):

        (JSC::CachedSourceProvider::decode const):

        (JSC::CachedUnlinkedSourceCodeShape::encode):

        (JSC::CachedUnlinkedSourceCodeShape::decode const):

        (JSC::CachedSourceCode::encode):

        (JSC::CachedSourceCode::decode const):

        (JSC::CachedProgramCodeBlock::encode):

        (JSC::CachedProgramCodeBlock::decode const):

        (JSC::CachedModuleCodeBlock::encode):

        (JSC::CachedModuleCodeBlock::decode const):

        (JSC::CachedEvalCodeBlock::encode):

        (JSC::CachedEvalCodeBlock::decode const):

        (JSC::CachedFunctionCodeBlock::encode):

        (JSC::CachedFunctionCodeBlock::decode const):

        (JSC::UnlinkedFunctionCodeBlock::UnlinkedFunctionCodeBlock):

        (JSC::UnlinkedCodeBlock::UnlinkedCodeBlock):

        (JSC::CachedCodeBlockType>::decode const):

        (JSC::UnlinkedProgramCodeBlock::UnlinkedProgramCodeBlock):

        (JSC::UnlinkedModuleProgramCodeBlock::UnlinkedModuleProgramCodeBlock):

        (JSC::UnlinkedEvalCodeBlock::UnlinkedEvalCodeBlock):

        (JSC::CachedFunctionExecutable::encode):

        (JSC::CachedFunctionExecutable::decode const):

        (JSC::UnlinkedFunctionExecutable::UnlinkedFunctionExecutable):

        (JSC::CachedCodeBlockType>::encode):

        (JSC::CachedSourceCodeKey::encode):

        (JSC::CachedSourceCodeKey::decode const):

        (JSC::CacheEntry::encode):

        (JSC::CacheEntry:: const):

        (JSC::encodeCodeBlock):

        * runtime/CodeCache.cpp:

        (JSC::CodeCache::getUnlinkedGlobalCodeBlock):

        (JSC::CodeCache::getUnlinkedGlobalFunctionExecutable):

        (JSC::CodeCache::write):

        * runtime/CodeCache.h:

        (JSC::CodeCacheMap::begin):

        (JSC::CodeCacheMap::end):

        (JSC::CodeCacheMap::findCacheAndUpdateAge):

        * runtime/JSBigInt.cpp:

        (JSC::JSBigInt::offsetOfData): Deleted.

        (JSC::JSBigInt::dataStorage): Deleted.

        * runtime/JSBigInt.h:

        * runtime/RegExp.h:

        * runtime/ScopedArgumentsTable.h:

        * runtime/SymbolTable.h:

2018-12-17  Tadeu Zagallo  <tzagallo@apple.com>

        Cache bytecode to disk

        https://bugs.webkit.org/show_bug.cgi?id=192782

        <rdar://problem/46084932>

        Reviewed by NOBODY (OOPS!).

        * wtf/BitVector.h:

		143BE26521C857770020CD17 /* CachedTypes.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = CachedTypes.h; sourceTree = "<group>"; };

				143BE26521C857770020CD17 /* CachedTypes.h */,

    JSC_COMMON_PRIVATE_IDENTIFIERS_EACH_WELL_KNOWN_SYMBOL(INITIALIZE_SYMBOL_PRIVATE_TO_PUBLIC_ENTRY)

#define INITIALIZE_SYMBOL_PRIVATE_TO_PUBLIC_ENTRY(name) m_privateToPublicMap.add(m_##name##Symbol.impl(), &m_##name##SymbolPrivateIdentifier);

    UnlinkedHandlerInfo()

    {

    }

    friend struct CachedInstructionStream;

template<typename CodeBlockType, typename CachedCodeBlockType>

struct CachedCodeBlock;

    template<typename CodeBlockType, typename CachedCodeBlockType>

    UnlinkedCodeBlock(Decoder&, Structure*, const CachedCodeBlock<CodeBlockType, CachedCodeBlockType>&);

    template<typename CodeBlockType, typename CachedCodeBlockType>

    friend struct CachedCodeBlock;

struct CachedEvalCodeBlock;

    friend CachedEvalCodeBlock;

    UnlinkedEvalCodeBlock(Decoder&, const CachedEvalCodeBlock&);

struct CachedFunctionCodeBlock;

    friend CachedFunctionCodeBlock;

    UnlinkedFunctionCodeBlock(Decoder&, const CachedFunctionCodeBlock&);

class Decoder;

struct CachedFunctionExecutable;

    friend CachedFunctionExecutable;

    UnlinkedFunctionExecutable(Decoder&, VariableEnvironment&, const CachedFunctionExecutable&);

    template<typename CodeBlockType, typename CachedCodeBlockType>

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

        : Base(decoder, structure, cachedCodeBlock)

    {

    }

    friend struct CachedMetadataTable;

class Decoder;

struct CachedModuleCodeBlock;

    friend CachedModuleCodeBlock;

    UnlinkedModuleProgramCodeBlock(Decoder&, const CachedModuleCodeBlock&);

struct CachedProgramCodeBlock;

    friend CachedProgramCodeBlock;

    UnlinkedProgramCodeBlock(Decoder&, const CachedProgramCodeBlock&);

#include "CodeCache.h"

    vm.codeCache()->write(vm);

        friend struct CachedSourceCode;

    friend struct CachedSourceCodeKey;

    friend struct CachedSourceCodeKey;

    bool operator!=(const SourceCodeKey& other) const

    {

        return !(*this == other);

    }

        template<typename SourceType, typename CacheType>

        friend struct CachedUnlinkedSourceCodeShape;

    friend struct CachedVariableEnvironment;

/*

 * 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);

    }

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

    {

        auto it = m_ptrToOffsetMap.find(ptr);

        if (it == m_ptrToOffsetMap.end())

            return std::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);

    }

    std::optional<void*> ptrForOffset(ptrdiff_t offset)

    {

        auto it = m_offsetToPtrMap.find(offset);

        if (it == m_offsetToPtrMap.end())

            return std::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 (std::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 (std::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<std::optional<SourceType<T>>, CachedOptional<T>> {

    bool isEmpty;

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

    {

        isEmpty = !source;

        if (isEmpty)

            return;

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

    }

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

    {

        if (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

    {

        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::createWithLength(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.m_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.m_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

    {