WTF_MAKE_NONCOPYABLE(ExpressionInfo);

WTF_DEPRECATED_MAKE_FAST_ALLOCATED(ExpressionInfo);

enum class FieldID : uint8_t { InstPC, Divot, Start, End };

class Decoder;

using InstPC = unsigned; // aka bytecode PC.

static constexpr InstPC maxInstPC = std::numeric_limits<unsigned>::max();

struct Chapter {

InstPC startInstPC;

unsigned startEncodedInfoIndex;

};

struct Entry {

void LEGACY_NODELETE reset()

{

instPC = 0;

divot = 0;

startOffset = 0;

endOffset = 0;

}

InstPC instPC { 0 };

unsigned divot { 0 };

unsigned startOffset { 0 }; // This value is relative to divot.

unsigned endOffset { 0 }; // This value is relative to divot.

};

struct EncodedInfo {

bool LEGACY_NODELETE isAbsInstPC() const;

bool LEGACY_NODELETE isExtension() const;

unsigned value;

};

struct Diff;

class Encoder {

public:

void encode(InstPC, unsigned divot, unsigned startOffset, unsigned endOffset);

template<typename RemapFunc>

void remap(Vector<unsigned>&& adjustments, RemapFunc);

Entry entry() const { return m_entry; }

std::unique_ptr<ExpressionInfo> createExpressionInfo();

void dumpEncodedInfo() // For debugging use only.

{

ExpressionInfo::dumpEncodedInfo(m_expressionInfoEncodedInfo.begin(), m_expressionInfoEncodedInfo.end());

}

private:

struct Wide {

enum class SortOrder : uint8_t { Single, Duo, Multi };

unsigned value;

FieldID fieldID;

SortOrder order { SortOrder::Multi };

};

static EncodedInfo LEGACY_NODELETE encodeAbsInstPC(InstPC absInstPC);

static EncodedInfo LEGACY_NODELETE encodeExtension(unsigned offset);

static constexpr EncodedInfo LEGACY_NODELETE encodeExtensionEnd();

static EncodedInfo LEGACY_NODELETE encodeSingle(FieldID, unsigned);

static EncodedInfo LEGACY_NODELETE encodeDuo(FieldID, unsigned value1, FieldID, unsigned value2);

static EncodedInfo LEGACY_NODELETE encodeMultiHeader(unsigned numWides, Wide*);

static EncodedInfo LEGACY_NODELETE encodeBasic(const Diff&);

void adjustInstPC(unsigned infoIndex, unsigned instPCDelta);

template<unsigned bitCount> bool LEGACY_NODELETE fits(Wide);

template<typename T, unsigned bitCount> bool fits(T);

Entry m_entry;

unsigned m_currentChapterStartIndex { 0 };

unsigned m_numberOfEncodedInfoExtensions { 0 };

Vector<ExpressionInfo::Chapter> m_expressionInfoChapters;

Vector<ExpressionInfo::EncodedInfo> m_expressionInfoEncodedInfo;

};

class Decoder {

public:

Decoder() = default;

Decoder(const ExpressionInfo&);

Decoder(Vector<ExpressionInfo::EncodedInfo>&);

IterationStatus LEGACY_NODELETE decode(std::optional<InstPC> targetInstPC = std::nullopt);

void LEGACY_NODELETE recacheInfo(Vector<ExpressionInfo::EncodedInfo>&);

EncodedInfo* currentInfo() const { return m_currentInfo; }

// This is meant to be used to jump to the start of a chapter, where the encoder

// always start over with no historical Entry values to compute diffs from.

// If you use this to point to any EncodedInfo other than the start of a chapter,

// then you're responsible for setting up the initial conditions of m_entry correctly

// apriori.

void setNextInfo(EncodedInfo* info) { m_nextInfo = info; }

Entry entry() const { return m_entry; }

void setEntry(Entry entry) { m_entry = entry; } // For debugging use only.

InstPC instPC() const { return m_entry.instPC; }

unsigned divot() const { return m_entry.divot; }

unsigned startOffset() const { return m_entry.startOffset; }

unsigned endOffset() const { return m_entry.endOffset; }

private:

struct Wide {

FieldID fieldID;

unsigned value;

};

void appendWide(FieldID id, unsigned value)

{

m_wides[m_numWides++] = { id, value };

}

Entry m_entry;

EncodedInfo* m_startInfo { nullptr };

EncodedInfo* m_endInfo { nullptr };

EncodedInfo* m_endExtensionInfo { nullptr };

EncodedInfo* m_currentInfo { nullptr };

EncodedInfo* m_nextInfo { nullptr };

bool m_hasDecodedFirstEntry { false };

unsigned m_numWides { 0 };

std::array<Wide, 6> m_wides;

};

~ExpressionInfo() = default;

// The caller holds the owning UnlinkedCodeBlock's lock, because compiler threads also look up

// entries (useSourceCodeDump) and lookups fill a cache.

Entry entryForInstPC(const ConcurrentJSLocker&, InstPC);

bool isEmpty() const { return !m_numberOfEncodedInfo; };

size_t LEGACY_NODELETE byteSize() const;

template<unsigned bitCount>

static void print(PrintStream&, FieldID, unsigned value);

static void dumpEncodedInfo(EncodedInfo* start, EncodedInfo* end); // For debugging use only.

ExpressionInfo(unsigned numberOfChapters, unsigned numberOfEncodedInfo, unsigned numberOfEncodedInfoExtensions);

ExpressionInfo(Vector<Chapter>&&, Vector<EncodedInfo>&&, unsigned numberOfEncodedInfoExtensions);

template<typename T, unsigned bitCount> static T LEGACY_NODELETE cast(unsigned);

static bool LEGACY_NODELETE isSpecial(unsigned);

