54b5aaee6fb49f7433c5c8f60b672c0fe3755d3d
[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 "DFGOSRExitCompiler.h"
33 #include "DFGOperations.h"
34 #include "DFGRegisterBank.h"
35 #include "DFGSlowPathGenerator.h"
36 #include "DFGSpeculativeJIT.h"
37 #include "DFGThunks.h"
38 #include "JSGlobalData.h"
39 #include "LinkBuffer.h"
40
41 namespace JSC { namespace DFG {
42
43 void JITCompiler::linkOSRExits()
44 {
45     for (unsigned i = 0; i < codeBlock()->numberOfOSRExits(); ++i) {
46         OSRExit& exit = codeBlock()->osrExit(i);
47         exit.m_check.initialJump().link(this);
48         jitAssertHasValidCallFrame();
49         store32(TrustedImm32(i), &globalData()->osrExitIndex);
50         exit.m_check.switchToLateJump(patchableJump());
51     }
52 }
53
54 void JITCompiler::compileEntry()
55 {
56     // This code currently matches the old JIT. In the function header we need to
57     // pop the return address (since we do not allow any recursion on the machine
58     // stack), and perform a fast register file check.
59     // FIXME: https://bugs.webkit.org/show_bug.cgi?id=56292
60     // We'll need to convert the remaining cti_ style calls (specifically the register file
61     // check) which will be dependent on stack layout. (We'd need to account for this in
62     // both normal return code and when jumping to an exception handler).
63     preserveReturnAddressAfterCall(GPRInfo::regT2);
64     emitPutToCallFrameHeader(GPRInfo::regT2, RegisterFile::ReturnPC);
65     emitPutImmediateToCallFrameHeader(m_codeBlock, RegisterFile::CodeBlock);
66 }
67
68 void JITCompiler::compileBody(SpeculativeJIT& speculative)
69 {
70     // We generate the speculative code path, followed by OSR exit code to return
71     // to the old JIT code if speculations fail.
72
73 #if DFG_ENABLE(JIT_BREAK_ON_EVERY_FUNCTION)
74     // Handy debug tool!
75     breakpoint();
76 #endif
77     
78     addPtr(TrustedImm32(1), AbsoluteAddress(codeBlock()->addressOfSpeculativeSuccessCounter()));
79
80     bool compiledSpeculative = speculative.compile();
81     ASSERT_UNUSED(compiledSpeculative, compiledSpeculative);
82 }
83
84 void JITCompiler::compileExceptionHandlers()
85 {
86     // Iterate over the m_calls vector, checking for jumps to link.
87     bool didLinkExceptionCheck = false;
88     for (unsigned i = 0; i < m_exceptionChecks.size(); ++i) {
89         Jump& exceptionCheck = m_exceptionChecks[i].m_exceptionCheck;
90         if (exceptionCheck.isSet()) {
91             exceptionCheck.link(this);
92             didLinkExceptionCheck = true;
93         }
94     }
95
96     // If any exception checks were linked, generate code to lookup a handler.
97     if (didLinkExceptionCheck) {
98         // lookupExceptionHandler is passed two arguments, exec (the CallFrame*), and
99         // the index into the CodeBlock's callReturnIndexVector corresponding to the
100         // call that threw the exception (this was set in nonPreservedNonReturnGPR, when
101         // the exception check was planted).
102         move(GPRInfo::nonPreservedNonReturnGPR, GPRInfo::argumentGPR1);
103         move(GPRInfo::callFrameRegister, GPRInfo::argumentGPR0);
104 #if CPU(X86)
105         // FIXME: should use the call abstraction, but this is currently in the SpeculativeJIT layer!
106         poke(GPRInfo::argumentGPR0);
107         poke(GPRInfo::argumentGPR1, 1);
108 #endif
109         m_calls.append(CallLinkRecord(call(), lookupExceptionHandler));
110         // lookupExceptionHandler leaves the handler CallFrame* in the returnValueGPR,
111         // and the address of the handler in returnValueGPR2.
112         jump(GPRInfo::returnValueGPR2);
113     }
114 }
115
116 void JITCompiler::link(LinkBuffer& linkBuffer)
117 {
118     // Link the code, populate data in CodeBlock data structures.
119 #if DFG_ENABLE(DEBUG_VERBOSE)
120     dataLog("JIT code for %p start at [%p, %p). Size = %zu.\n", m_codeBlock, linkBuffer.debugAddress(), static_cast<char*>(linkBuffer.debugAddress()) + linkBuffer.debugSize(), linkBuffer.debugSize());
121 #endif
122
123     // Link all calls out from the JIT code to their respective functions.
124     for (unsigned i = 0; i < m_calls.size(); ++i)
125         linkBuffer.link(m_calls[i].m_call, m_calls[i].m_function);
126
127     if (m_codeBlock->needsCallReturnIndices()) {
128         m_codeBlock->callReturnIndexVector().reserveCapacity(m_exceptionChecks.size());
129         for (unsigned i = 0; i < m_exceptionChecks.size(); ++i) {
130             unsigned returnAddressOffset = linkBuffer.returnAddressOffset(m_exceptionChecks[i].m_call);
131             CodeOrigin codeOrigin = m_exceptionChecks[i].m_codeOrigin;
132             while (codeOrigin.inlineCallFrame)
133                 codeOrigin = codeOrigin.inlineCallFrame->caller;
134             unsigned exceptionInfo = codeOrigin.bytecodeIndex;
135             m_codeBlock->callReturnIndexVector().append(CallReturnOffsetToBytecodeOffset(returnAddressOffset, exceptionInfo));
136         }
137     }
138
139     Vector<CodeOriginAtCallReturnOffset>& codeOrigins = m_codeBlock->codeOrigins();
140     codeOrigins.resize(m_exceptionChecks.size());
141     
142     for (unsigned i = 0; i < m_exceptionChecks.size(); ++i) {
143         CallExceptionRecord& record = m_exceptionChecks[i];
144         unsigned returnAddressOffset = linkBuffer.returnAddressOffset(m_exceptionChecks[i].m_call);
145         codeOrigins[i].codeOrigin = record.m_codeOrigin;
146         codeOrigins[i].callReturnOffset = returnAddressOffset;
147         record.m_token.assertCodeOriginIndex(i);
148     }
149     
150     m_codeBlock->setNumberOfStructureStubInfos(m_propertyAccesses.size());
151     for (unsigned i = 0; i < m_propertyAccesses.size(); ++i) {
152         StructureStubInfo& info = m_codeBlock->structureStubInfo(i);
153         CodeLocationCall callReturnLocation = linkBuffer.locationOf(m_propertyAccesses[i].m_slowPathGenerator->call());
154         info.codeOrigin = m_propertyAccesses[i].m_codeOrigin;
155         info.callReturnLocation = callReturnLocation;
156         info.patch.dfg.deltaCheckImmToCall = differenceBetweenCodePtr(linkBuffer.locationOf(m_propertyAccesses[i].m_structureImm), callReturnLocation);
157         info.patch.dfg.deltaCallToStructCheck = differenceBetweenCodePtr(callReturnLocation, linkBuffer.locationOf(m_propertyAccesses[i].m_structureCheck));
158 #if USE(JSVALUE64)
159         info.patch.dfg.deltaCallToLoadOrStore = differenceBetweenCodePtr(callReturnLocation, linkBuffer.locationOf(m_propertyAccesses[i].m_loadOrStore));
160 #else
161         info.patch.dfg.deltaCallToTagLoadOrStore = differenceBetweenCodePtr(callReturnLocation, linkBuffer.locationOf(m_propertyAccesses[i].m_tagLoadOrStore));
162         info.patch.dfg.deltaCallToPayloadLoadOrStore = differenceBetweenCodePtr(callReturnLocation, linkBuffer.locationOf(m_propertyAccesses[i].m_payloadLoadOrStore));
163 #endif
164         info.patch.dfg.deltaCallToSlowCase = differenceBetweenCodePtr(callReturnLocation, linkBuffer.locationOf(m_propertyAccesses[i].m_slowPathGenerator->label()));
165         info.patch.dfg.deltaCallToDone = differenceBetweenCodePtr(callReturnLocation, linkBuffer.locationOf(m_propertyAccesses[i].m_done));
166         info.patch.dfg.baseGPR = m_propertyAccesses[i].m_baseGPR;
167 #if USE(JSVALUE64)
168         info.patch.dfg.valueGPR = m_propertyAccesses[i].m_valueGPR;
169 #else
170         info.patch.dfg.valueTagGPR = m_propertyAccesses[i].m_valueTagGPR;
171         info.patch.dfg.valueGPR = m_propertyAccesses[i].m_valueGPR;
172 #endif
173         info.patch.dfg.scratchGPR = m_propertyAccesses[i].m_scratchGPR;
174         info.patch.dfg.registersFlushed = m_propertyAccesses[i].m_registerMode == PropertyAccessRecord::RegistersFlushed;
175     }
176     
177     m_codeBlock->setNumberOfCallLinkInfos(m_jsCalls.size());
178     for (unsigned i = 0; i < m_jsCalls.size(); ++i) {
179         CallLinkInfo& info = m_codeBlock->callLinkInfo(i);
180         info.callType = m_jsCalls[i].m_callType;
181         info.isDFG = true;
182         info.callReturnLocation = CodeLocationLabel(linkBuffer.locationOf(m_jsCalls[i].m_slowCall));
183         info.hotPathBegin = linkBuffer.locationOf(m_jsCalls[i].m_targetToCheck);
184         info.hotPathOther = linkBuffer.locationOfNearCall(m_jsCalls[i].m_fastCall);
185     }
186     
187     MacroAssemblerCodeRef osrExitThunk = globalData()->getCTIStub(osrExitGenerationThunkGenerator);
188     CodeLocationLabel target = CodeLocationLabel(osrExitThunk.code());
189     for (unsigned i = 0; i < codeBlock()->numberOfOSRExits(); ++i) {
190         OSRExit& exit = codeBlock()->osrExit(i);
191         linkBuffer.link(exit.m_check.lateJump(), target);
192         exit.m_check.correctLateJump(linkBuffer);
193     }
194     
195     codeBlock()->shrinkToFit(CodeBlock::LateShrink);
196 }
197
198 bool JITCompiler::compile(JITCode& entry)
199 {
200     compileEntry();
201     SpeculativeJIT speculative(*this);
202     compileBody(speculative);
203
204     // Generate slow path code.
205     speculative.runSlowPathGenerators();
206     
207     compileExceptionHandlers();
208     linkOSRExits();
209     
210     // Create OSR entry trampolines if necessary.
211     speculative.createOSREntries();
212
213     LinkBuffer linkBuffer(*m_globalData, this, m_codeBlock, JITCompilationCanFail);
214     if (linkBuffer.didFailToAllocate())
215         return false;
216     link(linkBuffer);
217     speculative.linkOSREntries(linkBuffer);
218
219     entry = JITCode(linkBuffer.finalizeCode(), JITCode::DFGJIT);
220     return true;
221 }
222
223 bool JITCompiler::compileFunction(JITCode& entry, MacroAssemblerCodePtr& entryWithArityCheck)
224 {
225     compileEntry();
226
227     // === Function header code generation ===
228     // This is the main entry point, without performing an arity check.
229     // If we needed to perform an arity check we will already have moved the return address,
230     // so enter after this.
231     Label fromArityCheck(this);
232     // Plant a check that sufficient space is available in the RegisterFile.
233     // FIXME: https://bugs.webkit.org/show_bug.cgi?id=56291
234     addPtr(TrustedImm32(m_codeBlock->m_numCalleeRegisters * sizeof(Register)), GPRInfo::callFrameRegister, GPRInfo::regT1);
235     Jump registerFileCheck = branchPtr(Below, AbsoluteAddress(m_globalData->interpreter->registerFile().addressOfEnd()), GPRInfo::regT1);
236     // Return here after register file check.
237     Label fromRegisterFileCheck = label();
238
239
240     // === Function body code generation ===
241     SpeculativeJIT speculative(*this);
242     compileBody(speculative);
243
244     // === Function footer code generation ===
245     //
246     // Generate code to perform the slow register file check (if the fast one in
247     // the function header fails), and generate the entry point with arity check.
248     //
249     // Generate the register file check; if the fast check in the function head fails,
250     // we need to call out to a helper function to check whether more space is available.
251     // FIXME: change this from a cti call to a DFG style operation (normal C calling conventions).
252     registerFileCheck.link(this);
253     move(stackPointerRegister, GPRInfo::argumentGPR0);
254     poke(GPRInfo::callFrameRegister, OBJECT_OFFSETOF(struct JITStackFrame, callFrame) / sizeof(void*));
255
256     CallBeginToken token = beginCall();
257     Call callRegisterFileCheck = call();
258     notifyCall(callRegisterFileCheck, CodeOrigin(0), token);
259     jump(fromRegisterFileCheck);
260     
261     // The fast entry point into a function does not check the correct number of arguments
262     // have been passed to the call (we only use the fast entry point where we can statically
263     // determine the correct number of arguments have been passed, or have already checked).
264     // In cases where an arity check is necessary, we enter here.
265     // FIXME: change this from a cti call to a DFG style operation (normal C calling conventions).
266     Label arityCheck = label();
267     compileEntry();
268
269     load32(AssemblyHelpers::payloadFor((VirtualRegister)RegisterFile::ArgumentCount), GPRInfo::regT1);
270     branch32(AboveOrEqual, GPRInfo::regT1, TrustedImm32(m_codeBlock->numParameters())).linkTo(fromArityCheck, this);
271     move(stackPointerRegister, GPRInfo::argumentGPR0);
272     poke(GPRInfo::callFrameRegister, OBJECT_OFFSETOF(struct JITStackFrame, callFrame) / sizeof(void*));
273     token = beginCall();
274     Call callArityCheck = call();
275     notifyCall(callArityCheck, CodeOrigin(0), token);
276     move(GPRInfo::regT0, GPRInfo::callFrameRegister);
277     jump(fromArityCheck);
278     
279     // Generate slow path code.
280     speculative.runSlowPathGenerators();
281     
282     compileExceptionHandlers();
283     linkOSRExits();
284     
285     // Create OSR entry trampolines if necessary.
286     speculative.createOSREntries();
287
288
289     // === Link ===
290     LinkBuffer linkBuffer(*m_globalData, this, m_codeBlock, JITCompilationCanFail);
291     if (linkBuffer.didFailToAllocate())
292         return false;
293     link(linkBuffer);
294     speculative.linkOSREntries(linkBuffer);
295     
296     // FIXME: switch the register file check & arity check over to DFGOpertaion style calls, not JIT stubs.
297     linkBuffer.link(callRegisterFileCheck, cti_register_file_check);
298     linkBuffer.link(callArityCheck, m_codeBlock->m_isConstructor ? cti_op_construct_arityCheck : cti_op_call_arityCheck);
299
300     entryWithArityCheck = linkBuffer.locationOf(arityCheck);
301     entry = JITCode(linkBuffer.finalizeCode(), JITCode::DFGJIT);
302     return true;
303 }
304
305 } } // namespace JSC::DFG
306
307 #endif // ENABLE(DFG_JIT)