typedef JSCell Base;

friend class BytecodeLivenessAnalysis;

friend class JIT;

friend class LLIntOffsetsExtractor;

enum CopyParsedBlockTag { CopyParsedBlock };

static constexpr unsigned StructureFlags = Base::StructureFlags | StructureIsImmortal;

static constexpr DestructionMode needsDestruction = NeedsDestruction;

template<typename, SubspaceAccess>

static void subspaceFor(VM&)

{

RELEASE_ASSERT_NOT_REACHED();

}

// GC strongly assumes CodeBlock is not a PreciseAllocation for now.

static constexpr uint8_t numberOfLowerTierPreciseCells = 0;

DECLARE_INFO;

CodeBlock(VM&, Structure*, CopyParsedBlockTag, CodeBlock& other);

CodeBlock(VM&, Structure*, ScriptExecutable* ownerExecutable, UnlinkedCodeBlock*, JSScope*);

void finishCreation(VM&, CopyParsedBlockTag, CodeBlock& other);

bool finishCreation(VM&, ScriptExecutable* ownerExecutable, UnlinkedCodeBlock*, JSScope*);

WriteBarrier<JSGlobalObject> m_globalObject;

struct CrashChecker {

enum Entry {

This,

Metadata,

BaselineJITData,

PropertyInlineCacheCount,

DFGJITData,

Destructed

};

#if ENABLE(CODEBLOCK_CRASH_ANALYSIS)

static constexpr bool isEnabled = true;

template<typename T>

static uint8_t hash(T src)

{

uintptr_t value = std::bit_cast<uintptr_t>(src);

value = value ^ (value >> 32);

value = value ^ (value >> 16);

value = value ^ (value >> 8);

return value;

}

template<typename T, typename U>

static uint8_t hash(T src1, U src2)

{

uintptr_t value1 = std::bit_cast<uintptr_t>(src1);

uintptr_t value2 = std::bit_cast<uintptr_t>(src2);

return hash(value1 ^ value2);

}

uint8_t get(unsigned index) { return m_data >> (index * CHAR_BIT); }

void set(unsigned index, uint8_t value) { m_data |= static_cast<uintptr_t>(value) << (index * CHAR_BIT); }

uintptr_t value() const { return m_data; }

private:

uintptr_t m_data { 0 };

#else

static constexpr bool isEnabled = false;

template<typename T> static uint8_t hash(T) { return 0; }

template<typename T, typename U> static uint8_t hash(T, U) { return 0; }

uint8_t get(unsigned) { return 0; }

void set(unsigned, uint8_t) { }

uintptr_t value() const { return 0; }

#endif

};

JS_EXPORT_PRIVATE ~CodeBlock();

UnlinkedCodeBlock* unlinkedCodeBlock() const LIFETIME_BOUND { return m_unlinkedCode.get(); }

UTF8CString inferredName() const;

String inferredNameWithHash() const;

CodeBlockHash hash() const;

bool LEGACY_NODELETE hasHash() const;

UTF8CString sourceCodeForTools() const;

UTF8CString sourceCodeOnOneLine() const; // As sourceCodeForTools(), but replaces all whitespace runs with a single space.

void dumpAssumingJITType(PrintStream&, JITType) const;

JS_EXPORT_PRIVATE void dump(PrintStream&) const;

void dumpSimpleName(PrintStream&) const;

MetadataTable* metadataTable() const { return m_metadata.get(); }

unsigned numParameters() const { return m_numParameters; }

void setNumParameters(unsigned newValue, bool allocateArgumentValueProfiles);

bool couldBeTainted() const { return m_couldBeTainted; }

unsigned numberOfArgumentsToSkip() const { return m_numberOfArgumentsToSkip; }

unsigned numCalleeLocals() const { return m_numCalleeLocals; }

unsigned numVars() const { return m_numVars; }

unsigned numTmps() const { return m_unlinkedCode->hasCheckpoints() * maxNumCheckpointTmps; }

static constexpr ptrdiff_t offsetOfNumParameters() { return OBJECT_OFFSETOF(CodeBlock, m_numParameters); }

static constexpr ptrdiff_t offsetOfVM() { return OBJECT_OFFSETOF(CodeBlock, m_vm); }

CodeBlock* alternative() const { return static_cast<CodeBlock*>(m_alternative.get()); }

void setAlternative(VM&, CodeBlock*);

template <typename Functor> void forEachRelatedCodeBlock(NOESCAPE const Functor& functor)

{

Vector<CodeBlock*, 4> codeBlocks;

codeBlocks.append(this);

while (!codeBlocks.isEmpty()) {

CodeBlock* currentCodeBlock = codeBlocks.takeLast();

functor(currentCodeBlock);

if (CodeBlock* alternative = currentCodeBlock->alternative())

codeBlocks.append(alternative);

if (CodeBlock* osrEntryBlock = currentCodeBlock->specialOSREntryBlockOrNull())

codeBlocks.append(osrEntryBlock);

}

}

