Unreviewed, rolling out r156474.
[WebKit-https.git] / Source / JavaScriptCore / dfg / DFGOSREntry.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 "DFGOSREntry.h"
28
29 #if ENABLE(DFG_JIT)
30
31 #include "CallFrame.h"
32 #include "CodeBlock.h"
33 #include "DFGJITCode.h"
34 #include "DFGNode.h"
35 #include "JIT.h"
36 #include "Operations.h"
37
38 namespace JSC { namespace DFG {
39
40 void* prepareOSREntry(ExecState* exec, CodeBlock* codeBlock, unsigned bytecodeIndex)
41 {
42 #if DFG_ENABLE(OSR_ENTRY)
43     ASSERT(JITCode::isOptimizingJIT(codeBlock->jitType()));
44     ASSERT(codeBlock->alternative());
45     ASSERT(codeBlock->alternative()->jitType() == JITCode::BaselineJIT);
46     ASSERT(!codeBlock->jitCodeMap());
47
48     if (Options::verboseOSR()) {
49         dataLog(
50             "DFG OSR in ", *codeBlock->alternative(), " -> ", *codeBlock,
51             " from bc#", bytecodeIndex, "\n");
52     }
53     
54     VM* vm = &exec->vm();
55     if (codeBlock->jitType() != JITCode::DFGJIT) {
56         RELEASE_ASSERT(codeBlock->jitType() == JITCode::FTLJIT);
57         
58         // When will this happen? We could have:
59         //
60         // - An exit from the FTL JIT into the baseline JIT followed by an attempt
61         //   to reenter. We're fine with allowing this to fail. If it happens
62         //   enough we'll just reoptimize. It basically means that the OSR exit cost
63         //   us dearly and so reoptimizing is the right thing to do.
64         //
65         // - We have recursive code with hot loops. Consider that foo has a hot loop
66         //   that calls itself. We have two foo's on the stack, lets call them foo1
67         //   and foo2, with foo1 having called foo2 from foo's hot loop. foo2 gets
68         //   optimized all the way into the FTL. Then it returns into foo1, and then
69         //   foo1 wants to get optimized. It might reach this conclusion from its
70         //   hot loop and attempt to OSR enter. And we'll tell it that it can't. It
71         //   might be worth addressing this case, but I just think this case will
72         //   be super rare. For now, if it does happen, it'll cause some compilation
73         //   thrashing.
74         
75         if (Options::verboseOSR())
76             dataLog("    OSR failed because the target code block is not DFG.\n");
77         return 0;
78     }
79     
80     OSREntryData* entry = codeBlock->jitCode()->dfg()->osrEntryDataForBytecodeIndex(bytecodeIndex);
81     
82     if (!entry) {
83         if (Options::verboseOSR())
84             dataLogF("    OSR failed because the entrypoint was optimized out.\n");
85         return 0;
86     }
87     
88     ASSERT(entry->m_bytecodeIndex == bytecodeIndex);
89     
90     // The code below checks if it is safe to perform OSR entry. It may find
91     // that it is unsafe to do so, for any number of reasons, which are documented
92     // below. If the code decides not to OSR then it returns 0, and it's the caller's
93     // responsibility to patch up the state in such a way as to ensure that it's
94     // both safe and efficient to continue executing baseline code for now. This
95     // should almost certainly include calling either codeBlock->optimizeAfterWarmUp()
96     // or codeBlock->dontOptimizeAnytimeSoon().
97     
98     // 1) Verify predictions. If the predictions are inconsistent with the actual
99     //    values, then OSR entry is not possible at this time. It's tempting to
100     //    assume that we could somehow avoid this case. We can certainly avoid it
101     //    for first-time loop OSR - that is, OSR into a CodeBlock that we have just
102     //    compiled. Then we are almost guaranteed that all of the predictions will
103     //    check out. It would be pretty easy to make that a hard guarantee. But
104     //    then there would still be the case where two call frames with the same
105     //    baseline CodeBlock are on the stack at the same time. The top one
106     //    triggers compilation and OSR. In that case, we may no longer have
107     //    accurate value profiles for the one deeper in the stack. Hence, when we
108     //    pop into the CodeBlock that is deeper on the stack, we might OSR and
109     //    realize that the predictions are wrong. Probably, in most cases, this is
110     //    just an anomaly in the sense that the older CodeBlock simply went off
111     //    into a less-likely path. So, the wisest course of action is to simply not
112     //    OSR at this time.
113     
114     for (size_t argument = 0; argument < entry->m_expectedValues.numberOfArguments(); ++argument) {
115         if (argument >= exec->argumentCountIncludingThis()) {
116             if (Options::verboseOSR()) {
117                 dataLogF("    OSR failed because argument %zu was not passed, expected ", argument);
118                 entry->m_expectedValues.argument(argument).dump(WTF::dataFile());
119                 dataLogF(".\n");
120             }
121             return 0;
122         }
123         
124         JSValue value;
125         if (!argument)
126             value = exec->hostThisValue();
127         else
128             value = exec->argument(argument - 1);
129         
130         if (!entry->m_expectedValues.argument(argument).validate(value)) {
131             if (Options::verboseOSR()) {
132                 dataLog(
133                     "    OSR failed because argument ", argument, " is ", value,
134                     ", expected ", entry->m_expectedValues.argument(argument), ".\n");
135             }
136             return 0;
137         }
138     }
139     
140     for (size_t local = 0; local < entry->m_expectedValues.numberOfLocals(); ++local) {
141         if (entry->m_localsForcedDouble.get(local)) {
142             if (!exec->registers()[localToOperand(local)].jsValue().isNumber()) {
143                 if (Options::verboseOSR()) {
144                     dataLog(
145                         "    OSR failed because variable ", localToOperand(local), " is ",
146                         exec->registers()[localToOperand(local)].jsValue(), ", expected number.\n");
147                 }
148                 return 0;
149             }
150             continue;
151         }
152         if (entry->m_localsForcedMachineInt.get(local)) {
153             if (!exec->registers()[localToOperand(local)].jsValue().isMachineInt()) {
154                 if (Options::verboseOSR()) {
155                     dataLog(
156                         "    OSR failed because variable ", localToOperand(local), " is ",
157                         exec->registers()[localToOperand(local)].jsValue(), ", expected ",
158                         "machine int.\n");
159                 }
160                 return 0;
161             }
162             continue;
163         }
164         if (!entry->m_expectedValues.local(local).validate(exec->registers()[localToOperand(local)].jsValue())) {
165             if (Options::verboseOSR()) {
166                 dataLog(
167                     "    OSR failed because variable ", localToOperand(local), " is ",
168                     exec->registers()[localToOperand(local)].jsValue(), ", expected ",
169                     entry->m_expectedValues.local(local), ".\n");
170             }
171             return 0;
172         }
173     }
174
175     // 2) Check the stack height. The DFG JIT may require a taller stack than the
176     //    baseline JIT, in some cases. If we can't grow the stack, then don't do
177     //    OSR right now. That's the only option we have unless we want basic block
178     //    boundaries to start throwing RangeErrors. Although that would be possible,
179     //    it seems silly: you'd be diverting the program to error handling when it
180     //    would have otherwise just kept running albeit less quickly.
181     
182     if (!vm->interpreter->stack().grow(&exec->registers()[localToOperand(codeBlock->m_numCalleeRegisters)])) {
183         if (Options::verboseOSR())
184             dataLogF("    OSR failed because stack growth failed.\n");
185         return 0;
186     }
187     
188     if (Options::verboseOSR())
189         dataLogF("    OSR should succeed.\n");
190     
191     // 3) Perform data format conversions.
192     for (size_t local = 0; local < entry->m_expectedValues.numberOfLocals(); ++local) {
193         if (entry->m_localsForcedDouble.get(local))
194             *bitwise_cast<double*>(exec->registers() + localToOperand(local)) = exec->registers()[localToOperand(local)].jsValue().asNumber();
195         if (entry->m_localsForcedMachineInt.get(local))
196             *bitwise_cast<int64_t*>(exec->registers() + localToOperand(local)) = exec->registers()[localToOperand(local)].jsValue().asMachineInt() << JSValue::int52ShiftAmount;
197     }
198     
199     // 4) Fix the call frame.
200     
201     exec->setCodeBlock(codeBlock);
202     
203     // 5) Find and return the destination machine code address.
204     
205     void* result = codeBlock->jitCode()->executableAddressAtOffset(entry->m_machineCodeOffset);
206     
207     if (Options::verboseOSR())
208         dataLogF("    OSR returning machine code address %p.\n", result);
209     
210     return result;
211 #else // DFG_ENABLE(OSR_ENTRY)
212     UNUSED_PARAM(exec);
213     UNUSED_PARAM(codeBlock);
214     UNUSED_PARAM(bytecodeIndex);
215     return 0;
216 #endif
217 }
218
219 } } // namespace JSC::DFG
220
221 #endif // ENABLE(DFG_JIT)