WTF_MAKE_NONCOPYABLE(Encoder);

WTF_FORBID_HEAP_ALLOCATION;

class Allocation {

friend class Encoder;

public:

uint8_t* buffer() const { return m_buffer; }

ptrdiff_t offset() const { return m_offset; }

private:

Allocation(uint8_t* buffer, ptrdiff_t offset)

: m_buffer(buffer)

, m_offset(offset)

{

}

uint8_t* m_buffer;

ptrdiff_t m_offset;

};

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

: m_vm(vm)

, m_fd(fd)

, m_baseOffset(0)

, m_currentPage(nullptr)

{

allocateNewPage();

}

VM& vm() { return m_vm; }

Allocation malloc(unsigned size)

{

RELEASE_ASSERT(size);

ptrdiff_t offset;

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

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

allocateNewPage(size);

return malloc(size);

}

template<typename T, typename... Args>

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

{

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

}

ptrdiff_t offsetOf(const void* address)

{

ptrdiff_t offset;

ptrdiff_t baseOffset = 0;

for (const auto& page : m_pages) {

if (page.getOffset(address, offset))

return baseOffset + offset;

baseOffset += page.size();

}

RELEASE_ASSERT_NOT_REACHED();

return 0;

}

void cachePtr(const void* ptr, ptrdiff_t offset)

{

m_ptrToOffsetMap.add(ptr, offset);

}

Optional<ptrdiff_t> cachedOffsetForPtr(const void* ptr)

{

auto it = m_ptrToOffsetMap.find(ptr);

if (it == m_ptrToOffsetMap.end())

return WTF::nullopt;

return { it->value };

}

void addLeafExecutable(const UnlinkedFunctionExecutable* executable, ptrdiff_t offset)

{

m_leafExecutables.add(executable, offset);

}

RefPtr<CachedBytecode> release(BytecodeCacheError& error)

{

if (!m_currentPage)

return nullptr;

m_currentPage->alignEnd();

if (FileSystem::isHandleValid(m_fd)) {

return releaseMapped(error);

}

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

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

unsigned offset = 0;

for (const auto& page : m_pages) {

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

offset += page.size();

}

RELEASE_ASSERT(offset == size);

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

}

RefPtr<CachedBytecode> releaseMapped(BytecodeCacheError& error)

{

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

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

error = BytecodeCacheError::StandardError(errno);

return nullptr;

}

for (const auto& page : m_pages) {

int bytesWritten = FileSystem::writeToFile(m_fd, reinterpret_cast<char*>(page.buffer()), page.size());

if (bytesWritten == -1) {

error = BytecodeCacheError::StandardError(errno);

return nullptr;

}

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

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

return nullptr;

}

}

bool success;

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

if (!success) {

error = BytecodeCacheError::StandardError(errno);

return nullptr;

}

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

}

class Page {

public:

Page(size_t size)

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

, m_capacity(size)

{

}

bool malloc(size_t size, ptrdiff_t& result)

{

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

ptrdiff_t offset = roundUpToMultipleOf(alignment, m_offset);

size = roundUpToMultipleOf(alignment, size);

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

return false;

result = offset;

m_offset = offset + size;

return true;

}

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

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

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

{

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

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

result = addr - m_buffer.get();

return true;

}

return false;

}

void alignEnd()

{

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

if (size == m_offset)

return;

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

m_offset = size;

}

private:

MallocPtr<uint8_t, VMMalloc> m_buffer;

ptrdiff_t m_offset { 0 };

size_t m_capacity;

};

void allocateNewPage(size_t size = 0)

{

static size_t minPageSize = pageSize();

if (m_currentPage) {

m_currentPage->alignEnd();

m_baseOffset += m_currentPage->size();

}

if (size < minPageSize)

size = minPageSize;

else

size = roundUpToMultipleOf(minPageSize, size);

m_pages.append(Page { size });

m_currentPage = &m_pages.last();

}

VM& m_vm;

FileSystem::PlatformFileHandle m_fd;

ptrdiff_t m_baseOffset;

Page* m_currentPage;

Vector<Page> m_pages;

HashMap<const void*, ptrdiff_t> m_ptrToOffsetMap;

LeafExecutableMap m_leafExecutables;

: m_vm(vm)

, m_cachedBytecode(WTFMove(cachedBytecode))

, m_provider(provider)

