[apple/javascriptcore.git] / dfg / DFGSlowPathGenerator.h

/*
 * Copyright (C) 2012 Apple Inc. All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY APPLE INC. ``AS IS'' AND ANY
 * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
 * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL APPLE INC. OR
 * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
 * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
 * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 
 */

#ifndef DFGSlowPathGenerator_h
#define DFGSlowPathGenerator_h

#if ENABLE(DFG_JIT)

#include "DFGCommon.h"
#include "DFGSilentRegisterSavePlan.h"
#include "DFGSpeculativeJIT.h"
#include <wtf/FastMalloc.h>

namespace JSC { namespace DFG {

class SlowPathGenerator {
    WTF_MAKE_FAST_ALLOCATED;
public:
    SlowPathGenerator(SpeculativeJIT* jit)
        : m_currentNode(jit->m_currentNode)
    {
    }
    virtual ~SlowPathGenerator() { }
    void generate(SpeculativeJIT* jit)
    {
        m_label = jit->m_jit.label();
        jit->m_currentNode = m_currentNode;
        generateInternal(jit);
        if (!ASSERT_DISABLED)
            jit->m_jit.abortWithReason(DFGSlowPathGeneratorFellThrough);
    }
    MacroAssembler::Label label() const { return m_label; }
    virtual MacroAssembler::Call call() const
    {
        RELEASE_ASSERT_NOT_REACHED(); // By default slow path generators don't have a call.
        return MacroAssembler::Call();
    }
protected:
    virtual void generateInternal(SpeculativeJIT*) = 0;
    MacroAssembler::Label m_label;
    Node* m_currentNode;
};

template<typename JumpType>
class JumpingSlowPathGenerator : public SlowPathGenerator {
public:
    JumpingSlowPathGenerator(JumpType from, SpeculativeJIT* jit)
        : SlowPathGenerator(jit)
        , m_from(from)
        , m_to(jit->m_jit.label())
    {
    }
    
protected:
    void linkFrom(SpeculativeJIT* jit)
    {
        m_from.link(&jit->m_jit);
    }
    
    void jumpTo(SpeculativeJIT* jit)
    {
        jit->m_jit.jump().linkTo(m_to, &jit->m_jit);
    }

    JumpType m_from;
    MacroAssembler::Label m_to;
};

template<typename JumpType, typename FunctionType, typename ResultType>
class CallSlowPathGenerator : public JumpingSlowPathGenerator<JumpType> {
public:
    CallSlowPathGenerator(
        JumpType from, SpeculativeJIT* jit, FunctionType function,
        SpillRegistersMode spillMode, ResultType result)
        : JumpingSlowPathGenerator<JumpType>(from, jit)
        , m_function(function)
        , m_spillMode(spillMode)
        , m_result(result)
    {
        if (m_spillMode == NeedToSpill)
            jit->silentSpillAllRegistersImpl(false, m_plans, extractResult(result));
    }
    
    virtual MacroAssembler::Call call() const override
    {
        return m_call;
    }
    
protected:
    void setUp(SpeculativeJIT* jit)
    {
        this->linkFrom(jit);
        if (m_spillMode == NeedToSpill) {
            for (unsigned i = 0; i < m_plans.size(); ++i)
                jit->silentSpill(m_plans[i]);
        }
    }
    
    void recordCall(MacroAssembler::Call call)
    {
        m_call = call;
    }
    
    void tearDown(SpeculativeJIT* jit)
    {
        if (m_spillMode == NeedToSpill) {
            GPRReg canTrample = SpeculativeJIT::pickCanTrample(extractResult(m_result));
            for (unsigned i = m_plans.size(); i--;)
                jit->silentFill(m_plans[i], canTrample);
        }
        this->jumpTo(jit);
    }

