54ab6287ed6b1f3799e362d1b2adb88526113bd0
[WebKit-https.git] / Source / JavaScriptCore / dfg / DFGOSRExitCompiler32_64.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(JSVALUE32_64)
29
30 #include "DFGOSRExitCompiler.h"
31
32 #include "DFGOperations.h"
33 #include "DFGOSRExitCompilerCommon.h"
34 #include "DFGSpeculativeJIT.h"
35 #include "JSCInlines.h"
36 #include <wtf/DataLog.h>
37
38 namespace JSC { namespace DFG {
39
40 void OSRExitCompiler::compileExit(const OSRExit& exit, const Operands<ValueRecovery>& operands, SpeculationRecovery* recovery)
41 {
42     // 1) Pro-forma stuff.
43     if (Options::printEachOSRExit()) {
44         SpeculationFailureDebugInfo* debugInfo = new SpeculationFailureDebugInfo;
45         debugInfo->codeBlock = m_jit.codeBlock();
46         
47         m_jit.debugCall(debugOperationPrintSpeculationFailure, debugInfo);
48     }
49     
50     // Need to ensure that the stack pointer accounts for the worst-case stack usage at exit.
51     m_jit.addPtr(
52         CCallHelpers::TrustedImm32(
53             -m_jit.codeBlock()->jitCode()->dfgCommon()->requiredRegisterCountForExit * sizeof(Register)),
54         CCallHelpers::framePointerRegister, CCallHelpers::stackPointerRegister);
55     
56     // 2) Perform speculation recovery. This only comes into play when an operation
57     //    starts mutating state before verifying the speculation it has already made.
58     
59     if (recovery) {
60         switch (recovery->type()) {
61         case SpeculativeAdd:
62             m_jit.sub32(recovery->src(), recovery->dest());
63             break;
64             
65         case BooleanSpeculationCheck:
66             break;
67             
68         default:
69             break;
70         }
71     }
72
73     // 3) Refine some value profile, if appropriate.
74     
75     if (!!exit.m_jsValueSource) {
76         if (exit.m_kind == BadCache || exit.m_kind == BadIndexingType) {
77             // If the instruction that this originated from has an array profile, then
78             // refine it. If it doesn't, then do nothing. The latter could happen for
79             // hoisted checks, or checks emitted for operations that didn't have array
80             // profiling - either ops that aren't array accesses at all, or weren't
81             // known to be array acceses in the bytecode. The latter case is a FIXME
82             // while the former case is an outcome of a CheckStructure not knowing why
83             // it was emitted (could be either due to an inline cache of a property
84             // property access, or due to an array profile).
85             
86             // Note: We are free to assume that the jsValueSource is already known to
87             // be a cell since both BadCache and BadIndexingType exits occur after
88             // the cell check would have already happened.
89             
90             CodeOrigin codeOrigin = exit.m_codeOriginForExitProfile;
91             if (ArrayProfile* arrayProfile = m_jit.baselineCodeBlockFor(codeOrigin)->getArrayProfile(codeOrigin.bytecodeIndex)) {
92                 GPRReg usedRegister1;
93                 GPRReg usedRegister2;
94                 if (exit.m_jsValueSource.isAddress()) {
95                     usedRegister1 = exit.m_jsValueSource.base();
96                     usedRegister2 = InvalidGPRReg;
97                 } else {
98                     usedRegister1 = exit.m_jsValueSource.payloadGPR();
99                     if (exit.m_jsValueSource.hasKnownTag())
100                         usedRegister2 = InvalidGPRReg;
101                     else
102                         usedRegister2 = exit.m_jsValueSource.tagGPR();
103                 }
104                 
105                 GPRReg scratch1;
106                 GPRReg scratch2;
107                 scratch1 = AssemblyHelpers::selectScratchGPR(usedRegister1, usedRegister2);
108                 scratch2 = AssemblyHelpers::selectScratchGPR(usedRegister1, usedRegister2, scratch1);
109                 
110 #if CPU(ARM64)
111                 m_jit.pushToSave(scratch1);
112                 m_jit.pushToSave(scratch2);
113 #else
114                 m_jit.push(scratch1);
115                 m_jit.push(scratch2);
116 #endif
117                 
118                 GPRReg value;
119                 if (exit.m_jsValueSource.isAddress()) {
120                     value = scratch1;
121                     m_jit.loadPtr(AssemblyHelpers::Address(exit.m_jsValueSource.asAddress()), value);
122                 } else
123                     value = exit.m_jsValueSource.payloadGPR();
124                 
125                 m_jit.loadPtr(AssemblyHelpers::Address(value, JSCell::structureOffset()), scratch1);
126                 m_jit.storePtr(scratch1, arrayProfile->addressOfLastSeenStructure());
127                 m_jit.load8(AssemblyHelpers::Address(scratch1, Structure::indexingTypeOffset()), scratch1);
128                 m_jit.move(AssemblyHelpers::TrustedImm32(1), scratch2);
129                 m_jit.lshift32(scratch1, scratch2);
130                 m_jit.or32(scratch2, AssemblyHelpers::AbsoluteAddress(arrayProfile->addressOfArrayModes()));
131                 
132 #if CPU(ARM64)
133                 m_jit.popToRestore(scratch2);
134                 m_jit.popToRestore(scratch1);
135 #else
136                 m_jit.pop(scratch2);
137                 m_jit.pop(scratch1);
138 #endif
139             }
140         }
141         
142         if (!!exit.m_valueProfile) {
143             EncodedJSValue* bucket = exit.m_valueProfile.getSpecFailBucket(0);
144         
145             if (exit.m_jsValueSource.isAddress()) {
146                 // Save a register so we can use it.
147                 GPRReg scratch = AssemblyHelpers::selectScratchGPR(exit.m_jsValueSource.base());
148                 
149 #if CPU(ARM64)
150                 m_jit.pushToSave(scratch);
151 #else
152                 m_jit.push(scratch);
153 #endif
154
155                 m_jit.load32(exit.m_jsValueSource.asAddress(OBJECT_OFFSETOF(EncodedValueDescriptor, asBits.tag)), scratch);
156                 m_jit.store32(scratch, &bitwise_cast<EncodedValueDescriptor*>(bucket)->asBits.tag);
157                 m_jit.load32(exit.m_jsValueSource.asAddress(OBJECT_OFFSETOF(EncodedValueDescriptor, asBits.payload)), scratch);
158                 m_jit.store32(scratch, &bitwise_cast<EncodedValueDescriptor*>(bucket)->asBits.payload);
159                 
160 #if CPU(ARM64)
161                 m_jit.popToRestore(scratch);
162 #else
163                 m_jit.pop(scratch);
164 #endif
165             } else if (exit.m_jsValueSource.hasKnownTag()) {
166                 m_jit.store32(AssemblyHelpers::TrustedImm32(exit.m_jsValueSource.tag()), &bitwise_cast<EncodedValueDescriptor*>(bucket)->asBits.tag);
167                 m_jit.store32(exit.m_jsValueSource.payloadGPR(), &bitwise_cast<EncodedValueDescriptor*>(bucket)->asBits.payload);
168             } else {
169                 m_jit.store32(exit.m_jsValueSource.tagGPR(), &bitwise_cast<EncodedValueDescriptor*>(bucket)->asBits.tag);
170                 m_jit.store32(exit.m_jsValueSource.payloadGPR(), &bitwise_cast<EncodedValueDescriptor*>(bucket)->asBits.payload);
171             }
172         }
173     }
174     
175     // Do a simplified OSR exit. See DFGOSRExitCompiler64.cpp's comment regarding how and wny we
176     // do this simple approach.
177
178     // 4) Save all state from GPRs into the scratch buffer.
179     
180     ScratchBuffer* scratchBuffer = m_jit.vm()->scratchBufferForSize(sizeof(EncodedJSValue) * operands.size());
181     EncodedJSValue* scratch = scratchBuffer ? static_cast<EncodedJSValue*>(scratchBuffer->dataBuffer()) : 0;
182     
183     for (size_t index = 0; index < operands.size(); ++index) {
184         const ValueRecovery& recovery = operands[index];
185         
186         switch (recovery.technique()) {
187         case UnboxedInt32InGPR:
188         case UnboxedBooleanInGPR:
189         case UnboxedCellInGPR:
190             m_jit.store32(
191                 recovery.gpr(),
192                 &bitwise_cast<EncodedValueDescriptor*>(scratch + index)->asBits.payload);
193             break;
194             
195         case InPair:
196             m_jit.store32(
197                 recovery.tagGPR(),
198                 &bitwise_cast<EncodedValueDescriptor*>(scratch + index)->asBits.tag);
199             m_jit.store32(
200                 recovery.payloadGPR(),
201                 &bitwise_cast<EncodedValueDescriptor*>(scratch + index)->asBits.payload);
202             break;
203             
204         default:
205             break;
206         }
207     }
208     
209     // Now 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(), MacroAssembler::Address(GPRInfo::regT0));
220             break;
221             
222         default:
223             break;
224         }
225     }
226     
227     // Now all FPRs are free to reuse.
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 Int32DisplacedInJSStack:
239         case DoubleDisplacedInJSStack:
240         case CellDisplacedInJSStack:
241         case BooleanDisplacedInJSStack:
242             m_jit.load32(
243                 AssemblyHelpers::tagFor(recovery.virtualRegister()),
244                 GPRInfo::regT0);
245             m_jit.load32(
246                 AssemblyHelpers::payloadFor(recovery.virtualRegister()),
247                 GPRInfo::regT1);
248             m_jit.store32(
249                 GPRInfo::regT0,
250                 &bitwise_cast<EncodedValueDescriptor*>(scratch + index)->asBits.tag);
251             m_jit.store32(
252                 GPRInfo::regT1,
253                 &bitwise_cast<EncodedValueDescriptor*>(scratch + index)->asBits.payload);
254             break;
255             
256         default:
257             break;
258         }
259     }
260     
261     // 7) Do all data format conversions and store the results into the stack.
262     
263     bool haveArguments = false;
264     
265     for (size_t index = 0; index < operands.size(); ++index) {
266         const ValueRecovery& recovery = operands[index];
267         int operand = operands.operandForIndex(index);
268         
269         switch (recovery.technique()) {
270         case InPair:
271         case InFPR:
272         case DisplacedInJSStack:
273         case DoubleDisplacedInJSStack:
274             m_jit.load32(
275                 &bitwise_cast<EncodedValueDescriptor*>(scratch + index)->asBits.tag,
276                 GPRInfo::regT0);
277             m_jit.load32(
278                 &bitwise_cast<EncodedValueDescriptor*>(scratch + index)->asBits.payload,
279                 GPRInfo::regT1);
280             m_jit.store32(
281                 GPRInfo::regT0,
282                 AssemblyHelpers::tagFor(operand));
283             m_jit.store32(
284                 GPRInfo::regT1,
285                 AssemblyHelpers::payloadFor(operand));
286             break;
287             
288         case UnboxedInt32InGPR:
289         case Int32DisplacedInJSStack:
290             m_jit.load32(
291                 &bitwise_cast<EncodedValueDescriptor*>(scratch + index)->asBits.payload,
292                 GPRInfo::regT0);
293             m_jit.store32(
294                 AssemblyHelpers::TrustedImm32(JSValue::Int32Tag),
295                 AssemblyHelpers::tagFor(operand));
296             m_jit.store32(
297                 GPRInfo::regT0,
298                 AssemblyHelpers::payloadFor(operand));
299             break;
300             
301         case UnboxedCellInGPR:
302         case CellDisplacedInJSStack:
303             m_jit.load32(
304                 &bitwise_cast<EncodedValueDescriptor*>(scratch + index)->asBits.payload,
305                 GPRInfo::regT0);
306             m_jit.store32(
307                 AssemblyHelpers::TrustedImm32(JSValue::CellTag),
308                 AssemblyHelpers::tagFor(operand));
309             m_jit.store32(
310                 GPRInfo::regT0,
311                 AssemblyHelpers::payloadFor(operand));
312             break;
313             
314         case UnboxedBooleanInGPR:
315         case BooleanDisplacedInJSStack:
316             m_jit.load32(
317                 &bitwise_cast<EncodedValueDescriptor*>(scratch + index)->asBits.payload,
318                 GPRInfo::regT0);
319             m_jit.store32(
320                 AssemblyHelpers::TrustedImm32(JSValue::BooleanTag),
321                 AssemblyHelpers::tagFor(operand));
322             m_jit.store32(
323                 GPRInfo::regT0,
324                 AssemblyHelpers::payloadFor(operand));
325             break;
326             
327         case Constant:
328             m_jit.store32(
329                 AssemblyHelpers::TrustedImm32(recovery.constant().tag()),
330                 AssemblyHelpers::tagFor(operand));
331             m_jit.store32(
332                 AssemblyHelpers::TrustedImm32(recovery.constant().payload()),
333                 AssemblyHelpers::payloadFor(operand));
334             break;
335             
336         case ArgumentsThatWereNotCreated:
337             haveArguments = true;
338             m_jit.store32(
339                 AssemblyHelpers::TrustedImm32(JSValue().tag()),
340                 AssemblyHelpers::tagFor(operand));
341             m_jit.store32(
342                 AssemblyHelpers::TrustedImm32(JSValue().payload()),
343                 AssemblyHelpers::payloadFor(operand));
344             break;
345             
346         default:
347             break;
348         }
349     }
350     
351     // 8) Adjust the old JIT's execute counter. Since we are exiting OSR, we know
352     //    that all new calls into this code will go to the new JIT, so the execute
353     //    counter only affects call frames that performed OSR exit and call frames
354     //    that were still executing the old JIT at the time of another call frame's
355     //    OSR exit. We want to ensure that the following is true:
356     //
357     //    (a) Code the performs an OSR exit gets a chance to reenter optimized
358     //        code eventually, since optimized code is faster. But we don't
359     //        want to do such reentery too aggressively (see (c) below).
360     //
361     //    (b) If there is code on the call stack that is still running the old
362     //        JIT's code and has never OSR'd, then it should get a chance to
363     //        perform OSR entry despite the fact that we've exited.
364     //
365     //    (c) Code the performs an OSR exit should not immediately retry OSR
366     //        entry, since both forms of OSR are expensive. OSR entry is
367     //        particularly expensive.
368     //
369     //    (d) Frequent OSR failures, even those that do not result in the code
370     //        running in a hot loop, result in recompilation getting triggered.
371     //
372     //    To ensure (c), we'd like to set the execute counter to
373     //    counterValueForOptimizeAfterWarmUp(). This seems like it would endanger
374     //    (a) and (b), since then every OSR exit would delay the opportunity for
375     //    every call frame to perform OSR entry. Essentially, if OSR exit happens
376     //    frequently and the function has few loops, then the counter will never
377     //    become non-negative and OSR entry will never be triggered. OSR entry
378     //    will only happen if a loop gets hot in the old JIT, which does a pretty
379     //    good job of ensuring (a) and (b). But that doesn't take care of (d),
380     //    since each speculation failure would reset the execute counter.
381     //    So we check here if the number of speculation failures is significantly
382     //    larger than the number of successes (we want 90% success rate), and if
383     //    there have been a large enough number of failures. If so, we set the
384     //    counter to 0; otherwise we set the counter to
385     //    counterValueForOptimizeAfterWarmUp().
386     
387     handleExitCounts(m_jit, exit);
388     
389     // 9) Reify inlined call frames.
390     
391     reifyInlinedCallFrames(m_jit, exit);
392     
393     // 10) Create arguments if necessary and place them into the appropriate aliased
394     //     registers.
395     
396     if (haveArguments) {
397         HashSet<InlineCallFrame*, DefaultHash<InlineCallFrame*>::Hash,
398             NullableHashTraits<InlineCallFrame*>> didCreateArgumentsObject;
399
400         for (size_t index = 0; index < operands.size(); ++index) {
401             const ValueRecovery& recovery = operands[index];
402             if (recovery.technique() != ArgumentsThatWereNotCreated)
403                 continue;
404             int operand = operands.operandForIndex(index);
405             // Find the right inline call frame.
406             InlineCallFrame* inlineCallFrame = 0;
407             for (InlineCallFrame* current = exit.m_codeOrigin.inlineCallFrame;
408                  current;
409                  current = current->caller.inlineCallFrame) {
410                 if (current->stackOffset >= operand) {
411                     inlineCallFrame = current;
412                     break;
413                 }
414             }
415
416             if (!m_jit.baselineCodeBlockFor(inlineCallFrame)->usesArguments())
417                 continue;
418             VirtualRegister argumentsRegister = m_jit.baselineArgumentsRegisterFor(inlineCallFrame);
419             if (didCreateArgumentsObject.add(inlineCallFrame).isNewEntry) {
420                 // We know this call frame optimized out an arguments object that
421                 // the baseline JIT would have created. Do that creation now.
422                 if (inlineCallFrame) {
423                     m_jit.setupArgumentsWithExecState(
424                         AssemblyHelpers::TrustedImmPtr(inlineCallFrame));
425                     m_jit.move(
426                         AssemblyHelpers::TrustedImmPtr(
427                             bitwise_cast<void*>(operationCreateInlinedArguments)),
428                         GPRInfo::nonArgGPR0);
429                 } else {
430                     m_jit.setupArgumentsExecState();
431                     m_jit.move(
432                         AssemblyHelpers::TrustedImmPtr(
433                             bitwise_cast<void*>(operationCreateArguments)),
434                         GPRInfo::nonArgGPR0);
435                 }
436                 m_jit.call(GPRInfo::nonArgGPR0);
437                 m_jit.store32(
438                     AssemblyHelpers::TrustedImm32(JSValue::CellTag),
439                     AssemblyHelpers::tagFor(argumentsRegister));
440                 m_jit.store32(
441                     GPRInfo::returnValueGPR,
442                     AssemblyHelpers::payloadFor(argumentsRegister));
443                 m_jit.store32(
444                     AssemblyHelpers::TrustedImm32(JSValue::CellTag),
445                     AssemblyHelpers::tagFor(unmodifiedArgumentsRegister(argumentsRegister)));
446                 m_jit.store32(
447                     GPRInfo::returnValueGPR,
448                     AssemblyHelpers::payloadFor(unmodifiedArgumentsRegister(argumentsRegister)));
449                 m_jit.move(GPRInfo::returnValueGPR, GPRInfo::regT0); // no-op move on almost all platforms.
450             }
451
452             m_jit.load32(AssemblyHelpers::payloadFor(argumentsRegister), GPRInfo::regT0);
453             m_jit.store32(
454                 AssemblyHelpers::TrustedImm32(JSValue::CellTag),
455                 AssemblyHelpers::tagFor(operand));
456             m_jit.store32(GPRInfo::regT0, AssemblyHelpers::payloadFor(operand));
457         }
458     }
459
460     // 12) And finish.
461     adjustAndJumpToTarget(m_jit, exit);
462 }
463
464 } } // namespace JSC::DFG
465
466 #endif // ENABLE(DFG_JIT) && USE(JSVALUE32_64)