{

{

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

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

return addr - m_cachedBytecode->data();

{

auto it = m_offsetToPtrMap.find(offset);

if (it == m_offsetToPtrMap.end())

return WTF::nullopt;

return { it->value };

{

auto it = m_environmentToHandleMap.find(environment);

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

return it->value;

{

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

RELEASE_ASSERT(addResult.isNewEntry);

WTF_MAKE_NONCOPYABLE(CachedObject<Source>);

using SourceType_ = Source;

CachedObject() = default;

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

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

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

void* operator new(size_t) = delete;

void operator delete(void*) = delete;

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

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

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

template<typename, typename>

friend class CachedPtr;

friend struct CachedPtrOffsets;

VariableLengthObject()

: VariableLengthObjectBase(s_invalidOffset)

{

}

bool isEmpty() const

{

return m_offset == s_invalidOffset;

}

const uint8_t* buffer() const

{

ASSERT(!isEmpty());

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

}

template<typename T>

const T* buffer() const

{

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

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

}

uint8_t* allocate(Encoder& encoder, size_t size)

{

ptrdiff_t offsetOffset = encoder.offsetOf(&m_offset);

auto result = encoder.malloc(size);

m_offset = result.offset() - offsetOffset;

return result.buffer();

}

template<typename T>

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

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

// <rdar://problem/49792205>

__attribute__((optnone))

#endif

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

{

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

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

return new (result) T[size];

}

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

};

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

class CachedPtr : public VariableLengthObject<Source*> {

template<typename, typename, typename>

friend class CachedRefPtr;

friend struct CachedPtrOffsets;

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

{

if (!src)

return;

if (Optional<ptrdiff_t> offset = encoder.cachedOffsetForPtr(src)) {

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

return;

}

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

cachedObject->encode(encoder, *src);

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

}

template<typename... Args>

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

{

if (this->isEmpty()) {

isNewAllocation = false;

return nullptr;

}

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

if (Optional<void*> ptr = decoder.cachedPtrForOffset(bufferOffset)) {

isNewAllocation = false;

return static_cast<Source*>(*ptr);

}

isNewAllocation = true;

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

decoder.cacheOffset(bufferOffset, ptr);

return ptr;

}

template<typename... Args>

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

{

bool unusedIsNewAllocation;

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

}

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

const T* get() const

{

RELEASE_ASSERT(!this->isEmpty());

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

}

};

ptrdiff_t CachedPtrOffsets::offsetOffset()

{

return OBJECT_OFFSETOF(CachedPtr<void>, m_offset);

}

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

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

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

{

m_ptr.encode(encoder, src);

}

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

{

encode(encoder, src.get());

}

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

{

bool isNewAllocation;

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

if (!decodedPtr)

return nullptr;

if (isNewAllocation) {

decoder.addFinalizer([=] {

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

});

}

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

return adoptRef(decodedPtr);

}

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

{

src = decode(decoder);

}

CachedPtr<T, Source> m_ptr;

};

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

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

friend struct CachedWriteBarrierOffsets;

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

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

{

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

}

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

{

Source* decodedPtr = m_ptr.decode(decoder);

if (decodedPtr)

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

}

CachedPtr<T, Source> m_ptr;

};

ptrdiff_t CachedWriteBarrierOffsets::ptrOffset()

{

return OBJECT_OFFSETOF(CachedWriteBarrier<void>, m_ptr);

}

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

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

void encode(Encoder& encoder, const Vector<SourceType<T>, InlineCapacity, OverflowHandler, 16, Malloc>& vector)

{

m_size = vector.size();

if (!m_size)

return;

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

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

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

}

void encode(Encoder& encoder, const RefCountedArray<SourceType<T>>& vector)

{

m_size = vector.size();

if (!m_size)

return;

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

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

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

}

template<typename... Args>

void decode(Decoder& decoder, Vector<SourceType<T>, InlineCapacity, OverflowHandler, 16, Malloc>& vector, Args... args) const

{

if (!m_size)

return;

vector.resizeToFit(m_size);

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

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

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

}

template<typename... Args>

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

{

if (!m_size)

return;

vector = RefCountedArray<SourceType<T>>(m_size);

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

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

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

}

unsigned m_size;

};

template<typename First, typename Second>

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

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

{

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

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

}

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

{

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

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

}

First m_first;

Second m_second;

};

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

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

template<typename K, typename V>

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

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

{

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

unsigned i = 0;

for (const auto& it : map)

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

m_entries.encode(encoder, entriesVector);

}

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

{

SourceType<decltype(m_entries)> decodedEntries;

m_entries.decode(decoder, decodedEntries);

for (const auto& pair : decodedEntries)

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

}

CachedVector<CachedPair<Key, Value>> m_entries;

};

template<typename T>

class CachedUniquedStringImplBase : public VariableLengthObject<T> {

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

{

m_isAtomic = string.isAtom();

m_isSymbol = string.isSymbol();

m_isWellKnownSymbol = false;

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

if (m_isSymbol) {

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

if (!symbol->isNullSymbol()) {

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

if (!symbol->isPrivate()) {

m_isWellKnownSymbol = true;

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

}

}

}

m_is8Bit = impl->is8Bit();

m_length = impl->length();

if (!m_length)

return;

unsigned size = m_length;

const void* payload;

if (m_is8Bit)

payload = impl->characters8();

else {

payload = impl->characters16();

size *= 2;

}

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

memcpy(buffer, payload, size);

}

UniquedStringImpl* decode(Decoder& decoder) const

{

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

if (!m_isSymbol)

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

SymbolImpl* symbol;

if (m_isWellKnownSymbol)

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

else

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

RELEASE_ASSERT(symbol);

String str = symbol;

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

ASSERT(impl->isSymbol());

if (m_isWellKnownSymbol)

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

else

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

return static_cast<UniquedStringImpl*>(impl);

};

if (!m_length) {

if (m_isSymbol)

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

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

}

if (m_is8Bit)

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

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

}

