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

/*
 * Copyright (C) 2012, 2013 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 "DFGVariableEventStream.h"

#if ENABLE(DFG_JIT)

#include "CodeBlock.h"
#include "DFGValueSource.h"
#include "Operations.h"
#include <wtf/DataLog.h>
#include <wtf/HashMap.h>

namespace JSC { namespace DFG {

void VariableEventStream::logEvent(const VariableEvent& event)
{
    dataLogF("seq#%u:", static_cast<unsigned>(size()));
    event.dump(WTF::dataFile());
    dataLogF(" ");
}

namespace {

struct MinifiedGenerationInfo {
    bool filled; // true -> in gpr/fpr/pair, false -> spilled
    VariableRepresentation u;
    DataFormat format;
    
    MinifiedGenerationInfo()
        : format(DataFormatNone)
    {
    }
    
    void update(const VariableEvent& event)
    {
        switch (event.kind()) {
        case BirthToFill:
        case Fill:
            filled = true;
            break;
        case BirthToSpill:
        case Spill:
            filled = false;
            break;
        case Death:
            format = DataFormatNone;
            return;
        default:
            return;
        }
        
        u = event.variableRepresentation();
        format = event.dataFormat();
    }
};

} // namespace

bool VariableEventStream::tryToSetConstantRecovery(ValueRecovery& recovery, CodeBlock* codeBlock, MinifiedNode* node) const
{
    if (!node)
        return false;
    
    if (node->hasConstantNumber()) {
        recovery = ValueRecovery::constant(
            codeBlock->constantRegister(
                FirstConstantRegisterIndex + node->constantNumber()).get());
        return true;
    }
    
    if (node->hasWeakConstant()) {
        recovery = ValueRecovery::constant(node->weakConstant());
        return true;
    }
    
    if (node->op() == PhantomArguments) {
        recovery = ValueRecovery::argumentsThatWereNotCreated();
        return true;
    }
    
    return false;
}

void VariableEventStream::reconstruct(
    CodeBlock* codeBlock, CodeOrigin codeOrigin, MinifiedGraph& graph,
    unsigned index, Operands<ValueRecovery>& valueRecoveries) const
{
    ASSERT(codeBlock->getJITType() == JITCode::DFGJIT);
    CodeBlock* baselineCodeBlock = codeBlock->baselineVersion();
    
    unsigned numVariables;
    if (codeOrigin.inlineCallFrame)
        numVariables = baselineCodeBlockForInlineCallFrame(codeOrigin.inlineCallFrame)->m_numCalleeRegisters + codeOrigin.inlineCallFrame->stackOffset;
    else
        numVariables = baselineCodeBlock->m_numCalleeRegisters;
    
    // Crazy special case: if we're at index == 0 then this must be an argument check
    // failure, in which case all variables are already set up. The recoveries should
    // reflect this.
    if (!index) {
        valueRecoveries = Operands<ValueRecovery>(codeBlock->numParameters(), numVariables);
        for (size_t i = 0; i < valueRecoveries.size(); ++i)
            valueRecoveries[i] = ValueRecovery::alreadyInJSStack();
        return;
    }
    
    // Step 1: Find the last checkpoint, and figure out the number of virtual registers as we go.
    unsigned startIndex = index - 1;
    while (at(startIndex).kind() != Reset)
        startIndex--;
    
#if DFG_ENABLE(DEBUG_VERBOSE)
    dataLogF("Computing OSR exit recoveries starting at seq#%u.\n", startIndex);
#endif

    // Step 2: Create a mock-up of the DFG's state and execute the events.
    Operands<ValueSource> operandSources(codeBlock->numParameters(), numVariables);
    HashMap<MinifiedID, MinifiedGenerationInfo> generationInfos;
    for (unsigned i = startIndex; i < index; ++i) {
        const VariableEvent& event = at(i);
        switch (event.kind()) {
        case Reset:
            // nothing to do.
            break;
        case BirthToFill:
        case BirthToSpill: {
            MinifiedGenerationInfo info;
            info.update(event);
            generationInfos.add(event.id(), info);
            break;
        }
        case Fill:
        case Spill:
        case Death: {
            HashMap<MinifiedID, MinifiedGenerationInfo>::iterator iter = generationInfos.find(event.id());
            ASSERT(iter != generationInfos.end());
            iter->value.update(event);
            break;
        }
        case MovHintEvent:
            if (operandSources.hasOperand(event.operand()))
                operandSources.setOperand(event.operand(), ValueSource(event.id()));
            break;
        case SetLocalEvent:
            if (operandSources.hasOperand(event.operand()))
                operandSources.setOperand(event.operand(), ValueSource::forDataFormat(event.dataFormat()));
            break;
        default:
            RELEASE_ASSERT_NOT_REACHED();
            break;
        }
    }
    
    // Step 3: Compute value recoveries!
    valueRecoveries = Operands<ValueRecovery>(codeBlock->numParameters(), numVariables);
    for (unsigned i = 0; i < operandSources.size(); ++i) {
        ValueSource& source = operandSources[i];
        if (source.isTriviallyRecoverable()) {
            valueRecoveries[i] = source.valueRecovery();
            continue;
        }
        
        ASSERT(source.kind() == HaveNode);
        MinifiedNode* node = graph.at(source.id());
        if (tryToSetConstantRecovery(valueRecoveries[i], codeBlock, node))
            continue;
        
        MinifiedGenerationInfo info = generationInfos.get(source.id());
        if (info.format == DataFormatNone) {
            // Try to see if there is an alternate node that would contain the value we want.
            // There are four possibilities:
            //
            // Int32ToDouble: We can use this in place of the original node, but
            //    we'd rather not; so we use it only if it is the only remaining
            //    live version.
            //
            // ValueToInt32: If the only remaining live version of the value is
            //    ValueToInt32, then we can use it.
            //
            // UInt32ToNumber: If the only live version of the value is a UInt32ToNumber
            //    then the only remaining uses are ones that want a properly formed number
            //    rather than a UInt32 intermediate.
            //
            // DoubleAsInt32: Same as UInt32ToNumber.
            //
            // The reverse of the above: This node could be a UInt32ToNumber, but its
            //    alternative is still alive. This means that the only remaining uses of
            //    the number would be fine with a UInt32 intermediate.
            
            bool found = false;
            
            if (node && node->op() == UInt32ToNumber) {
                MinifiedID id = node->child1();
                if (tryToSetConstantRecovery(valueRecoveries[i], codeBlock, graph.at(id)))
                    continue;
                info = generationInfos.get(id);
                if (info.format != DataFormatNone)
                    found = true;
            }
            
            if (!found) {
                MinifiedID int32ToDoubleID;
                MinifiedID valueToInt32ID;
                MinifiedID uint32ToNumberID;
                MinifiedID doubleAsInt32ID;
                
                HashMap<MinifiedID, MinifiedGenerationInfo>::iterator iter = generationInfos.begin();
                HashMap<MinifiedID, MinifiedGenerationInfo>::iterator end = generationInfos.end();
                for (; iter != end; ++iter) {
                    MinifiedID id = iter->key;
                    node = graph.at(id);
                    if (!node)
                        continue;
                    if (!node->hasChild1())
                        continue;
                    if (node->child1() != source.id())
                        continue;
                    if (iter->value.format == DataFormatNone)
                        continue;
                    switch (node->op()) {
                    case Int32ToDouble:
                    case ForwardInt32ToDouble:
                        int32ToDoubleID = id;
                        break;
                    case ValueToInt32:
                        valueToInt32ID = id;
                        break;
                    case UInt32ToNumber:
                        uint32ToNumberID = id;
                        break;
                    case DoubleAsInt32:
                        doubleAsInt32ID = id;
                        break;
                    default:
                        break;
                    }
                }
                
                MinifiedID idToUse;
                if (!!doubleAsInt32ID)
                    idToUse = doubleAsInt32ID;
                else if (!!int32ToDoubleID)
                    idToUse = int32ToDoubleID;
                else if (!!valueToInt32ID)
                    idToUse = valueToInt32ID;
                else if (!!uint32ToNumberID)
                    idToUse = uint32ToNumberID;
                
                if (!!idToUse) {
                    info = generationInfos.get(idToUse);
                    ASSERT(info.format != DataFormatNone);
                    found = true;
                }
            }
            
            if (!found) {
                valueRecoveries[i] = ValueRecovery::constant(jsUndefined());
                continue;
            }
        }
        
        ASSERT(info.format != DataFormatNone);
        
        if (info.filled) {
            if (info.format == DataFormatDouble) {
                valueRecoveries[i] = ValueRecovery::inFPR(info.u.fpr);
                continue;
            }
#if USE(JSVALUE32_64)
            if (info.format & DataFormatJS) {
                valueRecoveries[i] = ValueRecovery::inPair(info.u.pair.tagGPR, info.u.pair.payloadGPR);
                continue;
            }
#endif
            valueRecoveries[i] = ValueRecovery::inGPR(info.u.gpr, info.format);
            continue;
        }
        
        valueRecoveries[i] =
            ValueRecovery::displacedInJSStack(static_cast<VirtualRegister>(info.u.virtualReg), info.format);
    }
    
    // Step 4: Make sure that for locals that coincide with true call frame headers, the exit compiler knows
    // that those values don't have to be recovered. Signal this by using ValueRecovery::alreadyInJSStack()
    for (InlineCallFrame* inlineCallFrame = codeOrigin.inlineCallFrame; inlineCallFrame; inlineCallFrame = inlineCallFrame->caller.inlineCallFrame) {
        for (unsigned i = JSStack::CallFrameHeaderSize; i--;)
            valueRecoveries.setLocal(inlineCallFrame->stackOffset - i - 1, ValueRecovery::alreadyInJSStack());
    }
}

} } // namespace JSC::DFG

#endif // ENABLE(DFG_JIT)
Commit	Line	Data
93a37866 A	1	/*
	2	* Copyright (C) 2012, 2013 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 "DFGVariableEventStream.h"
	28
	29	#if ENABLE(DFG_JIT)
	30
	31	#include "CodeBlock.h"
	32	#include "DFGValueSource.h"
	33	#include "Operations.h"
	34	#include <wtf/DataLog.h>
	35	#include <wtf/HashMap.h>
	36
	37	namespace JSC { namespace DFG {
	38
	39	void VariableEventStream::logEvent(const VariableEvent& event)
	40	{
	41	dataLogF("seq#%u:", static_cast<unsigned>(size()));
	42	event.dump(WTF::dataFile());
	43	dataLogF(" ");
	44	}
	45
	46	namespace {
	47
	48	struct MinifiedGenerationInfo {
	49	bool filled; // true -> in gpr/fpr/pair, false -> spilled
	50	VariableRepresentation u;
	51	DataFormat format;
	52
	53	MinifiedGenerationInfo()
	54	: format(DataFormatNone)
	55	{
	56	}
	57
	58	void update(const VariableEvent& event)
	59	{
	60	switch (event.kind()) {
	61	case BirthToFill:
	62	case Fill:
	63	filled = true;
	64	break;
65	case BirthToSpill:
66	case Spill:
67	filled = false;
68	break;
69	case Death:
70	format = DataFormatNone;
71	return;
72	default:
73	return;
74	}
75
76	u = event.variableRepresentation();
77	format = event.dataFormat();
78	}
79	};
80
81	} // namespace
82
83	bool VariableEventStream::tryToSetConstantRecovery(ValueRecovery& recovery, CodeBlock* codeBlock, MinifiedNode* node) const
84	{
85	if (!node)
86	return false;
87
88	if (node->hasConstantNumber()) {
89	recovery = ValueRecovery::constant(
90	codeBlock->constantRegister(
91	FirstConstantRegisterIndex + node->constantNumber()).get());
92	return true;
93	}
94
95	if (node->hasWeakConstant()) {
96	recovery = ValueRecovery::constant(node->weakConstant());
97	return true;
98	}
99
100	if (node->op() == PhantomArguments) {
101	recovery = ValueRecovery::argumentsThatWereNotCreated();
102	return true;
103	}
104
105	return false;
106	}
107
108	void VariableEventStream::reconstruct(
109	CodeBlock* codeBlock, CodeOrigin codeOrigin, MinifiedGraph& graph,
110	unsigned index, Operands<ValueRecovery>& valueRecoveries) const
111	{
112	ASSERT(codeBlock->getJITType() == JITCode::DFGJIT);
113	CodeBlock* baselineCodeBlock = codeBlock->baselineVersion();
114
115	unsigned numVariables;
116	if (codeOrigin.inlineCallFrame)
117	numVariables = baselineCodeBlockForInlineCallFrame(codeOrigin.inlineCallFrame)->m_numCalleeRegisters + codeOrigin.inlineCallFrame->stackOffset;
118	else
119	numVariables = baselineCodeBlock->m_numCalleeRegisters;
120
121	// Crazy special case: if we're at index == 0 then this must be an argument check
122	// failure, in which case all variables are already set up. The recoveries should
123	// reflect this.
124	if (!index) {
125	valueRecoveries = Operands<ValueRecovery>(codeBlock->numParameters(), numVariables);
126	for (size_t i = 0; i < valueRecoveries.size(); ++i)
127	valueRecoveries[i] = ValueRecovery::alreadyInJSStack();
128	return;
129	}
130
131	// Step 1: Find the last checkpoint, and figure out the number of virtual registers as we go.
132	unsigned startIndex = index - 1;
133	while (at(startIndex).kind() != Reset)
134	startIndex--;
135
136	#if DFG_ENABLE(DEBUG_VERBOSE)
137	dataLogF("Computing OSR exit recoveries starting at seq#%u.\n", startIndex);
138	#endif
139
140	// Step 2: Create a mock-up of the DFG's state and execute the events.
141	Operands<ValueSource> operandSources(codeBlock->numParameters(), numVariables);
142	HashMap<MinifiedID, MinifiedGenerationInfo> generationInfos;
143	for (unsigned i = startIndex; i < index; ++i) {
144	const VariableEvent& event = at(i);
145	switch (event.kind()) {
146	case Reset:
147	// nothing to do.
148	break;
149	case BirthToFill:
150	case BirthToSpill: {
151	MinifiedGenerationInfo info;
152	info.update(event);
153	generationInfos.add(event.id(), info);
154	break;
155	}
156	case Fill:
157	case Spill:
158	case Death: {
159	HashMap<MinifiedID, MinifiedGenerationInfo>::iterator iter = generationInfos.find(event.id());
160	ASSERT(iter != generationInfos.end());
161	iter->value.update(event);
162	break;
163	}
164	case MovHintEvent:
165	if (operandSources.hasOperand(event.operand()))
166	operandSources.setOperand(event.operand(), ValueSource(event.id()));
167	break;
168	case SetLocalEvent:
169	if (operandSources.hasOperand(event.operand()))
170	operandSources.setOperand(event.operand(), ValueSource::forDataFormat(event.dataFormat()));
171	break;
172	default:
173	RELEASE_ASSERT_NOT_REACHED();
174	break;
175	}
176	}
177
178	// Step 3: Compute value recoveries!
179	valueRecoveries = Operands<ValueRecovery>(codeBlock->numParameters(), numVariables);
180	for (unsigned i = 0; i < operandSources.size(); ++i) {
181	ValueSource& source = operandSources[i];
182	if (source.isTriviallyRecoverable()) {
183	valueRecoveries[i] = source.valueRecovery();
184	continue;
185	}
186
187	ASSERT(source.kind() == HaveNode);
188	MinifiedNode* node = graph.at(source.id());
189	if (tryToSetConstantRecovery(valueRecoveries[i], codeBlock, node))
190	continue;
191
192	MinifiedGenerationInfo info = generationInfos.get(source.id());
193	if (info.format == DataFormatNone) {
194	// Try to see if there is an alternate node that would contain the value we want.
195	// There are four possibilities:
196	//
197	// Int32ToDouble: We can use this in place of the original node, but
198	// we'd rather not; so we use it only if it is the only remaining
199	// live version.
200	//
201	// ValueToInt32: If the only remaining live version of the value is
202	// ValueToInt32, then we can use it.
203	//
204	// UInt32ToNumber: If the only live version of the value is a UInt32ToNumber
205	// then the only remaining uses are ones that want a properly formed number
206	// rather than a UInt32 intermediate.
207	//
208	// DoubleAsInt32: Same as UInt32ToNumber.
209	//
210	// The reverse of the above: This node could be a UInt32ToNumber, but its
211	// alternative is still alive. This means that the only remaining uses of
212	// the number would be fine with a UInt32 intermediate.
213
214	bool found = false;
215
216	if (node && node->op() == UInt32ToNumber) {
217	MinifiedID id = node->child1();
218	if (tryToSetConstantRecovery(valueRecoveries[i], codeBlock, graph.at(id)))
219	continue;
220	info = generationInfos.get(id);
221	if (info.format != DataFormatNone)
222	found = true;
223	}
224
225	if (!found) {
226	MinifiedID int32ToDoubleID;
227	MinifiedID valueToInt32ID;
228	MinifiedID uint32ToNumberID;
229	MinifiedID doubleAsInt32ID;
230
231	HashMap<MinifiedID, MinifiedGenerationInfo>::iterator iter = generationInfos.begin();
232	HashMap<MinifiedID, MinifiedGenerationInfo>::iterator end = generationInfos.end();
233	for (; iter != end; ++iter) {
234	MinifiedID id = iter->key;
235	node = graph.at(id);
236	if (!node)
237	continue;
238	if (!node->hasChild1())
239	continue;
240	if (node->child1() != source.id())
241	continue;
242	if (iter->value.format == DataFormatNone)
243	continue;
244	switch (node->op()) {
245	case Int32ToDouble:
246	case ForwardInt32ToDouble:
247	int32ToDoubleID = id;
248	break;
249	case ValueToInt32:
250	valueToInt32ID = id;
251	break;
252	case UInt32ToNumber:
253	uint32ToNumberID = id;
254	break;
255	case DoubleAsInt32:
256	doubleAsInt32ID = id;
257	break;
258	default:
259	break;
260	}
261	}
262
263	MinifiedID idToUse;
264	if (!!doubleAsInt32ID)
265	idToUse = doubleAsInt32ID;
266	else if (!!int32ToDoubleID)
267	idToUse = int32ToDoubleID;
268	else if (!!valueToInt32ID)
269	idToUse = valueToInt32ID;
270	else if (!!uint32ToNumberID)
271	idToUse = uint32ToNumberID;
272
273	if (!!idToUse) {
274	info = generationInfos.get(idToUse);
275	ASSERT(info.format != DataFormatNone);
276	found = true;
277	}
278	}
279
280	if (!found) {
281	valueRecoveries[i] = ValueRecovery::constant(jsUndefined());
282	continue;
283	}
284	}
285
286	ASSERT(info.format != DataFormatNone);
287
288	if (info.filled) {
289	if (info.format == DataFormatDouble) {
290	valueRecoveries[i] = ValueRecovery::inFPR(info.u.fpr);
291	continue;
292	}
293	#if USE(JSVALUE32_64)
294	if (info.format & DataFormatJS) {
295	valueRecoveries[i] = ValueRecovery::inPair(info.u.pair.tagGPR, info.u.pair.payloadGPR);
296	continue;
297	}
298	#endif
299	valueRecoveries[i] = ValueRecovery::inGPR(info.u.gpr, info.format);
300	continue;
301	}
302
303	valueRecoveries[i] =
304	ValueRecovery::displacedInJSStack(static_cast<VirtualRegister>(info.u.virtualReg), info.format);
305	}
306
307	// Step 4: Make sure that for locals that coincide with true call frame headers, the exit compiler knows
308	// that those values don't have to be recovered. Signal this by using ValueRecovery::alreadyInJSStack()
309	for (InlineCallFrame* inlineCallFrame = codeOrigin.inlineCallFrame; inlineCallFrame; inlineCallFrame = inlineCallFrame->caller.inlineCallFrame) {
310	for (unsigned i = JSStack::CallFrameHeaderSize; i--;)
311	valueRecoveries.setLocal(inlineCallFrame->stackOffset - i - 1, ValueRecovery::alreadyInJSStack());
312	}
313	}
314
315	} } // namespace JSC::DFG
316
317	#endif // ENABLE(DFG_JIT)
318