{

using namespace DFG;

Graph& graph = state.graph;

CodeBlock* codeBlock = graph.m_codeBlock;

VM& vm = graph.m_vm;

// B3 will create its own jump tables as needed.

codeBlock->clearSwitchJumpTables();

state.jitCode->common.requiredRegisterCountForExit = graph.requiredRegisterCountForExit();

if (!graph.m_plan.inlineCallFrames()->isEmpty())

state.jitCode->common.inlineCallFrames = graph.m_plan.inlineCallFrames();

graph.registerFrozenValues();

// Create the entrypoint. Note that we use this entrypoint totally differently

// depending on whether we're doing OSR entry or not.

CCallHelpers jit(codeBlock);

std::unique_ptr<LinkBuffer> linkBuffer;

CCallHelpers::Address frame = CCallHelpers::Address(

CCallHelpers::stackPointerRegister, -static_cast<int32_t>(AssemblyHelpers::prologueStackPointerDelta()));

Profiler::Compilation* compilation = graph.compilation();

if (UNLIKELY(compilation)) {

compilation->addDescription(

Profiler::OriginStack(),

toCString("Generated FTL JIT code for ", CodeBlockWithJITType(codeBlock, JITType::FTLJIT), ", instructions size = ", graph.m_codeBlock->instructionsSize(), ":\n"));

graph.ensureSSADominators();

graph.ensureSSANaturalLoops();

const char* prefix = " ";

DumpContext dumpContext;

StringPrintStream out;

Node* lastNode = nullptr;

for (size_t blockIndex = 0; blockIndex < graph.numBlocks(); ++blockIndex) {

BasicBlock* block = graph.block(blockIndex);

if (!block)

continue;

graph.dumpBlockHeader(out, prefix, block, Graph::DumpLivePhisOnly, &dumpContext);

compilation->addDescription(Profiler::OriginStack(), out.toCString());

out.reset();

for (size_t nodeIndex = 0; nodeIndex < block->size(); ++nodeIndex) {

Node* node = block->at(nodeIndex);

Profiler::OriginStack stack;

if (node->origin.semantic.isSet()) {

stack = Profiler::OriginStack(

*vm.m_perBytecodeProfiler, codeBlock, node->origin.semantic);

}

if (graph.dumpCodeOrigin(out, prefix, lastNode, node, &dumpContext)) {

compilation->addDescription(stack, out.toCString());

out.reset();

}

graph.dump(out, prefix, node, &dumpContext);

compilation->addDescription(stack, out.toCString());

out.reset();

if (node->origin.semantic.isSet())

lastNode = node;

}

}

dumpContext.dump(out, prefix);

compilation->addDescription(Profiler::OriginStack(), out.toCString());

out.reset();

out.print(" Disassembly:\n");

out.print(" <not implemented yet>\n");

compilation->addDescription(Profiler::OriginStack(), out.toCString());

out.reset();

state.jitCode->common.compilation = compilation;

}

switch (graph.m_plan.mode()) {

case FTLMode: {

bool requiresArityFixup = codeBlock->numParameters() != 1;

if (codeBlock->codeType() == FunctionCode && requiresArityFixup) {

CCallHelpers::JumpList mainPathJumps;

jit.load32(

frame.withOffset(sizeof(Register) * CallFrameSlot::argumentCountIncludingThis),

GPRInfo::regT1);

mainPathJumps.append(jit.branch32(

CCallHelpers::AboveOrEqual, GPRInfo::regT1,

CCallHelpers::TrustedImm32(codeBlock->numParameters())));

jit.emitFunctionPrologue();

jit.move(CCallHelpers::TrustedImmPtr(codeBlock->globalObject()), GPRInfo::argumentGPR0);

jit.storePtr(GPRInfo::callFrameRegister, &vm.topCallFrame);

CCallHelpers::Call callArityCheck = jit.call(OperationPtrTag);

auto noException = jit.branch32(CCallHelpers::GreaterThanOrEqual, GPRInfo::returnValueGPR, CCallHelpers::TrustedImm32(0));

jit.copyCalleeSavesToEntryFrameCalleeSavesBuffer(vm.topEntryFrame);

jit.move(CCallHelpers::TrustedImmPtr(&vm), GPRInfo::argumentGPR0);

jit.prepareCallOperation(vm);

CCallHelpers::Call callLookupExceptionHandlerFromCallerFrame = jit.call(OperationPtrTag);

jit.jumpToExceptionHandler(vm);

noException.link(&jit);

if (ASSERT_ENABLED) {

jit.load64(vm.addressOfException(), GPRInfo::regT1);

jit.jitAssertIsNull(GPRInfo::regT1);

}

jit.move(GPRInfo::returnValueGPR, GPRInfo::argumentGPR0);

jit.emitFunctionEpilogue();

jit.untagReturnAddress();

mainPathJumps.append(jit.branchTest32(CCallHelpers::Zero, GPRInfo::argumentGPR0));

jit.emitFunctionPrologue();

CCallHelpers::Call callArityFixup = jit.nearCall();

jit.emitFunctionEpilogue();

jit.untagReturnAddress();

mainPathJumps.append(jit.jump());

linkBuffer = makeUnique<LinkBuffer>(jit, codeBlock, JITCompilationCanFail);

if (linkBuffer->didFailToAllocate()) {

state.allocationFailed = true;

return;

}

linkBuffer->link(callArityCheck, FunctionPtr<OperationPtrTag>(codeBlock->isConstructor() ? operationConstructArityCheck : operationCallArityCheck));

linkBuffer->link(callLookupExceptionHandlerFromCallerFrame, FunctionPtr<OperationPtrTag>(operationLookupExceptionHandlerFromCallerFrame));

linkBuffer->link(callArityFixup, FunctionPtr<JITThunkPtrTag>(vm.getCTIStub(arityFixupGenerator).code()));

linkBuffer->link(mainPathJumps, state.generatedFunction);

}

state.jitCode->initializeAddressForCall(state.generatedFunction);

break;

}

case FTLForOSREntryMode: {

// We jump to here straight from DFG code, after having boxed up all of the

// values into the scratch buffer. Everything should be good to go - at this

// point we've even done the stack check. Basically we just have to make the

// call to the B3-generated code.

CCallHelpers::Label start = jit.label();

jit.emitFunctionEpilogue();

jit.untagReturnAddress();

CCallHelpers::Jump mainPathJump = jit.jump();

linkBuffer = makeUnique<LinkBuffer>(jit, codeBlock, JITCompilationCanFail);

if (linkBuffer->didFailToAllocate()) {

state.allocationFailed = true;

return;

}

linkBuffer->link(mainPathJump, state.generatedFunction);

state.jitCode->initializeAddressForCall(linkBuffer->locationOf<JSEntryPtrTag>(start));

break;

}

default:

RELEASE_ASSERT_NOT_REACHED();

break;

}

state.finalizer->entrypointLinkBuffer = WTFMove(linkBuffer);

state.finalizer->function = state.generatedFunction;

state.finalizer->jitCode = state.jitCode;