VM& vm, FunctionPtr<CFunctionPtrTag> generationFunction, PtrTag resultTag, const char* name, unsigned extraPopsToRestore, FrameAndStackAdjustmentRequirement frameAndStackAdjustmentRequirement)

{

AssemblyHelpers jit(nullptr);

if (frameAndStackAdjustmentRequirement == FrameAndStackAdjustmentRequirement::Needed) {

// This needs to happen before we use the scratch buffer because this function also uses the scratch buffer.

adjustFrameAndStackInOSRExitCompilerThunk<FTL::JITCode>(jit, vm, JITType::FTLJIT);

}

// Note that the "return address" will be the ID that we pass to the generation function.

ptrdiff_t stackMisalignment = MacroAssembler::pushToSaveByteOffset();

// Pretend that we're a C call frame.

jit.pushToSave(MacroAssembler::framePointerRegister);

jit.move(MacroAssembler::stackPointerRegister, MacroAssembler::framePointerRegister);

stackMisalignment += MacroAssembler::pushToSaveByteOffset();

// Now create ourselves enough stack space to give saveAllRegisters() a scratch slot.

unsigned numberOfRequiredPops = 0;

do {

jit.pushToSave(GPRInfo::regT0);

stackMisalignment += MacroAssembler::pushToSaveByteOffset();

numberOfRequiredPops++;

} while (stackMisalignment % stackAlignmentBytes());

ScratchBuffer* scratchBuffer = vm.scratchBufferForSize(requiredScratchMemorySizeInBytes());

char* buffer = static_cast<char*>(scratchBuffer->dataBuffer());

saveAllRegisters(jit, buffer);

// Tell GC mark phase how much of the scratch buffer is active during call.

jit.move(MacroAssembler::TrustedImmPtr(scratchBuffer->addressOfActiveLength()), GPRInfo::nonArgGPR0);

jit.storePtr(MacroAssembler::TrustedImmPtr(requiredScratchMemorySizeInBytes()), GPRInfo::nonArgGPR0);

jit.loadPtr(GPRInfo::callFrameRegister, GPRInfo::argumentGPR0);

jit.peek(

GPRInfo::argumentGPR1,

(stackMisalignment - MacroAssembler::pushToSaveByteOffset()) / sizeof(void*));

jit.prepareCallOperation(vm);

MacroAssembler::Call functionCall = jit.call(OperationPtrTag);

// At this point we want to make a tail call to what was returned to us in the

// returnValueGPR. But at the same time as we do this, we must restore all registers.

// The way we will accomplish this is by arranging to have the tail call target in the

// return address "slot" (be it a register or the stack).

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

// Make sure we tell the GC that we're not using the scratch buffer anymore.

jit.move(MacroAssembler::TrustedImmPtr(scratchBuffer->addressOfActiveLength()), GPRInfo::regT1);

jit.storePtr(MacroAssembler::TrustedImmPtr(nullptr), GPRInfo::regT1);

// Prepare for tail call.

while (numberOfRequiredPops--)

jit.popToRestore(GPRInfo::regT1);

jit.popToRestore(MacroAssembler::framePointerRegister);

// When we came in here, there was an additional thing pushed to the stack. Some clients want it

// popped before proceeding.

while (extraPopsToRestore--)

jit.popToRestore(GPRInfo::regT1);

// Put the return address wherever the return instruction wants it. On all platforms, this

// ensures that the return address is out of the way of register restoration.

jit.restoreReturnAddressBeforeReturn(GPRInfo::regT0);

restoreAllRegisters(jit, buffer);

#if CPU(ARM64E)

jit.untagPtr(resultTag, AssemblyHelpers::linkRegister);

jit.tagReturnAddress();

#else

UNUSED_PARAM(resultTag);

#endif

jit.ret();

LinkBuffer patchBuffer(jit, GLOBAL_THUNK_ID);

patchBuffer.link(functionCall, generationFunction.retagged<OperationPtrTag>());

return FINALIZE_CODE(patchBuffer, JITThunkPtrTag, "%s", name);

{

unsigned extraPopsToRestore = 0;

return genericGenerationThunkGenerator(

vm, operationCompileFTLOSRExit, OSRExitPtrTag, "FTL OSR exit generation thunk", extraPopsToRestore, FrameAndStackAdjustmentRequirement::Needed);

{

unsigned extraPopsToRestore = 1;

return genericGenerationThunkGenerator(

vm, operationCompileFTLLazySlowPath, JITStubRoutinePtrTag, "FTL lazy slow path generation thunk", extraPopsToRestore, FrameAndStackAdjustmentRequirement::NotNeeded);

{

if (!Options::clobberAllRegsInFTLICSlowPath())

return;

RegisterSet clobber = RegisterSet::allRegisters();

clobber.exclude(RegisterSet::reservedHardwareRegisters());

clobber.exclude(RegisterSet::stackRegisters());

clobber.exclude(RegisterSet::calleeSaveRegisters());

clobber.exclude(dontClobber);

GPRReg someGPR = InvalidGPRReg;

for (Reg reg = Reg::first(); reg <= Reg::last(); reg = reg.next()) {

if (!clobber.get(reg) || !reg.isGPR())

continue;

jit.move(AssemblyHelpers::TrustedImm32(0x1337beef), reg.gpr());

someGPR = reg.gpr();

}

for (Reg reg = Reg::first(); reg <= Reg::last(); reg = reg.next()) {

if (!clobber.get(reg) || !reg.isFPR())

continue;

jit.move64ToDouble(someGPR, reg.fpr());

}

{

AssemblyHelpers jit(nullptr);

jit.tagReturnAddress();

// We want to save the given registers at the given offset, then we want to save the

// old return address somewhere past that offset, and then finally we want to make the

// call.

size_t currentOffset = key.offset() + sizeof(void*);

#if CPU(X86_64)

currentOffset += sizeof(void*);

#endif

for (MacroAssembler::RegisterID reg = MacroAssembler::firstRegister(); reg <= MacroAssembler::lastRegister(); reg = static_cast<MacroAssembler::RegisterID>(reg + 1)) {

if (!key.usedRegisters().get(reg))

continue;

jit.storePtr(reg, AssemblyHelpers::Address(MacroAssembler::stackPointerRegister, currentOffset));

currentOffset += sizeof(void*);

}

for (MacroAssembler::FPRegisterID reg = MacroAssembler::firstFPRegister(); reg <= MacroAssembler::lastFPRegister(); reg = static_cast<MacroAssembler::FPRegisterID>(reg + 1)) {

if (!key.usedRegisters().get(reg))

continue;

jit.storeDouble(reg, AssemblyHelpers::Address(MacroAssembler::stackPointerRegister, currentOffset));

currentOffset += sizeof(double);

}

jit.preserveReturnAddressAfterCall(GPRInfo::nonArgGPR0);

jit.storePtr(GPRInfo::nonArgGPR0, AssemblyHelpers::Address(MacroAssembler::stackPointerRegister, key.offset()));

jit.prepareCallOperation(vm);

registerClobberCheck(jit, key.argumentRegisters());

AssemblyHelpers::Call call = jit.call(OperationPtrTag);

jit.loadPtr(AssemblyHelpers::Address(MacroAssembler::stackPointerRegister, key.offset()), GPRInfo::nonPreservedNonReturnGPR);

jit.restoreReturnAddressBeforeReturn(GPRInfo::nonPreservedNonReturnGPR);

for (MacroAssembler::FPRegisterID reg = MacroAssembler::lastFPRegister(); ; reg = static_cast<MacroAssembler::FPRegisterID>(reg - 1)) {

if (key.usedRegisters().get(reg)) {

currentOffset -= sizeof(double);

jit.loadDouble(AssemblyHelpers::Address(MacroAssembler::stackPointerRegister, currentOffset), reg);

}

if (reg == MacroAssembler::firstFPRegister())

break;

}

for (MacroAssembler::RegisterID reg = MacroAssembler::lastRegister(); ; reg = static_cast<MacroAssembler::RegisterID>(reg - 1)) {

if (key.usedRegisters().get(reg)) {

currentOffset -= sizeof(void*);

jit.loadPtr(AssemblyHelpers::Address(MacroAssembler::stackPointerRegister, currentOffset), reg);

}

if (reg == MacroAssembler::firstRegister())

break;

}

jit.ret();

LinkBuffer patchBuffer(jit, GLOBAL_THUNK_ID);

patchBuffer.link(call, key.callTarget());

return FINALIZE_CODE(patchBuffer, JITThunkPtrTag, "FTL slow path call thunk for %s", toCString(key).data());