// B3 doesn't need the exception spill slot because we just use the 

#if FTL_USES_B3

        // FIXME: Need a story for exceptions.

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

        PatckpointValue* patchpoint = m_out.patchpoint(Int64);

        patchpoint->append(jsCallee, ValueRep::SomeRegister);

        if (jsArguments)

            patchpoint->append(jsArguments, ValueRep::SomeRegister);

        patchpoint->append(thisArg, ValueRep::SomeRegister);

        patchpoint->clobber(RegisterSet::macroScratchRegisters());

        parchpoint->clobberLate(RegisterSet::volatileRegistersForJSCall());

        patchpoint->resultConstraint = ValueRep::reg(GPRInfo::returnValueGPR);

        // This is the minimum amount of call arg area stack space that all JS->JS calls always have.

        unsigned minimumJSCallAreaSize =

            sizeof(CallerFrameAndPC) +

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

        // This is the number of spill slots we will want.

        unsigned spillAreaSize = 3 * sizeof(EncodedJSValue);

        CodeOrigin codeOrigin = codeOriginDescriptionOfCallSite();

        State* state = &m_ftlState;

        patchpoint->setGenerator(

            [=] (CCallHelpers& jit, const StackmapGenerationParams& params) {

                AllowMacroScratchRegisterUsage allowScratch(jit);

                CallSiteIndex callSiteIndex =

                    state->jitCode->common.addUniqueCallSiteIndex(codeOrigin);

                // FIXME: We would ask the OSR exit descriptor to prepare and then we would modify

                // the OSRExit data structure inside the OSRExitHandle to link it up to this call.

                // Also, the exception checks JumpList should be linked to somewhere.

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

                CCallHelpers::JumpList exceptions;

                jit.store32(

                    CCallHelpers::TrustedImm32(callSiteIndex.bits()),

                    CCallHelpers::tagFor(VirtualRegister(JSStack::ArgumentCount)));

                CallLinkInfo* callLinkInfo = jit.codeBlock()->addCallLinkInfo();

                CallVarargsData* data = node->callVarargsData();

                unsigned argIndex = 1;

                GPRReg calleeGPR = params[argIndex++].gpr();

                GPRReg argumentsGPR = InvalidGPRReg;

                bool forwarding = false;

                if (jsArguments)

                    argumentsGPR = params[argIndex++].gpr();

                else

                    forwarding = true;

                GPRReg thisGPR = params[argIndex++].gpr();

                // 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);

                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);

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

                };

                unsigned originalStackHeight = params.proc().frameSize();

                unsigned extraStack = sizeof(CallerFrameAndPC) + WTF::roundUpToMultipleOf(stackAlignmentBytes(), 5 * sizeof(void*));

            });

#else