#pragma once
#if ENABLE(DFG_JIT)
#include "CodeBlock.h"
#include "CompilationResult.h"
#include "DFGCommonData.h"
#include "DFGMinifiedGraph.h"
#include "DFGOSREntry.h"
#include "DFGOSRExit.h"
#include "DFGVariableEventStream.h"
#include "ExecutionCounter.h"
#include "JITCode.h"
#include <wtf/SegmentedVector.h>
namespace JSC {
class TrackedReferences;
namespace DFG {
class JITCompiler;
class JITCode final : public DirectJITCode {
public:
JITCode();
~JITCode() final;
CommonData* dfgCommon() final;
JITCode* dfg() final;
OSREntryData* appendOSREntryData(BytecodeIndex bytecodeIndex, CodeLocationLabel<OSREntryPtrTag> machineCode)
{
DFG::OSREntryData entry;
entry.m_bytecodeIndex = bytecodeIndex;
entry.m_machineCode = machineCode;
osrEntry.append(entry);
return &osrEntry.last();
}
OSREntryData* osrEntryDataForBytecodeIndex(BytecodeIndex bytecodeIndex)
{
return tryBinarySearch<OSREntryData, BytecodeIndex>(
osrEntry, osrEntry.size(), bytecodeIndex,
getOSREntryDataBytecodeIndex);
}
void finalizeOSREntrypoints();
unsigned appendOSRExit(const OSRExit& exit)
{
unsigned result = osrExit.size();
osrExit.append(exit);
return result;
}
OSRExit& lastOSRExit()
{
return osrExit.last();
}
unsigned appendSpeculationRecovery(const SpeculationRecovery& recovery)
{
unsigned result = speculationRecovery.size();
speculationRecovery.append(recovery);
return result;
}
void reconstruct(
CodeBlock*, CodeOrigin, unsigned streamIndex, Operands<ValueRecovery>& result);
void reconstruct(
CallFrame*, CodeBlock*, CodeOrigin, unsigned streamIndex, Operands<Optional<JSValue>>& result);
#if ENABLE(FTL_JIT)
bool checkIfOptimizationThresholdReached(CodeBlock*);
void optimizeNextInvocation(CodeBlock*);
void dontOptimizeAnytimeSoon(CodeBlock*);
void optimizeAfterWarmUp(CodeBlock*);
void optimizeSoon(CodeBlock*);
void forceOptimizationSlowPathConcurrently(CodeBlock*);
void setOptimizationThresholdBasedOnCompilationResult(CodeBlock*, CompilationResult);
#endif // ENABLE(FTL_JIT)
void validateReferences(const TrackedReferences&) final;
void shrinkToFit(const ConcurrentJSLocker&) final;
RegisterSet liveRegistersToPreserveAtExceptionHandlingCallSite(CodeBlock*, CallSiteIndex) final;
#if ENABLE(FTL_JIT)
CodeBlock* osrEntryBlock() { return m_osrEntryBlock.get(); }
void setOSREntryBlock(VM&, const JSCell* owner, CodeBlock* osrEntryBlock);
void clearOSREntryBlockAndResetThresholds(CodeBlock* dfgCodeBlock);
#endif
static ptrdiff_t commonDataOffset() { return OBJECT_OFFSETOF(JITCode, common); }
Optional<CodeOrigin> findPC(CodeBlock*, void* pc) final;
using DirectJITCode::initializeCodeRefForDFG;
private:
friend class JITCompiler;
public:
CommonData common;
Vector<DFG::OSREntryData> osrEntry;
SegmentedVector<DFG::OSRExit, 8> osrExit;
Vector<DFG::SpeculationRecovery> speculationRecovery;
DFG::VariableEventStream variableEventStream;
DFG::MinifiedGraph minifiedDFG;
#if ENABLE(FTL_JIT)
uint8_t neverExecutedEntry { 1 };
UpperTierExecutionCounter tierUpCounter;
HashMap<BytecodeIndex, Vector<BytecodeIndex>> tierUpInLoopHierarchy;
HashMap<BytecodeIndex, unsigned> bytecodeIndexToStreamIndex;
enum class TriggerReason : uint8_t {
DontTrigger,
CompilationDone,
StartCompilation,
};
HashMap<BytecodeIndex, TriggerReason> tierUpEntryTriggers;
WriteBarrier<CodeBlock> m_osrEntryBlock;
unsigned osrEntryRetry;
bool abandonOSREntry;
#endif // ENABLE(FTL_JIT)
};
} }
#endif // ENABLE(DFG_JIT)