CodeSpecializationKind specializationKind() const

{

return specializationFromIsConstruct(isConstructor());

}

CodeBlock* alternativeForJettison();

JS_EXPORT_PRIVATE CodeBlock* LEGACY_NODELETE baselineAlternative();

// FIXME: Get rid of this.

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

CodeBlock* LEGACY_NODELETE baselineVersion();

DECLARE_VISIT_CHILDREN;

static size_t estimatedSize(JSCell*, VM&);

static void destroy(JSCell*);

void reconcileWeakReferencesAtGCEnd(VM&, CollectionScope);

void notifyLexicalBindingUpdate();

void dumpSource();

void dumpSource(PrintStream&);

void dumpBytecode();

void dumpBytecode(PrintStream&);

void dumpBytecode(PrintStream& out, const JSInstructionStream::Ref& it, const ICStatusMap& = ICStatusMap());

void dumpBytecode(PrintStream& out, unsigned bytecodeOffset, const ICStatusMap& = ICStatusMap());

void dumpExceptionHandlers(PrintStream&);

void printStructures(PrintStream&, const JSInstruction*);

void printStructure(PrintStream&, const char* name, const JSInstruction*, int operand);

void LEGACY_NODELETE dumpMathICStats();

bool isConstructor() const { return m_unlinkedCode->isConstructor(); }

CodeType codeType() const { return m_unlinkedCode->codeType(); }

JSParserScriptMode scriptMode() const { return m_unlinkedCode->scriptMode(); }

bool hasInstalledVMTrapsBreakpoints() const;

bool canInstallVMTrapBreakpoints() const;

bool installVMTrapBreakpoints();

ALWAYS_INLINE bool isTemporaryRegister(VirtualRegister reg)

{

return reg.offset() >= static_cast<int>(m_numVars);

}

HandlerInfo* LEGACY_NODELETE handlerForBytecodeIndex(BytecodeIndex, RequiredHandler = RequiredHandler::AnyHandler);

HandlerInfo* LEGACY_NODELETE handlerForIndex(unsigned, RequiredHandler = RequiredHandler::AnyHandler);

void removeExceptionHandlerForCallSite(DisposableCallSiteIndex);

LineColumn lineColumnForBytecodeIndex(BytecodeIndex) const;

ExpressionInfo::Entry expressionInfoForBytecodeIndex(BytecodeIndex) const;

std::optional<BytecodeIndex> bytecodeIndexFromCallSiteIndex(CallSiteIndex);

// Because we might throw out baseline JIT code and all its baseline JIT data (m_jitData),

// you need to be careful about the lifetime of when you use the return value of this function.

// The return value may have raw pointers into this data structure that gets thrown away.

// Specifically, you need to ensure that no GC can be finalized (typically that means no

// allocations) between calling this and the last use of it.

void getICStatusMap(const ConcurrentJSLocker&, ICStatusMap& result);

void getICStatusMap(ICStatusMap& result);

#if ENABLE(JIT)

void setupWithUnlinkedBaselineCode(Ref<BaselineJITCode>);

static constexpr ptrdiff_t offsetOfJITData() { return OBJECT_OFFSETOF(CodeBlock, m_jitData); }

const JITCodeMap& jitCodeMap();

std::optional<CodeOrigin> findPC(void* pc);

#endif // ENABLE(JIT)

void unlinkOrUpgradeIncomingCalls(VM&, CodeBlock*);

void linkIncomingCall(JSCell* caller, CallLinkInfoBase*);

const JSInstruction* outOfLineJumpTarget(const JSInstruction* pc);

int outOfLineJumpOffset(JSInstructionStream::Offset offset)

{

return m_unlinkedCode->outOfLineJumpOffset(offset);

}

int outOfLineJumpOffset(const JSInstruction* pc);

int outOfLineJumpOffset(const JSInstructionStream::Ref& instruction)

{

return outOfLineJumpOffset(instruction.ptr());

}

inline unsigned bytecodeOffset(const JSInstruction* returnAddress)

{

const auto* instructionsBegin = instructions().at(0).ptr();

const auto* instructionsEnd = reinterpret_cast<const JSInstruction*>(reinterpret_cast<uintptr_t>(instructionsBegin) + instructions().size());

RELEASE_ASSERT(returnAddress >= instructionsBegin && returnAddress < instructionsEnd);

return returnAddress - instructionsBegin;

}

inline BytecodeIndex bytecodeIndex(const JSInstruction* returnAddress)

{

return BytecodeIndex(bytecodeOffset(returnAddress));

}

const JSInstructionStream& instructions() const LIFETIME_BOUND { return m_unlinkedCode->instructions(); }

const JSInstruction* instructionAt(BytecodeIndex index) const { return instructions().at(index).ptr(); }

size_t predictedMachineCodeSize();

unsigned instructionsSize() const { return instructions().size(); }

