b525efe7a019ad8be4bf3ca968b2b74830b02743
[WebKit-https.git] / Source / JavaScriptCore / dfg / DFGOSRExitCompiler64.cpp
1 /*
2  * Copyright (C) 2011, 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
28 #if ENABLE(DFG_JIT) && USE(JSVALUE64)
29
30 #include "DFGOSRExitCompiler.h"
31
32 #include "DFGOperations.h"
33 #include "DFGOSRExitCompilerCommon.h"
34 #include "DFGSpeculativeJIT.h"
35 #include "JSCInlines.h"
36 #include "VirtualRegister.h"
37
38 #include <wtf/DataLog.h>
39
40 namespace JSC { namespace DFG {
41
42 void OSRExitCompiler::compileExit(const OSRExit& exit, const Operands<ValueRecovery>& operands, SpeculationRecovery* recovery)
43 {
44     m_jit.jitAssertTagsInPlace();
45
46     // 1) Pro-forma stuff.
47     if (Options::printEachOSRExit()) {
48         SpeculationFailureDebugInfo* debugInfo = new SpeculationFailureDebugInfo;
49         debugInfo->codeBlock = m_jit.codeBlock();
50         
51         m_jit.debugCall(debugOperationPrintSpeculationFailure, debugInfo);
52     }
53     
54     // Need to ensure that the stack pointer accounts for the worst-case stack usage at exit.
55     m_jit.addPtr(
56         CCallHelpers::TrustedImm32(
57             -m_jit.codeBlock()->jitCode()->dfgCommon()->requiredRegisterCountForExit * sizeof(Register)),
58         CCallHelpers::framePointerRegister, CCallHelpers::stackPointerRegister);
59     
60     // 2) Perform speculation recovery. This only comes into play when an operation
61     //    starts mutating state before verifying the speculation it has already made.
62     
63     if (recovery) {
64         switch (recovery->type()) {
65         case SpeculativeAdd:
66             m_jit.sub32(recovery->src(), recovery->dest());
67             m_jit.or64(GPRInfo::tagTypeNumberRegister, recovery->dest());
68             break;
69             
70         case BooleanSpeculationCheck:
71             m_jit.xor64(AssemblyHelpers::TrustedImm32(static_cast<int32_t>(ValueFalse)), recovery->dest());
72             break;
73             
74         default:
75             break;
76         }
77     }
78
79     // 3) Refine some array and/or value profile, if appropriate.
80     
81     if (!!exit.m_jsValueSource) {
82         if (exit.m_kind == BadCache || exit.m_kind == BadIndexingType) {
83             // If the instruction that this originated from has an array profile, then
84             // refine it. If it doesn't, then do nothing. The latter could happen for
85             // hoisted checks, or checks emitted for operations that didn't have array
86             // profiling - either ops that aren't array accesses at all, or weren't
87             // known to be array acceses in the bytecode. The latter case is a FIXME
88             // while the former case is an outcome of a CheckStructure not knowing why
89             // it was emitted (could be either due to an inline cache of a property
90             // property access, or due to an array profile).
91             
92             CodeOrigin codeOrigin = exit.m_codeOriginForExitProfile;
93             if (ArrayProfile* arrayProfile = m_jit.baselineCodeBlockFor(codeOrigin)->getArrayProfile(codeOrigin.bytecodeIndex)) {
94                 GPRReg usedRegister;
95                 if (exit.m_jsValueSource.isAddress())
96                     usedRegister = exit.m_jsValueSource.base();
97                 else
98                     usedRegister = exit.m_jsValueSource.gpr();
99                 
100                 GPRReg scratch1;
101                 GPRReg scratch2;
102                 scratch1 = AssemblyHelpers::selectScratchGPR(usedRegister);
103                 scratch2 = AssemblyHelpers::selectScratchGPR(usedRegister, scratch1);
104                 
105 #if CPU(ARM64)
106                 m_jit.pushToSave(scratch1);
107                 m_jit.pushToSave(scratch2);
108 #else
109                 m_jit.push(scratch1);
110                 m_jit.push(scratch2);
111 #endif
112                 
113                 GPRReg value;
114                 if (exit.m_jsValueSource.isAddress()) {
115                     value = scratch1;
116                     m_jit.loadPtr(AssemblyHelpers::Address(exit.m_jsValueSource.asAddress()), value);
117                 } else
118                     value = exit.m_jsValueSource.gpr();
119                 
120                 m_jit.loadPtr(AssemblyHelpers::Address(value, JSCell::structureOffset()), scratch1);
121                 m_jit.storePtr(scratch1, arrayProfile->addressOfLastSeenStructure());
122                 m_jit.load8(AssemblyHelpers::Address(scratch1, Structure::indexingTypeOffset()), scratch1);
123                 m_jit.move(AssemblyHelpers::TrustedImm32(1), scratch2);
124                 m_jit.lshift32(scratch1, scratch2);
125                 m_jit.or32(scratch2, AssemblyHelpers::AbsoluteAddress(arrayProfile->addressOfArrayModes()));
126                 
127 #if CPU(ARM64)
128                 m_jit.popToRestore(scratch2);
129                 m_jit.popToRestore(scratch1);
130 #else
131                 m_jit.pop(scratch2);
132                 m_jit.pop(scratch1);
133 #endif
134             }
135         }
136         
137         if (!!exit.m_valueProfile) {
138             EncodedJSValue* bucket = exit.m_valueProfile.getSpecFailBucket(0);
139             
140             if (exit.m_jsValueSource.isAddress()) {
141                 // We can't be sure that we have a spare register. So use the tagTypeNumberRegister,
142                 // since we know how to restore it.
143                 m_jit.load64(AssemblyHelpers::Address(exit.m_jsValueSource.asAddress()), GPRInfo::tagTypeNumberRegister);
144                 m_jit.store64(GPRInfo::tagTypeNumberRegister, bucket);
145                 m_jit.move(AssemblyHelpers::TrustedImm64(TagTypeNumber), GPRInfo::tagTypeNumberRegister);
146             } else
147                 m_jit.store64(exit.m_jsValueSource.gpr(), bucket);
148         }
149     }
150     
151     // What follows is an intentionally simple OSR exit implementation that generates
152     // fairly poor code but is very easy to hack. In particular, it dumps all state that
153     // needs conversion into a scratch buffer so that in step 6, where we actually do the
154     // conversions, we know that all temp registers are free to use and the variable is
155     // definitely in a well-known spot in the scratch buffer regardless of whether it had
156     // originally been in a register or spilled. This allows us to decouple "where was
157     // the variable" from "how was it represented". Consider that the
158     // Int32DisplacedInJSStack recovery: it tells us that the value is in a
159     // particular place and that that place holds an unboxed int32. We have two different
160     // places that a value could be (displaced, register) and a bunch of different
161     // ways of representing a value. The number of recoveries is two * a bunch. The code
162     // below means that we have to have two + a bunch cases rather than two * a bunch.
163     // Once we have loaded the value from wherever it was, the reboxing is the same
164     // regardless of its location. Likewise, before we do the reboxing, the way we get to
165     // the value (i.e. where we load it from) is the same regardless of its type. Because
166     // the code below always dumps everything into a scratch buffer first, the two
167     // questions become orthogonal, which simplifies adding new types and adding new
168     // locations.
169     //
170     // This raises the question: does using such a suboptimal implementation of OSR exit,
171     // where we always emit code to dump all state into a scratch buffer only to then
172     // dump it right back into the stack, hurt us in any way? The asnwer is that OSR exits
173     // are rare. Our tiering strategy ensures this. This is because if an OSR exit is
174     // taken more than ~100 times, we jettison the DFG code block along with all of its
175     // exits. It is impossible for an OSR exit - i.e. the code we compile below - to
176     // execute frequently enough for the codegen to matter that much. It probably matters
177     // enough that we don't want to turn this into some super-slow function call, but so
178     // long as we're generating straight-line code, that code can be pretty bad. Also
179     // because we tend to exit only along one OSR exit from any DFG code block - that's an
180     // empirical result that we're extremely confident about - the code size of this
181     // doesn't matter much. Hence any attempt to optimize the codegen here is just purely
182     // harmful to the system: it probably won't reduce either net memory usage or net
183     // execution time. It will only prevent us from cleanly decoupling "where was the
184     // variable" from "how was it represented", which will make it more difficult to add
185     // features in the future and it will make it harder to reason about bugs.
186
187     // 4) Save all state from GPRs into the scratch buffer.
188     
189     ScratchBuffer* scratchBuffer = m_jit.vm()->scratchBufferForSize(sizeof(EncodedJSValue) * operands.size());
190     EncodedJSValue* scratch = scratchBuffer ? static_cast<EncodedJSValue*>(scratchBuffer->dataBuffer()) : 0;
191     
192     for (size_t index = 0; index < operands.size(); ++index) {
193         const ValueRecovery& recovery = operands[index];
194         
195         switch (recovery.technique()) {
196         case InGPR:
197         case UnboxedInt32InGPR:
198         case UnboxedInt52InGPR:
199         case UnboxedStrictInt52InGPR:
200         case UnboxedCellInGPR:
201             m_jit.store64(recovery.gpr(), scratch + index);
202             break;
203             
204         default:
205             break;
206         }
207     }
208     
209     // And voila, all GPRs are free to reuse.
210     
211     // 5) Save all state from FPRs into the scratch buffer.
212     
213     for (size_t index = 0; index < operands.size(); ++index) {
214         const ValueRecovery& recovery = operands[index];
215         
216         switch (recovery.technique()) {
217         case InFPR:
218             m_jit.move(AssemblyHelpers::TrustedImmPtr(scratch + index), GPRInfo::regT0);
219             m_jit.storeDouble(recovery.fpr(), GPRInfo::regT0);
220             break;
221             
222         default:
223             break;
224         }
225     }
226     
227     // Now, all FPRs are also free.
228     
229     // 6) Save all state from the stack into the scratch buffer. For simplicity we
230     //    do this even for state that's already in the right place on the stack.
231     //    It makes things simpler later.
232
233     for (size_t index = 0; index < operands.size(); ++index) {
234         const ValueRecovery& recovery = operands[index];
235         
236         switch (recovery.technique()) {
237         case DisplacedInJSStack:
238         case CellDisplacedInJSStack:
239         case BooleanDisplacedInJSStack:
240         case Int32DisplacedInJSStack:
241         case DoubleDisplacedInJSStack:
242         case Int52DisplacedInJSStack:
243         case StrictInt52DisplacedInJSStack:
244             m_jit.load64(AssemblyHelpers::addressFor(recovery.virtualRegister()), GPRInfo::regT0);
245             m_jit.store64(GPRInfo::regT0, scratch + index);
246             break;
247             
248         default:
249             break;
250         }
251     }
252     
253     // 7) Do all data format conversions and store the results into the stack.
254     
255     bool haveArguments = false;
256     
257     for (size_t index = 0; index < operands.size(); ++index) {
258         const ValueRecovery& recovery = operands[index];
259         int operand = operands.operandForIndex(index);
260         
261         switch (recovery.technique()) {
262         case InGPR:
263         case UnboxedCellInGPR:
264         case DisplacedInJSStack:
265         case CellDisplacedInJSStack:
266         case BooleanDisplacedInJSStack:
267             m_jit.load64(scratch + index, GPRInfo::regT0);
268             m_jit.store64(GPRInfo::regT0, AssemblyHelpers::addressFor(operand));
269             break;
270             
271         case UnboxedInt32InGPR:
272         case Int32DisplacedInJSStack:
273             m_jit.load64(scratch + index, GPRInfo::regT0);
274             m_jit.zeroExtend32ToPtr(GPRInfo::regT0, GPRInfo::regT0);
275             m_jit.or64(GPRInfo::tagTypeNumberRegister, GPRInfo::regT0);
276             m_jit.store64(GPRInfo::regT0, AssemblyHelpers::addressFor(operand));
277             break;
278             
279         case UnboxedInt52InGPR:
280         case Int52DisplacedInJSStack:
281             m_jit.load64(scratch + index, GPRInfo::regT0);
282             m_jit.rshift64(
283                 AssemblyHelpers::TrustedImm32(JSValue::int52ShiftAmount), GPRInfo::regT0);
284             m_jit.boxInt52(GPRInfo::regT0, GPRInfo::regT0, GPRInfo::regT1, FPRInfo::fpRegT0);
285             m_jit.store64(GPRInfo::regT0, AssemblyHelpers::addressFor(operand));
286             break;
287             
288         case UnboxedStrictInt52InGPR:
289         case StrictInt52DisplacedInJSStack:
290             m_jit.load64(scratch + index, GPRInfo::regT0);
291             m_jit.boxInt52(GPRInfo::regT0, GPRInfo::regT0, GPRInfo::regT1, FPRInfo::fpRegT0);
292             m_jit.store64(GPRInfo::regT0, AssemblyHelpers::addressFor(operand));
293             break;
294             
295         case InFPR:
296         case DoubleDisplacedInJSStack:
297             m_jit.move(AssemblyHelpers::TrustedImmPtr(scratch + index), GPRInfo::regT0);
298             m_jit.loadDouble(GPRInfo::regT0, FPRInfo::fpRegT0);
299             m_jit.boxDouble(FPRInfo::fpRegT0, GPRInfo::regT0);
300             m_jit.store64(GPRInfo::regT0, AssemblyHelpers::addressFor(operand));
301             break;
302             
303         case Constant:
304             m_jit.store64(
305                 AssemblyHelpers::TrustedImm64(JSValue::encode(recovery.constant())),
306                 AssemblyHelpers::addressFor(operand));
307             break;
308             
309         case ArgumentsThatWereNotCreated:
310             haveArguments = true;
311             // We can't restore this yet but we can make sure that the stack appears
312             // sane.
313             m_jit.store64(
314                 AssemblyHelpers::TrustedImm64(JSValue::encode(JSValue())),
315                 AssemblyHelpers::addressFor(operand));
316             break;
317             
318         default:
319             break;
320         }
321     }
322     
323     // 8) Adjust the old JIT's execute counter. Since we are exiting OSR, we know
324     //    that all new calls into this code will go to the new JIT, so the execute
325     //    counter only affects call frames that performed OSR exit and call frames
326     //    that were still executing the old JIT at the time of another call frame's
327     //    OSR exit. We want to ensure that the following is true:
328     //
329     //    (a) Code the performs an OSR exit gets a chance to reenter optimized
330     //        code eventually, since optimized code is faster. But we don't
331     //        want to do such reentery too aggressively (see (c) below).
332     //
333     //    (b) If there is code on the call stack that is still running the old
334     //        JIT's code and has never OSR'd, then it should get a chance to
335     //        perform OSR entry despite the fact that we've exited.
336     //
337     //    (c) Code the performs an OSR exit should not immediately retry OSR
338     //        entry, since both forms of OSR are expensive. OSR entry is
339     //        particularly expensive.
340     //
341     //    (d) Frequent OSR failures, even those that do not result in the code
342     //        running in a hot loop, result in recompilation getting triggered.
343     //
344     //    To ensure (c), we'd like to set the execute counter to
345     //    counterValueForOptimizeAfterWarmUp(). This seems like it would endanger
346     //    (a) and (b), since then every OSR exit would delay the opportunity for
347     //    every call frame to perform OSR entry. Essentially, if OSR exit happens
348     //    frequently and the function has few loops, then the counter will never
349     //    become non-negative and OSR entry will never be triggered. OSR entry
350     //    will only happen if a loop gets hot in the old JIT, which does a pretty
351     //    good job of ensuring (a) and (b). But that doesn't take care of (d),
352     //    since each speculation failure would reset the execute counter.
353     //    So we check here if the number of speculation failures is significantly
354     //    larger than the number of successes (we want 90% success rate), and if
355     //    there have been a large enough number of failures. If so, we set the
356     //    counter to 0; otherwise we set the counter to
357     //    counterValueForOptimizeAfterWarmUp().
358     
359     handleExitCounts(m_jit, exit);
360     
361     // 9) Reify inlined call frames.
362     
363     reifyInlinedCallFrames(m_jit, exit);
364     
365     // 10) Create arguments if necessary and place them into the appropriate aliased
366     //     registers.
367     
368     if (haveArguments) {
369         HashSet<InlineCallFrame*, DefaultHash<InlineCallFrame*>::Hash,
370             NullableHashTraits<InlineCallFrame*>> didCreateArgumentsObject;
371
372         for (size_t index = 0; index < operands.size(); ++index) {
373             const ValueRecovery& recovery = operands[index];
374             if (recovery.technique() != ArgumentsThatWereNotCreated)
375                 continue;
376             int operand = operands.operandForIndex(index);
377             // Find the right inline call frame.
378             InlineCallFrame* inlineCallFrame = 0;
379             for (InlineCallFrame* current = exit.m_codeOrigin.inlineCallFrame;
380                  current;
381                  current = current->caller.inlineCallFrame) {
382                 if (current->stackOffset >= operand) {
383                     inlineCallFrame = current;
384                     break;
385                 }
386             }
387
388             if (!m_jit.baselineCodeBlockFor(inlineCallFrame)->usesArguments())
389                 continue;
390             VirtualRegister argumentsRegister = m_jit.baselineArgumentsRegisterFor(inlineCallFrame);
391             if (didCreateArgumentsObject.add(inlineCallFrame).isNewEntry) {
392                 // We know this call frame optimized out an arguments object that
393                 // the baseline JIT would have created. Do that creation now.
394                 if (inlineCallFrame) {
395                     m_jit.addPtr(AssemblyHelpers::TrustedImm32(inlineCallFrame->stackOffset * sizeof(EncodedJSValue)), GPRInfo::callFrameRegister, GPRInfo::regT0);
396                     m_jit.setupArguments(GPRInfo::regT0);
397                 } else
398                     m_jit.setupArgumentsExecState();
399                 m_jit.move(
400                     AssemblyHelpers::TrustedImmPtr(
401                         bitwise_cast<void*>(operationCreateArguments)),
402                     GPRInfo::nonArgGPR0);
403                 m_jit.call(GPRInfo::nonArgGPR0);
404                 m_jit.store64(GPRInfo::returnValueGPR, AssemblyHelpers::addressFor(argumentsRegister));
405                 m_jit.store64(
406                     GPRInfo::returnValueGPR,
407                     AssemblyHelpers::addressFor(unmodifiedArgumentsRegister(argumentsRegister)));
408                 m_jit.move(GPRInfo::returnValueGPR, GPRInfo::regT0); // no-op move on almost all platforms.
409             }
410
411             m_jit.load64(AssemblyHelpers::addressFor(argumentsRegister), GPRInfo::regT0);
412             m_jit.store64(GPRInfo::regT0, AssemblyHelpers::addressFor(operand));
413         }
414     }
415
416     // 12) And finish.
417     adjustAndJumpToTarget(m_jit, exit);
418 }
419
420 } } // namespace JSC::DFG
421
422 #endif // ENABLE(DFG_JIT) && USE(JSVALUE64)