static bool LEGACY_NODELETE isWideOrSpecial(unsigned);

static size_t payloadSizeInBytes(size_t numChapters, size_t numberOfEncodedInfo, size_t numberOfEncodedInfoExtensions)

{

size_t size = numChapters * sizeof(Chapter) + (numberOfEncodedInfo + numberOfEncodedInfoExtensions) * sizeof(EncodedInfo);

return roundUpToMultipleOf<sizeof(unsigned)>(size);

}

static size_t totalSizeInBytes(size_t numChapters, size_t numberOfEncodedInfo, size_t numberOfEncodedInfoExtensions)

{

return sizeof(ExpressionInfo) + payloadSizeInBytes(numChapters, numberOfEncodedInfo, numberOfEncodedInfoExtensions);

}

EncodedInfo* LEGACY_NODELETE findChapterEncodedInfoJustBelow(InstPC) const;

Entry LEGACY_NODELETE decodeEntryForInstPC(InstPC);

Chapter* chapters() const

{

return std::bit_cast<Chapter*>(this + 1);

}

EncodedInfo* encodedInfo() const

{

return std::bit_cast<EncodedInfo*>(&chapters()[m_numberOfChapters]);

}

EncodedInfo* endEncodedInfo() const

{

return &encodedInfo()[m_numberOfEncodedInfo];

}

EncodedInfo* endExtensionEncodedInfo() const

{

return &encodedInfo()[m_numberOfEncodedInfo + m_numberOfEncodedInfoExtensions];

}

size_t payloadSize() const

{

return payloadSizeInBytes(m_numberOfChapters, m_numberOfEncodedInfo, m_numberOfEncodedInfoExtensions) / sizeof(unsigned);

}

unsigned* payload() const

{

return std::bit_cast<unsigned*>(this + 1);

}

static std::unique_ptr<ExpressionInfo> createUninitialized(unsigned numberOfChapters, unsigned numberOfEncodedInfo, unsigned numberOfEncodedInfoExtensions);

static constexpr unsigned bitsPerWord = sizeof(unsigned) * CHAR_BIT;

// Number of bits of each field in Basic encoding.

static constexpr unsigned instPCBits = 5;

static constexpr unsigned divotBits = 11;

static constexpr unsigned startBits = 8;

static constexpr unsigned endBits = 8;

static_assert(instPCBits + divotBits + startBits + endBits == bitsPerWord);

// Bias values used for the signed diff values which make it easier to do range checks on these.

static constexpr unsigned divotBias = (1 << divotBits) / 2;

static constexpr unsigned instPCShift = bitsPerWord - instPCBits;

static constexpr unsigned divotShift = instPCShift - divotBits;

static constexpr unsigned startShift = divotShift - startBits;

static constexpr unsigned endShift = startShift - endBits;

static constexpr unsigned specialHeader = (1 << instPCBits) - 1;

static constexpr unsigned wideHeader = specialHeader - 1;

static constexpr unsigned maxInstPCValue = wideHeader - 1;

static constexpr unsigned maxBiasedDivotValue = (1 << divotBits) - 1;

static constexpr unsigned maxStartValue = (1 << startBits) - 1;

static constexpr unsigned maxEndValue = (1 << endBits) - 1;

// Number of bits in Wide / Special encodings.

static constexpr unsigned specialValueBits = 26;

static constexpr unsigned singleValueBits = 23;

static constexpr unsigned duoValueBits = 10;

static constexpr unsigned fullValueBits = 32;

static constexpr unsigned multiSizeBits = 5;

static constexpr unsigned fieldIDBits = 3;

static constexpr unsigned maxSpecialValue = (1 << specialValueBits) - 1;

static constexpr unsigned maxSingleValue = (1 << singleValueBits) - 1;

static constexpr unsigned maxDuoValue = (1 << duoValueBits) - 1;

static constexpr unsigned invalidFieldID = (1 << fieldIDBits) - 1;

static constexpr unsigned multiSizeMask = (1 << multiSizeBits) - 1;

static constexpr unsigned fieldIDMask = (1 << fieldIDBits) - 1;

static constexpr unsigned headerShift = bitsPerWord - instPCBits;

static constexpr unsigned multiBitShift = headerShift - 1;

static_assert(headerShift == 27);

static_assert(multiBitShift == 26);

static constexpr unsigned specialValueShift = multiBitShift - specialValueBits;

static_assert(!specialValueShift);

static constexpr unsigned firstFieldIDShift = multiBitShift - fieldIDBits;

static constexpr unsigned singleValueShift = firstFieldIDShift - singleValueBits;

static_assert(!singleValueShift);

static constexpr unsigned duoFirstValueShift = firstFieldIDShift - duoValueBits;

static constexpr unsigned duoSecondFieldIDShift = duoFirstValueShift - fieldIDBits;

static constexpr unsigned duoSecondValueShift = duoSecondFieldIDShift - duoValueBits;

static_assert(!duoSecondValueShift);

static constexpr unsigned multiSizeShift = firstFieldIDShift - multiSizeBits;

static constexpr unsigned multiFirstFieldShift = multiSizeShift - fieldIDBits;

static constexpr unsigned numberOfWordsBetweenChapters = 10000;

UncheckedKeyHashMap<InstPC, Entry, WTF::IntHash<InstPC>, WTF::UnsignedWithZeroKeyHashTraits<InstPC>> m_cachedEntries;

unsigned m_numberOfChapters;

unsigned m_numberOfEncodedInfo;

unsigned m_numberOfEncodedInfoExtensions;

// Followed by the following which are allocated but are dynamically sized.

// Chapter chapters[numberOfChapters];

// EncodedInfo encodedInfo[numberOfEncodedInfo + numberOfEncodedInfoExtensions];

friend class CachedExpressionInfo;