unsigned bytecodeCost() const;

unsigned bytecodeCostForFTLInlining() const;

// Exactly equivalent to codeBlock->ownerExecutable()->newReplacementCodeBlockFor(codeBlock->specializationKind())

CodeBlock* newReplacement();

CodeBlock* LEGACY_NODELETE replacement();

void setJITCode(Ref<JSC::JITCode>&& code)

{

if (!code->isShared())

heap()->reportExtraMemoryAllocated(this, code->size());

ConcurrentJSLocker locker(m_lock);

WTF::storeStoreFence(); // This is probably not needed because the lock will also do something similar, but it's good to be paranoid.

m_jitCode = WTF::move(code);

}

RefPtr<JSC::JITCode> jitCode() { return m_jitCode; }

static constexpr ptrdiff_t jitCodeOffset() { return OBJECT_OFFSETOF(CodeBlock, m_jitCode); }

JITType jitType() const

{

auto* jitCode = m_jitCode.get();

JITType result = JSC::JITCode::jitTypeFor(jitCode);

return result;

}

bool hasBaselineJITProfiling() const

{

return jitType() == JITType::BaselineJIT;

}

CodePtr<JSEntryPtrTag> addressForCallConcurrently(const ConcurrentJSLocker&, ArityCheckMode) const;

#if ENABLE(JIT)

DFG::CapabilityLevel computeCapabilityLevel();

DFG::CapabilityLevel capabilityLevel();

DFG::CapabilityLevel capabilityLevelState() { return static_cast<DFG::CapabilityLevel>(m_capabilityLevelState); }

CodeBlock* LEGACY_NODELETE optimizedReplacement(JITType typeToReplace);

CodeBlock* optimizedReplacement(); // the typeToReplace is my JITType

bool LEGACY_NODELETE hasOptimizedReplacement(JITType typeToReplace);

bool hasOptimizedReplacement(); // the typeToReplace is my JITType

#endif

void jettison(Profiler::JettisonReason, ReoptimizationMode = DontCountReoptimization, const FireDetail* = nullptr);

ScriptExecutable* ownerExecutable() const LIFETIME_BOUND { return m_ownerExecutable.get(); }

VM& vm() const { return *m_vm; }

VirtualRegister thisRegister() const { return m_unlinkedCode->thisRegister(); }

void setScopeRegister(VirtualRegister scopeRegister)

{

ASSERT(scopeRegister.isLocal() || !scopeRegister.isValid());

m_scopeRegister = scopeRegister;

}

VirtualRegister scopeRegister() const

{

return m_scopeRegister;

}

PutPropertySlot::Context putByIdContext() const

{

if (codeType() == EvalCode)

return PutPropertySlot::PutByIdEval;

return PutPropertySlot::PutById;

}

const SourceCode& source() const LIFETIME_BOUND { return m_ownerExecutable->source(); }

unsigned sourceOffset() const { return m_ownerExecutable->source().startOffset(); }

String nameForRegister(VirtualRegister);

static constexpr ptrdiff_t offsetOfArgumentValueProfiles() { return OBJECT_OFFSETOF(CodeBlock, m_argumentValueProfiles); }

unsigned numberOfArgumentValueProfiles()

{

ASSERT(m_argumentValueProfiles.size() == static_cast<unsigned>(m_numParameters) || !Options::useJIT() || !JITCode::isBaselineCode(jitType()));

return m_argumentValueProfiles.size();

}

ArgumentValueProfile& valueProfileForArgument(unsigned argumentIndex)

{

ASSERT(Options::useJIT()); // This is only called from the various JIT compilers or places that first check numberOfArgumentValueProfiles before calling this.

ASSERT(JITCode::isBaselineCode(jitType()));

return m_argumentValueProfiles[argumentIndex];

}

FixedVector<ArgumentValueProfile>& argumentValueProfiles() LIFETIME_BOUND { return m_argumentValueProfiles; }

ValueProfile& valueProfileForOffset(unsigned profileOffset) { return m_metadata->valueProfileForOffset(profileOffset); }

ValueProfile* LEGACY_NODELETE tryGetValueProfileForBytecodeIndex(BytecodeIndex);

ValueProfile& LEGACY_NODELETE valueProfileForBytecodeIndex(BytecodeIndex);

SpeculatedType valueProfilePredictionForBytecodeIndex(BytecodeIndex, JSValue* specFailValue = nullptr);

template<typename Functor> void forEachValueProfile(NOESCAPE const Functor&);

template<typename Functor> void forEachArrayAllocationProfile(NOESCAPE const Functor&);

template<typename Functor> void forEachObjectAllocationProfile(NOESCAPE const Functor&);

template<typename Functor> void forEachLLIntOrBaselineCallLinkInfo(NOESCAPE const Functor&);

BinaryArithProfile* LEGACY_NODELETE binaryArithProfileForBytecodeIndex(BytecodeIndex);

