OLD | NEW |
1 // Copyright 2014 the V8 project authors. All rights reserved. | 1 // Copyright 2014 the V8 project authors. All rights reserved. |
2 // Use of this source code is governed by a BSD-style license that can be | 2 // Use of this source code is governed by a BSD-style license that can be |
3 // found in the LICENSE file. | 3 // found in the LICENSE file. |
4 | 4 |
5 #ifndef V8_IC_HANDLER_COMPILER_H_ | 5 #ifndef V8_IC_HANDLER_COMPILER_H_ |
6 #define V8_IC_HANDLER_COMPILER_H_ | 6 #define V8_IC_HANDLER_COMPILER_H_ |
7 | 7 |
8 #include "src/ic/access-compiler.h" | 8 #include "src/ic/access-compiler.h" |
9 #include "src/ic/ic-state.h" | 9 #include "src/ic/ic-state.h" |
10 | 10 |
11 namespace v8 { | 11 namespace v8 { |
12 namespace internal { | 12 namespace internal { |
13 | 13 |
14 class CallOptimization; | 14 class CallOptimization; |
15 | 15 |
16 enum PrototypeCheckType { CHECK_ALL_MAPS, SKIP_RECEIVER }; | 16 enum PrototypeCheckType { CHECK_ALL_MAPS, SKIP_RECEIVER }; |
17 | 17 |
18 class PropertyHandlerCompiler : public PropertyAccessCompiler { | 18 class PropertyHandlerCompiler : public PropertyAccessCompiler { |
19 public: | 19 public: |
20 static Handle<Code> Find(Handle<Name> name, Handle<Map> map, Code::Kind kind, | 20 static Handle<Code> Find(Handle<Name> name, Handle<Map> map, Code::Kind kind, |
21 CacheHolderFlag cache_holder, Code::StubType type); | 21 CacheHolderFlag cache_holder, Code::StubType type); |
22 | 22 |
23 protected: | 23 protected: |
24 PropertyHandlerCompiler(Isolate* isolate, Code::Kind kind, | 24 PropertyHandlerCompiler(Isolate* isolate, Code::Kind kind, Handle<Map> map, |
25 Handle<HeapType> type, Handle<JSObject> holder, | 25 Handle<JSObject> holder, CacheHolderFlag cache_holder) |
26 CacheHolderFlag cache_holder) | |
27 : PropertyAccessCompiler(isolate, kind, cache_holder), | 26 : PropertyAccessCompiler(isolate, kind, cache_holder), |
28 type_(type), | 27 map_(map), |
29 holder_(holder) {} | 28 holder_(holder) {} |
30 | 29 |
31 virtual ~PropertyHandlerCompiler() {} | 30 virtual ~PropertyHandlerCompiler() {} |
32 | 31 |
33 virtual Register FrontendHeader(Register object_reg, Handle<Name> name, | 32 virtual Register FrontendHeader(Register object_reg, Handle<Name> name, |
34 Label* miss) { | 33 Label* miss) { |
35 UNREACHABLE(); | 34 UNREACHABLE(); |
36 return receiver(); | 35 return receiver(); |
37 } | 36 } |
38 | 37 |
(...skipping 53 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
92 // The scratch and holder registers are always clobbered, but the object | 91 // The scratch and holder registers are always clobbered, but the object |
93 // register is only clobbered if it the same as the holder register. The | 92 // register is only clobbered if it the same as the holder register. The |
94 // function returns a register containing the holder - either object_reg or | 93 // function returns a register containing the holder - either object_reg or |
95 // holder_reg. | 94 // holder_reg. |
96 Register CheckPrototypes(Register object_reg, Register holder_reg, | 95 Register CheckPrototypes(Register object_reg, Register holder_reg, |
97 Register scratch1, Register scratch2, | 96 Register scratch1, Register scratch2, |
98 Handle<Name> name, Label* miss, | 97 Handle<Name> name, Label* miss, |
99 PrototypeCheckType check = CHECK_ALL_MAPS); | 98 PrototypeCheckType check = CHECK_ALL_MAPS); |
100 | 99 |
101 Handle<Code> GetCode(Code::Kind kind, Code::StubType type, Handle<Name> name); | 100 Handle<Code> GetCode(Code::Kind kind, Code::StubType type, Handle<Name> name); |
102 void set_type_for_object(Handle<Object> object); | |
103 void set_holder(Handle<JSObject> holder) { holder_ = holder; } | 101 void set_holder(Handle<JSObject> holder) { holder_ = holder; } |
104 Handle<HeapType> type() const { return type_; } | 102 Handle<Map> map() const { return map_; } |
| 103 void set_map(Handle<Map> map) { map_ = map; } |
105 Handle<JSObject> holder() const { return holder_; } | 104 Handle<JSObject> holder() const { return holder_; } |
106 | 105 |
107 private: | 106 private: |
108 Handle<HeapType> type_; | 107 Handle<Map> map_; |
109 Handle<JSObject> holder_; | 108 Handle<JSObject> holder_; |
110 }; | 109 }; |
111 | 110 |
112 | 111 |
113 class NamedLoadHandlerCompiler : public PropertyHandlerCompiler { | 112 class NamedLoadHandlerCompiler : public PropertyHandlerCompiler { |
114 public: | 113 public: |
115 NamedLoadHandlerCompiler(Isolate* isolate, Handle<HeapType> type, | 114 NamedLoadHandlerCompiler(Isolate* isolate, Handle<Map> map, |
116 Handle<JSObject> holder, | 115 Handle<JSObject> holder, |
117 CacheHolderFlag cache_holder) | 116 CacheHolderFlag cache_holder) |
118 : PropertyHandlerCompiler(isolate, Code::LOAD_IC, type, holder, | 117 : PropertyHandlerCompiler(isolate, Code::LOAD_IC, map, holder, |
119 cache_holder) {} | 118 cache_holder) {} |
120 | 119 |
121 virtual ~NamedLoadHandlerCompiler() {} | 120 virtual ~NamedLoadHandlerCompiler() {} |
122 | 121 |
123 Handle<Code> CompileLoadField(Handle<Name> name, FieldIndex index); | 122 Handle<Code> CompileLoadField(Handle<Name> name, FieldIndex index); |
124 | 123 |
125 Handle<Code> CompileLoadCallback(Handle<Name> name, | 124 Handle<Code> CompileLoadCallback(Handle<Name> name, |
126 Handle<ExecutableAccessorInfo> callback); | 125 Handle<ExecutableAccessorInfo> callback); |
127 | 126 |
128 Handle<Code> CompileLoadCallback(Handle<Name> name, | 127 Handle<Code> CompileLoadCallback(Handle<Name> name, |
129 const CallOptimization& call_optimization, | 128 const CallOptimization& call_optimization, |
130 int accessor_index); | 129 int accessor_index); |
131 | 130 |
132 Handle<Code> CompileLoadConstant(Handle<Name> name, int constant_index); | 131 Handle<Code> CompileLoadConstant(Handle<Name> name, int constant_index); |
133 | 132 |
134 // The LookupIterator is used to perform a lookup behind the interceptor. If | 133 // The LookupIterator is used to perform a lookup behind the interceptor. If |
135 // the iterator points to a LookupIterator::PROPERTY, its access will be | 134 // the iterator points to a LookupIterator::PROPERTY, its access will be |
136 // inlined. | 135 // inlined. |
137 Handle<Code> CompileLoadInterceptor(LookupIterator* it); | 136 Handle<Code> CompileLoadInterceptor(LookupIterator* it); |
138 | 137 |
139 Handle<Code> CompileLoadViaGetter(Handle<Name> name, int accessor_index, | 138 Handle<Code> CompileLoadViaGetter(Handle<Name> name, int accessor_index, |
140 int expected_arguments); | 139 int expected_arguments); |
141 | 140 |
142 Handle<Code> CompileLoadGlobal(Handle<PropertyCell> cell, Handle<Name> name, | 141 Handle<Code> CompileLoadGlobal(Handle<PropertyCell> cell, Handle<Name> name, |
143 bool is_configurable); | 142 bool is_configurable); |
144 | 143 |
145 // Static interface | 144 // Static interface |
146 static Handle<Code> ComputeLoadNonexistent(Handle<Name> name, | 145 static Handle<Code> ComputeLoadNonexistent(Handle<Name> name, |
147 Handle<HeapType> type); | 146 Handle<Map> map); |
148 | 147 |
149 static void GenerateLoadViaGetter(MacroAssembler* masm, Handle<HeapType> type, | 148 static void GenerateLoadViaGetter(MacroAssembler* masm, Handle<Map> map, |
150 Register receiver, Register holder, | 149 Register receiver, Register holder, |
151 int accessor_index, int expected_arguments, | 150 int accessor_index, int expected_arguments, |
152 Register scratch); | 151 Register scratch); |
153 | 152 |
154 static void GenerateLoadViaGetterForDeopt(MacroAssembler* masm) { | 153 static void GenerateLoadViaGetterForDeopt(MacroAssembler* masm) { |
155 GenerateLoadViaGetter(masm, Handle<HeapType>::null(), no_reg, no_reg, -1, | 154 GenerateLoadViaGetter(masm, Handle<Map>::null(), no_reg, no_reg, -1, -1, |
156 -1, no_reg); | 155 no_reg); |
157 } | 156 } |
158 | 157 |
159 static void GenerateLoadFunctionPrototype(MacroAssembler* masm, | 158 static void GenerateLoadFunctionPrototype(MacroAssembler* masm, |
160 Register receiver, | 159 Register receiver, |
161 Register scratch1, | 160 Register scratch1, |
162 Register scratch2, | 161 Register scratch2, |
163 Label* miss_label); | 162 Label* miss_label); |
164 | 163 |
165 // These constants describe the structure of the interceptor arguments on the | 164 // These constants describe the structure of the interceptor arguments on the |
166 // stack. The arguments are pushed by the (platform-specific) | 165 // stack. The arguments are pushed by the (platform-specific) |
(...skipping 39 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
206 Register prototype, | 205 Register prototype, |
207 Label* miss); | 206 Label* miss); |
208 | 207 |
209 | 208 |
210 Register scratch4() { return registers_[5]; } | 209 Register scratch4() { return registers_[5]; } |
211 }; | 210 }; |
212 | 211 |
213 | 212 |
214 class NamedStoreHandlerCompiler : public PropertyHandlerCompiler { | 213 class NamedStoreHandlerCompiler : public PropertyHandlerCompiler { |
215 public: | 214 public: |
216 explicit NamedStoreHandlerCompiler(Isolate* isolate, Handle<HeapType> type, | 215 explicit NamedStoreHandlerCompiler(Isolate* isolate, Handle<Map> map, |
217 Handle<JSObject> holder) | 216 Handle<JSObject> holder) |
218 : PropertyHandlerCompiler(isolate, Code::STORE_IC, type, holder, | 217 : PropertyHandlerCompiler(isolate, Code::STORE_IC, map, holder, |
219 kCacheOnReceiver) {} | 218 kCacheOnReceiver) {} |
220 | 219 |
221 virtual ~NamedStoreHandlerCompiler() {} | 220 virtual ~NamedStoreHandlerCompiler() {} |
222 | 221 |
223 Handle<Code> CompileStoreTransition(Handle<Map> transition, | 222 Handle<Code> CompileStoreTransition(Handle<Map> transition, |
224 Handle<Name> name); | 223 Handle<Name> name); |
225 Handle<Code> CompileStoreField(LookupIterator* it); | 224 Handle<Code> CompileStoreField(LookupIterator* it); |
226 Handle<Code> CompileStoreCallback(Handle<JSObject> object, Handle<Name> name, | 225 Handle<Code> CompileStoreCallback(Handle<JSObject> object, Handle<Name> name, |
227 int accessor_index); | 226 int accessor_index); |
228 Handle<Code> CompileStoreCallback(Handle<JSObject> object, Handle<Name> name, | 227 Handle<Code> CompileStoreCallback(Handle<JSObject> object, Handle<Name> name, |
229 const CallOptimization& call_optimization, | 228 const CallOptimization& call_optimization, |
230 int accessor_index); | 229 int accessor_index); |
231 Handle<Code> CompileStoreViaSetter(Handle<JSObject> object, Handle<Name> name, | 230 Handle<Code> CompileStoreViaSetter(Handle<JSObject> object, Handle<Name> name, |
232 int accessor_index, | 231 int accessor_index, |
233 int expected_arguments); | 232 int expected_arguments); |
234 Handle<Code> CompileStoreInterceptor(Handle<Name> name); | 233 Handle<Code> CompileStoreInterceptor(Handle<Name> name); |
235 | 234 |
236 static void GenerateStoreViaSetter(MacroAssembler* masm, | 235 static void GenerateStoreViaSetter(MacroAssembler* masm, Handle<Map> map, |
237 Handle<HeapType> type, Register receiver, | 236 Register receiver, Register holder, |
238 Register holder, int accessor_index, | 237 int accessor_index, int expected_arguments, |
239 int expected_arguments, Register scratch); | 238 Register scratch); |
240 | 239 |
241 static void GenerateStoreViaSetterForDeopt(MacroAssembler* masm) { | 240 static void GenerateStoreViaSetterForDeopt(MacroAssembler* masm) { |
242 GenerateStoreViaSetter(masm, Handle<HeapType>::null(), no_reg, no_reg, -1, | 241 GenerateStoreViaSetter(masm, Handle<Map>::null(), no_reg, no_reg, -1, -1, |
243 -1, no_reg); | 242 no_reg); |
244 } | 243 } |
245 | 244 |
246 static void GenerateSlow(MacroAssembler* masm); | 245 static void GenerateSlow(MacroAssembler* masm); |
247 | 246 |
248 protected: | 247 protected: |
249 virtual Register FrontendHeader(Register object_reg, Handle<Name> name, | 248 virtual Register FrontendHeader(Register object_reg, Handle<Name> name, |
250 Label* miss); | 249 Label* miss); |
251 | 250 |
252 virtual void FrontendFooter(Handle<Name> name, Label* miss); | 251 virtual void FrontendFooter(Handle<Name> name, Label* miss); |
253 void GenerateRestoreName(Label* label, Handle<Name> name); | 252 void GenerateRestoreName(Label* label, Handle<Name> name); |
(...skipping 23 matching lines...) Expand all Loading... |
277 } | 276 } |
278 | 277 |
279 static Register value(); | 278 static Register value(); |
280 }; | 279 }; |
281 | 280 |
282 | 281 |
283 class ElementHandlerCompiler : public PropertyHandlerCompiler { | 282 class ElementHandlerCompiler : public PropertyHandlerCompiler { |
284 public: | 283 public: |
285 explicit ElementHandlerCompiler(Isolate* isolate) | 284 explicit ElementHandlerCompiler(Isolate* isolate) |
286 : PropertyHandlerCompiler(isolate, Code::KEYED_LOAD_IC, | 285 : PropertyHandlerCompiler(isolate, Code::KEYED_LOAD_IC, |
287 Handle<HeapType>::null(), | 286 Handle<Map>::null(), Handle<JSObject>::null(), |
288 Handle<JSObject>::null(), kCacheOnReceiver) {} | 287 kCacheOnReceiver) {} |
289 | 288 |
290 virtual ~ElementHandlerCompiler() {} | 289 virtual ~ElementHandlerCompiler() {} |
291 | 290 |
292 void CompileElementHandlers(MapHandleList* receiver_maps, | 291 void CompileElementHandlers(MapHandleList* receiver_maps, |
293 CodeHandleList* handlers); | 292 CodeHandleList* handlers); |
294 | 293 |
295 static void GenerateStoreSlow(MacroAssembler* masm); | 294 static void GenerateStoreSlow(MacroAssembler* masm); |
296 }; | 295 }; |
297 } | 296 } |
298 } // namespace v8::internal | 297 } // namespace v8::internal |
299 | 298 |
300 #endif // V8_IC_HANDLER_COMPILER_H_ | 299 #endif // V8_IC_HANDLER_COMPILER_H_ |
OLD | NEW |