void adoptMathICs(MathICHolder& other);

JITAddIC* addJITAddIC(BinaryArithProfile*);

JITMulIC* addJITMulIC(BinaryArithProfile*);

JITSubIC* addJITSubIC(BinaryArithProfile*);

JITNegIC* addJITNegIC(UnaryArithProfile*);

Bag<JITAddIC> m_addICs;

Bag<JITMulIC> m_mulICs;

Bag<JITNegIC> m_negICs;

Bag<JITSubIC> m_subICs;

WTF_MAKE_NONCOPYABLE(JITConstantPool);

using Constant = unsigned;

enum class Type : uint8_t {

FunctionDecl,

FunctionExpr,

};

using Value = JITConstant<Type>;

JITConstantPool() = default;

JITConstantPool(JITConstantPool&&) = default;

JITConstantPool& operator=(JITConstantPool&&) = default;

JITConstantPool(Vector<Value>&& constants)

: m_constants(WTF::move(constants))

{

}

size_t size() const { return m_constants.size(); }

Value at(size_t i) const { return m_constants[i]; }

FixedVector<Value> m_constants;

BaselineJITCode(CodeRef<JSEntryPtrTag>, CodePtr<JSEntryPtrTag> withArityCheck);

~BaselineJITCode() override;

PCToCodeOriginMap* pcToCodeOriginMap() LIFETIME_BOUND override { return m_pcToCodeOriginMap.get(); }

CodeLocationLabel<JSInternalPtrTag> getCallLinkDoneLocationForBytecodeIndex(BytecodeIndex) const;

double livenessRate() const { return m_livenessRate; }

void setLivenessRate(double rate) { m_livenessRate = rate; }

double fullnessRate() const { return m_fullnessRate; }

void setFullnessRate(double rate) { m_fullnessRate = rate; }

FixedVector<BaselineUnlinkedCallLinkInfo> m_unlinkedCalls;

FixedVector<BaselineUnlinkedPropertyInlineCache> m_unlinkedPropertyInlineCaches;

FixedVector<SimpleJumpTable> m_switchJumpTables;

FixedVector<StringJumpTable> m_stringSwitchJumpTables;

JITCodeMap m_jitCodeMap;

JITConstantPool m_constantPool;

std::unique_ptr<PCToCodeOriginMap> m_pcToCodeOriginMap;

// The percentage of ValueProfiles that had some profiling data in them.

double m_livenessRate { 0 };

// The percentage of ValueProfile buckets that had a value in them.

double m_fullnessRate { 0 };

bool m_isShareable { true };

friend class LLIntOffsetsExtractor;

using Base = ButterflyArray<BaselineJITData, HandlerPropertyInlineCache, void*>;

static std::unique_ptr<BaselineJITData> create(unsigned propertyCacheSize, unsigned poolSize, CodeBlock* codeBlock)

{

return std::unique_ptr<BaselineJITData> { createImpl(propertyCacheSize, poolSize, codeBlock) };

}

explicit BaselineJITData(unsigned poolSize, unsigned propertyCacheSize, CodeBlock*);

static constexpr ptrdiff_t offsetOfGlobalObject() { return OBJECT_OFFSETOF(BaselineJITData, m_globalObject); }

static constexpr ptrdiff_t offsetOfStackOffset() { return OBJECT_OFFSETOF(BaselineJITData, m_stackOffset); }

static constexpr ptrdiff_t offsetOfJITExecuteCounter() { return OBJECT_OFFSETOF(BaselineJITData, m_executeCounter) + OBJECT_OFFSETOF(BaselineExecutionCounter, m_counter); }

static constexpr ptrdiff_t offsetOfJITExecutionActiveThreshold() { return OBJECT_OFFSETOF(BaselineJITData, m_executeCounter) + OBJECT_OFFSETOF(BaselineExecutionCounter, m_activeThreshold); }

static constexpr ptrdiff_t offsetOfJITExecutionTotalCount() { return OBJECT_OFFSETOF(BaselineJITData, m_executeCounter) + OBJECT_OFFSETOF(BaselineExecutionCounter, m_totalCount); }

HandlerPropertyInlineCache& propertyCache(unsigned index)

{

auto span = propertyInlineCaches();

return span[span.size() - index - 1];

}

auto propertyInlineCaches() -> decltype(leadingSpan())

{

return leadingSpan();

}

BaselineExecutionCounter& executeCounter() LIFETIME_BOUND { return m_executeCounter; }

const BaselineExecutionCounter& executeCounter() const LIFETIME_BOUND { return m_executeCounter; }

JSGlobalObject* m_globalObject { nullptr }; // This is not marked since owner CodeBlock will mark JSGlobalObject.

intptr_t m_stackOffset { 0 };

BaselineExecutionCounter m_executeCounter;