    FunctionType m_function;
    SpillRegistersMode m_spillMode;
    ResultType m_result;
    MacroAssembler::Call m_call;
    Vector<SilentRegisterSavePlan, 2> m_plans;
};

template<typename JumpType, typename FunctionType, typename ResultType>
class CallResultAndNoArgumentsSlowPathGenerator
    : public CallSlowPathGenerator<JumpType, FunctionType, ResultType> {
public:
    CallResultAndNoArgumentsSlowPathGenerator(
        JumpType from, SpeculativeJIT* jit, FunctionType function,
        SpillRegistersMode spillMode, ResultType result)
        : CallSlowPathGenerator<JumpType, FunctionType, ResultType>(
            from, jit, function, spillMode, result)
    {
    }
    
protected:
    virtual void generateInternal(SpeculativeJIT* jit) override
    {
        this->setUp(jit);
        this->recordCall(jit->callOperation(this->m_function, extractResult(this->m_result)));
        this->tearDown(jit);
    }
};

template<
    typename JumpType, typename FunctionType, typename ResultType,
    typename ArgumentType1>
class CallResultAndOneArgumentSlowPathGenerator
    : public CallSlowPathGenerator<JumpType, FunctionType, ResultType> {
public:
    CallResultAndOneArgumentSlowPathGenerator(
        JumpType from, SpeculativeJIT* jit, FunctionType function,
        SpillRegistersMode spillMode, ResultType result, ArgumentType1 argument1)
        : CallSlowPathGenerator<JumpType, FunctionType, ResultType>(
            from, jit, function, spillMode, result)
        , m_argument1(argument1)
    {
    }
    
protected:
    virtual void generateInternal(SpeculativeJIT* jit) override
    {
        this->setUp(jit);
        this->recordCall(jit->callOperation(this->m_function, extractResult(this->m_result), m_argument1));
        this->tearDown(jit);
    }

    ArgumentType1 m_argument1;
};

template<
    typename JumpType, typename FunctionType, typename ResultType,
    typename ArgumentType1, typename ArgumentType2>
class CallResultAndTwoArgumentsSlowPathGenerator
    : public CallSlowPathGenerator<JumpType, FunctionType, ResultType> {
public:
    CallResultAndTwoArgumentsSlowPathGenerator(
        JumpType from, SpeculativeJIT* jit, FunctionType function,
        SpillRegistersMode spillMode, ResultType result, ArgumentType1 argument1,
        ArgumentType2 argument2)
        : CallSlowPathGenerator<JumpType, FunctionType, ResultType>(
            from, jit, function, spillMode, result)
        , m_argument1(argument1)
        , m_argument2(argument2)
    {
    }
    
protected:
    virtual void generateInternal(SpeculativeJIT* jit) override
    {
        this->setUp(jit);
        this->recordCall(jit->callOperation(this->m_function, extractResult(this->m_result), m_argument1, m_argument2));
        this->tearDown(jit);
    }

    ArgumentType1 m_argument1;
    ArgumentType2 m_argument2;
};

template<
    typename JumpType, typename FunctionType, typename ResultType,
    typename ArgumentType1, typename ArgumentType2, typename ArgumentType3>
class CallResultAndThreeArgumentsSlowPathGenerator
    : public CallSlowPathGenerator<JumpType, FunctionType, ResultType> {
public:
    CallResultAndThreeArgumentsSlowPathGenerator(
        JumpType from, SpeculativeJIT* jit, FunctionType function,
        SpillRegistersMode spillMode, ResultType result, ArgumentType1 argument1,
        ArgumentType2 argument2, ArgumentType3 argument3)
        : CallSlowPathGenerator<JumpType, FunctionType, ResultType>(
            from, jit, function, spillMode, result)
        , m_argument1(argument1)
        , m_argument2(argument2)
        , m_argument3(argument3)
    {
    }

protected:    
    virtual void generateInternal(SpeculativeJIT* jit) override
    {
        this->setUp(jit);
        this->recordCall(
            jit->callOperation(
                this->m_function, extractResult(this->m_result), m_argument1, m_argument2,
                m_argument3));
        this->tearDown(jit);
    }

    ArgumentType1 m_argument1;
    ArgumentType2 m_argument2;
    ArgumentType3 m_argument3;
};

template<
    typename JumpType, typename FunctionType, typename ResultType,
    typename ArgumentType1, typename ArgumentType2, typename ArgumentType3,
    typename ArgumentType4>
class CallResultAndFourArgumentsSlowPathGenerator
    : public CallSlowPathGenerator<JumpType, FunctionType, ResultType> {
public:
    CallResultAndFourArgumentsSlowPathGenerator(
        JumpType from, SpeculativeJIT* jit, FunctionType function,
        SpillRegistersMode spillMode, ResultType result, ArgumentType1 argument1,
        ArgumentType2 argument2, ArgumentType3 argument3, ArgumentType4 argument4)
        : CallSlowPathGenerator<JumpType, FunctionType, ResultType>(
            from, jit, function, spillMode, result)
        , m_argument1(argument1)
        , m_argument2(argument2)
        , m_argument3(argument3)
        , m_argument4(argument4)
    {
    }
    
protected:
    void generateInternal(SpeculativeJIT* jit)
    {
        this->setUp(jit);
        this->recordCall(
            jit->callOperation(
                this->m_function, extractResult(this->m_result), m_argument1, m_argument2,
                m_argument3, m_argument4));
        this->tearDown(jit);
    }

    ArgumentType1 m_argument1;
    ArgumentType2 m_argument2;
    ArgumentType3 m_argument3;
    ArgumentType4 m_argument4;
};

template<
    typename JumpType, typename FunctionType, typename ResultType,
    typename ArgumentType1, typename ArgumentType2, typename ArgumentType3,
    typename ArgumentType4, typename ArgumentType5>
class CallResultAndFiveArgumentsSlowPathGenerator
    : public CallSlowPathGenerator<JumpType, FunctionType, ResultType> {
public:
    CallResultAndFiveArgumentsSlowPathGenerator(
        JumpType from, SpeculativeJIT* jit, FunctionType function,
        SpillRegistersMode spillMode, ResultType result, ArgumentType1 argument1,
        ArgumentType2 argument2, ArgumentType3 argument3, ArgumentType4 argument4,
        ArgumentType5 argument5)
        : CallSlowPathGenerator<JumpType, FunctionType, ResultType>(
            from, jit, function, spillMode, result)
        , m_argument1(argument1)
        , m_argument2(argument2)
        , m_argument3(argument3)
        , m_argument4(argument4)
        , m_argument5(argument5)
    {
    }

protected:    
    void generateInternal(SpeculativeJIT* jit)
    {
        this->setUp(jit);
        this->recordCall(
            jit->callOperation(
                this->m_function, extractResult(this->m_result), m_argument1, m_argument2,
                m_argument3, m_argument4, m_argument5));
        this->tearDown(jit);
    }

    ArgumentType1 m_argument1;
    ArgumentType2 m_argument2;
    ArgumentType3 m_argument3;
    ArgumentType4 m_argument4;
    ArgumentType5 m_argument5;
};

template<typename JumpType, typename FunctionType, typename ResultType>
inline std::unique_ptr<SlowPathGenerator> slowPathCall(
    JumpType from, SpeculativeJIT* jit, FunctionType function,
    ResultType result, SpillRegistersMode spillMode = NeedToSpill)
{
    return std::make_unique<CallResultAndNoArgumentsSlowPathGenerator<JumpType, FunctionType, ResultType>>(
        from, jit, function, spillMode, result);
}

template<
    typename JumpType, typename FunctionType, typename ResultType,
    typename ArgumentType1>
inline std::unique_ptr<SlowPathGenerator> slowPathCall(
    JumpType from, SpeculativeJIT* jit, FunctionType function,
    ResultType result, ArgumentType1 argument1,
    SpillRegistersMode spillMode = NeedToSpill)
{
    return std::make_unique<CallResultAndOneArgumentSlowPathGenerator<JumpType, FunctionType, ResultType, ArgumentType1>>(
        from, jit, function, spillMode, result, argument1);
}

template<
    typename JumpType, typename FunctionType, typename ResultType,
    typename ArgumentType1, typename ArgumentType2>
inline std::unique_ptr<SlowPathGenerator> slowPathCall(
    JumpType from, SpeculativeJIT* jit, FunctionType function,
    ResultType result, ArgumentType1 argument1, ArgumentType2 argument2,
    SpillRegistersMode spillMode = NeedToSpill)
{
    return std::make_unique<CallResultAndTwoArgumentsSlowPathGenerator<JumpType, FunctionType, ResultType, ArgumentType1, ArgumentType2>>(
        from, jit, function, spillMode, result, argument1, argument2);
}

template<
    typename JumpType, typename FunctionType, typename ResultType,
    typename ArgumentType1, typename ArgumentType2, typename ArgumentType3>
inline std::unique_ptr<SlowPathGenerator> slowPathCall(
    JumpType from, SpeculativeJIT* jit, FunctionType function,
    ResultType result, ArgumentType1 argument1, ArgumentType2 argument2,
    ArgumentType3 argument3, SpillRegistersMode spillMode = NeedToSpill)
{
    return std::make_unique<CallResultAndThreeArgumentsSlowPathGenerator<JumpType, FunctionType, ResultType, ArgumentType1, ArgumentType2,
        ArgumentType3>>(from, jit, function, spillMode, result, argument1, argument2, argument3);
}

template<
    typename JumpType, typename FunctionType, typename ResultType,
    typename ArgumentType1, typename ArgumentType2, typename ArgumentType3,
    typename ArgumentType4>
inline std::unique_ptr<SlowPathGenerator> slowPathCall(
    JumpType from, SpeculativeJIT* jit, FunctionType function,
    ResultType result, ArgumentType1 argument1, ArgumentType2 argument2,
    ArgumentType3 argument3, ArgumentType4 argument4,
    SpillRegistersMode spillMode = NeedToSpill)
{
    return std::make_unique<CallResultAndFourArgumentsSlowPathGenerator<JumpType, FunctionType, ResultType, ArgumentType1, ArgumentType2,
        ArgumentType3, ArgumentType4>>(from, jit, function, spillMode, result, argument1, argument2, argument3, argument4);
}

template<
    typename JumpType, typename FunctionType, typename ResultType,
    typename ArgumentType1, typename ArgumentType2, typename ArgumentType3,
    typename ArgumentType4, typename ArgumentType5>
inline std::unique_ptr<SlowPathGenerator> slowPathCall(
    JumpType from, SpeculativeJIT* jit, FunctionType function,
    ResultType result, ArgumentType1 argument1, ArgumentType2 argument2,
    ArgumentType3 argument3, ArgumentType4 argument4, ArgumentType5 argument5,
    SpillRegistersMode spillMode = NeedToSpill)
{
    return std::make_unique<CallResultAndFiveArgumentsSlowPathGenerator<JumpType, FunctionType, ResultType, ArgumentType1, ArgumentType2,
        ArgumentType3, ArgumentType4, ArgumentType5>>(from, jit, function, spillMode, result, argument1, argument2, argument3,
        argument4, argument5);
}

template<typename JumpType, typename DestinationType, typename SourceType, unsigned numberOfAssignments>
class AssigningSlowPathGenerator : public JumpingSlowPathGenerator<JumpType> {
public:
    AssigningSlowPathGenerator(
        JumpType from, SpeculativeJIT* jit,
        DestinationType destination[numberOfAssignments],
        SourceType source[numberOfAssignments])
        : JumpingSlowPathGenerator<JumpType>(from, jit)
    {
        for (unsigned i = numberOfAssignments; i--;) {
            m_destination[i] = destination[i];
            m_source[i] = source[i];
        }
    }

protected:
    virtual void generateInternal(SpeculativeJIT* jit) override
    {
        this->linkFrom(jit);
        for (unsigned i = numberOfAssignments; i--;)
            jit->m_jit.move(m_source[i], m_destination[i]);
        this->jumpTo(jit);
    }

private:
    DestinationType m_destination[numberOfAssignments];
    SourceType m_source[numberOfAssignments];
};

template<typename JumpType, typename DestinationType, typename SourceType, unsigned numberOfAssignments>
inline std::unique_ptr<SlowPathGenerator> slowPathMove(
    JumpType from, SpeculativeJIT* jit, SourceType source[numberOfAssignments], DestinationType destination[numberOfAssignments])
{
    return std::make_unique<AssigningSlowPathGenerator<JumpType, DestinationType, SourceType, numberOfAssignments>>(
        from, jit, destination, source);
}

template<typename JumpType, typename DestinationType, typename SourceType>
inline std::unique_ptr<SlowPathGenerator> slowPathMove(
    JumpType from, SpeculativeJIT* jit, SourceType source, DestinationType destination)
{
    SourceType sourceArray[1] = { source };
    DestinationType destinationArray[1] = { destination };
    return std::make_unique<AssigningSlowPathGenerator<JumpType, DestinationType, SourceType, 1>>(
        from, jit, destinationArray, sourceArray);
}

template<typename JumpType, typename DestinationType, typename SourceType>
inline std::unique_ptr<SlowPathGenerator> slowPathMove(
    JumpType from, SpeculativeJIT* jit, SourceType source1, DestinationType destination1, SourceType source2, DestinationType destination2)
{
    SourceType sourceArray[2] = { source1, source2 };
    DestinationType destinationArray[2] = { destination1, destination2 };
    return std::make_unique<AssigningSlowPathGenerator<JumpType, DestinationType, SourceType, 2>>(
        from, jit, destinationArray, sourceArray);
}

} } // namespace JSC::DFG