bool m_is8Bit : 1;

bool m_isSymbol : 1;

bool m_isWellKnownSymbol : 1;

bool m_isAtomic : 1;

unsigned m_length;

};

class CachedUniquedStringImpl : public CachedUniquedStringImplBase<UniquedStringImpl> { };

class CachedStringImpl : public CachedUniquedStringImplBase<StringImpl> { };

class CachedString : public VariableLengthObject<String> {

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

{

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

}

String decode(Decoder& decoder) const

{

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

}

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

{

dst = decode(decoder);

}

CachedRefPtr<CachedUniquedStringImpl> m_impl;

};

class CachedIdentifier : public VariableLengthObject<Identifier> {

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

{

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

}

Identifier decode(Decoder& decoder) const

{

String str = m_string.decode(decoder);

if (str.isNull())

return Identifier();

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

}

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

{

ident = decode(decoder);

}

CachedString m_string;

};

template<typename T>

class CachedOptional : public VariableLengthObject<Optional<SourceType<T>>> {

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

{

if (!source)

return;

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

}

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

{

if (this->isEmpty())

return WTF::nullopt;

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

}

void decode(Decoder& decoder, 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

{

RELEASE_ASSERT(!this->isEmpty());

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

}

};

class CachedSimpleJumpTable : public CachedObject<UnlinkedSimpleJumpTable> {

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

{

m_min = jumpTable.min;

m_branchOffsets.encode(encoder, jumpTable.branchOffsets);

}

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

{

jumpTable.min = m_min;

m_branchOffsets.decode(decoder, jumpTable.branchOffsets);

}

int32_t m_min;

CachedVector<int32_t> m_branchOffsets;

};

class CachedStringJumpTable : public CachedObject<UnlinkedStringJumpTable> {

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

{

m_offsetTable.encode(encoder, jumpTable.offsetTable);

}

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

{

m_offsetTable.decode(decoder, jumpTable.offsetTable);

}

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

};

class CachedBitVector : public VariableLengthObject<BitVector> {

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

{

m_numBits = bitVector.size();

if (!m_numBits)

return;

size_t sizeInBytes = BitVector::byteCount(m_numBits);

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

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

}

void decode(Decoder&, BitVector& bitVector) const

{

if (!m_numBits)

return;

bitVector.ensureSize(m_numBits);

size_t sizeInBytes = BitVector::byteCount(m_numBits);

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

}

size_t m_numBits;

};

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

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

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

{

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

unsigned i = 0;

for (const auto& item : set)

entriesVector[i++] = item;

m_entries.encode(encoder, entriesVector);

}

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

{

SourceType<decltype(m_entries)> entriesVector;

m_entries.decode(decoder, entriesVector);

for (const auto& item : entriesVector)

set.add(item);

}

CachedVector<T> m_entries;

};

class CachedConstantIdentifierSetEntry : public VariableLengthObject<ConstantIdentifierSetEntry> {

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

{

m_constant = entry.second;

m_set.encode(encoder, entry.first);

}

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

{

entry.second = m_constant;

m_set.decode(decoder, entry.first);

}

unsigned m_constant;

CachedHashSet<CachedRefPtr<CachedUniquedStringImpl>, IdentifierRepHash> m_set;

};

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

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

{

m_exceptionHandlers.encode(encoder, rareData.m_exceptionHandlers);

m_switchJumpTables.encode(encoder, rareData.m_switchJumpTables);

m_stringSwitchJumpTables.encode(encoder, rareData.m_stringSwitchJumpTables);

m_expressionInfoFatPositions.encode(encoder, rareData.m_expressionInfoFatPositions);

m_typeProfilerInfoMap.encode(encoder, rareData.m_typeProfilerInfoMap);

m_opProfileControlFlowBytecodeOffsets.encode(encoder, rareData.m_opProfileControlFlowBytecodeOffsets);

m_bitVectors.encode(encoder, rareData.m_bitVectors);

m_constantIdentifierSets.encode(encoder, rareData.m_constantIdentifierSets);

m_needsClassFieldInitializer = rareData.m_needsClassFieldInitializer;

}

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

{

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

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

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

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

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

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

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

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

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

rareData->m_needsClassFieldInitializer = m_needsClassFieldInitializer;

return rareData;

}