UnaryArithProfile* LEGACY_NODELETE unaryArithProfileForBytecodeIndex(BytecodeIndex);

BinaryArithProfile* LEGACY_NODELETE binaryArithProfileForPC(const JSInstruction*);

UnaryArithProfile* LEGACY_NODELETE unaryArithProfileForPC(const JSInstruction*);

bool LEGACY_NODELETE couldTakeSpecialArithFastCase(BytecodeIndex bytecodeOffset);

ArrayProfile* LEGACY_NODELETE getArrayProfile(BytecodeIndex);

// Exception handling support

size_t numberOfExceptionHandlers() const { return m_rareData ? m_rareData->m_exceptionHandlers.size() : 0; }

HandlerInfo& exceptionHandler(int index) { RELEASE_ASSERT(m_rareData); return m_rareData->m_exceptionHandlers[index]; }

bool hasExpressionInfo() { return m_unlinkedCode->hasExpressionInfo(); }

#if ENABLE(DFG_JIT)

DFG::CodeOriginPool& codeOrigins();

// Having code origins implies that there has been some inlining.

bool hasCodeOrigins()

{

return JSC::JITCode::isOptimizingJIT(jitType());

}

bool canGetCodeOrigin(CallSiteIndex index)

{

if (!hasCodeOrigins())

return false;

return index.bits() < codeOrigins().size();

}

CodeOrigin codeOrigin(CallSiteIndex index)

{

return codeOrigins().get(index.bits());

}

CompressedLazyValueProfileHolder& lazyValueProfiles()

{

return m_lazyValueProfiles;

}

#endif // ENABLE(DFG_JIT)

// Constant Pool

#if ENABLE(DFG_JIT)

size_t numberOfIdentifiers() const { return m_unlinkedCode->numberOfIdentifiers() + numberOfDFGIdentifiers(); }

size_t numberOfDFGIdentifiers() const;

const Identifier& identifier(int index) const;

#else

size_t numberOfIdentifiers() const { return m_unlinkedCode->numberOfIdentifiers(); }

const Identifier& identifier(int index) const { return m_unlinkedCode->identifier(index); }

#endif

#if ASSERT_ENABLED

bool hasIdentifier(UniquedStringImpl*);

bool wasDestructed();

#endif

Vector<WriteBarrier<Unknown>>& constants() LIFETIME_BOUND { return m_constantRegisters; }

unsigned addConstant(const ConcurrentJSLocker&, JSValue v)

{

unsigned result = m_constantRegisters.size();

m_constantRegisters.append(WriteBarrier<Unknown>());

m_constantRegisters.last().set(*m_vm, this, v);

return result;

}

unsigned addConstantLazily(const ConcurrentJSLocker&)

{

unsigned result = m_constantRegisters.size();

m_constantRegisters.append(WriteBarrier<Unknown>());

return result;

}

const Vector<WriteBarrier<Unknown>>& constantRegisters() LIFETIME_BOUND { return m_constantRegisters; }

WriteBarrier<Unknown>& constantRegister(VirtualRegister reg) { return m_constantRegisters[reg.toConstantIndex()]; }

ALWAYS_INLINE JSValue getConstant(VirtualRegister reg) const { return m_constantRegisters[reg.toConstantIndex()].get(); }

bool LEGACY_NODELETE isConstantOwnedByUnlinkedCodeBlock(VirtualRegister) const;

ALWAYS_INLINE SourceCodeRepresentation constantSourceCodeRepresentation(VirtualRegister reg) const { return m_unlinkedCode->constantSourceCodeRepresentation(reg); }

ALWAYS_INLINE SourceCodeRepresentation constantSourceCodeRepresentation(unsigned index) const { return m_unlinkedCode->constantSourceCodeRepresentation(index); }

static constexpr ptrdiff_t offsetOfConstantsVectorBuffer() { return OBJECT_OFFSETOF(CodeBlock, m_constantRegisters) + decltype(m_constantRegisters)::dataMemoryOffset(); }

FunctionExecutable* functionDecl(int index) { return m_functionDecls[index].get(); }

int numberOfFunctionDecls() { return m_functionDecls.size(); }

std::span<const WriteBarrier<FunctionExecutable>> functionDecls() { return m_functionDecls.span(); }

FunctionExecutable* functionExpr(int index) { return m_functionExprs[index].get(); }

std::span<const WriteBarrier<FunctionExecutable>> functionExprs() { return m_functionExprs.span(); }

const BitVector& bitVector(size_t i) LIFETIME_BOUND { return m_unlinkedCode->bitVector(i); }

JSC::Heap* heap() const LIFETIME_BOUND { return &m_vm->heap; }

JSGlobalObject* globalObject() LIFETIME_BOUND { return m_globalObject.get(); }

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

JSGlobalObject* globalObjectFor(CodeOrigin);

BytecodeLivenessAnalysis& livenessAnalysis()

