[apple/javascriptcore.git] / dfg / DFGJITCodeGenerator.cpp

/*
 * Copyright (C) 2011 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. 
 */

#include "config.h"
#include "DFGJITCodeGenerator.h"

#if ENABLE(DFG_JIT)

#include "DFGNonSpeculativeJIT.h"
#include "DFGSpeculativeJIT.h"
#include "LinkBuffer.h"

namespace JSC { namespace DFG {

GPRReg JITCodeGenerator::fillInteger(NodeIndex nodeIndex, DataFormat& returnFormat)
{
    Node& node = m_jit.graph()[nodeIndex];
    VirtualRegister virtualRegister = node.virtualRegister();
    GenerationInfo& info = m_generationInfo[virtualRegister];

    if (info.registerFormat() == DataFormatNone) {
        GPRReg gpr = allocate();

        if (node.isConstant()) {
            m_gprs.retain(gpr, virtualRegister, SpillOrderConstant);
            if (isInt32Constant(nodeIndex)) {
                m_jit.move(MacroAssembler::Imm32(valueOfInt32Constant(nodeIndex)), gpr);
                info.fillInteger(gpr);
                returnFormat = DataFormatInteger;
                return gpr;
            }
            if (isDoubleConstant(nodeIndex)) {
                JSValue jsValue = jsNumber(valueOfDoubleConstant(nodeIndex));
                m_jit.move(MacroAssembler::ImmPtr(JSValue::encode(jsValue)), gpr);
            } else {
                ASSERT(isJSConstant(nodeIndex));
                JSValue jsValue = valueOfJSConstant(nodeIndex);
                m_jit.move(MacroAssembler::ImmPtr(JSValue::encode(jsValue)), gpr);
            }
        } else {
            ASSERT(info.spillFormat() == DataFormatJS || info.spillFormat() == DataFormatJSInteger);
            m_gprs.retain(gpr, virtualRegister, SpillOrderSpilled);
            m_jit.loadPtr(JITCompiler::addressFor(virtualRegister), gpr);
        }

        // Since we statically know that we're filling an integer, and values
        // in the RegisterFile are boxed, this must be DataFormatJSInteger.
        // We will check this with a jitAssert below.
        info.fillJSValue(gpr, DataFormatJSInteger);
        unlock(gpr);
    }

    switch (info.registerFormat()) {
    case DataFormatNone:
        // Should have filled, above.
    case DataFormatJSDouble:
    case DataFormatDouble:
    case DataFormatJS:
    case DataFormatCell:
    case DataFormatJSCell:
        // Should only be calling this function if we know this operand to be integer.
        ASSERT_NOT_REACHED();

    case DataFormatJSInteger: {
        GPRReg gpr = info.gpr();
        m_gprs.lock(gpr);
        m_jit.jitAssertIsJSInt32(gpr);
        returnFormat = DataFormatJSInteger;
        return gpr;
    }

    case DataFormatInteger: {
        GPRReg gpr = info.gpr();
        m_gprs.lock(gpr);
        m_jit.jitAssertIsInt32(gpr);
        returnFormat = DataFormatInteger;
        return gpr;
    }
    }

    ASSERT_NOT_REACHED();
    return InvalidGPRReg;
}

FPRReg JITCodeGenerator::fillDouble(NodeIndex nodeIndex)
{
    Node& node = m_jit.graph()[nodeIndex];
    VirtualRegister virtualRegister = node.virtualRegister();
    GenerationInfo& info = m_generationInfo[virtualRegister];

    if (info.registerFormat() == DataFormatNone) {
        GPRReg gpr = allocate();

        if (node.isConstant()) {
            if (isInt32Constant(nodeIndex)) {
                // FIXME: should not be reachable?
                m_jit.move(MacroAssembler::Imm32(valueOfInt32Constant(nodeIndex)), gpr);
                m_gprs.retain(gpr, virtualRegister, SpillOrderConstant);
                info.fillInteger(gpr);
                unlock(gpr);
            } else if (isDoubleConstant(nodeIndex)) {
                FPRReg fpr = fprAllocate();
                m_jit.move(MacroAssembler::ImmPtr(reinterpret_cast<void*>(reinterpretDoubleToIntptr(valueOfDoubleConstant(nodeIndex)))), gpr);
                m_jit.movePtrToDouble(gpr, fpr);
                unlock(gpr);

                m_fprs.retain(fpr, virtualRegister, SpillOrderDouble);
                info.fillDouble(fpr);
                return fpr;
            } else {
                // FIXME: should not be reachable?
                ASSERT(isJSConstant(nodeIndex));
                JSValue jsValue = valueOfJSConstant(nodeIndex);
                m_jit.move(MacroAssembler::ImmPtr(JSValue::encode(jsValue)), gpr);
                m_gprs.retain(gpr, virtualRegister, SpillOrderConstant);
                info.fillJSValue(gpr, DataFormatJS);
                unlock(gpr);
            }
        } else {
            DataFormat spillFormat = info.spillFormat();
            ASSERT(spillFormat & DataFormatJS);
            m_gprs.retain(gpr, virtualRegister, SpillOrderSpilled);
            m_jit.loadPtr(JITCompiler::addressFor(virtualRegister), gpr);
            info.fillJSValue(gpr, m_isSpeculative ? spillFormat : DataFormatJS);
            unlock(gpr);
        }
    }

    switch (info.registerFormat()) {
    case DataFormatNone:
        // Should have filled, above.
    case DataFormatCell:
    case DataFormatJSCell:
        // Should only be calling this function if we know this operand to be numeric.
        ASSERT_NOT_REACHED();

    case DataFormatJS: {
        GPRReg jsValueGpr = info.gpr();
        m_gprs.lock(jsValueGpr);
        FPRReg fpr = fprAllocate();
        GPRReg tempGpr = allocate(); // FIXME: can we skip this allocation on the last use of the virtual register?

        JITCompiler::Jump isInteger = m_jit.branchPtr(MacroAssembler::AboveOrEqual, jsValueGpr, GPRInfo::tagTypeNumberRegister);

        m_jit.jitAssertIsJSDouble(jsValueGpr);

        // First, if we get here we have a double encoded as a JSValue
        m_jit.move(jsValueGpr, tempGpr);
        m_jit.addPtr(GPRInfo::tagTypeNumberRegister, tempGpr);
        m_jit.movePtrToDouble(tempGpr, fpr);
        JITCompiler::Jump hasUnboxedDouble = m_jit.jump();

        // Finally, handle integers.
        isInteger.link(&m_jit);
        m_jit.convertInt32ToDouble(jsValueGpr, fpr);
        hasUnboxedDouble.link(&m_jit);

        m_gprs.release(jsValueGpr);
        m_gprs.unlock(jsValueGpr);
        m_gprs.unlock(tempGpr);
        m_fprs.retain(fpr, virtualRegister, SpillOrderDouble);
        info.fillDouble(fpr);
        return fpr;
    }

    case DataFormatJSInteger:
    case DataFormatInteger: {
        FPRReg fpr = fprAllocate();
        GPRReg gpr = info.gpr();
        m_gprs.lock(gpr);

        m_jit.convertInt32ToDouble(gpr, fpr);

        m_gprs.release(gpr);
        m_gprs.unlock(gpr);
        m_fprs.retain(fpr, virtualRegister, SpillOrderDouble);
        info.fillDouble(fpr);
        return fpr;
    }

    // Unbox the double
    case DataFormatJSDouble: {
        GPRReg gpr = info.gpr();
        FPRReg fpr = unboxDouble(gpr);

        m_gprs.release(gpr);
        m_fprs.retain(fpr, virtualRegister, SpillOrderDouble);

        info.fillDouble(fpr);
        return fpr;
    }

    case DataFormatDouble: {
        FPRReg fpr = info.fpr();
        m_fprs.lock(fpr);
        return fpr;
    }
    }

    ASSERT_NOT_REACHED();
    return InvalidFPRReg;
}

GPRReg JITCodeGenerator::fillJSValue(NodeIndex nodeIndex)
{
    Node& node = m_jit.graph()[nodeIndex];
    VirtualRegister virtualRegister = node.virtualRegister();
    GenerationInfo& info = m_generationInfo[virtualRegister];

    switch (info.registerFormat()) {
    case DataFormatNone: {
        GPRReg gpr = allocate();

        if (node.isConstant()) {
            if (isInt32Constant(nodeIndex)) {
                info.fillJSValue(gpr, DataFormatJSInteger);
                JSValue jsValue = jsNumber(valueOfInt32Constant(nodeIndex));
                m_jit.move(MacroAssembler::ImmPtr(JSValue::encode(jsValue)), gpr);
            } else if (isDoubleConstant(nodeIndex)) {
                info.fillJSValue(gpr, DataFormatJSDouble);
                JSValue jsValue(JSValue::EncodeAsDouble, valueOfDoubleConstant(nodeIndex));
                m_jit.move(MacroAssembler::ImmPtr(JSValue::encode(jsValue)), gpr);
            } else {
                ASSERT(isJSConstant(nodeIndex));
                JSValue jsValue = valueOfJSConstant(nodeIndex);
                m_jit.move(MacroAssembler::ImmPtr(JSValue::encode(jsValue)), gpr);
                info.fillJSValue(gpr, DataFormatJS);
            }

            m_gprs.retain(gpr, virtualRegister, SpillOrderConstant);
        } else {
            DataFormat spillFormat = info.spillFormat();
            ASSERT(spillFormat & DataFormatJS);
            m_gprs.retain(gpr, virtualRegister, SpillOrderSpilled);
            m_jit.loadPtr(JITCompiler::addressFor(virtualRegister), gpr);
            info.fillJSValue(gpr, m_isSpeculative ? spillFormat : DataFormatJS);
        }
        return gpr;
    }

    case DataFormatInteger: {
        GPRReg gpr = info.gpr();
        // If the register has already been locked we need to take a copy.
        // If not, we'll zero extend in place, so mark on the info that this is now type DataFormatInteger, not DataFormatJSInteger.
        if (m_gprs.isLocked(gpr)) {
            GPRReg result = allocate();
            m_jit.orPtr(GPRInfo::tagTypeNumberRegister, gpr, result);
            return result;
        }
        m_gprs.lock(gpr);
        m_jit.orPtr(GPRInfo::tagTypeNumberRegister, gpr);
        info.fillJSValue(gpr, DataFormatJSInteger);
        return gpr;
    }

    case DataFormatDouble: {
        FPRReg fpr = info.fpr();
        GPRReg gpr = boxDouble(fpr);

        // Update all info
        info.fillJSValue(gpr, DataFormatJSDouble);
        m_fprs.release(fpr);
        m_gprs.retain(gpr, virtualRegister, SpillOrderJS);

        return gpr;
    }

    case DataFormatCell:
        // No retag required on JSVALUE64!
    case DataFormatJS:
    case DataFormatJSInteger:
    case DataFormatJSDouble:
    case DataFormatJSCell: {
        GPRReg gpr = info.gpr();
        m_gprs.lock(gpr);
        return gpr;
    }
    }

    ASSERT_NOT_REACHED();
    return InvalidGPRReg;
}

void JITCodeGenerator::useChildren(Node& node)
{
    NodeIndex child1 = node.child1;
    if (child1 == NoNode) {
        ASSERT(node.child2 == NoNode && node.child3 == NoNode);
        return;
    }
    use(child1);

    NodeIndex child2 = node.child2;
    if (child2 == NoNode) {
        ASSERT(node.child3 == NoNode);
        return;
    }
    use(child2);

    NodeIndex child3 = node.child3;
    if (child3 == NoNode)
        return;
    use(child3);
}

#ifndef NDEBUG
static const char* dataFormatString(DataFormat format)
{
    // These values correspond to the DataFormat enum.
    const char* strings[] = {
        "[  ]",
        "[ i]",
        "[ d]",
        "[ c]",
        "Err!",
        "Err!",
        "Err!",
        "Err!",
        "[J ]",
        "[Ji]",
        "[Jd]",
        "[Jc]",
        "Err!",
        "Err!",
        "Err!",
        "Err!",
    };
    return strings[format];
}

void JITCodeGenerator::dump(const char* label)
{
    if (label)
        fprintf(stderr, "<%s>\n", label);

    fprintf(stderr, "  gprs:\n");
    m_gprs.dump();
    fprintf(stderr, "  fprs:\n");
    m_fprs.dump();
    fprintf(stderr, "  VirtualRegisters:\n");
    for (unsigned i = 0; i < m_generationInfo.size(); ++i) {
        GenerationInfo& info = m_generationInfo[i];
        if (info.alive())
            fprintf(stderr, "    % 3d:%s%s", i, dataFormatString(info.registerFormat()), dataFormatString(info.spillFormat()));
        else
            fprintf(stderr, "    % 3d:[__][__]", i);
        if (info.registerFormat() == DataFormatDouble)
            fprintf(stderr, ":fpr%d\n", info.fpr());
        else if (info.registerFormat() != DataFormatNone) {
            ASSERT(info.gpr() != InvalidGPRReg);
            fprintf(stderr, ":%s\n", GPRInfo::debugName(info.gpr()));
        } else
            fprintf(stderr, "\n");
    }
    if (label)
        fprintf(stderr, "</%s>\n", label);
}
#endif


#if DFG_CONSISTENCY_CHECK
void JITCodeGenerator::checkConsistency()
{
    bool failed = false;

    for (gpr_iterator iter = m_gprs.begin(); iter != m_gprs.end(); ++iter) {
        if (iter.isLocked()) {
            fprintf(stderr, "DFG_CONSISTENCY_CHECK failed: gpr %s is locked.\n", iter.debugName());
            failed = true;
        }
    }
    for (fpr_iterator iter = m_fprs.begin(); iter != m_fprs.end(); ++iter) {
        if (iter.isLocked()) {
            fprintf(stderr, "DFG_CONSISTENCY_CHECK failed: fpr %s is locked.\n", iter.debugName());
            failed = true;
        }
    }

    for (unsigned i = 0; i < m_generationInfo.size(); ++i) {
        VirtualRegister virtualRegister = (VirtualRegister)i;
        GenerationInfo& info = m_generationInfo[virtualRegister];
        if (!info.alive())
            continue;
        switch (info.registerFormat()) {
        case DataFormatNone:
            break;
        case DataFormatInteger:
        case DataFormatCell:
        case DataFormatJS:
        case DataFormatJSInteger:
        case DataFormatJSDouble:
        case DataFormatJSCell: {
            GPRReg gpr = info.gpr();
            ASSERT(gpr != InvalidGPRReg);
            if (m_gprs.name(gpr) != virtualRegister) {
                fprintf(stderr, "DFG_CONSISTENCY_CHECK failed: name mismatch for virtual register %d (gpr %s).\n", virtualRegister, GPRInfo::debugName(gpr));
                failed = true;
            }
            break;
        }
        case DataFormatDouble: {
            FPRReg fpr = info.fpr();
            ASSERT(fpr != InvalidFPRReg);
            if (m_fprs.name(fpr) != virtualRegister) {
                fprintf(stderr, "DFG_CONSISTENCY_CHECK failed: name mismatch for virtual register %d (fpr %s).\n", virtualRegister, FPRInfo::debugName(fpr));
                failed = true;
            }
            break;
        }
        }
    }

    for (gpr_iterator iter = m_gprs.begin(); iter != m_gprs.end(); ++iter) {
        VirtualRegister virtualRegister = iter.name();
        if (virtualRegister == InvalidVirtualRegister)
            continue;

        GenerationInfo& info = m_generationInfo[virtualRegister];
        if (iter.regID() != info.gpr()) {
            fprintf(stderr, "DFG_CONSISTENCY_CHECK failed: name mismatch for gpr %s (virtual register %d).\n", iter.debugName(), virtualRegister);
            failed = true;
        }
    }

    for (fpr_iterator iter = m_fprs.begin(); iter != m_fprs.end(); ++iter) {
        VirtualRegister virtualRegister = iter.name();
        if (virtualRegister == InvalidVirtualRegister)
            continue;

        GenerationInfo& info = m_generationInfo[virtualRegister];
        if (iter.regID() != info.fpr()) {
            fprintf(stderr, "DFG_CONSISTENCY_CHECK failed: name mismatch for fpr %s (virtual register %d).\n", iter.debugName(), virtualRegister);
            failed = true;
        }
    }

    if (failed) {
        dump();
        CRASH();
    }
}
#endif

GPRTemporary::GPRTemporary(JITCodeGenerator* jit)
    : m_jit(jit)
    , m_gpr(InvalidGPRReg)
{
    m_gpr = m_jit->allocate();
}

GPRTemporary::GPRTemporary(JITCodeGenerator* jit, SpeculateIntegerOperand& op1)
    : m_jit(jit)
    , m_gpr(InvalidGPRReg)
{
    if (m_jit->canReuse(op1.index()))
        m_gpr = m_jit->reuse(op1.gpr());
    else
        m_gpr = m_jit->allocate();
}

GPRTemporary::GPRTemporary(JITCodeGenerator* jit, SpeculateIntegerOperand& op1, SpeculateIntegerOperand& op2)
    : m_jit(jit)
    , m_gpr(InvalidGPRReg)
{
    if (m_jit->canReuse(op1.index()))
        m_gpr = m_jit->reuse(op1.gpr());
    else if (m_jit->canReuse(op2.index()))
        m_gpr = m_jit->reuse(op2.gpr());
    else
        m_gpr = m_jit->allocate();
}

GPRTemporary::GPRTemporary(JITCodeGenerator* jit, IntegerOperand& op1)
    : m_jit(jit)
    , m_gpr(InvalidGPRReg)
{
    if (m_jit->canReuse(op1.index()))
        m_gpr = m_jit->reuse(op1.gpr());
    else
        m_gpr = m_jit->allocate();
}

GPRTemporary::GPRTemporary(JITCodeGenerator* jit, IntegerOperand& op1, IntegerOperand& op2)
    : m_jit(jit)
    , m_gpr(InvalidGPRReg)
{
    if (m_jit->canReuse(op1.index()))
        m_gpr = m_jit->reuse(op1.gpr());
    else if (m_jit->canReuse(op2.index()))
        m_gpr = m_jit->reuse(op2.gpr());
    else
        m_gpr = m_jit->allocate();
}

GPRTemporary::GPRTemporary(JITCodeGenerator* jit, SpeculateCellOperand& op1)
    : m_jit(jit)
    , m_gpr(InvalidGPRReg)
{
    if (m_jit->canReuse(op1.index()))
        m_gpr = m_jit->reuse(op1.gpr());
    else
        m_gpr = m_jit->allocate();
}

GPRTemporary::GPRTemporary(JITCodeGenerator* jit, JSValueOperand& op1)
    : m_jit(jit)
    , m_gpr(InvalidGPRReg)
{
    if (m_jit->canReuse(op1.index()))
        m_gpr = m_jit->reuse(op1.gpr());
    else
        m_gpr = m_jit->allocate();
}

FPRTemporary::FPRTemporary(JITCodeGenerator* jit)
    : m_jit(jit)
    , m_fpr(InvalidFPRReg)
{
    m_fpr = m_jit->fprAllocate();
}

FPRTemporary::FPRTemporary(JITCodeGenerator* jit, DoubleOperand& op1)
    : m_jit(jit)
    , m_fpr(InvalidFPRReg)
{
    if (m_jit->canReuse(op1.index()))
        m_fpr = m_jit->reuse(op1.fpr());
    else
        m_fpr = m_jit->fprAllocate();
}

FPRTemporary::FPRTemporary(JITCodeGenerator* jit, DoubleOperand& op1, DoubleOperand& op2)
    : m_jit(jit)
    , m_fpr(InvalidFPRReg)
{
    if (m_jit->canReuse(op1.index()))
        m_fpr = m_jit->reuse(op1.fpr());
    else if (m_jit->canReuse(op2.index()))
        m_fpr = m_jit->reuse(op2.fpr());
    else
        m_fpr = m_jit->fprAllocate();
}

} } // namespace JSC::DFG

