OLD | NEW |
1 // Copyright 2012 the V8 project authors. All rights reserved. | 1 // Copyright 2012 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_H_ | 5 #ifndef V8_IC_H_ |
6 #define V8_IC_H_ | 6 #define V8_IC_H_ |
7 | 7 |
8 #include "src/macro-assembler.h" | 8 #include "src/macro-assembler.h" |
9 | 9 |
10 namespace v8 { | 10 namespace v8 { |
(...skipping 165 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
176 ConstantPoolArray* constant_pool); | 176 ConstantPoolArray* constant_pool); |
177 static inline void SetTargetAtAddress(Address address, | 177 static inline void SetTargetAtAddress(Address address, |
178 Code* target, | 178 Code* target, |
179 ConstantPoolArray* constant_pool); | 179 ConstantPoolArray* constant_pool); |
180 static void OnTypeFeedbackChanged(Isolate* isolate, Address address, | 180 static void OnTypeFeedbackChanged(Isolate* isolate, Address address, |
181 State old_state, State new_state, | 181 State old_state, State new_state, |
182 bool target_remains_ic_stub); | 182 bool target_remains_ic_stub); |
183 static void PostPatching(Address address, Code* target, Code* old_target); | 183 static void PostPatching(Address address, Code* target, Code* old_target); |
184 | 184 |
185 // Compute the handler either by compiling or by retrieving a cached version. | 185 // Compute the handler either by compiling or by retrieving a cached version. |
186 Handle<Code> ComputeHandler(LookupIterator* lookup, Handle<Object> object, | 186 Handle<Code> ComputeHandler(LookupIterator* lookup, |
187 Handle<Name> name, | |
188 Handle<Object> value = Handle<Code>::null()); | 187 Handle<Object> value = Handle<Code>::null()); |
189 virtual Handle<Code> CompileHandler(LookupIterator* lookup, | 188 virtual Handle<Code> CompileHandler(LookupIterator* lookup, |
190 Handle<Object> object, | 189 Handle<Object> value, |
191 Handle<Name> name, Handle<Object> value, | |
192 CacheHolderFlag cache_holder) { | 190 CacheHolderFlag cache_holder) { |
193 UNREACHABLE(); | 191 UNREACHABLE(); |
194 return Handle<Code>::null(); | 192 return Handle<Code>::null(); |
195 } | 193 } |
196 // Temporary copy of the above, but using a LookupResult. | |
197 // TODO(jkummerow): Migrate callers to LookupIterator and delete these. | |
198 Handle<Code> ComputeStoreHandler(LookupResult* lookup, Handle<Object> object, | |
199 Handle<Name> name, | |
200 Handle<Object> value = Handle<Code>::null()); | |
201 virtual Handle<Code> CompileStoreHandler(LookupResult* lookup, | |
202 Handle<Object> object, | |
203 Handle<Name> name, | |
204 Handle<Object> value, | |
205 CacheHolderFlag cache_holder) { | |
206 UNREACHABLE(); | |
207 return Handle<Code>::null(); | |
208 } | |
209 | 194 |
210 void UpdateMonomorphicIC(Handle<Code> handler, Handle<Name> name); | 195 void UpdateMonomorphicIC(Handle<Code> handler, Handle<Name> name); |
211 bool UpdatePolymorphicIC(Handle<Name> name, Handle<Code> code); | 196 bool UpdatePolymorphicIC(Handle<Name> name, Handle<Code> code); |
212 void UpdateMegamorphicCache(HeapType* type, Name* name, Code* code); | 197 void UpdateMegamorphicCache(HeapType* type, Name* name, Code* code); |
213 | 198 |
214 void CopyICToMegamorphicCache(Handle<Name> name); | 199 void CopyICToMegamorphicCache(Handle<Name> name); |
215 bool IsTransitionOfMonomorphicTarget(Map* source_map, Map* target_map); | 200 bool IsTransitionOfMonomorphicTarget(Map* source_map, Map* target_map); |
216 void PatchCache(Handle<Name> name, Handle<Code> code); | 201 void PatchCache(Handle<Name> name, Handle<Code> code); |
217 Code::Kind kind() const { return kind_; } | 202 Code::Kind kind() const { return kind_; } |
218 Code::Kind handler_kind() const { | 203 Code::Kind handler_kind() const { |
219 if (kind_ == Code::KEYED_LOAD_IC) return Code::LOAD_IC; | 204 if (kind_ == Code::KEYED_LOAD_IC) return Code::LOAD_IC; |
220 DCHECK(kind_ == Code::LOAD_IC || kind_ == Code::STORE_IC || | 205 DCHECK(kind_ == Code::LOAD_IC || kind_ == Code::STORE_IC || |
221 kind_ == Code::KEYED_STORE_IC); | 206 kind_ == Code::KEYED_STORE_IC); |
222 return kind_; | 207 return kind_; |
223 } | 208 } |
224 virtual Handle<Code> megamorphic_stub() { | 209 virtual Handle<Code> megamorphic_stub() { |
225 UNREACHABLE(); | 210 UNREACHABLE(); |
226 return Handle<Code>::null(); | 211 return Handle<Code>::null(); |
227 } | 212 } |
228 | 213 |
229 bool TryRemoveInvalidPrototypeDependentStub(Handle<Object> receiver, | 214 bool TryRemoveInvalidPrototypeDependentStub(Handle<Object> receiver, |
230 Handle<String> name); | 215 Handle<String> name); |
231 | 216 |
232 ExtraICState extra_ic_state() const { return extra_ic_state_; } | 217 ExtraICState extra_ic_state() const { return extra_ic_state_; } |
233 void set_extra_ic_state(ExtraICState state) { | 218 void set_extra_ic_state(ExtraICState state) { |
234 extra_ic_state_ = state; | 219 extra_ic_state_ = state; |
235 } | 220 } |
236 | 221 |
237 Handle<HeapType> receiver_type() { return receiver_type_; } | 222 Handle<HeapType> receiver_type() { return receiver_type_; } |
| 223 void update_receiver_type(Handle<Object> receiver) { |
| 224 receiver_type_ = CurrentTypeOf(receiver, isolate_); |
| 225 } |
238 | 226 |
239 void TargetMaps(MapHandleList* list) { | 227 void TargetMaps(MapHandleList* list) { |
240 FindTargetMaps(); | 228 FindTargetMaps(); |
241 for (int i = 0; i < target_maps_.length(); i++) { | 229 for (int i = 0; i < target_maps_.length(); i++) { |
242 list->Add(target_maps_.at(i)); | 230 list->Add(target_maps_.at(i)); |
243 } | 231 } |
244 } | 232 } |
245 | 233 |
246 void TargetTypes(TypeHandleList* list) { | 234 void TargetTypes(TypeHandleList* list) { |
247 FindTargetMaps(); | 235 FindTargetMaps(); |
(...skipping 238 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
486 } else { | 474 } else { |
487 DCHECK_EQ(Code::KEYED_LOAD_IC, kind()); | 475 DCHECK_EQ(Code::KEYED_LOAD_IC, kind()); |
488 return isolate()->builtins()->KeyedLoadIC_Slow(); | 476 return isolate()->builtins()->KeyedLoadIC_Slow(); |
489 } | 477 } |
490 } | 478 } |
491 | 479 |
492 virtual Handle<Code> megamorphic_stub(); | 480 virtual Handle<Code> megamorphic_stub(); |
493 | 481 |
494 // Update the inline cache and the global stub cache based on the | 482 // Update the inline cache and the global stub cache based on the |
495 // lookup result. | 483 // lookup result. |
496 void UpdateCaches(LookupIterator* lookup, Handle<Object> object, | 484 void UpdateCaches(LookupIterator* lookup); |
497 Handle<Name> name); | |
498 | 485 |
499 virtual Handle<Code> CompileHandler(LookupIterator* lookup, | 486 virtual Handle<Code> CompileHandler(LookupIterator* lookup, |
500 Handle<Object> object, | |
501 Handle<Name> name, | |
502 Handle<Object> unused, | 487 Handle<Object> unused, |
503 CacheHolderFlag cache_holder); | 488 CacheHolderFlag cache_holder); |
504 | 489 |
505 private: | 490 private: |
506 virtual Handle<Code> pre_monomorphic_stub() const; | 491 virtual Handle<Code> pre_monomorphic_stub() const; |
507 static Handle<Code> pre_monomorphic_stub(Isolate* isolate, | 492 static Handle<Code> pre_monomorphic_stub(Isolate* isolate, |
508 ExtraICState extra_state); | 493 ExtraICState extra_state); |
509 | 494 |
510 Handle<Code> SimpleFieldLoad(FieldIndex index); | 495 Handle<Code> SimpleFieldLoad(FieldIndex index); |
511 | 496 |
(...skipping 114 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
626 static Handle<Code> initialize_stub(Isolate* isolate, | 611 static Handle<Code> initialize_stub(Isolate* isolate, |
627 StrictMode strict_mode); | 612 StrictMode strict_mode); |
628 | 613 |
629 MUST_USE_RESULT MaybeHandle<Object> Store( | 614 MUST_USE_RESULT MaybeHandle<Object> Store( |
630 Handle<Object> object, | 615 Handle<Object> object, |
631 Handle<Name> name, | 616 Handle<Name> name, |
632 Handle<Object> value, | 617 Handle<Object> value, |
633 JSReceiver::StoreFromKeyed store_mode = | 618 JSReceiver::StoreFromKeyed store_mode = |
634 JSReceiver::CERTAINLY_NOT_STORE_FROM_KEYED); | 619 JSReceiver::CERTAINLY_NOT_STORE_FROM_KEYED); |
635 | 620 |
| 621 bool LookupForWrite(LookupIterator* it, Handle<Object> value, |
| 622 JSReceiver::StoreFromKeyed store_mode); |
| 623 |
636 protected: | 624 protected: |
637 virtual Handle<Code> megamorphic_stub(); | 625 virtual Handle<Code> megamorphic_stub(); |
638 | 626 |
639 // Stub accessors. | 627 // Stub accessors. |
640 virtual Handle<Code> generic_stub() const; | 628 virtual Handle<Code> generic_stub() const; |
641 | 629 |
642 virtual Handle<Code> slow_stub() const { | 630 virtual Handle<Code> slow_stub() const { |
643 return isolate()->builtins()->StoreIC_Slow(); | 631 return isolate()->builtins()->StoreIC_Slow(); |
644 } | 632 } |
645 | 633 |
646 virtual Handle<Code> pre_monomorphic_stub() const { | 634 virtual Handle<Code> pre_monomorphic_stub() const { |
647 return pre_monomorphic_stub(isolate(), strict_mode()); | 635 return pre_monomorphic_stub(isolate(), strict_mode()); |
648 } | 636 } |
649 | 637 |
650 static Handle<Code> pre_monomorphic_stub(Isolate* isolate, | 638 static Handle<Code> pre_monomorphic_stub(Isolate* isolate, |
651 StrictMode strict_mode); | 639 StrictMode strict_mode); |
652 | 640 |
653 // Update the inline cache and the global stub cache based on the | 641 // Update the inline cache and the global stub cache based on the |
654 // lookup result. | 642 // lookup result. |
655 void UpdateCaches(LookupResult* lookup, | 643 void UpdateCaches(LookupIterator* lookup, Handle<Object> value, |
656 Handle<JSObject> receiver, | 644 JSReceiver::StoreFromKeyed store_mode); |
657 Handle<Name> name, | 645 virtual Handle<Code> CompileHandler(LookupIterator* lookup, |
658 Handle<Object> value); | 646 Handle<Object> value, |
659 virtual Handle<Code> CompileStoreHandler(LookupResult* lookup, | 647 CacheHolderFlag cache_holder); |
660 Handle<Object> object, | |
661 Handle<Name> name, | |
662 Handle<Object> value, | |
663 CacheHolderFlag cache_holder); | |
664 | 648 |
665 private: | 649 private: |
666 void set_target(Code* code) { | 650 void set_target(Code* code) { |
667 // Strict mode must be preserved across IC patching. | 651 // Strict mode must be preserved across IC patching. |
668 DCHECK(GetStrictMode(code->extra_ic_state()) == | 652 DCHECK(GetStrictMode(code->extra_ic_state()) == |
669 GetStrictMode(target()->extra_ic_state())); | 653 GetStrictMode(target()->extra_ic_state())); |
670 IC::set_target(code); | 654 IC::set_target(code); |
671 } | 655 } |
672 | 656 |
673 static void Clear(Isolate* isolate, | 657 static void Clear(Isolate* isolate, |
(...skipping 366 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1040 DECLARE_RUNTIME_FUNCTION(ElementsTransitionAndStoreIC_Miss); | 1024 DECLARE_RUNTIME_FUNCTION(ElementsTransitionAndStoreIC_Miss); |
1041 DECLARE_RUNTIME_FUNCTION(BinaryOpIC_Miss); | 1025 DECLARE_RUNTIME_FUNCTION(BinaryOpIC_Miss); |
1042 DECLARE_RUNTIME_FUNCTION(BinaryOpIC_MissWithAllocationSite); | 1026 DECLARE_RUNTIME_FUNCTION(BinaryOpIC_MissWithAllocationSite); |
1043 DECLARE_RUNTIME_FUNCTION(CompareNilIC_Miss); | 1027 DECLARE_RUNTIME_FUNCTION(CompareNilIC_Miss); |
1044 DECLARE_RUNTIME_FUNCTION(ToBooleanIC_Miss); | 1028 DECLARE_RUNTIME_FUNCTION(ToBooleanIC_Miss); |
1045 | 1029 |
1046 | 1030 |
1047 } } // namespace v8::internal | 1031 } } // namespace v8::internal |
1048 | 1032 |
1049 #endif // V8_IC_H_ | 1033 #endif // V8_IC_H_ |
OLD | NEW |