The DFG should be able to tier-up and OSR enter into the FTL
[WebKit-https.git] / Source / JavaScriptCore / dfg / DFGOSREntry.cpp
1 /*
2  * Copyright (C) 2011 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()[local].jsValue().isNumber()) {
143                 if (Options::verboseOSR()) {
144                     dataLog(
145                         "    OSR failed because variable ", local, " is ",
146                         exec->registers()[local].jsValue(), ", expected number.\n");
147                 }
148                 return 0;
149             }
150             continue;
151         }
152         if (!entry->m_expectedValues.local(local).validate(exec->registers()[local].jsValue())) {
153             if (Options::verboseOSR()) {
154                 dataLog(
155                     "    OSR failed because variable ", local, " is ",
156                     exec->registers()[local].jsValue(), ", expected ",
157                     entry->m_expectedValues.local(local), ".\n");
158             }
159             return 0;
160         }
161     }
162
163     // 2) Check the stack height. The DFG JIT may require a taller stack than the
164     //    baseline JIT, in some cases. If we can't grow the stack, then don't do
165     //    OSR right now. That's the only option we have unless we want basic block
166     //    boundaries to start throwing RangeErrors. Although that would be possible,
167     //    it seems silly: you'd be diverting the program to error handling when it
168     //    would have otherwise just kept running albeit less quickly.
169     
170     if (!vm->interpreter->stack().grow(&exec->registers()[codeBlock->m_numCalleeRegisters])) {
171         if (Options::verboseOSR())
172             dataLogF("    OSR failed because stack growth failed.\n");
173         return 0;
174     }
175     
176     if (Options::verboseOSR())
177         dataLogF("    OSR should succeed.\n");
178     
179     // 3) Perform data format conversions.
180     for (size_t local = 0; local < entry->m_expectedValues.numberOfLocals(); ++local) {
181         if (entry->m_localsForcedDouble.get(local))
182             *bitwise_cast<double*>(exec->registers() + local) = exec->registers()[local].jsValue().asNumber();
183     }
184     
185     // 4) Fix the call frame.
186     
187     exec->setCodeBlock(codeBlock);
188     
189     // 5) Find and return the destination machine code address.
190     
191     void* result = codeBlock->jitCode()->executableAddressAtOffset(entry->m_machineCodeOffset);
192     
193     if (Options::verboseOSR())
194         dataLogF("    OSR returning machine code address %p.\n", result);
195     
196     return result;
197 #else // DFG_ENABLE(OSR_ENTRY)
198     UNUSED_PARAM(exec);
199     UNUSED_PARAM(codeBlock);
200     UNUSED_PARAM(bytecodeIndex);
201     return 0;
202 #endif
203 }
204
205 } } // namespace JSC::DFG
206
207 #endif // ENABLE(DFG_JIT)