#endif // ENABLD(DFG_JIT)

#endif // DFGSlowPathGenerator_h
Commit	Line	Data
93a37866 A	1	/*
	2	* Copyright (C) 2012 Apple Inc. All rights reserved.
	3	*
	4	* Redistribution and use in source and binary forms, with or without
	5	* modification, are permitted provided that the following conditions
	6	* are met:
	7	* 1. Redistributions of source code must retain the above copyright
	8	* notice, this list of conditions and the following disclaimer.
	9	* 2. Redistributions in binary form must reproduce the above copyright
	10	* notice, this list of conditions and the following disclaimer in the
	11	* documentation and/or other materials provided with the distribution.
	12	*
	13	* THIS SOFTWARE IS PROVIDED BY APPLE INC. ``AS IS'' AND ANY
	14	* EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
	15	* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
	16	* PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR
	17	* CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
	18	* EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
	19	* PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
	20	* PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
	21	* OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
	22	* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
	23	* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
	24	*/
	25
	26	#ifndef DFGSlowPathGenerator_h
	27	#define DFGSlowPathGenerator_h
	28
93a37866 A	29	#if ENABLE(DFG_JIT)
	30
	31	#include "DFGCommon.h"
	32	#include "DFGSilentRegisterSavePlan.h"
	33	#include "DFGSpeculativeJIT.h"
