DFG JIT cannot compile op_new_object, op_new_array,
[WebKit.git] / Source / JavaScriptCore / dfg / DFGCapabilities.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 DFGCapabilities_h
27 #define DFGCapabilities_h
28
29 #include "Interpreter.h"
30 #include <wtf/Platform.h>
31
32 namespace JSC { namespace DFG {
33
34 #define ENABLE_DFG_RESTRICTIONS 1
35
36 #if ENABLE(DFG_JIT)
37 // Fast check functions; if they return true it is still necessary to
38 // check opcodes.
39 inline bool mightCompileEval(CodeBlock*) { return true; }
40 inline bool mightCompileProgram(CodeBlock*) { return true; }
41 inline bool mightCompileFunctionForCall(CodeBlock*) { return true; }
42 inline bool mightCompileFunctionForConstruct(CodeBlock*) { return true; }
43
44 // Opcode checking.
45 inline bool canCompileOpcode(OpcodeID opcodeID)
46 {
47     switch (opcodeID) {
48     case op_enter:
49     case op_convert_this:
50     case op_create_this:
51     case op_get_callee:
52     case op_bitand:
53     case op_bitor:
54     case op_bitxor:
55     case op_rshift:
56     case op_lshift:
57     case op_urshift:
58     case op_pre_inc:
59     case op_post_inc:
60     case op_pre_dec:
61     case op_post_dec:
62     case op_add:
63     case op_sub:
64     case op_mul:
65     case op_mod:
66     case op_div:
67 #if ENABLE(DEBUG_WITH_BREAKPOINT)
68     case op_debug:
69 #endif
70     case op_mov:
71     case op_check_has_instance:
72     case op_instanceof:
73     case op_not:
74     case op_less:
75     case op_lesseq:
76     case op_greater:
77     case op_greatereq:
78     case op_eq:
79     case op_eq_null:
80     case op_stricteq:
81     case op_neq:
82     case op_neq_null:
83     case op_nstricteq:
84     case op_get_by_val:
85     case op_put_by_val:
86     case op_method_check:
87     case op_get_scoped_var:
88     case op_put_scoped_var:
89     case op_get_by_id:
90     case op_put_by_id:
91     case op_get_global_var:
92     case op_put_global_var:
93     case op_jmp:
94     case op_loop:
95     case op_jtrue:
96     case op_jfalse:
97     case op_loop_if_true:
98     case op_loop_if_false:
99     case op_jeq_null:
100     case op_jneq_null:
101     case op_jless:
102     case op_jlesseq:
103     case op_jgreater:
104     case op_jgreatereq:
105     case op_jnless:
106     case op_jnlesseq:
107     case op_jngreater:
108     case op_jngreatereq:
109     case op_loop_hint:
110     case op_loop_if_less:
111     case op_loop_if_lesseq:
112     case op_loop_if_greater:
113     case op_loop_if_greatereq:
114     case op_ret:
115     case op_end:
116 #if USE(JSVALUE64)
117     case op_call:
118     case op_construct:
119 #endif
120     case op_call_put_result:
121     case op_resolve:
122     case op_resolve_base:
123     case op_resolve_global:
124     case op_new_object:
125     case op_new_array:
126     case op_new_array_buffer:
127     case op_strcat:
128     case op_to_primitive:
129     case op_throw:
130     case op_throw_reference_error:
131         return true;
132         
133     // Opcodes we support conditionally. Enabling these opcodes currently results in
134     // performance regressions. Each node that we disable under restrictions has a
135     // comment describing what we know about the regression so far.
136         
137     // Regresses string-validate-input, probably because it uses comparisons (< and >)
138     // on strings, which currently will cause speculation failures in some cases.
139     case op_new_regexp: 
140 #if ENABLE(DFG_RESTRICTIONS)
141         return false;
142 #else
143         return true;
144 #endif
145         
146     default:
147         return false;
148     }
149 }
150
151 bool canCompileOpcodes(CodeBlock*);
152 #else // ENABLE(DFG_JIT)
153 inline bool mightCompileEval(CodeBlock*) { return false; }
154 inline bool mightCompileProgram(CodeBlock*) { return false; }
155 inline bool mightCompileFunctionForCall(CodeBlock*) { return false; }
156 inline bool mightCompileFunctionForConstruct(CodeBlock*) { return false; }
157 inline bool canCompileOpcode(OpcodeID) { return false; }
158 inline bool canCompileOpcodes(CodeBlock*) { return false; }
159 #endif // ENABLE(DFG_JIT)
160
161 inline bool canCompileEval(CodeBlock* codeBlock)
162 {
163     return mightCompileEval(codeBlock) && canCompileOpcodes(codeBlock);
164 }
165
166 inline bool canCompileProgram(CodeBlock* codeBlock)
167 {
168     return mightCompileProgram(codeBlock) && canCompileOpcodes(codeBlock);
169 }
170
171 inline bool canCompileFunctionForCall(CodeBlock* codeBlock)
172 {
173     return mightCompileFunctionForCall(codeBlock) && canCompileOpcodes(codeBlock);
174 }
175
176 inline bool canCompileFunctionForConstruct(CodeBlock* codeBlock)
177 {
178     return mightCompileFunctionForConstruct(codeBlock) && canCompileOpcodes(codeBlock);
179 }
180
181 } } // namespace JSC::DFG
182
183 #endif // DFGCapabilities_h
184