{

return m_unlinkedCode->livenessAnalysis(this);

}

void validate();

// Jump Tables

#if ENABLE(JIT)

SimpleJumpTable& baselineSwitchJumpTable(int tableIndex);

StringJumpTable& baselineStringSwitchJumpTable(int tableIndex);

void setBaselineJITData(std::unique_ptr<BaselineJITData>&&);

BaselineJITData* baselineJITData()

{

if (!JSC::JITCode::isOptimizingJIT(jitType()))

return std::bit_cast<BaselineJITData*>(m_jitData);

return nullptr;

}

#if ENABLE(DFG_JIT)

void setDFGJITData(std::unique_ptr<DFG::JITData>&& jitData)

{

ASSERT(!m_jitData);

WTF::storeStoreFence(); // m_jitData is accessed from concurrent GC threads.

m_jitData = jitData.release();

checker().set(CrashChecker::DFGJITData, checker().hash(this, m_jitData));

}

DFG::JITData* dfgJITData()

{

if (JSC::JITCode::isOptimizingJIT(jitType()))

return std::bit_cast<DFG::JITData*>(m_jitData);

return nullptr;

}

#endif

#endif

size_t numberOfUnlinkedSwitchJumpTables() const { return m_unlinkedCode->numberOfUnlinkedSwitchJumpTables(); }

const UnlinkedSimpleJumpTable& unlinkedSwitchJumpTable(int tableIndex) LIFETIME_BOUND { return m_unlinkedCode->unlinkedSwitchJumpTable(tableIndex); }

#if ENABLE(DFG_JIT)

StringJumpTable& dfgStringSwitchJumpTable(int tableIndex);

SimpleJumpTable& dfgSwitchJumpTable(int tableIndex);

#endif

size_t numberOfUnlinkedStringSwitchJumpTables() const { return m_unlinkedCode->numberOfUnlinkedStringSwitchJumpTables(); }

const UnlinkedStringJumpTable& unlinkedStringSwitchJumpTable(int tableIndex) LIFETIME_BOUND { return m_unlinkedCode->unlinkedStringSwitchJumpTable(tableIndex); }

DirectEvalCodeCache& directEvalCodeCache() { createRareDataIfNecessary(); return m_rareData->m_directEvalCodeCache; }

enum class ShrinkMode {

// Shrink prior to generating machine code that may point directly into vectors.

EarlyShrink,

// Shrink after generating machine code, and after possibly creating new vectors

// and appending to others. At this time it is not safe to shrink certain vectors

// because we would have generated machine code that references them directly.

LateShrink,

};

void shrinkToFit(const ConcurrentJSLocker&, ShrinkMode);

// Functions for controlling when JITting kicks in, in a mixed mode

// execution world.

bool checkIfJITThresholdReached();

void dontJITAnytimeSoon()

{

m_unlinkedCode->llintExecuteCounter().deferIndefinitely();

}

void jitSoon();

void jitNextInvocation();

const BaselineExecutionCounter& llintExecuteCounter() const

{

return m_unlinkedCode->llintExecuteCounter();

}

typedef UncheckedKeyHashMap<std::tuple<StructureID, BytecodeIndex>, FixedVector<LLIntPrototypeLoadAdaptiveStructureWatchpoint>> StructureWatchpointMap;

StructureWatchpointMap& llintGetByIdWatchpointMap() LIFETIME_BOUND { return m_llintGetByIdWatchpointMap; }

// Functions for controlling when tiered compilation kicks in. This

// controls both when the optimizing compiler is invoked and when OSR

// entry happens. Two triggers exist: the loop trigger and the return

// trigger. In either case, when an addition to m_jitExecuteCounter

// causes it to become non-negative, the optimizing compiler is

// invoked. This includes a fast check to see if this CodeBlock has

// already been optimized (i.e. replacement() returns a CodeBlock

// that was optimized with a higher tier JIT than this one). In the

// case of the loop trigger, if the optimized compilation succeeds

// (or has already succeeded in the past) then OSR is attempted to

// redirect program flow into the optimized code.

// These functions are called from within the optimization triggers,

// and are used as a single point at which we define the heuristics

// for how much warm-up is mandated before the next optimization

// trigger files. All CodeBlocks start out with optimizeAfterWarmUp(),

// as this is called from the CodeBlock constructor.

// When we observe a lot of speculation failures, we trigger a

// reoptimization. But each time, we increase the optimization trigger

// to avoid thrashing.

JS_EXPORT_PRIVATE unsigned LEGACY_NODELETE reoptimizationRetryCounter() const;

void LEGACY_NODELETE countReoptimization();

#if !ENABLE(C_LOOP)

static unsigned numberOfLLIntBaselineCalleeSaveRegisters() { return RegisterSet::llintBaselineCalleeSaveRegisters().numberOfSetRegisters(); }

static size_t llintBaselineCalleeSaveSpaceAsVirtualRegisters();

