0c8ffef84f2fb38c3063c29ae409d1e304fb62b5
[WebKit-https.git] / Source / JavaScriptCore / dfg / DFGJITCompiler.cpp
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 "DFGJITCompiler.h"
28
29 #if ENABLE(DFG_JIT)
30
31 #include "CodeBlock.h"
32 #include "DFGJITCodeGenerator.h"
33 #include "DFGNonSpeculativeJIT.h"
34 #include "DFGOperations.h"
35 #include "DFGRegisterBank.h"
36 #include "DFGSpeculativeJIT.h"
37 #include "JSGlobalData.h"
38 #include "LinkBuffer.h"
39
40 namespace JSC { namespace DFG {
41
42 // This method used to fill a numeric value to a FPR when linking speculative -> non-speculative.
43 void JITCompiler::fillNumericToDouble(NodeIndex nodeIndex, FPRReg fpr, GPRReg temporary)
44 {
45     Node& node = graph()[nodeIndex];
46
47     if (node.isConstant()) {
48         ASSERT(node.op == DoubleConstant);
49         move(MacroAssembler::ImmPtr(reinterpret_cast<void*>(reinterpretDoubleToIntptr(valueOfDoubleConstant(nodeIndex)))), temporary);
50         movePtrToDouble(temporary, fpr);
51     } else {
52         loadPtr(addressFor(node.virtualRegister()), temporary);
53         Jump isInteger = branchPtr(MacroAssembler::AboveOrEqual, temporary, GPRInfo::tagTypeNumberRegister);
54         jitAssertIsJSDouble(temporary);
55         addPtr(GPRInfo::tagTypeNumberRegister, temporary);
56         movePtrToDouble(temporary, fpr);
57         Jump hasUnboxedDouble = jump();
58         isInteger.link(this);
59         convertInt32ToDouble(temporary, fpr);
60         hasUnboxedDouble.link(this);
61     }
62 }
63
64 // This method used to fill an integer value to a GPR when linking speculative -> non-speculative.
65 void JITCompiler::fillInt32ToInteger(NodeIndex nodeIndex, GPRReg gpr)
66 {
67     Node& node = graph()[nodeIndex];
68
69     if (node.isConstant()) {
70         ASSERT(node.op == Int32Constant);
71         move(MacroAssembler::Imm32(valueOfInt32Constant(nodeIndex)), gpr);
72     } else {
73 #if DFG_JIT_ASSERT
74         // Redundant load, just so we can check the tag!
75         loadPtr(addressFor(node.virtualRegister()), gpr);
76         jitAssertIsJSInt32(gpr);
77 #endif
78         load32(addressFor(node.virtualRegister()), gpr);
79     }
80 }
81
82 // This method used to fill a JSValue to a GPR when linking speculative -> non-speculative.
83 void JITCompiler::fillToJS(NodeIndex nodeIndex, GPRReg gpr)
84 {
85     Node& node = graph()[nodeIndex];
86
87     if (node.isConstant()) {
88         if (isInt32Constant(nodeIndex)) {
89             JSValue jsValue = jsNumber(valueOfInt32Constant(nodeIndex));
90             move(MacroAssembler::ImmPtr(JSValue::encode(jsValue)), gpr);
91         } else if (isDoubleConstant(nodeIndex)) {
92             JSValue jsValue(JSValue::EncodeAsDouble, valueOfDoubleConstant(nodeIndex));
93             move(MacroAssembler::ImmPtr(JSValue::encode(jsValue)), gpr);
94         } else {
95             ASSERT(isJSConstant(nodeIndex));
96             JSValue jsValue = valueOfJSConstant(nodeIndex);
97             move(MacroAssembler::ImmPtr(JSValue::encode(jsValue)), gpr);
98         }
99         return;
100     }
101
102     loadPtr(addressFor(node.virtualRegister()), gpr);
103 }
104
105 void JITCompiler::jumpFromSpeculativeToNonSpeculative(const SpeculationCheck& check, const EntryLocation& entry, SpeculationRecovery* recovery)
106 {
107     ASSERT(check.m_nodeIndex == entry.m_nodeIndex);
108
109     // Link the jump from the Speculative path to here.
110     check.m_check.link(this);
111
112 #if DFG_DEBUG_VERBOSE
113     fprintf(stderr, "Speculation failure for Node @%d at JIT offset 0x%x\n", (int)check.m_nodeIndex, debugOffset());
114 #endif
115 #if DFG_JIT_BREAK_ON_SPECULATION_FAILURE
116     breakpoint();
117 #endif
118
119     // Does this speculation check require any additional recovery to be performed,
120     // to restore any state that has been overwritten before we enter back in to the
121     // non-speculative path.
122     if (recovery) {
123         // The only additional recovery we currently support is for integer add operation
124         ASSERT(recovery->type() == SpeculativeAdd);
125         // Revert the add.
126         sub32(recovery->src(), recovery->dest());
127     }
128
129     // FIXME: - This is hideously inefficient!
130     // Where a value is live in a register in the speculative path, and is required in a register
131     // on the non-speculative path, we should not need to be spilling it and reloading (we may
132     // need to spill anyway, if the value is marked as spilled on the non-speculative path).
133     // This may also be spilling values that don't need spilling, e.g. are already spilled,
134     // are constants, or are arguments.
135
136     // Spill all GPRs in use by the speculative path.
137     for (unsigned index = 0; index < GPRInfo::numberOfRegisters; ++index) {
138         NodeIndex nodeIndex = check.m_gprInfo[index].nodeIndex;
139         if (nodeIndex == NoNode)
140             continue;
141
142         DataFormat dataFormat = check.m_gprInfo[index].format;
143         VirtualRegister virtualRegister = graph()[nodeIndex].virtualRegister();
144
145         ASSERT(dataFormat == DataFormatInteger || DataFormatCell || dataFormat & DataFormatJS);
146         if (dataFormat == DataFormatInteger)
147             orPtr(GPRInfo::tagTypeNumberRegister, GPRInfo::toRegister(index));
148         storePtr(GPRInfo::toRegister(index), addressFor(virtualRegister));
149     }
150
151     // Spill all FPRs in use by the speculative path.
152     for (unsigned index = 0; index < FPRInfo::numberOfRegisters; ++index) {
153         NodeIndex nodeIndex = check.m_fprInfo[index];
154         if (nodeIndex == NoNode)
155             continue;
156
157         VirtualRegister virtualRegister = graph()[nodeIndex].virtualRegister();
158
159         moveDoubleToPtr(FPRInfo::toRegister(index), GPRInfo::regT0);
160         subPtr(GPRInfo::tagTypeNumberRegister, GPRInfo::regT0);
161         storePtr(GPRInfo::regT0, addressFor(virtualRegister));
162     }
163
164     // Fill all FPRs in use by the non-speculative path.
165     for (unsigned index = 0; index < FPRInfo::numberOfRegisters; ++index) {
166         NodeIndex nodeIndex = entry.m_fprInfo[index];
167         if (nodeIndex == NoNode)
168             continue;
169
170         fillNumericToDouble(nodeIndex, FPRInfo::toRegister(index), GPRInfo::regT0);
171     }
172
173     // Fill all GPRs in use by the non-speculative path.
174     for (unsigned index = 0; index < GPRInfo::numberOfRegisters; ++index) {
175         NodeIndex nodeIndex = entry.m_gprInfo[index].nodeIndex;
176         if (nodeIndex == NoNode)
177             continue;
178
179         DataFormat dataFormat = entry.m_gprInfo[index].format;
180         if (dataFormat == DataFormatInteger)
181             fillInt32ToInteger(nodeIndex, GPRInfo::toRegister(index));
182         else {
183             ASSERT(dataFormat & DataFormatJS || dataFormat == DataFormatCell); // Treat cell as JSValue for now!
184             fillToJS(nodeIndex, GPRInfo::toRegister(index));
185             // FIXME: For subtypes of DataFormatJS, should jitAssert the subtype?
186         }
187     }
188
189     // Jump into the non-speculative path.
190     jump(entry.m_entry);
191 }
192
193 void JITCompiler::linkSpeculationChecks(SpeculativeJIT& speculative, NonSpeculativeJIT& nonSpeculative)
194 {
195     // Iterators to walk over the set of bail outs & corresponding entry points.
196     SpeculationCheckVector::Iterator checksIter = speculative.speculationChecks().begin();
197     SpeculationCheckVector::Iterator checksEnd = speculative.speculationChecks().end();
198     NonSpeculativeJIT::EntryLocationVector::Iterator entriesIter = nonSpeculative.entryLocations().begin();
199     NonSpeculativeJIT::EntryLocationVector::Iterator entriesEnd = nonSpeculative.entryLocations().end();
200
201     // Iterate over the speculation checks.
202     while (checksIter != checksEnd) {
203         // For every bail out from the speculative path, we must have provided an entry point
204         // into the non-speculative one.
205         ASSERT(checksIter->m_nodeIndex == entriesIter->m_nodeIndex);
206
207         // There may be multiple bail outs that map to the same entry point!
208         do {
209             ASSERT(checksIter != checksEnd);
210             ASSERT(entriesIter != entriesEnd);
211
212             // Plant code to link this speculation failure.
213             const SpeculationCheck& check = *checksIter;
214             const EntryLocation& entry = *entriesIter;
215             jumpFromSpeculativeToNonSpeculative(check, entry, speculative.speculationRecovery(check.m_recoveryIndex));
216              ++checksIter;
217         } while (checksIter != checksEnd && checksIter->m_nodeIndex == entriesIter->m_nodeIndex);
218          ++entriesIter;
219     }
220
221     // FIXME: https://bugs.webkit.org/show_bug.cgi?id=56289
222     ASSERT(!(checksIter != checksEnd));
223     ASSERT(!(entriesIter != entriesEnd));
224 }
225
226 void JITCompiler::compileFunction(JITCode& entry, MacroAssemblerCodePtr& entryWithArityCheck)
227 {
228     // === Stage 1 - Function header code generation ===
229     //
230     // This code currently matches the old JIT. In the function header we need to
231     // pop the return address (since we do not allow any recursion on the machine
232     // stack), and perform a fast register file check.
233
234     // This is the main entry point, without performing an arity check.
235     // FIXME: https://bugs.webkit.org/show_bug.cgi?id=56292
236     // We'll need to convert the remaining cti_ style calls (specifically the register file
237     // check) which will be dependent on stack layout. (We'd need to account for this in
238     // both normal return code and when jumping to an exception handler).
239     preserveReturnAddressAfterCall(GPRInfo::regT2);
240     emitPutToCallFrameHeader(GPRInfo::regT2, RegisterFile::ReturnPC);
241     // If we needed to perform an arity check we will already have moved the return address,
242     // so enter after this.
243     Label fromArityCheck(this);
244
245     // Setup a pointer to the codeblock in the CallFrameHeader.
246     emitPutImmediateToCallFrameHeader(m_codeBlock, RegisterFile::CodeBlock);
247
248     // Plant a check that sufficient space is available in the RegisterFile.
249     // FIXME: https://bugs.webkit.org/show_bug.cgi?id=56291
250     addPtr(Imm32(m_codeBlock->m_numCalleeRegisters * sizeof(Register)), GPRInfo::callFrameRegister, GPRInfo::regT1);
251     Jump registerFileCheck = branchPtr(Below, AbsoluteAddress(m_globalData->interpreter->registerFile().addressOfEnd()), GPRInfo::regT1);
252     // Return here after register file check.
253     Label fromRegisterFileCheck = label();
254
255
256     // === Stage 2 - Function body code generation ===
257     //
258     // We generate the speculative code path, followed by the non-speculative
259     // code for the function. Next we need to link the two together, making
260     // bail-outs from the speculative path jump to the corresponding point on
261     // the non-speculative one (and generating any code necessary to juggle
262     // register values around, rebox values, and ensure spilled, to match the
263     // non-speculative path's requirements).
264
265 #if DFG_JIT_BREAK_ON_EVERY_FUNCTION
266     // Handy debug tool!
267     breakpoint();
268 #endif
269
270     // First generate the speculative path.
271     Label speculativePathBegin = label();
272     SpeculativeJIT speculative(*this);
273 #if !DFG_DEBUG_LOCAL_DISBALE_SPECULATIVE
274     bool compiledSpeculative = speculative.compile();
275 #else
276     bool compiledSpeculative = false;
277 #endif
278
279     // Next, generate the non-speculative path. We pass this a SpeculationCheckIndexIterator
280     // to allow it to check which nodes in the graph may bail out, and may need to reenter the
281     // non-speculative path.
282     if (compiledSpeculative) {
283         SpeculationCheckIndexIterator checkIterator(speculative.speculationChecks());
284         NonSpeculativeJIT nonSpeculative(*this);
285         nonSpeculative.compile(checkIterator);
286
287         // Link the bail-outs from the speculative path to the corresponding entry points into the non-speculative one.
288         linkSpeculationChecks(speculative, nonSpeculative);
289     } else {
290 #if DFG_DEBUG_VERBOSE
291         fprintf(stderr, "SpeculativeJIT was terminated.\n");
292 #endif
293
294         // If compilation through the SpeculativeJIT failed, throw away the code we generated.
295         m_calls.clear();
296         m_propertyAccesses.clear();
297         rewindToLabel(speculativePathBegin);
298
299         SpeculationCheckVector noChecks;
300         SpeculationCheckIndexIterator checkIterator(noChecks);
301         NonSpeculativeJIT nonSpeculative(*this);
302         nonSpeculative.compile(checkIterator);
303     }
304
305     // === Stage 3 - Function footer code generation ===
306     //
307     // Generate code to lookup and jump to exception handlers, to perform the slow
308     // register file check (if the fast one in the function header fails), and
309     // generate the entry point with arity check.
310
311     // Iterate over the m_calls vector, checking for exception checks,
312     // and linking them to here.
313     unsigned exceptionCheckCount = 0;
314     for (unsigned i = 0; i < m_calls.size(); ++i) {
315         Jump& exceptionCheck = m_calls[i].m_exceptionCheck;
316         if (exceptionCheck.isSet()) {
317             exceptionCheck.link(this);
318             ++exceptionCheckCount;
319         }
320     }
321     // If any exception checks were linked, generate code to lookup a handler.
322     if (exceptionCheckCount) {
323         // lookupExceptionHandler is passed two arguments, exec (the CallFrame*), and
324         // an identifier for the operation that threw the exception, which we can use
325         // to look up handler information. The identifier we use is the return address
326         // of the call out from JIT code that threw the exception; this is still
327         // available on the stack, just below the stack pointer!
328         move(GPRInfo::callFrameRegister, GPRInfo::argumentGPR0);
329         peek(GPRInfo::argumentGPR1, -1);
330         m_calls.append(CallRecord(call(), lookupExceptionHandler));
331         // lookupExceptionHandler leaves the handler CallFrame* in the returnValueGPR,
332         // and the address of the handler in returnValueGPR2.
333         jump(GPRInfo::returnValueGPR2);
334     }
335
336     // Generate the register file check; if the fast check in the function head fails,
337     // we need to call out to a helper function to check whether more space is available.
338     // FIXME: change this from a cti call to a DFG style operation (normal C calling conventions).
339     registerFileCheck.link(this);
340     move(stackPointerRegister, GPRInfo::argumentGPR0);
341     poke(GPRInfo::callFrameRegister, OBJECT_OFFSETOF(struct JITStackFrame, callFrame) / sizeof(void*));
342     Call callRegisterFileCheck = call();
343     jump(fromRegisterFileCheck);
344
345     // The fast entry point into a function does not check the correct number of arguments
346     // have been passed to the call (we only use the fast entry point where we can statically
347     // determine the correct number of arguments have been passed, or have already checked).
348     // In cases where an arity check is necessary, we enter here.
349     // FIXME: change this from a cti call to a DFG style operation (normal C calling conventions).
350     Label arityCheck = label();
351     preserveReturnAddressAfterCall(GPRInfo::regT2);
352     emitPutToCallFrameHeader(GPRInfo::regT2, RegisterFile::ReturnPC);
353     branch32(Equal, GPRInfo::regT1, Imm32(m_codeBlock->m_numParameters)).linkTo(fromArityCheck, this);
354     move(stackPointerRegister, GPRInfo::argumentGPR0);
355     poke(GPRInfo::callFrameRegister, OBJECT_OFFSETOF(struct JITStackFrame, callFrame) / sizeof(void*));
356     Call callArityCheck = call();
357     move(GPRInfo::regT0, GPRInfo::callFrameRegister);
358     jump(fromArityCheck);
359
360
361     // === Stage 4 - Link ===
362     //
363     // Link the code, populate data in CodeBlock data structures.
364
365     LinkBuffer linkBuffer(*m_globalData, this, m_globalData->executableAllocator);
366
367 #if DFG_DEBUG_VERBOSE
368     fprintf(stderr, "JIT code start at %p\n", linkBuffer.debugAddress());
369 #endif
370
371     // Link all calls out from the JIT code to their respective functions.
372     for (unsigned i = 0; i < m_calls.size(); ++i)
373         linkBuffer.link(m_calls[i].m_call, m_calls[i].m_function);
374
375     if (m_codeBlock->needsCallReturnIndices()) {
376         m_codeBlock->callReturnIndexVector().reserveCapacity(exceptionCheckCount);
377         for (unsigned i = 0; i < m_calls.size(); ++i) {
378             if (m_calls[i].m_exceptionCheck.isSet()) {
379                 unsigned returnAddressOffset = linkBuffer.returnAddressOffset(m_calls[i].m_call);
380                 unsigned exceptionInfo = m_calls[i].m_exceptionInfo;
381                 m_codeBlock->callReturnIndexVector().append(CallReturnOffsetToBytecodeOffset(returnAddressOffset, exceptionInfo));
382             }
383         }
384     }
385
386     m_codeBlock->setNumberOfStructureStubInfos(m_propertyAccesses.size());
387     for (unsigned i = 0; i < m_propertyAccesses.size(); ++i) {
388         StructureStubInfo& info = m_codeBlock->structureStubInfo(i);
389         info.callReturnLocation = linkBuffer.locationOf(m_propertyAccesses[i].m_functionCall);
390         info.u.unset.deltaCheckToCall = m_propertyAccesses[i].m_deltaCheckToCall;
391         info.u.unset.deltaCallToLoad = m_propertyAccesses[i].m_deltaCallToLoad;
392     }
393
394     // FIXME: switch the register file check & arity check over to DFGOpertaion style calls, not JIT stubs.
395     linkBuffer.link(callRegisterFileCheck, cti_register_file_check);
396     linkBuffer.link(callArityCheck, m_codeBlock->m_isConstructor ? cti_op_construct_arityCheck : cti_op_call_arityCheck);
397
398     entryWithArityCheck = linkBuffer.locationOf(arityCheck);
399     entry = linkBuffer.finalizeCode();
400 }
401
402 #if DFG_JIT_ASSERT
403 void JITCompiler::jitAssertIsInt32(GPRReg gpr)
404 {
405 #if CPU(X86_64)
406     Jump checkInt32 = branchPtr(BelowOrEqual, gpr, TrustedImmPtr(reinterpret_cast<void*>(static_cast<uintptr_t>(0xFFFFFFFFu))));
407     breakpoint();
408     checkInt32.link(this);
409 #else
410     UNUSED_PARAM(gpr);
411 #endif
412 }
413
414 void JITCompiler::jitAssertIsJSInt32(GPRReg gpr)
415 {
416     Jump checkJSInt32 = branchPtr(AboveOrEqual, gpr, GPRInfo::tagTypeNumberRegister);
417     breakpoint();
418     checkJSInt32.link(this);
419 }
420
421 void JITCompiler::jitAssertIsJSNumber(GPRReg gpr)
422 {
423     Jump checkJSNumber = branchTestPtr(MacroAssembler::NonZero, gpr, GPRInfo::tagTypeNumberRegister);
424     breakpoint();
425     checkJSNumber.link(this);
426 }
427
428 void JITCompiler::jitAssertIsJSDouble(GPRReg gpr)
429 {
430     Jump checkJSInt32 = branchPtr(AboveOrEqual, gpr, GPRInfo::tagTypeNumberRegister);
431     Jump checkJSNumber = branchTestPtr(MacroAssembler::NonZero, gpr, GPRInfo::tagTypeNumberRegister);
432     checkJSInt32.link(this);
433     breakpoint();
434     checkJSNumber.link(this);
435 }
436 #endif
437
438 #if ENABLE(SAMPLING_COUNTERS) && CPU(X86_64) // Or any other 64-bit platform!
439 void JITCompiler::emitCount(AbstractSamplingCounter& counter, uint32_t increment)
440 {
441     addPtr(TrustedImm32(increment), AbsoluteAddress(counter.addressOfCounter()));
442 }
443 #endif
444
445 #if ENABLE(SAMPLING_COUNTERS) && CPU(X86) // Or any other little-endian 32-bit platform!
446 void JITCompiler::emitCount(AbstractSamplingCounter& counter, uint32_t increment)
447 {
448     intptr_t hiWord = reinterpret_cast<intptr_t>(counter.addressOfCounter()) + sizeof(int32_t);
449     add32(TrustedImm32(increment), AbsoluteAddress(counter.addressOfCounter()));
450     addWithCarry32(TrustedImm32(0), AbsoluteAddress(reinterpret_cast<void*>(hiWord)));
451 }
452 #endif
453
454 #if ENABLE(SAMPLING_FLAGS)
455 void JITCompiler::setSamplingFlag(int32_t flag)
456 {
457     ASSERT(flag >= 1);
458     ASSERT(flag <= 32);
459     or32(TrustedImm32(1u << (flag - 1)), AbsoluteAddress(SamplingFlags::addressOfFlags()));
460 }
461
462 void JITCompiler::clearSamplingFlag(int32_t flag)
463 {
464     ASSERT(flag >= 1);
465     ASSERT(flag <= 32);
466     and32(TrustedImm32(~(1u << (flag - 1))), AbsoluteAddress(SamplingFlags::addressOfFlags()));
467 }
468 #endif
469
470 } } // namespace JSC::DFG
471
472 #endif