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