static size_t LEGACY_NODELETE calleeSaveSpaceAsVirtualRegisters(const RegisterAtOffsetList&);

#else

static unsigned numberOfLLIntBaselineCalleeSaveRegisters() { return 0; }

static size_t llintBaselineCalleeSaveSpaceAsVirtualRegisters() { return 1; };

static size_t calleeSaveSpaceAsVirtualRegisters(const RegisterAtOffsetList&) { return 0; }

#endif

#if ENABLE(JIT)

unsigned LEGACY_NODELETE numberOfDFGCompiles();

int32_t LEGACY_NODELETE codeTypeThresholdMultiplier() const;

int32_t adjustedCounterValue(int32_t desiredThreshold);

const BaselineExecutionCounter& baselineExecuteCounter();

unsigned optimizationDelayCounter() const { return m_optimizationDelayCounter; }

// Check if the optimization threshold has been reached, and if not,

// adjust the heuristics accordingly. Returns true if the threshold has

// been reached.

bool checkIfOptimizationThresholdReached();

// Call this to force the next optimization trigger to fire. This is

// rarely wise, since optimization triggers are typically more

// expensive than executing baseline code.

void optimizeNextInvocation();

// Call this to prevent optimization from happening again. Note that

// optimization will still happen after roughly 2^29 invocations,

// so this is really meant to delay that as much as possible. This

// is called if optimization failed, and we expect it to fail in

// the future as well.

void dontOptimizeAnytimeSoon();

// Call this to reinitialize the counter to its starting state,

// forcing a warm-up to happen before the next optimization trigger

// fires. This is called in the CodeBlock constructor. It also

// makes sense to call this if an OSR exit occurred. Note that

// OSR exit code is code generated, so the value of the execute

// counter that this corresponds to is also available directly.

void optimizeAfterWarmUp();

void optimizeAfterWarmUpIgnoreQuickTierUp();

// Call this to force an optimization trigger to fire only after

// a lot of warm-up.

void optimizeAfterLongWarmUp();

// Call this to cause an optimization trigger to fire soon, but

// not necessarily the next one. This makes sense if optimization

// succeeds. Successful optimization means that all calls are

// relinked to the optimized code, so this only affects call

// frames that are still executing this CodeBlock. The value here

// is tuned to strike a balance between the cost of OSR entry

// (which is too high to warrant making every loop back edge to

// trigger OSR immediately) and the cost of executing baseline

// code (which is high enough that we don't necessarily want to

// have a full warm-up). The intuition for calling this instead of

// optimizeNextInvocation() is for the case of recursive functions

// with loops. Consider that there may be N call frames of some

// recursive function, for a reasonably large value of N. The top

// one triggers optimization, and then returns, and then all of

// the others return. We don't want optimization to be triggered on

// each return, as that would be superfluous. It only makes sense

// to trigger optimization if one of those functions becomes hot

// in the baseline code.

void optimizeSoon();

void forceOptimizationSlowPathConcurrently();

void setOptimizationThresholdBasedOnCompilationResult(CompilationResult);

BytecodeIndex LEGACY_NODELETE bytecodeIndexForExit(BytecodeIndex) const;

uint32_t osrExitCounter() const { return m_osrExitCounter; }

void countOSRExit() { m_osrExitCounter++; }

static constexpr ptrdiff_t offsetOfOSRExitCounter() { return OBJECT_OFFSETOF(CodeBlock, m_osrExitCounter); }

uint32_t LEGACY_NODELETE adjustedExitCountThreshold(uint32_t desiredThreshold);

uint32_t LEGACY_NODELETE exitCountThresholdForReoptimization();

uint32_t LEGACY_NODELETE exitCountThresholdForReoptimizationFromLoop();

bool LEGACY_NODELETE shouldReoptimizeNow();

bool LEGACY_NODELETE shouldReoptimizeFromLoopNow();

void LEGACY_NODELETE didInstallDFGCode();

void LEGACY_NODELETE didDFGJettison(Profiler::JettisonReason);

void LEGACY_NODELETE didFailDFGCompilation();

#if ENABLE(FTL_JIT)

void LEGACY_NODELETE didInstallFTLCode();

void LEGACY_NODELETE didFTLJettison(Profiler::JettisonReason);

void LEGACY_NODELETE didFailFTLCompilation();

#endif

#else // No JIT

void optimizeAfterWarmUp() { }

void optimizeAfterWarmUpIgnoreQuickTierUp() { }

unsigned numberOfDFGCompiles() { return 0; }

#endif

bool shouldOptimizeNowFromBaseline();

void updateAllNonLazyValueProfilePredictions();

void updateAllLazyValueProfilePredictions();

void updateAllArrayProfilePredictions();

void updateAllArrayAllocationProfilePredictions();

void updateAllPredictions();

void updatePredictionsConcurrently();

unsigned frameRegisterCount();

int stackPointerOffset();