#endif
Commit	Line	Data
14957cd0 A	1	/*
	2	* Copyright (C) 2011 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	#include "config.h"
	27	#include "DFGJITCodeGenerator.h"
	28
	29	#if ENABLE(DFG_JIT)
	30
	31	#include "DFGNonSpeculativeJIT.h"
	32	#include "DFGSpeculativeJIT.h"
	33	#include "LinkBuffer.h"
	34
	35	namespace JSC { namespace DFG {
	36
	37	GPRReg JITCodeGenerator::fillInteger(NodeIndex nodeIndex, DataFormat& returnFormat)
	38	{
	39	Node& node = m_jit.graph()[nodeIndex];
	40	VirtualRegister virtualRegister = node.virtualRegister();
	41	GenerationInfo& info = m_generationInfo[virtualRegister];
	42
	43	if (info.registerFormat() == DataFormatNone) {
	44	GPRReg gpr = allocate();
	45
	46	if (node.isConstant()) {
	47	m_gprs.retain(gpr, virtualRegister, SpillOrderConstant);
	48	if (isInt32Constant(nodeIndex)) {
	49	m_jit.move(MacroAssembler::Imm32(valueOfInt32Constant(nodeIndex)), gpr);
	50	info.fillInteger(gpr);
	51	returnFormat = DataFormatInteger;
	52	return gpr;
	53	}
	54	if (isDoubleConstant(nodeIndex)) {
	55	JSValue jsValue = jsNumber(valueOfDoubleConstant(nodeIndex));
	56	m_jit.move(MacroAssembler::ImmPtr(JSValue::encode(jsValue)), gpr);
	57	} else {
	58	ASSERT(isJSConstant(nodeIndex));
	59	JSValue jsValue = valueOfJSConstant(nodeIndex);
	60	m_jit.move(MacroAssembler::ImmPtr(JSValue::encode(jsValue)), gpr);
	61	}
	62	} else {
	63	ASSERT(info.spillFormat() == DataFormatJS \|\| info.spillFormat() == DataFormatJSInteger);
	64	m_gprs.retain(gpr, virtualRegister, SpillOrderSpilled);
65	m_jit.loadPtr(JITCompiler::addressFor(virtualRegister), gpr);
66	}
67
68	// Since we statically know that we're filling an integer, and values
69	// in the RegisterFile are boxed, this must be DataFormatJSInteger.
70	// We will check this with a jitAssert below.
71	info.fillJSValue(gpr, DataFormatJSInteger);
72	unlock(gpr);
73	}
74
75	switch (info.registerFormat()) {
76	case DataFormatNone:
77	// Should have filled, above.
78	case DataFormatJSDouble:
79	case DataFormatDouble:
80	case DataFormatJS:
81	case DataFormatCell:
82	case DataFormatJSCell:
83	// Should only be calling this function if we know this operand to be integer.
84	ASSERT_NOT_REACHED();
85
86	case DataFormatJSInteger: {
87	GPRReg gpr = info.gpr();
88	m_gprs.lock(gpr);
89	m_jit.jitAssertIsJSInt32(gpr);
90	returnFormat = DataFormatJSInteger;
91	return gpr;
92	}
93
94	case DataFormatInteger: {
95	GPRReg gpr = info.gpr();
96	m_gprs.lock(gpr);
97	m_jit.jitAssertIsInt32(gpr);
98	returnFormat = DataFormatInteger;
99	return gpr;
100	}
101	}
102
103	ASSERT_NOT_REACHED();
104	return InvalidGPRReg;
105	}
106
107	FPRReg JITCodeGenerator::fillDouble(NodeIndex nodeIndex)
108	{
109	Node& node = m_jit.graph()[nodeIndex];
110	VirtualRegister virtualRegister = node.virtualRegister();
111	GenerationInfo& info = m_generationInfo[virtualRegister];
112
113	if (info.registerFormat() == DataFormatNone) {
114	GPRReg gpr = allocate();
115
116	if (node.isConstant()) {
117	if (isInt32Constant(nodeIndex)) {
118	// FIXME: should not be reachable?
119	m_jit.move(MacroAssembler::Imm32(valueOfInt32Constant(nodeIndex)), gpr);
120	m_gprs.retain(gpr, virtualRegister, SpillOrderConstant);
121	info.fillInteger(gpr);
122	unlock(gpr);
123	} else if (isDoubleConstant(nodeIndex)) {
124	FPRReg fpr = fprAllocate();
125	m_jit.move(MacroAssembler::ImmPtr(reinterpret_cast<void*>(reinterpretDoubleToIntptr(valueOfDoubleConstant(nodeIndex)))), gpr);
126	m_jit.movePtrToDouble(gpr, fpr);
127	unlock(gpr);
128
129	m_fprs.retain(fpr, virtualRegister, SpillOrderDouble);
130	info.fillDouble(fpr);
131	return fpr;
132	} else {
133	// FIXME: should not be reachable?
134	ASSERT(isJSConstant(nodeIndex));
135	JSValue jsValue = valueOfJSConstant(nodeIndex);
136	m_jit.move(MacroAssembler::ImmPtr(JSValue::encode(jsValue)), gpr);
137	m_gprs.retain(gpr, virtualRegister, SpillOrderConstant);
138	info.fillJSValue(gpr, DataFormatJS);
139	unlock(gpr);
140	}
141	} else {
142	DataFormat spillFormat = info.spillFormat();
143	ASSERT(spillFormat & DataFormatJS);
144	m_gprs.retain(gpr, virtualRegister, SpillOrderSpilled);
145	m_jit.loadPtr(JITCompiler::addressFor(virtualRegister), gpr);
146	info.fillJSValue(gpr, m_isSpeculative ? spillFormat : DataFormatJS);
147	unlock(gpr);
148	}
149	}
150
151	switch (info.registerFormat()) {
152	case DataFormatNone:
153	// Should have filled, above.
154	case DataFormatCell:
155	case DataFormatJSCell:
156	// Should only be calling this function if we know this operand to be numeric.
157	ASSERT_NOT_REACHED();
158
159	case DataFormatJS: {
160	GPRReg jsValueGpr = info.gpr();
161	m_gprs.lock(jsValueGpr);
162	FPRReg fpr = fprAllocate();
163	GPRReg tempGpr = allocate(); // FIXME: can we skip this allocation on the last use of the virtual register?
164
165	JITCompiler::Jump isInteger = m_jit.branchPtr(MacroAssembler::AboveOrEqual, jsValueGpr, GPRInfo::tagTypeNumberRegister);
166
167	m_jit.jitAssertIsJSDouble(jsValueGpr);
168
169	// First, if we get here we have a double encoded as a JSValue
170	m_jit.move(jsValueGpr, tempGpr);
171	m_jit.addPtr(GPRInfo::tagTypeNumberRegister, tempGpr);
172	m_jit.movePtrToDouble(tempGpr, fpr);
173	JITCompiler::Jump hasUnboxedDouble = m_jit.jump();
174
175	// Finally, handle integers.
176	isInteger.link(&m_jit);
177	m_jit.convertInt32ToDouble(jsValueGpr, fpr);
178	hasUnboxedDouble.link(&m_jit);
179
180	m_gprs.release(jsValueGpr);
181	m_gprs.unlock(jsValueGpr);
182	m_gprs.unlock(tempGpr);
183	m_fprs.retain(fpr, virtualRegister, SpillOrderDouble);
184	info.fillDouble(fpr);
185	return fpr;
186	}
187
188	case DataFormatJSInteger:
189	case DataFormatInteger: {
190	FPRReg fpr = fprAllocate();
191	GPRReg gpr = info.gpr();
192	m_gprs.lock(gpr);
193
194	m_jit.convertInt32ToDouble(gpr, fpr);
195
196	m_gprs.release(gpr);
197	m_gprs.unlock(gpr);
198	m_fprs.retain(fpr, virtualRegister, SpillOrderDouble);
199	info.fillDouble(fpr);
200	return fpr;
201	}
202
203	// Unbox the double
204	case DataFormatJSDouble: {
205	GPRReg gpr = info.gpr();
206	FPRReg fpr = unboxDouble(gpr);
207
208	m_gprs.release(gpr);
209	m_fprs.retain(fpr, virtualRegister, SpillOrderDouble);
210
211	info.fillDouble(fpr);
212	return fpr;
213	}
214
215	case DataFormatDouble: {
216	FPRReg fpr = info.fpr();
217	m_fprs.lock(fpr);
218	return fpr;
219	}
220	}
221
222	ASSERT_NOT_REACHED();
223	return InvalidFPRReg;
224	}
225
226	GPRReg JITCodeGenerator::fillJSValue(NodeIndex nodeIndex)
227	{
228	Node& node = m_jit.graph()[nodeIndex];
229	VirtualRegister virtualRegister = node.virtualRegister();
230	GenerationInfo& info = m_generationInfo[virtualRegister];
231
232	switch (info.registerFormat()) {
233	case DataFormatNone: {
234	GPRReg gpr = allocate();
235
236	if (node.isConstant()) {
237	if (isInt32Constant(nodeIndex)) {
238	info.fillJSValue(gpr, DataFormatJSInteger);
239	JSValue jsValue = jsNumber(valueOfInt32Constant(nodeIndex));
240	m_jit.move(MacroAssembler::ImmPtr(JSValue::encode(jsValue)), gpr);
241	} else if (isDoubleConstant(nodeIndex)) {
242	info.fillJSValue(gpr, DataFormatJSDouble);
243	JSValue jsValue(JSValue::EncodeAsDouble, valueOfDoubleConstant(nodeIndex));
244	m_jit.move(MacroAssembler::ImmPtr(JSValue::encode(jsValue)), gpr);
245	} else {
246	ASSERT(isJSConstant(nodeIndex));
247	JSValue jsValue = valueOfJSConstant(nodeIndex);
248	m_jit.move(MacroAssembler::ImmPtr(JSValue::encode(jsValue)), gpr);
249	info.fillJSValue(gpr, DataFormatJS);
250	}
251
252	m_gprs.retain(gpr, virtualRegister, SpillOrderConstant);
253	} else {
254	DataFormat spillFormat = info.spillFormat();
255	ASSERT(spillFormat & DataFormatJS);
256	m_gprs.retain(gpr, virtualRegister, SpillOrderSpilled);
257	m_jit.loadPtr(JITCompiler::addressFor(virtualRegister), gpr);
258	info.fillJSValue(gpr, m_isSpeculative ? spillFormat : DataFormatJS);
259	}
260	return gpr;
261	}
262
263	case DataFormatInteger: {
264	GPRReg gpr = info.gpr();
265	// If the register has already been locked we need to take a copy.
266	// If not, we'll zero extend in place, so mark on the info that this is now type DataFormatInteger, not DataFormatJSInteger.
267	if (m_gprs.isLocked(gpr)) {
268	GPRReg result = allocate();
269	m_jit.orPtr(GPRInfo::tagTypeNumberRegister, gpr, result);
270	return result;
271	}
272	m_gprs.lock(gpr);
273	m_jit.orPtr(GPRInfo::tagTypeNumberRegister, gpr);
274	info.fillJSValue(gpr, DataFormatJSInteger);
275	return gpr;
276	}
277
278	case DataFormatDouble: {
279	FPRReg fpr = info.fpr();
280	GPRReg gpr = boxDouble(fpr);
281
282	// Update all info
283	info.fillJSValue(gpr, DataFormatJSDouble);
284	m_fprs.release(fpr);
285	m_gprs.retain(gpr, virtualRegister, SpillOrderJS);
286
287	return gpr;
288	}
289
290	case DataFormatCell:
291	// No retag required on JSVALUE64!
292	case DataFormatJS:
293	case DataFormatJSInteger:
294	case DataFormatJSDouble:
295	case DataFormatJSCell: {
296	GPRReg gpr = info.gpr();
297	m_gprs.lock(gpr);
298	return gpr;
299	}
300	}
301
302	ASSERT_NOT_REACHED();
303	return InvalidGPRReg;
304	}
305
306	void JITCodeGenerator::useChildren(Node& node)
307	{
308	NodeIndex child1 = node.child1;
309	if (child1 == NoNode) {
310	ASSERT(node.child2 == NoNode && node.child3 == NoNode);
311	return;
312	}
313	use(child1);
314
315	NodeIndex child2 = node.child2;
316	if (child2 == NoNode) {
317	ASSERT(node.child3 == NoNode);
318	return;
319	}
320	use(child2);
321
322	NodeIndex child3 = node.child3;
323	if (child3 == NoNode)
324	return;
325	use(child3);
326	}
327
328	#ifndef NDEBUG
329	static const char* dataFormatString(DataFormat format)
330	{
331	// These values correspond to the DataFormat enum.
332	const char* strings[] = {
333	"[ ]",
334	"[ i]",
335	"[ d]",
336	"[ c]",
337	"Err!",
338	"Err!",
339	"Err!",
340	"Err!",
341	"[J ]",
342	"[Ji]",
343	"[Jd]",
344	"[Jc]",
345	"Err!",
346	"Err!",
347	"Err!",
348	"Err!",
349	};
350	return strings[format];
351	}
352
353	void JITCodeGenerator::dump(const char* label)
354	{
355	if (label)
356	fprintf(stderr, "<%s>\n", label);
357
358	fprintf(stderr, " gprs:\n");
359	m_gprs.dump();
360	fprintf(stderr, " fprs:\n");
361	m_fprs.dump();
362	fprintf(stderr, " VirtualRegisters:\n");
363	for (unsigned i = 0; i < m_generationInfo.size(); ++i) {
364	GenerationInfo& info = m_generationInfo[i];
365	if (info.alive())
366	fprintf(stderr, " % 3d:%s%s", i, dataFormatString(info.registerFormat()), dataFormatString(info.spillFormat()));
367	else
368	fprintf(stderr, " % 3d:[__][__]", i);
369	if (info.registerFormat() == DataFormatDouble)
370	fprintf(stderr, ":fpr%d\n", info.fpr());
371	else if (info.registerFormat() != DataFormatNone) {
372	ASSERT(info.gpr() != InvalidGPRReg);
373	fprintf(stderr, ":%s\n", GPRInfo::debugName(info.gpr()));
374	} else
375	fprintf(stderr, "\n");
376	}
377	if (label)
378	fprintf(stderr, "</%s>\n", label);
379	}
380	#endif
381
382
383	#if DFG_CONSISTENCY_CHECK
384	void JITCodeGenerator::checkConsistency()
385	{
386	bool failed = false;
387
388	for (gpr_iterator iter = m_gprs.begin(); iter != m_gprs.end(); ++iter) {
389	if (iter.isLocked()) {
390	fprintf(stderr, "DFG_CONSISTENCY_CHECK failed: gpr %s is locked.\n", iter.debugName());
391	failed = true;
392	}
393	}
394	for (fpr_iterator iter = m_fprs.begin(); iter != m_fprs.end(); ++iter) {
395	if (iter.isLocked()) {
396	fprintf(stderr, "DFG_CONSISTENCY_CHECK failed: fpr %s is locked.\n", iter.debugName());
397	failed = true;
398	}
399	}
400
401	for (unsigned i = 0; i < m_generationInfo.size(); ++i) {
402	VirtualRegister virtualRegister = (VirtualRegister)i;
403	GenerationInfo& info = m_generationInfo[virtualRegister];
404	if (!info.alive())
405	continue;
406	switch (info.registerFormat()) {
407	case DataFormatNone:
408	break;
409	case DataFormatInteger:
410	case DataFormatCell:
411	case DataFormatJS:
412	case DataFormatJSInteger:
413	case DataFormatJSDouble:
414	case DataFormatJSCell: {
415	GPRReg gpr = info.gpr();
416	ASSERT(gpr != InvalidGPRReg);
417	if (m_gprs.name(gpr) != virtualRegister) {
418	fprintf(stderr, "DFG_CONSISTENCY_CHECK failed: name mismatch for virtual register %d (gpr %s).\n", virtualRegister, GPRInfo::debugName(gpr));
419	failed = true;
420	}
421	break;
422	}
423	case DataFormatDouble: {
424	FPRReg fpr = info.fpr();
425	ASSERT(fpr != InvalidFPRReg);
426	if (m_fprs.name(fpr) != virtualRegister) {
427	fprintf(stderr, "DFG_CONSISTENCY_CHECK failed: name mismatch for virtual register %d (fpr %s).\n", virtualRegister, FPRInfo::debugName(fpr));
428	failed = true;
429	}
430	break;
431	}
432	}
433	}
434
435	for (gpr_iterator iter = m_gprs.begin(); iter != m_gprs.end(); ++iter) {
436	VirtualRegister virtualRegister = iter.name();
437	if (virtualRegister == InvalidVirtualRegister)
438	continue;
439
440	GenerationInfo& info = m_generationInfo[virtualRegister];
441	if (iter.regID() != info.gpr()) {
442	fprintf(stderr, "DFG_CONSISTENCY_CHECK failed: name mismatch for gpr %s (virtual register %d).\n", iter.debugName(), virtualRegister);
443	failed = true;
444	}
445	}
446
447	for (fpr_iterator iter = m_fprs.begin(); iter != m_fprs.end(); ++iter) {
448	VirtualRegister virtualRegister = iter.name();
449	if (virtualRegister == InvalidVirtualRegister)
450	continue;
451
452	GenerationInfo& info = m_generationInfo[virtualRegister];
453	if (iter.regID() != info.fpr()) {
454	fprintf(stderr, "DFG_CONSISTENCY_CHECK failed: name mismatch for fpr %s (virtual register %d).\n", iter.debugName(), virtualRegister);
455	failed = true;
456	}
457	}
458
459	if (failed) {
460	dump();
461	CRASH();
462	}
463	}
464	#endif
465
466	GPRTemporary::GPRTemporary(JITCodeGenerator* jit)
467	: m_jit(jit)
468	, m_gpr(InvalidGPRReg)
469	{
470	m_gpr = m_jit->allocate();
471	}
472
473	GPRTemporary::GPRTemporary(JITCodeGenerator* jit, SpeculateIntegerOperand& op1)
474	: m_jit(jit)
475	, m_gpr(InvalidGPRReg)
476	{
477	if (m_jit->canReuse(op1.index()))
478	m_gpr = m_jit->reuse(op1.gpr());
479	else
480	m_gpr = m_jit->allocate();
481	}
482
483	GPRTemporary::GPRTemporary(JITCodeGenerator* jit, SpeculateIntegerOperand& op1, SpeculateIntegerOperand& op2)
484	: m_jit(jit)
485	, m_gpr(InvalidGPRReg)
486	{
487	if (m_jit->canReuse(op1.index()))
488	m_gpr = m_jit->reuse(op1.gpr());
489	else if (m_jit->canReuse(op2.index()))
490	m_gpr = m_jit->reuse(op2.gpr());
491	else
492	m_gpr = m_jit->allocate();
493	}
494
495	GPRTemporary::GPRTemporary(JITCodeGenerator* jit, IntegerOperand& op1)
496	: m_jit(jit)
497	, m_gpr(InvalidGPRReg)
498	{
499	if (m_jit->canReuse(op1.index()))
500	m_gpr = m_jit->reuse(op1.gpr());
501	else
502	m_gpr = m_jit->allocate();
503	}
504
505	GPRTemporary::GPRTemporary(JITCodeGenerator* jit, IntegerOperand& op1, IntegerOperand& op2)
506	: m_jit(jit)
507	, m_gpr(InvalidGPRReg)
508	{
509	if (m_jit->canReuse(op1.index()))
510	m_gpr = m_jit->reuse(op1.gpr());
511	else if (m_jit->canReuse(op2.index()))
512	m_gpr = m_jit->reuse(op2.gpr());
513	else
514	m_gpr = m_jit->allocate();
515	}
516
517	GPRTemporary::GPRTemporary(JITCodeGenerator* jit, SpeculateCellOperand& op1)
518	: m_jit(jit)
519	, m_gpr(InvalidGPRReg)
520	{
521	if (m_jit->canReuse(op1.index()))
522	m_gpr = m_jit->reuse(op1.gpr());
523	else
524	m_gpr = m_jit->allocate();
525	}
526
527	GPRTemporary::GPRTemporary(JITCodeGenerator* jit, JSValueOperand& op1)
528	: m_jit(jit)
529	, m_gpr(InvalidGPRReg)
530	{
531	if (m_jit->canReuse(op1.index()))
532	m_gpr = m_jit->reuse(op1.gpr());
533	else
534	m_gpr = m_jit->allocate();
535	}
536
537	FPRTemporary::FPRTemporary(JITCodeGenerator* jit)
538	: m_jit(jit)
539	, m_fpr(InvalidFPRReg)
540	{
541	m_fpr = m_jit->fprAllocate();
542	}
543
544	FPRTemporary::FPRTemporary(JITCodeGenerator* jit, DoubleOperand& op1)
545	: m_jit(jit)
546	, m_fpr(InvalidFPRReg)
547	{
548	if (m_jit->canReuse(op1.index()))
549	m_fpr = m_jit->reuse(op1.fpr());
550	else
551	m_fpr = m_jit->fprAllocate();
552	}
553
554	FPRTemporary::FPRTemporary(JITCodeGenerator* jit, DoubleOperand& op1, DoubleOperand& op2)
555	: m_jit(jit)
556	, m_fpr(InvalidFPRReg)
557	{
558	if (m_jit->canReuse(op1.index()))
559	m_fpr = m_jit->reuse(op1.fpr());
560	else if (m_jit->canReuse(op2.index()))
561	m_fpr = m_jit->reuse(op2.fpr());
562	else
563	m_fpr = m_jit->fprAllocate();
564	}
565
566	} } // namespace JSC::DFG
567
568	#endif