: m_stackmapID(UINT_MAX)

, m_node(nullptr)

, m_instructionOffset(UINT_MAX)

{

: m_stackmapID(stackmapID)

, m_node(node)

, m_callBase(

(node->op() == ConstructVarargs || node->op() == ConstructForwardVarargs)

? CallLinkInfo::ConstructVarargs : CallLinkInfo::CallVarargs,

node->origin.semantic)

, m_instructionOffset(0)

{

ASSERT(

node->op() == CallVarargs || node->op() == CallForwardVarargs

|| node->op() == ConstructVarargs || node->op() == ConstructForwardVarargs);

{

// We are passed three pieces of information:

// - The callee.

// - The arguments object, if it's not a forwarding call.

// - The "this" value, if it's a constructor call.

CallVarargsData* data = m_node->callVarargsData();

GPRReg calleeGPR = GPRInfo::argumentGPR0;

GPRReg argumentsGPR = InvalidGPRReg;

GPRReg thisGPR = InvalidGPRReg;

bool forwarding = false;

switch (m_node->op()) {

case CallVarargs:

case ConstructVarargs:

argumentsGPR = GPRInfo::argumentGPR1;

thisGPR = GPRInfo::argumentGPR2;

break;

case CallForwardVarargs:

case ConstructForwardVarargs:

thisGPR = GPRInfo::argumentGPR1;

forwarding = true;

break;

default:

RELEASE_ASSERT_NOT_REACHED();

break;

}

const unsigned calleeSpillSlot = 0;

const unsigned argumentsSpillSlot = 1;

const unsigned thisSpillSlot = 2;

const unsigned stackPointerSpillSlot = 3;

// Get some scratch registers.

RegisterSet usedRegisters;

usedRegisters.merge(RegisterSet::stackRegisters());

usedRegisters.merge(RegisterSet::reservedHardwareRegisters());

usedRegisters.merge(RegisterSet::calleeSaveRegisters());

usedRegisters.set(calleeGPR);

if (argumentsGPR != InvalidGPRReg)

usedRegisters.set(argumentsGPR);

ASSERT(thisGPR);

usedRegisters.set(thisGPR);

ScratchRegisterAllocator allocator(usedRegisters);

GPRReg scratchGPR1 = allocator.allocateScratchGPR();

GPRReg scratchGPR2 = allocator.allocateScratchGPR();

GPRReg scratchGPR3 = allocator.allocateScratchGPR();

RELEASE_ASSERT(!allocator.numberOfReusedRegisters());

auto computeUsedStack = [&] (GPRReg targetGPR, unsigned extra) {

if (isARM64()) {

// Have to do this the weird way because $sp on ARM64 means zero when used in a subtraction.

jit.move(CCallHelpers::stackPointerRegister, targetGPR);

jit.negPtr(targetGPR);

jit.addPtr(GPRInfo::callFrameRegister, targetGPR);

} else {

jit.move(GPRInfo::callFrameRegister, targetGPR);

jit.subPtr(CCallHelpers::stackPointerRegister, targetGPR);

}

if (extra)

jit.subPtr(CCallHelpers::TrustedImm32(extra), targetGPR);

jit.urshiftPtr(CCallHelpers::Imm32(3), targetGPR);

};

auto callWithExceptionCheck = [&] (void* callee) {

jit.move(CCallHelpers::TrustedImmPtr(callee), GPRInfo::nonPreservedNonArgumentGPR);

jit.call(GPRInfo::nonPreservedNonArgumentGPR);

m_exceptions.append(jit.emitExceptionCheck(AssemblyHelpers::NormalExceptionCheck, AssemblyHelpers::FarJumpWidth));

};

if (isARM64()) {

jit.move(CCallHelpers::stackPointerRegister, scratchGPR1);

jit.storePtr(scratchGPR1, CCallHelpers::addressFor(spillSlotsOffset + stackPointerSpillSlot));

} else

jit.storePtr(CCallHelpers::stackPointerRegister, CCallHelpers::addressFor(spillSlotsOffset + stackPointerSpillSlot));

unsigned extraStack = sizeof(CallerFrameAndPC) +

WTF::roundUpToMultipleOf(stackAlignmentBytes(), 5 * sizeof(void*));

if (forwarding) {

CCallHelpers::JumpList slowCase;

computeUsedStack(scratchGPR2, 0);

emitSetupVarargsFrameFastCase(jit, scratchGPR2, scratchGPR1, scratchGPR2, scratchGPR3, m_node->child2()->origin.semantic.inlineCallFrame, data->firstVarArgOffset, slowCase);

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

slowCase.link(&jit);

jit.subPtr(CCallHelpers::TrustedImm32(extraStack), CCallHelpers::stackPointerRegister);

jit.setupArgumentsExecState();

callWithExceptionCheck(bitwise_cast<void*>(operationThrowStackOverflowForVarargs));

jit.abortWithReason(DFGVarargsThrowingPathDidNotThrow);

done.link(&jit);

jit.move(calleeGPR, GPRInfo::regT0);

} else {

// Gotta spill the callee, arguments, and this because we will need them later and we will have some

// calls that clobber them.

jit.store64(calleeGPR, CCallHelpers::addressFor(spillSlotsOffset + calleeSpillSlot));

jit.store64(argumentsGPR, CCallHelpers::addressFor(spillSlotsOffset + argumentsSpillSlot));

jit.store64(thisGPR, CCallHelpers::addressFor(spillSlotsOffset + thisSpillSlot));

computeUsedStack(scratchGPR1, 0);

jit.subPtr(CCallHelpers::TrustedImm32(extraStack), CCallHelpers::stackPointerRegister);

jit.setupArgumentsWithExecState(argumentsGPR, scratchGPR1, CCallHelpers::TrustedImm32(data->firstVarArgOffset));

callWithExceptionCheck(bitwise_cast<void*>(operationSizeFrameForVarargs));

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

computeUsedStack(scratchGPR2, extraStack);

jit.load64(CCallHelpers::addressFor(spillSlotsOffset + argumentsSpillSlot), argumentsGPR);

emitSetVarargsFrame(jit, scratchGPR1, false, scratchGPR2, scratchGPR2);

jit.addPtr(CCallHelpers::TrustedImm32(-extraStack), scratchGPR2, CCallHelpers::stackPointerRegister);

jit.setupArgumentsWithExecState(scratchGPR2, argumentsGPR, CCallHelpers::TrustedImm32(data->firstVarArgOffset), scratchGPR1);

callWithExceptionCheck(bitwise_cast<void*>(operationSetupVarargsFrame));

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

jit.load64(CCallHelpers::addressFor(spillSlotsOffset + thisSpillSlot), thisGPR);

jit.load64(CCallHelpers::addressFor(spillSlotsOffset + calleeSpillSlot), GPRInfo::regT0);

}

jit.addPtr(CCallHelpers::TrustedImm32(sizeof(CallerFrameAndPC)), scratchGPR2, CCallHelpers::stackPointerRegister);

jit.store64(thisGPR, CCallHelpers::calleeArgumentSlot(0));

// Henceforth we make the call. The base FTL call machinery expects the callee in regT0 and for the

// stack frame to already be set up, which it is.

jit.store64(GPRInfo::regT0, CCallHelpers::calleeFrameSlot(JSStack::Callee));

m_callBase.emit(jit);

// Undo the damage we've done.

if (isARM64()) {

GPRReg scratchGPRAtReturn = CCallHelpers::selectScratchGPR(GPRInfo::returnValueGPR);

jit.loadPtr(CCallHelpers::addressFor(spillSlotsOffset + stackPointerSpillSlot), scratchGPRAtReturn);

jit.move(scratchGPRAtReturn, CCallHelpers::stackPointerRegister);

} else

jit.loadPtr(CCallHelpers::addressFor(spillSlotsOffset + stackPointerSpillSlot), CCallHelpers::stackPointerRegister);

{

m_callBase.link(vm, linkBuffer);

linkBuffer.link(m_exceptions, exceptionHandler);