bool hasOpDebugForLineAndColumn(unsigned line, std::optional<unsigned> column);

bool hasDebuggerRequests() const { return m_debuggerRequests; }

static constexpr ptrdiff_t offsetOfDebuggerRequests() { return OBJECT_OFFSETOF(CodeBlock, m_debuggerRequests); }

void addBreakpoint(unsigned numBreakpoints);

void removeBreakpoint(unsigned numBreakpoints)

{

ASSERT(m_numBreakpoints >= numBreakpoints);

m_numBreakpoints -= numBreakpoints;

}

bool isJettisoned() const { return m_isJettisoned; }

enum SteppingMode {

SteppingModeDisabled,

SteppingModeEnabled

};

void setSteppingMode(SteppingMode);

void clearDebuggerRequests()

{

m_steppingMode = SteppingModeDisabled;

m_numBreakpoints = 0;

}

bool wasCompiledWithDebuggingOpcodes() const { return m_unlinkedCode->wasCompiledWithDebuggingOpcodes(); }

// This is intentionally public; it's the responsibility of anyone doing any

// of the following to hold the lock:

//

// - Modifying any inline cache in this code block.

//

// - Quering any inline cache in this code block, from a thread other than

// the main thread.

//

// Additionally, it's only legal to modify the inline cache on the main

// thread. This means that the main thread can query the inline cache without

// locking. This is crucial since executing the inline cache is effectively

// "querying" it.

//

// Another exception to the rules is that the GC can do whatever it wants

// without holding any locks, because the GC is guaranteed to wait until any

// concurrent compilation threads finish what they're doing.

mutable ConcurrentJSLock m_lock;

#if ENABLE(JIT)

unsigned m_capabilityLevelState : 2; // DFG::CapabilityLevel

#endif

bool m_didFailJITCompilation : 1;

bool m_didFailFTLCompilation : 1;

bool m_hasBeenCompiledWithFTL : 1;

bool m_isJettisoned : 1;

bool m_visitChildrenSkippedDueToOldAge { false };

// Internal methods for use by validation code. It would be private if it wasn't

// for the fact that we use it from anonymous namespaces.

void beginValidationDidFail();

NO_RETURN_DUE_TO_CRASH void endValidationDidFail();

struct RareData {

WTF_DEPRECATED_MAKE_STRUCT_FAST_ALLOCATED_WITH_HEAP_IDENTIFIER(RareData, CodeBlockRareData);

public:

Vector<HandlerInfo> m_exceptionHandlers;

DirectEvalCodeCache m_directEvalCodeCache;

};

void clearExceptionHandlers()

{

if (m_rareData)

m_rareData->m_exceptionHandlers.clear();

}

void appendExceptionHandler(const HandlerInfo& handler)

{

createRareDataIfNecessary(); // We may be handling the exception of an inlined call frame.

m_rareData->m_exceptionHandlers.append(handler);

}

DisposableCallSiteIndex newExceptionHandlingCallSiteIndex(CallSiteIndex originalCallSite);

void ensureCatchLivenessIsComputedForBytecodeIndex(BytecodeIndex);

bool hasTailCalls() const { return m_unlinkedCode->hasTailCalls(); }

template<typename Metadata>

Metadata& metadata(OpcodeID opcodeID, unsigned metadataID)

{

ASSERT(m_metadata);

ASSERT_UNUSED(opcodeID, opcodeID == Metadata::opcodeID);

return m_metadata->get<Metadata>()[metadataID];

}

template<typename Metadata>

ptrdiff_t offsetInMetadataTable(Metadata* metadata)

{

return std::bit_cast<uint8_t*>(metadata) - std::bit_cast<uint8_t*>(metadataTable());

}

size_t metadataSizeInBytes()

{

return m_unlinkedCode->metadataSizeInBytes();

}

MetadataTable* metadataTable() { return m_metadata.get(); }

const void* instructionsRawPointer() { return m_instructionsRawPointer; }

static constexpr ptrdiff_t offsetOfMetadataTable() { return OBJECT_OFFSETOF(CodeBlock, m_metadata); }

static constexpr ptrdiff_t offsetOfInstructionsRawPointer() { return OBJECT_OFFSETOF(CodeBlock, m_instructionsRawPointer); }

bool loopHintsAreEligibleForFuzzingEarlyReturn() { return m_unlinkedCode->loopHintsAreEligibleForFuzzingEarlyReturn(); }

double optimizationThresholdScalingFactor() const;

void reconcileLLIntInlineCachesAtGCEnd();

#if ENABLE(JIT)

void reconcileJITInlineCachesAtGCEnd();

#endif

#if ENABLE(DFG_JIT)

void tallyFrequentExitSites();

#else

void tallyFrequentExitSites() { }

#endif

friend class CodeBlockSet;

friend class FunctionExecutable;

friend class ScriptExecutable;

enum class QuickTierUpCheck : bool { Apply, Ignore };

