WebDriver: Implement page load strategy
[WebKit-https.git] / Source / JavaScriptCore / dfg / DFGOSRExit32_64.cpp
1 /*
2  * Copyright (C) 2011-2017 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 "DFGOSRExit.h"
28
29 #if ENABLE(DFG_JIT) && USE(JSVALUE32_64)
30
31 #include "DFGOSRExitCompilerCommon.h"
32 #include "DFGOperations.h"
33 #include "DFGSpeculativeJIT.h"
34 #include "JSCInlines.h"
35 #include <wtf/DataLog.h>
36
37 namespace JSC { namespace DFG {
38
39 void OSRExit::compileExit(CCallHelpers& jit, VM& vm, const OSRExit& exit, const Operands<ValueRecovery>& operands, SpeculationRecovery* recovery)
40 {
41     // Pro-forma stuff.
42     if (Options::printEachOSRExit()) {
43         SpeculationFailureDebugInfo* debugInfo = new SpeculationFailureDebugInfo;
44         debugInfo->codeBlock = jit.codeBlock();
45         debugInfo->kind = exit.m_kind;
46         debugInfo->bytecodeOffset = exit.m_codeOrigin.bytecodeIndex;
47         
48         jit.debugCall(vm, debugOperationPrintSpeculationFailure, debugInfo);
49     }
50
51     // Perform speculation recovery. This only comes into play when an operation
52     // starts mutating state before verifying the speculation it has already made.
53     
54     if (recovery) {
55         switch (recovery->type()) {
56         case SpeculativeAdd:
57             jit.sub32(recovery->src(), recovery->dest());
58             break;
59
60         case SpeculativeAddImmediate:
61             jit.sub32(AssemblyHelpers::Imm32(recovery->immediate()), recovery->dest());
62             break;
63             
64         case BooleanSpeculationCheck:
65             break;
66             
67         default:
68             break;
69         }
70     }
71
72     // Refine some value profile, if appropriate.
73     
74     if (!!exit.m_jsValueSource) {
75         if (exit.m_kind == BadCache || exit.m_kind == BadIndexingType) {
76             // If the instruction that this originated from has an array profile, then
77             // refine it. If it doesn't, then do nothing. The latter could happen for
78             // hoisted checks, or checks emitted for operations that didn't have array
79             // profiling - either ops that aren't array accesses at all, or weren't
80             // known to be array acceses in the bytecode. The latter case is a FIXME
81             // while the former case is an outcome of a CheckStructure not knowing why
82             // it was emitted (could be either due to an inline cache of a property
83             // property access, or due to an array profile).
84             
85             // Note: We are free to assume that the jsValueSource is already known to
86             // be a cell since both BadCache and BadIndexingType exits occur after
87             // the cell check would have already happened.
88             
89             CodeOrigin codeOrigin = exit.m_codeOriginForExitProfile;
90             if (ArrayProfile* arrayProfile = jit.baselineCodeBlockFor(codeOrigin)->getArrayProfile(codeOrigin.bytecodeIndex)) {
91                 GPRReg usedRegister1;
92                 GPRReg usedRegister2;
93                 if (exit.m_jsValueSource.isAddress()) {
94                     usedRegister1 = exit.m_jsValueSource.base();
95                     usedRegister2 = InvalidGPRReg;
96                 } else {
97                     usedRegister1 = exit.m_jsValueSource.payloadGPR();
98                     if (exit.m_jsValueSource.hasKnownTag())
99                         usedRegister2 = InvalidGPRReg;
100                     else
101                         usedRegister2 = exit.m_jsValueSource.tagGPR();
102                 }
103                 
104                 GPRReg scratch1;
105                 GPRReg scratch2;
106                 scratch1 = AssemblyHelpers::selectScratchGPR(usedRegister1, usedRegister2);
107                 scratch2 = AssemblyHelpers::selectScratchGPR(usedRegister1, usedRegister2, scratch1);
108                 
109                 jit.push(scratch1);
110                 jit.push(scratch2);
111                 
112                 GPRReg value;
113                 if (exit.m_jsValueSource.isAddress()) {
114                     value = scratch1;
115                     jit.loadPtr(AssemblyHelpers::Address(exit.m_jsValueSource.asAddress()), value);
116                 } else
117                     value = exit.m_jsValueSource.payloadGPR();
118                 
119                 jit.loadPtr(AssemblyHelpers::Address(value, JSCell::structureIDOffset()), scratch1);
120                 jit.storePtr(scratch1, arrayProfile->addressOfLastSeenStructureID());
121                 jit.load8(AssemblyHelpers::Address(scratch1, Structure::indexingTypeIncludingHistoryOffset()), scratch1);
122                 jit.move(AssemblyHelpers::TrustedImm32(1), scratch2);
123                 jit.lshift32(scratch1, scratch2);
124                 jit.or32(scratch2, AssemblyHelpers::AbsoluteAddress(arrayProfile->addressOfArrayModes()));
125                 
126                 jit.pop(scratch2);
127                 jit.pop(scratch1);
128             }
129         }
130         
131         if (MethodOfGettingAValueProfile profile = exit.m_valueProfile) {
132             if (exit.m_jsValueSource.isAddress()) {
133                 // Save a register so we can use it.
134                 GPRReg scratchPayload = AssemblyHelpers::selectScratchGPR(exit.m_jsValueSource.base());
135                 GPRReg scratchTag = AssemblyHelpers::selectScratchGPR(exit.m_jsValueSource.base(), scratchPayload);
136                 jit.pushToSave(scratchPayload);
137                 jit.pushToSave(scratchTag);
138
139                 JSValueRegs scratch(scratchTag, scratchPayload);
140                 
141                 jit.loadValue(exit.m_jsValueSource.asAddress(), scratch);
142                 profile.emitReportValue(jit, scratch);
143                 
144                 jit.popToRestore(scratchTag);
145                 jit.popToRestore(scratchPayload);
146             } else if (exit.m_jsValueSource.hasKnownTag()) {
147                 GPRReg scratchTag = AssemblyHelpers::selectScratchGPR(exit.m_jsValueSource.payloadGPR());
148                 jit.pushToSave(scratchTag);
149                 jit.move(AssemblyHelpers::TrustedImm32(exit.m_jsValueSource.tag()), scratchTag);
150                 JSValueRegs value(scratchTag, exit.m_jsValueSource.payloadGPR());
151                 profile.emitReportValue(jit, value);
152                 jit.popToRestore(scratchTag);
153             } else
154                 profile.emitReportValue(jit, exit.m_jsValueSource.regs());
155         }
156     }
157     
158     // Do a simplified OSR exit. See DFGOSRExitCompiler64.cpp's comment regarding how and wny we
159     // do this simple approach.
160
161     // Save all state from GPRs into the scratch buffer.
162     
163     ScratchBuffer* scratchBuffer = vm.scratchBufferForSize(sizeof(EncodedJSValue) * operands.size());
164     EncodedJSValue* scratch = scratchBuffer ? static_cast<EncodedJSValue*>(scratchBuffer->dataBuffer()) : 0;
165     
166     for (size_t index = 0; index < operands.size(); ++index) {
167         const ValueRecovery& recovery = operands[index];
168         
169         switch (recovery.technique()) {
170         case UnboxedInt32InGPR:
171         case UnboxedBooleanInGPR:
172         case UnboxedCellInGPR:
173             jit.store32(
174                 recovery.gpr(),
175                 &bitwise_cast<EncodedValueDescriptor*>(scratch + index)->asBits.payload);
176             break;
177             
178         case InPair:
179             jit.store32(
180                 recovery.tagGPR(),
181                 &bitwise_cast<EncodedValueDescriptor*>(scratch + index)->asBits.tag);
182             jit.store32(
183                 recovery.payloadGPR(),
184                 &bitwise_cast<EncodedValueDescriptor*>(scratch + index)->asBits.payload);
185             break;
186             
187         default:
188             break;
189         }
190     }
191     
192     // Now all GPRs are free to reuse.
193     
194     // Save all state from FPRs into the scratch buffer.
195     
196     for (size_t index = 0; index < operands.size(); ++index) {
197         const ValueRecovery& recovery = operands[index];
198         
199         switch (recovery.technique()) {
200         case UnboxedDoubleInFPR:
201         case InFPR:
202             jit.move(AssemblyHelpers::TrustedImmPtr(scratch + index), GPRInfo::regT0);
203             jit.storeDouble(recovery.fpr(), MacroAssembler::Address(GPRInfo::regT0));
204             break;
205             
206         default:
207             break;
208         }
209     }
210     
211     // Now all FPRs are free to reuse.
212     
213     // Save all state from the stack into the scratch buffer. For simplicity we
214     // do this even for state that's already in the right place on the stack.
215     // It makes things simpler later.
216     
217     for (size_t index = 0; index < operands.size(); ++index) {
218         const ValueRecovery& recovery = operands[index];
219         
220         switch (recovery.technique()) {
221         case DisplacedInJSStack:
222         case Int32DisplacedInJSStack:
223         case DoubleDisplacedInJSStack:
224         case CellDisplacedInJSStack:
225         case BooleanDisplacedInJSStack:
226             jit.load32(
227                 AssemblyHelpers::tagFor(recovery.virtualRegister()),
228                 GPRInfo::regT0);
229             jit.load32(
230                 AssemblyHelpers::payloadFor(recovery.virtualRegister()),
231                 GPRInfo::regT1);
232             jit.store32(
233                 GPRInfo::regT0,
234                 &bitwise_cast<EncodedValueDescriptor*>(scratch + index)->asBits.tag);
235             jit.store32(
236                 GPRInfo::regT1,
237                 &bitwise_cast<EncodedValueDescriptor*>(scratch + index)->asBits.payload);
238             break;
239             
240         default:
241             break;
242         }
243     }
244     
245     // Need to ensure that the stack pointer accounts for the worst-case stack usage at exit. This
246     // could toast some stack that the DFG used. We need to do it before storing to stack offsets
247     // used by baseline.
248     jit.addPtr(
249         CCallHelpers::TrustedImm32(
250             -jit.codeBlock()->jitCode()->dfgCommon()->requiredRegisterCountForExit * sizeof(Register)),
251         CCallHelpers::framePointerRegister, CCallHelpers::stackPointerRegister);
252     
253     // Restore the DFG callee saves and then save the ones the baseline JIT uses.
254     jit.emitRestoreCalleeSaves();
255     jit.emitSaveCalleeSavesFor(jit.baselineCodeBlock());
256
257     if (exit.isExceptionHandler())
258         jit.copyCalleeSavesToVMEntryFrameCalleeSavesBuffer(vm);
259
260     // Do all data format conversions and store the results into the stack.
261     
262     for (size_t index = 0; index < operands.size(); ++index) {
263         const ValueRecovery& recovery = operands[index];
264         VirtualRegister reg = operands.virtualRegisterForIndex(index);
265
266         if (reg.isLocal() && reg.toLocal() < static_cast<int>(jit.baselineCodeBlock()->calleeSaveSpaceAsVirtualRegisters()))
267             continue;
268
269         int operand = reg.offset();
270
271         switch (recovery.technique()) {
272         case InPair:
273         case DisplacedInJSStack:
274         case InFPR:
275             jit.load32(
276                 &bitwise_cast<EncodedValueDescriptor*>(scratch + index)->asBits.tag,
277                 GPRInfo::regT0);
278             jit.load32(
279                 &bitwise_cast<EncodedValueDescriptor*>(scratch + index)->asBits.payload,
280                 GPRInfo::regT1);
281             jit.store32(
282                 GPRInfo::regT0,
283                 AssemblyHelpers::tagFor(operand));
284             jit.store32(
285                 GPRInfo::regT1,
286                 AssemblyHelpers::payloadFor(operand));
287             break;
288             
289         case UnboxedDoubleInFPR:
290         case DoubleDisplacedInJSStack:
291             jit.move(AssemblyHelpers::TrustedImmPtr(scratch + index), GPRInfo::regT0);
292             jit.loadDouble(MacroAssembler::Address(GPRInfo::regT0), FPRInfo::fpRegT0);
293             jit.purifyNaN(FPRInfo::fpRegT0);
294             jit.storeDouble(FPRInfo::fpRegT0, AssemblyHelpers::addressFor(operand));
295             break;
296
297         case UnboxedInt32InGPR:
298         case Int32DisplacedInJSStack:
299             jit.load32(
300                 &bitwise_cast<EncodedValueDescriptor*>(scratch + index)->asBits.payload,
301                 GPRInfo::regT0);
302             jit.store32(
303                 AssemblyHelpers::TrustedImm32(JSValue::Int32Tag),
304                 AssemblyHelpers::tagFor(operand));
305             jit.store32(
306                 GPRInfo::regT0,
307                 AssemblyHelpers::payloadFor(operand));
308             break;
309             
310         case UnboxedCellInGPR:
311         case CellDisplacedInJSStack:
312             jit.load32(
313                 &bitwise_cast<EncodedValueDescriptor*>(scratch + index)->asBits.payload,
314                 GPRInfo::regT0);
315             jit.store32(
316                 AssemblyHelpers::TrustedImm32(JSValue::CellTag),
317                 AssemblyHelpers::tagFor(operand));
318             jit.store32(
319                 GPRInfo::regT0,
320                 AssemblyHelpers::payloadFor(operand));
321             break;
322             
323         case UnboxedBooleanInGPR:
324         case BooleanDisplacedInJSStack:
325             jit.load32(
326                 &bitwise_cast<EncodedValueDescriptor*>(scratch + index)->asBits.payload,
327                 GPRInfo::regT0);
328             jit.store32(
329                 AssemblyHelpers::TrustedImm32(JSValue::BooleanTag),
330                 AssemblyHelpers::tagFor(operand));
331             jit.store32(
332                 GPRInfo::regT0,
333                 AssemblyHelpers::payloadFor(operand));
334             break;
335             
336         case Constant:
337             jit.store32(
338                 AssemblyHelpers::TrustedImm32(recovery.constant().tag()),
339                 AssemblyHelpers::tagFor(operand));
340             jit.store32(
341                 AssemblyHelpers::TrustedImm32(recovery.constant().payload()),
342                 AssemblyHelpers::payloadFor(operand));
343             break;
344             
345         case DirectArgumentsThatWereNotCreated:
346         case ClonedArgumentsThatWereNotCreated:
347             // Don't do this, yet.
348             break;
349             
350         default:
351             break;
352         }
353     }
354     
355     // Now that things on the stack are recovered, do the arguments recovery. We assume that arguments
356     // recoveries don't recursively refer to each other. But, we don't try to assume that they only
357     // refer to certain ranges of locals. Hence why we need to do this here, once the stack is sensible.
358     // Note that we also roughly assume that the arguments might still be materialized outside of its
359     // inline call frame scope - but for now the DFG wouldn't do that.
360     
361     emitRestoreArguments(jit, operands);
362
363     // Adjust the old JIT's execute counter. Since we are exiting OSR, we know
364     // that all new calls into this code will go to the new JIT, so the execute
365     // counter only affects call frames that performed OSR exit and call frames
366     // that were still executing the old JIT at the time of another call frame's
367     // OSR exit. We want to ensure that the following is true:
368     //
369     // (a) Code the performs an OSR exit gets a chance to reenter optimized
370     //     code eventually, since optimized code is faster. But we don't
371     //     want to do such reentery too aggressively (see (c) below).
372     //
373     // (b) If there is code on the call stack that is still running the old
374     //     JIT's code and has never OSR'd, then it should get a chance to
375     //     perform OSR entry despite the fact that we've exited.
376     //
377     // (c) Code the performs an OSR exit should not immediately retry OSR
378     //     entry, since both forms of OSR are expensive. OSR entry is
379     //     particularly expensive.
380     //
381     // (d) Frequent OSR failures, even those that do not result in the code
382     //     running in a hot loop, result in recompilation getting triggered.
383     //
384     // To ensure (c), we'd like to set the execute counter to
385     // counterValueForOptimizeAfterWarmUp(). This seems like it would endanger
386     // (a) and (b), since then every OSR exit would delay the opportunity for
387     // every call frame to perform OSR entry. Essentially, if OSR exit happens
388     // frequently and the function has few loops, then the counter will never
389     // become non-negative and OSR entry will never be triggered. OSR entry
390     // will only happen if a loop gets hot in the old JIT, which does a pretty
391     // good job of ensuring (a) and (b). But that doesn't take care of (d),
392     // since each speculation failure would reset the execute counter.
393     // So we check here if the number of speculation failures is significantly
394     // larger than the number of successes (we want 90% success rate), and if
395     // there have been a large enough number of failures. If so, we set the
396     // counter to 0; otherwise we set the counter to
397     // counterValueForOptimizeAfterWarmUp().
398     
399     handleExitCounts(jit, exit);
400     
401     // Reify inlined call frames.
402     
403     reifyInlinedCallFrames(jit, exit);
404     
405     // And finish.
406     adjustAndJumpToTarget(vm, jit, exit);
407 }
408
409 } } // namespace JSC::DFG
410
411 #endif // ENABLE(DFG_JIT) && USE(JSVALUE32_64)