Towards 8 Bit Strings: Templatize JSC::Parser class by Lexer type
[WebKit-https.git] / Source / JavaScriptCore / dfg / DFGJITCompiler.h
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 #ifndef DFGJITCompiler_h
27 #define DFGJITCompiler_h
28
29 #if ENABLE(DFG_JIT)
30
31 #include <assembler/MacroAssembler.h>
32 #include <bytecode/CodeBlock.h>
33 #include <dfg/DFGAssemblyHelpers.h>
34 #include <dfg/DFGFPRInfo.h>
35 #include <dfg/DFGGPRInfo.h>
36 #include <dfg/DFGGraph.h>
37 #include <dfg/DFGRegisterBank.h>
38 #include <jit/JITCode.h>
39
40 namespace JSC {
41
42 class AbstractSamplingCounter;
43 class CodeBlock;
44 class JSGlobalData;
45
46 namespace DFG {
47
48 class JITCodeGenerator;
49 class NodeToRegisterMap;
50 class SpeculativeJIT;
51 class SpeculationRecovery;
52
53 struct EntryLocation;
54 struct OSRExit;
55
56 #if DFG_ENABLE(VERBOSE_SPECULATION_FAILURE)
57 struct SpeculationFailureDebugInfo {
58     CodeBlock* codeBlock;
59     unsigned debugOffset;
60 };
61 #endif
62
63 // === CallLinkRecord ===
64 //
65 // A record of a call out from JIT code that needs linking to a helper function.
66 // Every CallLinkRecord contains a reference to the call instruction & the function
67 // that it needs to be linked to.
68 struct CallLinkRecord {
69     CallLinkRecord(MacroAssembler::Call call, FunctionPtr function)
70         : m_call(call)
71         , m_function(function)
72     {
73     }
74
75     MacroAssembler::Call m_call;
76     FunctionPtr m_function;
77 };
78
79 // === CallExceptionRecord ===
80 //
81 // A record of a call out from JIT code that might throw an exception.
82 // Calls that might throw an exception also record the Jump taken on exception
83 // (unset if not present) and code origin used to recover handler/source info.
84 struct CallExceptionRecord {
85     CallExceptionRecord(MacroAssembler::Call call, CodeOrigin codeOrigin)
86         : m_call(call)
87         , m_codeOrigin(codeOrigin)
88     {
89     }
90
91     CallExceptionRecord(MacroAssembler::Call call, MacroAssembler::Jump exceptionCheck, CodeOrigin codeOrigin)
92         : m_call(call)
93         , m_exceptionCheck(exceptionCheck)
94         , m_codeOrigin(codeOrigin)
95     {
96     }
97
98     MacroAssembler::Call m_call;
99     MacroAssembler::Jump m_exceptionCheck;
100     CodeOrigin m_codeOrigin;
101 };
102
103 struct PropertyAccessRecord {
104 #if USE(JSVALUE64)
105     PropertyAccessRecord(MacroAssembler::DataLabelPtr deltaCheckImmToCall, MacroAssembler::Call functionCall, MacroAssembler::Jump deltaCallToStructCheck, MacroAssembler::DataLabelCompact deltaCallToLoadOrStore, MacroAssembler::Label deltaCallToSlowCase, MacroAssembler::Label deltaCallToDone, int8_t baseGPR, int8_t valueGPR, int8_t scratchGPR)
106 #elif USE(JSVALUE32_64)
107     PropertyAccessRecord(MacroAssembler::DataLabelPtr deltaCheckImmToCall, MacroAssembler::Call functionCall, MacroAssembler::Jump deltaCallToStructCheck, MacroAssembler::DataLabelCompact deltaCallToTagLoadOrStore, MacroAssembler::DataLabelCompact deltaCallToPayloadLoadOrStore, MacroAssembler::Label deltaCallToSlowCase, MacroAssembler::Label deltaCallToDone, int8_t baseGPR, int8_t valueTagGPR, int8_t valueGPR, int8_t scratchGPR)
108 #endif
109         : m_deltaCheckImmToCall(deltaCheckImmToCall)
110         , m_functionCall(functionCall)
111         , m_deltaCallToStructCheck(deltaCallToStructCheck)
112 #if USE(JSVALUE64)
113         , m_deltaCallToLoadOrStore(deltaCallToLoadOrStore)
114 #elif USE(JSVALUE32_64)
115         , m_deltaCallToTagLoadOrStore(deltaCallToTagLoadOrStore)
116         , m_deltaCallToPayloadLoadOrStore(deltaCallToPayloadLoadOrStore)
117 #endif
118         , m_deltaCallToSlowCase(deltaCallToSlowCase)
119         , m_deltaCallToDone(deltaCallToDone)
120         , m_baseGPR(baseGPR)
121 #if USE(JSVALUE32_64)
122         , m_valueTagGPR(valueTagGPR)
123 #endif
124         , m_valueGPR(valueGPR)
125         , m_scratchGPR(scratchGPR)
126     {
127     }
128
129     MacroAssembler::DataLabelPtr m_deltaCheckImmToCall;
130     MacroAssembler::Call m_functionCall;
131     MacroAssembler::Jump m_deltaCallToStructCheck;
132 #if USE(JSVALUE64)
133     MacroAssembler::DataLabelCompact m_deltaCallToLoadOrStore;
134 #elif USE(JSVALUE32_64)
135     MacroAssembler::DataLabelCompact m_deltaCallToTagLoadOrStore;
136     MacroAssembler::DataLabelCompact m_deltaCallToPayloadLoadOrStore;
137 #endif
138     MacroAssembler::Label m_deltaCallToSlowCase;
139     MacroAssembler::Label m_deltaCallToDone;
140     int8_t m_baseGPR;
141 #if USE(JSVALUE32_64)
142     int8_t m_valueTagGPR;
143 #endif
144     int8_t m_valueGPR;
145     int8_t m_scratchGPR;
146 };
147
148 // === JITCompiler ===
149 //
150 // DFG::JITCompiler is responsible for generating JIT code from the dataflow graph.
151 // It does so by delegating to the speculative & non-speculative JITs, which
152 // generate to a MacroAssembler (which the JITCompiler owns through an inheritance
153 // relationship). The JITCompiler holds references to information required during
154 // compilation, and also records information used in linking (e.g. a list of all
155 // call to be linked).
156 class JITCompiler : public AssemblyHelpers {
157 public:
158     JITCompiler(JSGlobalData* globalData, Graph& dfg, CodeBlock* codeBlock)
159         : AssemblyHelpers(globalData, codeBlock)
160         , m_graph(dfg)
161     {
162     }
163
164     void compile(JITCode& entry);
165     void compileFunction(JITCode& entry, MacroAssemblerCodePtr& entryWithArityCheck);
166
167     // Accessors for properties.
168     Graph& graph() { return m_graph; }
169
170     // Notify the JIT of a call that does not require linking.
171     void notifyCall(Call functionCall, CodeOrigin codeOrigin)
172     {
173         m_exceptionChecks.append(CallExceptionRecord(functionCall, codeOrigin));
174     }
175
176     // Add a call out from JIT code, without an exception check.
177     Call appendCall(const FunctionPtr& function)
178     {
179         Call functionCall = call();
180         m_calls.append(CallLinkRecord(functionCall, function));
181         return functionCall;
182     }
183
184     // Add a call out from JIT code, with an exception check.
185     Call addExceptionCheck(Call functionCall, CodeOrigin codeOrigin)
186     {
187 #if USE(JSVALUE64)
188         Jump exceptionCheck = branchTestPtr(NonZero, AbsoluteAddress(&globalData()->exception));
189 #elif USE(JSVALUE32_64)
190         Jump exceptionCheck = branch32(NotEqual, AbsoluteAddress(reinterpret_cast<char*>(&globalData()->exception) + OBJECT_OFFSETOF(JSValue, u.asBits.tag)), TrustedImm32(JSValue::EmptyValueTag));
191 #endif
192         m_exceptionChecks.append(CallExceptionRecord(functionCall, exceptionCheck, codeOrigin));
193         return functionCall;
194     }
195     
196     // Add a call out from JIT code, with a fast exception check that tests if the return value is zero.
197     Call addFastExceptionCheck(Call functionCall, CodeOrigin codeOrigin)
198     {
199         Jump exceptionCheck = branchTestPtr(Zero, GPRInfo::returnValueGPR);
200         m_exceptionChecks.append(CallExceptionRecord(functionCall, exceptionCheck, codeOrigin));
201         return functionCall;
202     }
203     
204     // Helper methods to check nodes for constants.
205     bool isConstant(NodeIndex nodeIndex) { return graph().isConstant(nodeIndex); }
206     bool isJSConstant(NodeIndex nodeIndex) { return graph().isJSConstant(nodeIndex); }
207     bool isInt32Constant(NodeIndex nodeIndex) { return graph().isInt32Constant(codeBlock(), nodeIndex); }
208     bool isDoubleConstant(NodeIndex nodeIndex) { return graph().isDoubleConstant(codeBlock(), nodeIndex); }
209     bool isNumberConstant(NodeIndex nodeIndex) { return graph().isNumberConstant(codeBlock(), nodeIndex); }
210     bool isBooleanConstant(NodeIndex nodeIndex) { return graph().isBooleanConstant(codeBlock(), nodeIndex); }
211     bool isFunctionConstant(NodeIndex nodeIndex) { return graph().isFunctionConstant(codeBlock(), nodeIndex); }
212     // Helper methods get constant values from nodes.
213     JSValue valueOfJSConstant(NodeIndex nodeIndex) { return graph().valueOfJSConstant(codeBlock(), nodeIndex); }
214     int32_t valueOfInt32Constant(NodeIndex nodeIndex) { return graph().valueOfInt32Constant(codeBlock(), nodeIndex); }
215     double valueOfNumberConstant(NodeIndex nodeIndex) { return graph().valueOfNumberConstant(codeBlock(), nodeIndex); }
216     bool valueOfBooleanConstant(NodeIndex nodeIndex) { return graph().valueOfBooleanConstant(codeBlock(), nodeIndex); }
217     JSFunction* valueOfFunctionConstant(NodeIndex nodeIndex) { return graph().valueOfFunctionConstant(codeBlock(), nodeIndex); }
218     
219     // Helper methods to get predictions
220     PredictedType getPrediction(Node& node) { return node.prediction(); }
221     PredictedType getPrediction(NodeIndex nodeIndex) { return getPrediction(graph()[nodeIndex]); }
222
223 #if USE(JSVALUE32_64)
224     void* addressOfDoubleConstant(NodeIndex nodeIndex)
225     {
226         ASSERT(isNumberConstant(nodeIndex));
227         unsigned constantIndex = graph()[nodeIndex].constantNumber();
228         return &(codeBlock()->constantRegister(FirstConstantRegisterIndex + constantIndex));
229     }
230
231     void emitLoadTag(NodeIndex, GPRReg tag);
232     void emitLoadPayload(NodeIndex, GPRReg payload);
233
234     void emitLoad(const JSValue&, GPRReg tag, GPRReg payload);
235     void emitLoad(NodeIndex, GPRReg tag, GPRReg payload);
236     void emitLoad2(NodeIndex index1, GPRReg tag1, GPRReg payload1, NodeIndex index2, GPRReg tag2, GPRReg payload2);
237
238     void emitLoadDouble(NodeIndex, FPRReg value);
239     void emitLoadInt32ToDouble(NodeIndex, FPRReg value);
240
241     void emitStore(NodeIndex, GPRReg tag, GPRReg payload);
242     void emitStore(NodeIndex, const JSValue constant);
243     void emitStoreInt32(NodeIndex, GPRReg payload, bool indexIsInt32 = false);
244     void emitStoreInt32(NodeIndex, TrustedImm32 payload, bool indexIsInt32 = false);
245     void emitStoreCell(NodeIndex, GPRReg payload, bool indexIsCell = false);
246     void emitStoreBool(NodeIndex, GPRReg payload, bool indexIsBool = false);
247     void emitStoreDouble(NodeIndex, FPRReg value);
248 #endif
249
250     void addPropertyAccess(const PropertyAccessRecord& record)
251     {
252         m_propertyAccesses.append(record);
253     }
254
255     void addMethodGet(Call slowCall, DataLabelPtr structToCompare, DataLabelPtr protoObj, DataLabelPtr protoStructToCompare, DataLabelPtr putFunction)
256     {
257         m_methodGets.append(MethodGetRecord(slowCall, structToCompare, protoObj, protoStructToCompare, putFunction));
258     }
259     
260     void addJSCall(Call fastCall, Call slowCall, DataLabelPtr targetToCheck, bool isCall, CodeOrigin codeOrigin)
261     {
262         m_jsCalls.append(JSCallRecord(fastCall, slowCall, targetToCheck, isCall, codeOrigin));
263     }
264     
265     void noticeOSREntry(BasicBlock& basicBlock)
266     {
267 #if DFG_ENABLE(OSR_ENTRY)
268         OSREntryData* entry = codeBlock()->appendDFGOSREntryData(basicBlock.bytecodeBegin, differenceBetween(m_startOfCode, label()));
269         
270         entry->m_expectedValues = basicBlock.valuesAtHead;
271         
272         // Fix the expected values: in our protocol, a dead variable will have an expected
273         // value of (None, []). But the old JIT may stash some values there. So we really
274         // need (Top, TOP).
275         for (size_t argument = 0; argument < basicBlock.variablesAtHead.numberOfArguments(); ++argument) {
276             if (basicBlock.variablesAtHead.argument(argument) == NoNode)
277                 entry->m_expectedValues.argument(argument).makeTop();
278         }
279         for (size_t local = 0; local < basicBlock.variablesAtHead.numberOfLocals(); ++local) {
280             if (basicBlock.variablesAtHead.local(local) == NoNode)
281                 entry->m_expectedValues.local(local).makeTop();
282         }
283 #else
284         UNUSED_PARAM(basicBlock);
285 #endif
286     }
287
288     ValueProfile* valueProfileFor(NodeIndex nodeIndex)
289     {
290         if (nodeIndex == NoNode)
291             return 0;
292         
293         return m_graph.valueProfileFor(nodeIndex, baselineCodeBlockFor(m_graph[nodeIndex].codeOrigin));
294     }
295     
296 private:
297     // Internal implementation to compile.
298     void compileEntry();
299     void compileBody();
300     void link(LinkBuffer&);
301
302     void exitSpeculativeWithOSR(const OSRExit&, SpeculationRecovery*);
303     void linkOSRExits(SpeculativeJIT&);
304     
305     // The dataflow graph currently being generated.
306     Graph& m_graph;
307
308     // Vector of calls out from JIT code, including exception handler information.
309     // Count of the number of CallRecords with exception handlers.
310     Vector<CallLinkRecord> m_calls;
311     Vector<CallExceptionRecord> m_exceptionChecks;
312     
313     // JIT code map for OSR entrypoints.
314     Label m_startOfCode;
315
316     struct MethodGetRecord {
317         MethodGetRecord(Call slowCall, DataLabelPtr structToCompare, DataLabelPtr protoObj, DataLabelPtr protoStructToCompare, DataLabelPtr putFunction)
318             : m_slowCall(slowCall)
319             , m_structToCompare(structToCompare)
320             , m_protoObj(protoObj)
321             , m_protoStructToCompare(protoStructToCompare)
322             , m_putFunction(putFunction)
323         {
324         }
325         
326         Call m_slowCall;
327         DataLabelPtr m_structToCompare;
328         DataLabelPtr m_protoObj;
329         DataLabelPtr m_protoStructToCompare;
330         DataLabelPtr m_putFunction;
331     };
332     
333     struct JSCallRecord {
334         JSCallRecord(Call fastCall, Call slowCall, DataLabelPtr targetToCheck, bool isCall, CodeOrigin codeOrigin)
335             : m_fastCall(fastCall)
336             , m_slowCall(slowCall)
337             , m_targetToCheck(targetToCheck)
338             , m_isCall(isCall)
339             , m_codeOrigin(codeOrigin)
340         {
341         }
342         
343         Call m_fastCall;
344         Call m_slowCall;
345         DataLabelPtr m_targetToCheck;
346         bool m_isCall;
347         CodeOrigin m_codeOrigin;
348     };
349
350     Vector<PropertyAccessRecord, 4> m_propertyAccesses;
351     Vector<MethodGetRecord, 4> m_methodGets;
352     Vector<JSCallRecord, 4> m_jsCalls;
353 };
354
355 } } // namespace JSC::DFG
356
357 #endif
358 #endif
359