template<QuickTierUpCheck> void optimizeAfterWarmUpImpl();

template<typename Visitor> ALWAYS_INLINE void visitChildren(Visitor&);

BytecodeLivenessAnalysis& livenessAnalysisSlow();

CodeBlock* specialOSREntryBlockOrNull();

void noticeIncomingCall(JSCell* caller);

void updateAllNonLazyValueProfilePredictionsAndCountLiveness(unsigned& numberOfLiveNonArgumentValueProfiles, unsigned& numberOfSamplesInProfiles);

Vector<unsigned> setConstantRegisters(const FixedVector<WriteBarrier<Unknown>>& constants, const FixedVector<SourceCodeRepresentation>& constantsSourceCodeRepresentation);

void initializeTemplateObjects(ScriptExecutable* topLevelExecutable, const Vector<unsigned>& templateObjectIndices);

void replaceConstant(VirtualRegister reg, JSValue value)

{

ASSERT(reg.isConstant() && static_cast<size_t>(reg.toConstantIndex()) < m_constantRegisters.size());

m_constantRegisters[reg.toConstantIndex()].set(*m_vm, this, value);

}

template<typename Visitor> bool shouldVisitStrongly(const ConcurrentJSLocker&, Visitor&);

bool shouldJettisonDueToWeakReference(VM&);

template<typename Visitor> bool shouldJettisonDueToOldAge(const ConcurrentJSLocker&, Visitor&);

template<typename Visitor> void propagateTransitions(const ConcurrentJSLocker&, Visitor&);

template<typename Visitor> void determineLiveness(const ConcurrentJSLocker&, Visitor&);

template<typename Visitor> void stronglyVisitStrongReferences(const ConcurrentJSLocker&, Visitor&);

template<typename Visitor> void stronglyVisitWeakReferences(const ConcurrentJSLocker&, Visitor&);

template<typename Visitor> void visitOSRExitTargets(const ConcurrentJSLocker&, Visitor&);

unsigned numberOfNonArgumentValueProfiles() { return totalNumberOfValueProfiles() - numberOfArgumentValueProfiles(); }

unsigned totalNumberOfValueProfiles() { return m_unlinkedCode->numberOfValueProfiles(); }

Seconds timeSinceCreation()

{

return ApproximateTime::now() - m_creationTime;

}

void createRareDataIfNecessary()

{

if (!m_rareData) {

auto rareData = makeUnique<RareData>();

WTF::storeStoreFence();

m_rareData = WTF::move(rareData);

}

}

void insertBasicBlockBoundariesForControlFlowProfiler();

void ensureCatchLivenessIsComputedForBytecodeIndexSlow(const OpCatch&, BytecodeIndex);

template<typename Func>

void forEachPropertyInlineCache(Func);

const unsigned m_numCalleeLocals;

const unsigned m_numVars;

unsigned m_numParameters;

union {

// The LLInt reads this union as a word and tests the sign bit to check m_couldBeTainted.

unsigned m_numberOfArgumentsToSkipAndCouldBeTainted { 0 };

struct {

unsigned m_numberOfArgumentsToSkip : 31;

unsigned m_couldBeTainted : 1;

};

};

uint32_t m_osrExitCounter { 0 };

union {

unsigned m_debuggerRequests;

struct {

unsigned m_hasDebuggerStatement : 1;

unsigned m_steppingMode : 1;

unsigned m_numBreakpoints : 30;

};

};

unsigned m_bytecodeCost { 0 };

VirtualRegister m_scopeRegister;

mutable CodeBlockHash m_hash;

WriteBarrier<UnlinkedCodeBlock> m_unlinkedCode;

WriteBarrier<ScriptExecutable> m_ownerExecutable;

// m_vm must be a pointer (instead of a reference) because the JSCLLIntOffsetsExtractor

// cannot handle it being a reference.

VM* const m_vm;

const void* const m_instructionsRawPointer { nullptr };

SentinelLinkedList<CallLinkInfoBase, BasicRawSentinelNode<CallLinkInfoBase>> m_incomingCalls;

uint16_t m_optimizationDelayCounter { 0 };

uint16_t m_reoptimizationRetryCounter { 0 };

float m_previousCounter { 0 };

StructureWatchpointMap m_llintGetByIdWatchpointMap;

RefPtr<JSC::JITCode> m_jitCode;

#if ENABLE(JIT)

void* m_jitData { nullptr };

#endif

RefPtr<MetadataTable> m_metadata;

#if ENABLE(DFG_JIT)

// This is relevant to non-DFG code blocks that serve as the profiled code block

// for DFG code blocks.

CompressedLazyValueProfileHolder m_lazyValueProfiles;

#endif

FixedVector<ArgumentValueProfile> m_argumentValueProfiles;

// Constant Pool

static_assert(sizeof(Register) == sizeof(WriteBarrier<Unknown>), "Register must be same size as WriteBarrier Unknown");