#include "config.h"

#include "CodeBlock.h"

#include "ArithProfile.h"

#include "BasicBlockLocation.h"

#include "ByValInfo.h"

#include "BytecodeDumper.h"

#include "BytecodeLivenessAnalysisInlines.h"

#include "BytecodeOperandsForCheckpoint.h"

#include "BytecodeStructs.h"

#include "CodeBlockInlines.h"

#include "CodeBlockSet.h"

#include "ControlFlowProfiler.h"

#include "DFGCapabilities.h"

#include "DFGCommon.h"

#include "DFGJITCode.h"

#include "DFGWorklist.h"

#include "EvalCodeBlock.h"

#include "FullCodeOrigin.h"

#include "FunctionCodeBlock.h"

#include "FunctionExecutableDump.h"

#include "GetPutInfo.h"

#include "InlineCallFrame.h"

#include "Instruction.h"

#include "InstructionStream.h"

#include "IsoCellSetInlines.h"

#include "JIT.h"

#include "JITMathIC.h"

#include "JSCInlines.h"

#include "JSCJSValue.h"

#include "JSLexicalEnvironment.h"

#include "JSModuleEnvironment.h"

#include "JSSet.h"

#include "JSString.h"

#include "JSTemplateObjectDescriptor.h"

#include "LLIntData.h"

#include "LLIntEntrypoint.h"

#include "LLIntExceptions.h"

#include "LLIntPrototypeLoadAdaptiveStructureWatchpoint.h"

#include "MetadataTable.h"

#include "ModuleProgramCodeBlock.h"

#include "ObjectAllocationProfileInlines.h"

#include "PCToCodeOriginMap.h"

#include "ProfilerDatabase.h"

#include "ProgramCodeBlock.h"

#include "ReduceWhitespace.h"

#include "SlotVisitorInlines.h"

#include "StackVisitor.h"

#include "StructureStubInfo.h"

#include "TypeLocationCache.h"

#include "TypeProfiler.h"

#include "VMInlines.h"

#include <wtf/Forward.h>

#include <wtf/SimpleStats.h>

#include <wtf/StringPrintStream.h>

#include <wtf/text/UniquedStringImpl.h>

#if ENABLE(ASSEMBLER)

#include "RegisterAtOffsetList.h"

#endif

#if ENABLE(FTL_JIT)

#include "FTLJITCode.h"

#endif

namespace JSC {

DEFINE_ALLOCATOR_WITH_HEAP_IDENTIFIER(CodeBlockRareData);

const ClassInfo CodeBlock::s_info = {

"CodeBlock", nullptr, nullptr, nullptr,

CREATE_METHOD_TABLE(CodeBlock)

};

CString CodeBlock::inferredName() const

}

bool CodeBlock::hasHash() const

{

return !!m_hash;

}

bool CodeBlock::isSafeToComputeHash() const

{

return !isCompilationThread();

}

CodeBlockHash CodeBlock::hash() const

}

CString CodeBlock::sourceCodeForTools() const

}

CString CodeBlock::sourceCodeOnOneLine() const

{

return reduceWhitespace(sourceCodeForTools());

}

CString CodeBlock::hashAsStringIfPossible() const

}

void CodeBlock::dumpAssumingJITType(PrintStream& out, JITType jitType) const

}

void CodeBlock::dump(PrintStream& out) const

{

dumpAssumingJITType(out, jitType());

}

void CodeBlock::dumpSource()

{

dumpSource(WTF::dataFile());

}

void CodeBlock::dumpSource(PrintStream& out)

}

void CodeBlock::dumpBytecode()

{

dumpBytecode(WTF::dataFile());

}

void CodeBlock::dumpBytecode(PrintStream& out)

}

void CodeBlock::dumpBytecode(PrintStream& out, const InstructionStream::Ref& it, const ICStatusMap& statusMap)

{

BytecodeDumper<CodeBlock>::dumpBytecode(this, out, it, statusMap);

}

void CodeBlock::dumpBytecode(PrintStream& out, unsigned bytecodeOffset, const ICStatusMap& statusMap)

}

namespace {

class PutToScopeFireDetail final : public FireDetail {

};

} // anonymous namespace

CodeBlock::CodeBlock(VM& vm, Structure* structure, CopyParsedBlockTag, CodeBlock& other)

}

void CodeBlock::finishCreation(VM& vm, CopyParsedBlockTag, CodeBlock& other)

}

CodeBlock::CodeBlock(VM& vm, Structure* structure, ScriptExecutable* ownerExecutable, UnlinkedCodeBlock* unlinkedCodeBlock, JSScope* scope)

}