81345200	34	#include <wtf/FastMalloc.h>
93a37866 A	35
	36	namespace JSC { namespace DFG {
	37
	38	class SlowPathGenerator {
	39	WTF_MAKE_FAST_ALLOCATED;
	40	public:
	41	SlowPathGenerator(SpeculativeJIT* jit)
	42	: m_currentNode(jit->m_currentNode)
	43	{
	44	}
	45	virtual ~SlowPathGenerator() { }
	46	void generate(SpeculativeJIT* jit)
	47	{
93a37866 A	48	m_label = jit->m_jit.label();
	49	jit->m_currentNode = m_currentNode;
	50	generateInternal(jit);
81345200 A	51	if (!ASSERT_DISABLED)
81345200 A	52	jit->m_jit.abortWithReason(DFGSlowPathGeneratorFellThrough);
93a37866 A	53	}
	54	MacroAssembler::Label label() const { return m_label; }
	55	virtual MacroAssembler::Call call() const
	56	{
	57	RELEASE_ASSERT_NOT_REACHED(); // By default slow path generators don't have a call.
	58	return MacroAssembler::Call();
	59	}
	60	protected:
	61	virtual void generateInternal(SpeculativeJIT*) = 0;
	62	MacroAssembler::Label m_label;
	63	Node* m_currentNode;
	64	};
	65
	66	template<typename JumpType>
	67	class JumpingSlowPathGenerator : public SlowPathGenerator {
	68	public:
	69	JumpingSlowPathGenerator(JumpType from, SpeculativeJIT* jit)
	70	: SlowPathGenerator(jit)
	71	, m_from(from)
	72	, m_to(jit->m_jit.label())
	73	{
	74	}
	75
	76	protected:
	77	void linkFrom(SpeculativeJIT* jit)
	78	{
	79	m_from.link(&jit->m_jit);
	80	}
	81
	82	void jumpTo(SpeculativeJIT* jit)
	83	{
	84	jit->m_jit.jump().linkTo(m_to, &jit->m_jit);
	85	}
	86
	87	JumpType m_from;
	88	MacroAssembler::Label m_to;
	89	};
	90
	91	template<typename JumpType, typename FunctionType, typename ResultType>
	92	class CallSlowPathGenerator : public JumpingSlowPathGenerator<JumpType> {
	93	public:
	94	CallSlowPathGenerator(
	95	JumpType from, SpeculativeJIT* jit, FunctionType function,
	96	SpillRegistersMode spillMode, ResultType result)
	97	: JumpingSlowPathGenerator<JumpType>(from, jit)
	98	, m_function(function)
	99	, m_spillMode(spillMode)
	100	, m_result(result)
	101	{
	102	if (m_spillMode == NeedToSpill)
81345200	103	jit->silentSpillAllRegistersImpl(false, m_plans, extractResult(result));
93a37866 A	104	}
93a37866 A	105
81345200	106	virtual MacroAssembler::Call call() const override
93a37866 A	107	{
	108	return m_call;
	109	}
	110
	111	protected:
	112	void setUp(SpeculativeJIT* jit)
	113	{
	114	this->linkFrom(jit);
	115	if (m_spillMode == NeedToSpill) {
	116	for (unsigned i = 0; i < m_plans.size(); ++i)
	117	jit->silentSpill(m_plans[i]);
	118	}
	119	}
	120
	121	void recordCall(MacroAssembler::Call call)
	122	{
	123	m_call = call;
	124	}
	125
	126	void tearDown(SpeculativeJIT* jit)
	127	{
	128	if (m_spillMode == NeedToSpill) {
81345200	129	GPRReg canTrample = SpeculativeJIT::pickCanTrample(extractResult(m_result));
93a37866 A	130	for (unsigned i = m_plans.size(); i--;)
	131	jit->silentFill(m_plans[i], canTrample);
	132	}
	133	this->jumpTo(jit);
	134	}
	135
	136	FunctionType m_function;
	137	SpillRegistersMode m_spillMode;
	138	ResultType m_result;
	139	MacroAssembler::Call m_call;
	140	Vector<SilentRegisterSavePlan, 2> m_plans;
	141	};
	142
	143	template<typename JumpType, typename FunctionType, typename ResultType>
	144	class CallResultAndNoArgumentsSlowPathGenerator
	145	: public CallSlowPathGenerator<JumpType, FunctionType, ResultType> {
	146	public:
	147	CallResultAndNoArgumentsSlowPathGenerator(
	148	JumpType from, SpeculativeJIT* jit, FunctionType function,
	149	SpillRegistersMode spillMode, ResultType result)
	150	: CallSlowPathGenerator<JumpType, FunctionType, ResultType>(
	151	from, jit, function, spillMode, result)
	152	{
	153	}
	154
	155	protected:
81345200	156	virtual void generateInternal(SpeculativeJIT* jit) override
93a37866 A	157	{
93a37866 A	158	this->setUp(jit);
81345200	159	this->recordCall(jit->callOperation(this->m_function, extractResult(this->m_result)));
93a37866 A	160	this->tearDown(jit);
	161	}
	162	};
	163
	164	template<
	165	typename JumpType, typename FunctionType, typename ResultType,
	166	typename ArgumentType1>
	167	class CallResultAndOneArgumentSlowPathGenerator
	168	: public CallSlowPathGenerator<JumpType, FunctionType, ResultType> {
	169	public:
	170	CallResultAndOneArgumentSlowPathGenerator(
	171	JumpType from, SpeculativeJIT* jit, FunctionType function,
	172	SpillRegistersMode spillMode, ResultType result, ArgumentType1 argument1)
	173	: CallSlowPathGenerator<JumpType, FunctionType, ResultType>(
	174	from, jit, function, spillMode, result)
	175	, m_argument1(argument1)
	176	{
	177	}
	178
	179	protected:
81345200	180	virtual void generateInternal(SpeculativeJIT* jit) override
93a37866 A	181	{
93a37866 A	182	this->setUp(jit);
81345200	183	this->recordCall(jit->callOperation(this->m_function, extractResult(this->m_result), m_argument1));
93a37866 A	184	this->tearDown(jit);
	185	}
	186
	187	ArgumentType1 m_argument1;
	188	};
	189
	190	template<
	191	typename JumpType, typename FunctionType, typename ResultType,
	192	typename ArgumentType1, typename ArgumentType2>
	193	class CallResultAndTwoArgumentsSlowPathGenerator
	194	: public CallSlowPathGenerator<JumpType, FunctionType, ResultType> {
	195	public:
	196	CallResultAndTwoArgumentsSlowPathGenerator(
	197	JumpType from, SpeculativeJIT* jit, FunctionType function,
	198	SpillRegistersMode spillMode, ResultType result, ArgumentType1 argument1,
	199	ArgumentType2 argument2)
	200	: CallSlowPathGenerator<JumpType, FunctionType, ResultType>(
	201	from, jit, function, spillMode, result)
	202	, m_argument1(argument1)
	203	, m_argument2(argument2)
	204	{
	205	}
	206
	207	protected:
81345200	208	virtual void generateInternal(SpeculativeJIT* jit) override
93a37866 A	209	{
93a37866 A	210	this->setUp(jit);
81345200	211	this->recordCall(jit->callOperation(this->m_function, extractResult(this->m_result), m_argument1, m_argument2));
93a37866 A	212	this->tearDown(jit);
	213	}
	214
	215	ArgumentType1 m_argument1;
	216	ArgumentType2 m_argument2;
	217	};
	218
	219	template<
	220	typename JumpType, typename FunctionType, typename ResultType,
	221	typename ArgumentType1, typename ArgumentType2, typename ArgumentType3>
	222	class CallResultAndThreeArgumentsSlowPathGenerator
	223	: public CallSlowPathGenerator<JumpType, FunctionType, ResultType> {
	224	public:
	225	CallResultAndThreeArgumentsSlowPathGenerator(
	226	JumpType from, SpeculativeJIT* jit, FunctionType function,
	227	SpillRegistersMode spillMode, ResultType result, ArgumentType1 argument1,
	228	ArgumentType2 argument2, ArgumentType3 argument3)
	229	: CallSlowPathGenerator<JumpType, FunctionType, ResultType>(
	230	from, jit, function, spillMode, result)
	231	, m_argument1(argument1)
	232	, m_argument2(argument2)
	233	, m_argument3(argument3)
	234	{
	235	}
	236
	237	protected:
81345200	238	virtual void generateInternal(SpeculativeJIT* jit) override
93a37866 A	239	{
	240	this->setUp(jit);
	241	this->recordCall(
	242	jit->callOperation(
81345200	243	this->m_function, extractResult(this->m_result), m_argument1, m_argument2,
93a37866 A	244	m_argument3));
	245	this->tearDown(jit);
	246	}
	247
	248	ArgumentType1 m_argument1;
	249	ArgumentType2 m_argument2;
	250	ArgumentType3 m_argument3;
	251	};
	252
	253	template<
	254	typename JumpType, typename FunctionType, typename ResultType,
	255	typename ArgumentType1, typename ArgumentType2, typename ArgumentType3,
	256	typename ArgumentType4>
	257	class CallResultAndFourArgumentsSlowPathGenerator
	258	: public CallSlowPathGenerator<JumpType, FunctionType, ResultType> {
	259	public:
	260	CallResultAndFourArgumentsSlowPathGenerator(
	261	JumpType from, SpeculativeJIT* jit, FunctionType function,
	262	SpillRegistersMode spillMode, ResultType result, ArgumentType1 argument1,
	263	ArgumentType2 argument2, ArgumentType3 argument3, ArgumentType4 argument4)
	264	: CallSlowPathGenerator<JumpType, FunctionType, ResultType>(
	265	from, jit, function, spillMode, result)
	266	, m_argument1(argument1)
	267	, m_argument2(argument2)
	268	, m_argument3(argument3)
	269	, m_argument4(argument4)
	270	{
	271	}
	272
	273	protected:
	274	void generateInternal(SpeculativeJIT* jit)
	275	{
	276	this->setUp(jit);
	277	this->recordCall(
	278	jit->callOperation(
81345200	279	this->m_function, extractResult(this->m_result), m_argument1, m_argument2,
93a37866 A	280	m_argument3, m_argument4));
	281	this->tearDown(jit);
	282	}
	283
	284	ArgumentType1 m_argument1;
	285	ArgumentType2 m_argument2;
	286	ArgumentType3 m_argument3;
	287	ArgumentType4 m_argument4;
	288	};
	289
	290	template<
	291	typename JumpType, typename FunctionType, typename ResultType,
	292	typename ArgumentType1, typename ArgumentType2, typename ArgumentType3,
	293	typename ArgumentType4, typename ArgumentType5>
	294	class CallResultAndFiveArgumentsSlowPathGenerator
	295	: public CallSlowPathGenerator<JumpType, FunctionType, ResultType> {
	296	public:
	297	CallResultAndFiveArgumentsSlowPathGenerator(
	298	JumpType from, SpeculativeJIT* jit, FunctionType function,
	299	SpillRegistersMode spillMode, ResultType result, ArgumentType1 argument1,
	300	ArgumentType2 argument2, ArgumentType3 argument3, ArgumentType4 argument4,
	301	ArgumentType5 argument5)
	302	: CallSlowPathGenerator<JumpType, FunctionType, ResultType>(
	303	from, jit, function, spillMode, result)
	304	, m_argument1(argument1)
	305	, m_argument2(argument2)
	306	, m_argument3(argument3)
	307	, m_argument4(argument4)
	308	, m_argument5(argument5)
	309	{
	310	}
	311
	312	protected:
	313	void generateInternal(SpeculativeJIT* jit)
	314	{
	315	this->setUp(jit);
	316	this->recordCall(
	317	jit->callOperation(
81345200	318	this->m_function, extractResult(this->m_result), m_argument1, m_argument2,
93a37866 A	319	m_argument3, m_argument4, m_argument5));
	320	this->tearDown(jit);
	321	}
	322
	323	ArgumentType1 m_argument1;
	324	ArgumentType2 m_argument2;
	325	ArgumentType3 m_argument3;
	326	ArgumentType4 m_argument4;
	327	ArgumentType5 m_argument5;
	328	};
	329
	330	template<typename JumpType, typename FunctionType, typename ResultType>
ed1e77d3	331	inline std::unique_ptr<SlowPathGenerator> slowPathCall(
93a37866 A	332	JumpType from, SpeculativeJIT* jit, FunctionType function,
	333	ResultType result, SpillRegistersMode spillMode = NeedToSpill)
	334	{
ed1e77d3 A	335	return std::make_unique<CallResultAndNoArgumentsSlowPathGenerator<JumpType, FunctionType, ResultType>>(
ed1e77d3 A	336	from, jit, function, spillMode, result);
93a37866 A	337	}
	338
	339	template<
	340	typename JumpType, typename FunctionType, typename ResultType,
	341	typename ArgumentType1>
ed1e77d3	342	inline std::unique_ptr<SlowPathGenerator> slowPathCall(
93a37866 A	343	JumpType from, SpeculativeJIT* jit, FunctionType function,
	344	ResultType result, ArgumentType1 argument1,
	345	SpillRegistersMode spillMode = NeedToSpill)
	346	{
ed1e77d3 A	347	return std::make_unique<CallResultAndOneArgumentSlowPathGenerator<JumpType, FunctionType, ResultType, ArgumentType1>>(
ed1e77d3 A	348	from, jit, function, spillMode, result, argument1);
93a37866 A	349	}
	350
	351	template<
	352	typename JumpType, typename FunctionType, typename ResultType,
	353	typename ArgumentType1, typename ArgumentType2>
ed1e77d3	354	inline std::unique_ptr<SlowPathGenerator> slowPathCall(
93a37866 A	355	JumpType from, SpeculativeJIT* jit, FunctionType function,
	356	ResultType result, ArgumentType1 argument1, ArgumentType2 argument2,
	357	SpillRegistersMode spillMode = NeedToSpill)
	358	{
ed1e77d3 A	359	return std::make_unique<CallResultAndTwoArgumentsSlowPathGenerator<JumpType, FunctionType, ResultType, ArgumentType1, ArgumentType2>>(
ed1e77d3 A	360	from, jit, function, spillMode, result, argument1, argument2);
93a37866 A	361	}
	362
	363	template<
	364	typename JumpType, typename FunctionType, typename ResultType,
	365	typename ArgumentType1, typename ArgumentType2, typename ArgumentType3>
ed1e77d3	366	inline std::unique_ptr<SlowPathGenerator> slowPathCall(
93a37866 A	367	JumpType from, SpeculativeJIT* jit, FunctionType function,
	368	ResultType result, ArgumentType1 argument1, ArgumentType2 argument2,
	369	ArgumentType3 argument3, SpillRegistersMode spillMode = NeedToSpill)
	370	{
ed1e77d3 A	371	return std::make_unique<CallResultAndThreeArgumentsSlowPathGenerator<JumpType, FunctionType, ResultType, ArgumentType1, ArgumentType2,
ed1e77d3 A	372	ArgumentType3>>(from, jit, function, spillMode, result, argument1, argument2, argument3);
93a37866 A	373	}
	374
	375	template<
	376	typename JumpType, typename FunctionType, typename ResultType,
	377	typename ArgumentType1, typename ArgumentType2, typename ArgumentType3,
	378	typename ArgumentType4>
ed1e77d3	379	inline std::unique_ptr<SlowPathGenerator> slowPathCall(
93a37866 A	380	JumpType from, SpeculativeJIT* jit, FunctionType function,
	381	ResultType result, ArgumentType1 argument1, ArgumentType2 argument2,
	382	ArgumentType3 argument3, ArgumentType4 argument4,
	383	SpillRegistersMode spillMode = NeedToSpill)
	384	{
ed1e77d3 A	385	return std::make_unique<CallResultAndFourArgumentsSlowPathGenerator<JumpType, FunctionType, ResultType, ArgumentType1, ArgumentType2,
ed1e77d3 A	386	ArgumentType3, ArgumentType4>>(from, jit, function, spillMode, result, argument1, argument2, argument3, argument4);
93a37866 A	387	}
	388
	389	template<
	390	typename JumpType, typename FunctionType, typename ResultType,
	391	typename ArgumentType1, typename ArgumentType2, typename ArgumentType3,
	392	typename ArgumentType4, typename ArgumentType5>
ed1e77d3	393	inline std::unique_ptr<SlowPathGenerator> slowPathCall(
93a37866 A	394	JumpType from, SpeculativeJIT* jit, FunctionType function,
	395	ResultType result, ArgumentType1 argument1, ArgumentType2 argument2,
	396	ArgumentType3 argument3, ArgumentType4 argument4, ArgumentType5 argument5,
	397	SpillRegistersMode spillMode = NeedToSpill)
	398	{
ed1e77d3 A	399	return std::make_unique<CallResultAndFiveArgumentsSlowPathGenerator<JumpType, FunctionType, ResultType, ArgumentType1, ArgumentType2,
	400	ArgumentType3, ArgumentType4, ArgumentType5>>(from, jit, function, spillMode, result, argument1, argument2, argument3,
	401	argument4, argument5);
93a37866 A	402	}
	403
	404	template<typename JumpType, typename DestinationType, typename SourceType, unsigned numberOfAssignments>
	405	class AssigningSlowPathGenerator : public JumpingSlowPathGenerator<JumpType> {
	406	public:
	407	AssigningSlowPathGenerator(
	408	JumpType from, SpeculativeJIT* jit,
	409	DestinationType destination[numberOfAssignments],
	410	SourceType source[numberOfAssignments])
	411	: JumpingSlowPathGenerator<JumpType>(from, jit)
	412	{
	413	for (unsigned i = numberOfAssignments; i--;) {
	414	m_destination[i] = destination[i];
	415	m_source[i] = source[i];
	416	}
	417	}
	418
	419	protected:
81345200	420	virtual void generateInternal(SpeculativeJIT* jit) override
93a37866 A	421	{
	422	this->linkFrom(jit);
	423	for (unsigned i = numberOfAssignments; i--;)
	424	jit->m_jit.move(m_source[i], m_destination[i]);
	425	this->jumpTo(jit);
	426	}
	427
	428	private:
	429	DestinationType m_destination[numberOfAssignments];
	430	SourceType m_source[numberOfAssignments];
	431	};
	432
	433	template<typename JumpType, typename DestinationType, typename SourceType, unsigned numberOfAssignments>
ed1e77d3	434	inline std::unique_ptr<SlowPathGenerator> slowPathMove(
93a37866 A	435	JumpType from, SpeculativeJIT* jit, SourceType source[numberOfAssignments], DestinationType destination[numberOfAssignments])
93a37866 A	436	{
ed1e77d3 A	437	return std::make_unique<AssigningSlowPathGenerator<JumpType, DestinationType, SourceType, numberOfAssignments>>(
ed1e77d3 A	438	from, jit, destination, source);
93a37866 A	439	}
	440
	441	template<typename JumpType, typename DestinationType, typename SourceType>
ed1e77d3	442	inline std::unique_ptr<SlowPathGenerator> slowPathMove(
93a37866 A	443	JumpType from, SpeculativeJIT* jit, SourceType source, DestinationType destination)
	444	{
	445	SourceType sourceArray[1] = { source };
	446	DestinationType destinationArray[1] = { destination };
ed1e77d3 A	447	return std::make_unique<AssigningSlowPathGenerator<JumpType, DestinationType, SourceType, 1>>(
ed1e77d3 A	448	from, jit, destinationArray, sourceArray);
93a37866 A	449	}
	450
	451	template<typename JumpType, typename DestinationType, typename SourceType>
ed1e77d3	452	inline std::unique_ptr<SlowPathGenerator> slowPathMove(
93a37866 A	453	JumpType from, SpeculativeJIT* jit, SourceType source1, DestinationType destination1, SourceType source2, DestinationType destination2)
	454	{
	455	SourceType sourceArray[2] = { source1, source2 };
	456	DestinationType destinationArray[2] = { destination1, destination2 };
ed1e77d3 A	457	return std::make_unique<AssigningSlowPathGenerator<JumpType, DestinationType, SourceType, 2>>(
ed1e77d3 A	458	from, jit, destinationArray, sourceArray);
93a37866 A	459	}
	460
	461	} } // namespace JSC::DFG
	462
	463	#endif // ENABLD(DFG_JIT)
	464
	465	#endif // DFGSlowPathGenerator_h
	466