bool CodeBlock::finishCreation(VM& vm, ScriptExecutable* ownerExecutable, UnlinkedCodeBlock* unlinkedCodeBlock,

}

void CodeBlock::finishCreationCommon(VM& vm)

{

m_ownerEdge.set(vm, this, ExecutableToCodeBlockEdge::create(vm, this));

}

CodeBlock::~CodeBlock()

{

VM& vm = *m_vm;

// We use unvalidatedGet because get() has a validation assertion that rejects access.

// This assertion is correct since destruction order of cells is not guaranteed, and member cells could already be destroyed.

// But for CodeBlock, we are ensuring the order: CodeBlock gets destroyed before UnlinkedCodeBlock gets destroyed.

// So, we can access member UnlinkedCodeBlock safely here. We bypass the assertion by using unvalidatedGet.

UnlinkedCodeBlock* unlinkedCodeBlock = m_unlinkedCode.unvalidatedGet();

if (UNLIKELY(Options::returnEarlyFromInfiniteLoopsForFuzzing() && JITCode::isBaselineCode(jitType()))) {

for (const auto& instruction : unlinkedCodeBlock->instructions()) {

if (instruction->is<OpLoopHint>())

vm.removeLoopHintExecutionCounter(instruction.ptr());

}

}

#if ENABLE(DFG_JIT)

// The JITCode (and its corresponding DFG::CommonData) may outlive the CodeBlock by

// a short amount of time after the CodeBlock is destructed. For example, the

// Interpreter::execute methods will ref JITCode before invoking it. This can

// result in the JITCode having a non-zero refCount when its owner CodeBlock is

// destructed.

//

// Hence, we cannot rely on DFG::CommonData destruction to clear these now invalid

// watchpoints in a timely manner. We'll ensure they are cleared here eagerly.

//

// We only need to do this for a DFG/FTL CodeBlock because only these will have a

// DFG:CommonData. Hence, the LLInt and Baseline will not have any of these watchpoints.

//

// Note also that the LLIntPrototypeLoadAdaptiveStructureWatchpoint is also related

// to the CodeBlock. However, its lifecycle is tied directly to the CodeBlock, and

// will be automatically cleared when the CodeBlock destructs.

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

jitCode()->dfgCommon()->clearWatchpoints();

#endif

vm.heap.codeBlockSet().remove(this);

if (UNLIKELY(vm.m_perBytecodeProfiler))

vm.m_perBytecodeProfiler->notifyDestruction(this);

if (!vm.heap.isShuttingDown() && unlinkedCodeBlock->didOptimize() == TriState::Indeterminate)

unlinkedCodeBlock->setDidOptimize(TriState::False);

#if ENABLE(VERBOSE_VALUE_PROFILE)

dumpValueProfiles();

#endif

// We may be destroyed before any CodeBlocks that refer to us are destroyed.

// Consider that two CodeBlocks become unreachable at the same time. There

// is no guarantee about the order in which the CodeBlocks are destroyed.

// So, if we don't remove incoming calls, and get destroyed before the

// CodeBlock(s) that have calls into us, then the CallLinkInfo vector's

// destructor will try to remove nodes from our (no longer valid) linked list.

unlinkIncomingCalls();

// Note that our outgoing calls will be removed from other CodeBlocks'

// m_incomingCalls linked lists through the execution of the ~CallLinkInfo

// destructors.

#if ENABLE(JIT)

if (auto* jitData = m_jitData.get()) {

for (StructureStubInfo* stubInfo : jitData->m_stubInfos) {

stubInfo->aboutToDie();

stubInfo->deref();

}

}

#endif // ENABLE(JIT)

}

void CodeBlock::setConstantIdentifierSetRegisters(VM& vm, const RefCountedArray<ConstantIdentifierSetEntry>& constants)

}

void CodeBlock::setConstantRegisters(const RefCountedArray<WriteBarrier<Unknown>>& constants, const RefCountedArray<SourceCodeRepresentation>& constantsSourceCodeRepresentation, ScriptExecutable* topLevelExecutable)

}

void CodeBlock::setAlternative(VM& vm, CodeBlock* alternative)

}

void CodeBlock::setNumParameters(int newValue)

}

CodeBlock* CodeBlock::specialOSREntryBlockOrNull()

{

#if ENABLE(FTL_JIT)

if (jitType() != JITType::DFGJIT)

return nullptr;

DFG::JITCode* jitCode = m_jitCode->dfg();

return jitCode->osrEntryBlock();

#else // ENABLE(FTL_JIT)

return 0;

#endif // ENABLE(FTL_JIT)

}

size_t CodeBlock::estimatedSize(JSCell* cell, VM& vm)

}