OLD | NEW |
1 // Copyright 2012 the V8 project authors. All rights reserved. | 1 // Copyright 2012 the V8 project authors. All rights reserved. |
2 // Redistribution and use in source and binary forms, with or without | 2 // Redistribution and use in source and binary forms, with or without |
3 // modification, are permitted provided that the following conditions are | 3 // modification, are permitted provided that the following conditions are |
4 // met: | 4 // met: |
5 // | 5 // |
6 // * Redistributions of source code must retain the above copyright | 6 // * Redistributions of source code must retain the above copyright |
7 // notice, this list of conditions and the following disclaimer. | 7 // notice, this list of conditions and the following disclaimer. |
8 // * Redistributions in binary form must reproduce the above | 8 // * Redistributions in binary form must reproduce the above |
9 // copyright notice, this list of conditions and the following | 9 // copyright notice, this list of conditions and the following |
10 // disclaimer in the documentation and/or other materials provided | 10 // disclaimer in the documentation and/or other materials provided |
(...skipping 87 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
98 Handle<Code> ComputeMonomorphicIC(Handle<HeapObject> receiver, | 98 Handle<Code> ComputeMonomorphicIC(Handle<HeapObject> receiver, |
99 Handle<Code> handler, | 99 Handle<Code> handler, |
100 Handle<Name> name, | 100 Handle<Name> name, |
101 StrictModeFlag strict_mode); | 101 StrictModeFlag strict_mode); |
102 | 102 |
103 // Computes the right stub matching. Inserts the result in the | 103 // Computes the right stub matching. Inserts the result in the |
104 // cache before returning. This might compile a stub if needed. | 104 // cache before returning. This might compile a stub if needed. |
105 Handle<Code> ComputeLoadNonexistent(Handle<Name> name, | 105 Handle<Code> ComputeLoadNonexistent(Handle<Name> name, |
106 Handle<JSObject> object); | 106 Handle<JSObject> object); |
107 | 107 |
108 Handle<Code> ComputeLoadField(Handle<Name> name, | |
109 Handle<JSObject> object, | |
110 Handle<JSObject> holder, | |
111 PropertyIndex field_index, | |
112 Representation representation); | |
113 | |
114 Handle<Code> ComputeLoadCallback(Handle<Name> name, | |
115 Handle<JSObject> object, | |
116 Handle<JSObject> holder, | |
117 Handle<ExecutableAccessorInfo> callback); | |
118 | |
119 Handle<Code> ComputeLoadCallback(Handle<Name> name, | |
120 Handle<JSObject> object, | |
121 Handle<JSObject> holder, | |
122 const CallOptimization& call_optimization); | |
123 | |
124 Handle<Code> ComputeLoadViaGetter(Handle<Name> name, | |
125 Handle<JSObject> object, | |
126 Handle<JSObject> holder, | |
127 Handle<JSFunction> getter); | |
128 | |
129 Handle<Code> ComputeLoadConstant(Handle<Name> name, | |
130 Handle<JSObject> object, | |
131 Handle<JSObject> holder, | |
132 Handle<Object> value); | |
133 | |
134 Handle<Code> ComputeLoadInterceptor(Handle<Name> name, | |
135 Handle<JSObject> object, | |
136 Handle<JSObject> holder); | |
137 | |
138 Handle<Code> ComputeLoadNormal(Handle<Name> name, | |
139 Handle<JSObject> object); | |
140 | |
141 Handle<Code> ComputeLoadGlobal(Handle<Name> name, | 108 Handle<Code> ComputeLoadGlobal(Handle<Name> name, |
142 Handle<JSObject> object, | 109 Handle<JSObject> object, |
143 Handle<GlobalObject> holder, | 110 Handle<GlobalObject> holder, |
144 Handle<PropertyCell> cell, | 111 Handle<PropertyCell> cell, |
145 bool is_dont_delete); | 112 bool is_dont_delete); |
146 | 113 |
147 // --- | 114 // --- |
148 | 115 |
149 Handle<Code> ComputeKeyedLoadField(Handle<Name> name, | 116 Handle<Code> ComputeKeyedLoadField(Handle<Name> name, |
150 Handle<JSObject> object, | 117 Handle<JSObject> object, |
(...skipping 15 matching lines...) Expand all Loading... |
166 | 133 |
167 Handle<Code> ComputeKeyedLoadConstant(Handle<Name> name, | 134 Handle<Code> ComputeKeyedLoadConstant(Handle<Name> name, |
168 Handle<JSObject> object, | 135 Handle<JSObject> object, |
169 Handle<JSObject> holder, | 136 Handle<JSObject> holder, |
170 Handle<Object> value); | 137 Handle<Object> value); |
171 | 138 |
172 Handle<Code> ComputeKeyedLoadInterceptor(Handle<Name> name, | 139 Handle<Code> ComputeKeyedLoadInterceptor(Handle<Name> name, |
173 Handle<JSObject> object, | 140 Handle<JSObject> object, |
174 Handle<JSObject> holder); | 141 Handle<JSObject> holder); |
175 | 142 |
176 // --- | |
177 | |
178 Handle<Code> ComputeStoreField(Handle<Name> name, | |
179 Handle<JSObject> object, | |
180 LookupResult* lookup, | |
181 StrictModeFlag strict_mode); | |
182 | |
183 Handle<Code> ComputeStoreTransition(Handle<Name> name, | |
184 Handle<JSObject> object, | |
185 LookupResult* lookup, | |
186 Handle<Map> transition, | |
187 StrictModeFlag strict_mode); | |
188 | |
189 Handle<Code> ComputeStoreNormal(StrictModeFlag strict_mode); | |
190 | |
191 Handle<Code> ComputeStoreGlobal(Handle<Name> name, | 143 Handle<Code> ComputeStoreGlobal(Handle<Name> name, |
192 Handle<GlobalObject> object, | 144 Handle<GlobalObject> object, |
193 Handle<PropertyCell> cell, | 145 Handle<PropertyCell> cell, |
194 Handle<Object> value, | 146 Handle<Object> value, |
195 StrictModeFlag strict_mode); | 147 StrictModeFlag strict_mode); |
196 | 148 |
197 Handle<Code> ComputeStoreCallback(Handle<Name> name, | |
198 Handle<JSObject> object, | |
199 Handle<JSObject> holder, | |
200 Handle<ExecutableAccessorInfo> callback, | |
201 StrictModeFlag strict_mode); | |
202 | |
203 Handle<Code> ComputeStoreCallback(Handle<Name> name, | |
204 Handle<JSObject> object, | |
205 Handle<JSObject> holder, | |
206 const CallOptimization& call_optimation, | |
207 StrictModeFlag strict_mode); | |
208 | |
209 Handle<Code> ComputeStoreViaSetter(Handle<Name> name, | |
210 Handle<JSObject> object, | |
211 Handle<JSObject> holder, | |
212 Handle<JSFunction> setter, | |
213 StrictModeFlag strict_mode); | |
214 | |
215 Handle<Code> ComputeStoreInterceptor(Handle<Name> name, | |
216 Handle<JSObject> object, | |
217 StrictModeFlag strict_mode); | |
218 | |
219 // --- | |
220 | |
221 Handle<Code> ComputeKeyedStoreField(Handle<Name> name, | |
222 Handle<JSObject> object, | |
223 LookupResult* lookup, | |
224 StrictModeFlag strict_mode); | |
225 Handle<Code> ComputeKeyedStoreTransition(Handle<Name> name, | |
226 Handle<JSObject> object, | |
227 LookupResult* lookup, | |
228 Handle<Map> transition, | |
229 StrictModeFlag strict_mode); | |
230 | |
231 Handle<Code> ComputeKeyedLoadElement(Handle<Map> receiver_map); | 149 Handle<Code> ComputeKeyedLoadElement(Handle<Map> receiver_map); |
232 | 150 |
233 Handle<Code> ComputeKeyedStoreElement(Handle<Map> receiver_map, | 151 Handle<Code> ComputeKeyedStoreElement(Handle<Map> receiver_map, |
234 StrictModeFlag strict_mode, | 152 StrictModeFlag strict_mode, |
235 KeyedAccessStoreMode store_mode); | 153 KeyedAccessStoreMode store_mode); |
236 | 154 |
237 // --- | |
238 | |
239 Handle<Code> ComputeCallField(int argc, | 155 Handle<Code> ComputeCallField(int argc, |
240 Code::Kind, | 156 Code::Kind, |
241 Code::ExtraICState extra_state, | 157 Code::ExtraICState extra_state, |
242 Handle<Name> name, | 158 Handle<Name> name, |
243 Handle<Object> object, | 159 Handle<Object> object, |
244 Handle<JSObject> holder, | 160 Handle<JSObject> holder, |
245 PropertyIndex index); | 161 PropertyIndex index); |
246 | 162 |
247 Handle<Code> ComputeCallConstant(int argc, | 163 Handle<Code> ComputeCallConstant(int argc, |
248 Code::Kind, | 164 Code::Kind, |
(...skipping 368 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
617 MacroAssembler masm_; | 533 MacroAssembler masm_; |
618 Failure* failure_; | 534 Failure* failure_; |
619 }; | 535 }; |
620 | 536 |
621 | 537 |
622 enum FrontendCheckType { PERFORM_INITIAL_CHECKS, SKIP_INITIAL_CHECKS }; | 538 enum FrontendCheckType { PERFORM_INITIAL_CHECKS, SKIP_INITIAL_CHECKS }; |
623 | 539 |
624 | 540 |
625 class BaseLoadStoreStubCompiler: public StubCompiler { | 541 class BaseLoadStoreStubCompiler: public StubCompiler { |
626 public: | 542 public: |
627 BaseLoadStoreStubCompiler(Isolate* isolate, Register* registers) | 543 BaseLoadStoreStubCompiler(Isolate* isolate, Code::Kind kind) |
628 : StubCompiler(isolate), registers_(registers) { } | 544 : StubCompiler(isolate), kind_(kind) { |
| 545 InitializeRegisters(); |
| 546 } |
629 virtual ~BaseLoadStoreStubCompiler() { } | 547 virtual ~BaseLoadStoreStubCompiler() { } |
630 | 548 |
631 Handle<Code> CompileMonomorphicIC(Handle<Map> receiver_map, | 549 Handle<Code> CompileMonomorphicIC(Handle<Map> receiver_map, |
632 Handle<Code> handler, | 550 Handle<Code> handler, |
633 Handle<Name> name); | 551 Handle<Name> name); |
634 | 552 |
635 Handle<Code> CompilePolymorphicIC(MapHandleList* receiver_maps, | 553 Handle<Code> CompilePolymorphicIC(MapHandleList* receiver_maps, |
636 CodeHandleList* handlers, | 554 CodeHandleList* handlers, |
637 Handle<Name> name, | 555 Handle<Name> name, |
638 Code::StubType type, | 556 Code::StubType type, |
(...skipping 32 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
671 Label* success); | 589 Label* success); |
672 | 590 |
673 Handle<Code> GetCode(Code::Kind kind, | 591 Handle<Code> GetCode(Code::Kind kind, |
674 Code::StubType type, | 592 Code::StubType type, |
675 Handle<Name> name); | 593 Handle<Name> name); |
676 | 594 |
677 Handle<Code> GetICCode(Code::Kind kind, | 595 Handle<Code> GetICCode(Code::Kind kind, |
678 Code::StubType type, | 596 Code::StubType type, |
679 Handle<Name> name, | 597 Handle<Name> name, |
680 InlineCacheState state = MONOMORPHIC); | 598 InlineCacheState state = MONOMORPHIC); |
| 599 Code::Kind kind() { return kind_; } |
| 600 |
| 601 Logger::LogEventsAndTags log_kind(Handle<Code> code) { |
| 602 if (!code->is_inline_cache_stub()) return Logger::STUB_TAG; |
| 603 if (kind_ == Code::LOAD_IC) { |
| 604 return code->ic_state() == MONOMORPHIC |
| 605 ? Logger::LOAD_IC_TAG : Logger::LOAD_POLYMORPHIC_IC_TAG; |
| 606 } else if (kind_ == Code::KEYED_LOAD_IC) { |
| 607 return code->ic_state() == MONOMORPHIC |
| 608 ? Logger::KEYED_LOAD_IC_TAG : Logger::KEYED_LOAD_POLYMORPHIC_IC_TAG; |
| 609 } else if (kind_ == Code::STORE_IC) { |
| 610 return code->ic_state() == MONOMORPHIC |
| 611 ? Logger::STORE_IC_TAG : Logger::STORE_POLYMORPHIC_IC_TAG; |
| 612 } else { |
| 613 return code->ic_state() == MONOMORPHIC |
| 614 ? Logger::KEYED_STORE_IC_TAG : Logger::KEYED_STORE_POLYMORPHIC_IC_TAG; |
| 615 } |
| 616 } |
| 617 void JitEvent(Handle<Name> name, Handle<Code> code); |
681 | 618 |
682 virtual Code::ExtraICState extra_state() { return Code::kNoExtraICState; } | 619 virtual Code::ExtraICState extra_state() { return Code::kNoExtraICState; } |
683 virtual Logger::LogEventsAndTags log_kind(Handle<Code> code) = 0; | |
684 virtual void JitEvent(Handle<Name> name, Handle<Code> code) = 0; | |
685 virtual Code::Kind kind() = 0; | |
686 virtual Register receiver() = 0; | 620 virtual Register receiver() = 0; |
687 virtual Register name() = 0; | 621 virtual Register name() = 0; |
688 virtual Register scratch1() = 0; | 622 virtual Register scratch1() = 0; |
689 virtual Register scratch2() = 0; | 623 virtual Register scratch2() = 0; |
690 virtual Register scratch3() = 0; | 624 virtual Register scratch3() = 0; |
691 | 625 |
| 626 void InitializeRegisters(); |
| 627 |
| 628 Code::Kind kind_; |
692 Register* registers_; | 629 Register* registers_; |
693 }; | 630 }; |
694 | 631 |
695 | 632 |
696 class BaseLoadStubCompiler: public BaseLoadStoreStubCompiler { | 633 class LoadStubCompiler: public BaseLoadStoreStubCompiler { |
697 public: | 634 public: |
698 BaseLoadStubCompiler(Isolate* isolate, Register* registers) | 635 LoadStubCompiler(Isolate* isolate, Code::Kind kind = Code::LOAD_IC) |
699 : BaseLoadStoreStubCompiler(isolate, registers) { } | 636 : BaseLoadStoreStubCompiler(isolate, kind) { } |
700 virtual ~BaseLoadStubCompiler() { } | 637 virtual ~LoadStubCompiler() { } |
701 | 638 |
702 Handle<Code> CompileLoadField(Handle<JSObject> object, | 639 Handle<Code> CompileLoadField(Handle<JSObject> object, |
703 Handle<JSObject> holder, | 640 Handle<JSObject> holder, |
704 Handle<Name> name, | 641 Handle<Name> name, |
705 PropertyIndex index, | 642 PropertyIndex index, |
706 Representation representation); | 643 Representation representation); |
707 | 644 |
708 Handle<Code> CompileLoadCallback(Handle<JSObject> object, | 645 Handle<Code> CompileLoadCallback(Handle<JSObject> object, |
709 Handle<JSObject> holder, | 646 Handle<JSObject> holder, |
710 Handle<Name> name, | 647 Handle<Name> name, |
711 Handle<ExecutableAccessorInfo> callback); | 648 Handle<ExecutableAccessorInfo> callback); |
712 | 649 |
713 Handle<Code> CompileLoadCallback(Handle<JSObject> object, | 650 Handle<Code> CompileLoadCallback(Handle<JSObject> object, |
714 Handle<JSObject> holder, | 651 Handle<JSObject> holder, |
715 Handle<Name> name, | 652 Handle<Name> name, |
716 const CallOptimization& call_optimization); | 653 const CallOptimization& call_optimization); |
717 | 654 |
718 Handle<Code> CompileLoadConstant(Handle<JSObject> object, | 655 Handle<Code> CompileLoadConstant(Handle<JSObject> object, |
719 Handle<JSObject> holder, | 656 Handle<JSObject> holder, |
720 Handle<Name> name, | 657 Handle<Name> name, |
721 Handle<Object> value); | 658 Handle<Object> value); |
722 | 659 |
723 Handle<Code> CompileLoadInterceptor(Handle<JSObject> object, | 660 Handle<Code> CompileLoadInterceptor(Handle<JSObject> object, |
724 Handle<JSObject> holder, | 661 Handle<JSObject> holder, |
725 Handle<Name> name); | 662 Handle<Name> name); |
726 | 663 |
| 664 Handle<Code> CompileLoadViaGetter(Handle<JSObject> object, |
| 665 Handle<JSObject> holder, |
| 666 Handle<Name> name, |
| 667 Handle<JSFunction> getter); |
| 668 |
| 669 static void GenerateLoadViaGetter(MacroAssembler* masm, |
| 670 Register receiver, |
| 671 Handle<JSFunction> getter); |
| 672 |
| 673 Handle<Code> CompileLoadNonexistent(Handle<JSObject> object, |
| 674 Handle<JSObject> last, |
| 675 Handle<Name> name, |
| 676 Handle<GlobalObject> global); |
| 677 |
| 678 Handle<Code> CompileLoadGlobal(Handle<JSObject> object, |
| 679 Handle<GlobalObject> holder, |
| 680 Handle<PropertyCell> cell, |
| 681 Handle<Name> name, |
| 682 bool is_dont_delete); |
| 683 |
| 684 static Register* registers(); |
| 685 |
727 protected: | 686 protected: |
728 virtual Register HandlerFrontendHeader(Handle<JSObject> object, | 687 virtual Register HandlerFrontendHeader(Handle<JSObject> object, |
729 Register object_reg, | 688 Register object_reg, |
730 Handle<JSObject> holder, | 689 Handle<JSObject> holder, |
731 Handle<Name> name, | 690 Handle<Name> name, |
732 Label* miss); | 691 Label* miss); |
733 | 692 |
734 virtual void HandlerFrontendFooter(Handle<Name> name, | 693 virtual void HandlerFrontendFooter(Handle<Name> name, |
735 Label* success, | 694 Label* success, |
736 Label* miss); | 695 Label* miss); |
(...skipping 30 matching lines...) Expand all Loading... |
767 | 726 |
768 virtual Register receiver() { return registers_[0]; } | 727 virtual Register receiver() { return registers_[0]; } |
769 virtual Register name() { return registers_[1]; } | 728 virtual Register name() { return registers_[1]; } |
770 virtual Register scratch1() { return registers_[2]; } | 729 virtual Register scratch1() { return registers_[2]; } |
771 virtual Register scratch2() { return registers_[3]; } | 730 virtual Register scratch2() { return registers_[3]; } |
772 virtual Register scratch3() { return registers_[4]; } | 731 virtual Register scratch3() { return registers_[4]; } |
773 Register scratch4() { return registers_[5]; } | 732 Register scratch4() { return registers_[5]; } |
774 }; | 733 }; |
775 | 734 |
776 | 735 |
777 class LoadStubCompiler: public BaseLoadStubCompiler { | 736 class KeyedLoadStubCompiler: public LoadStubCompiler { |
778 public: | |
779 explicit LoadStubCompiler(Isolate* isolate) | |
780 : BaseLoadStubCompiler(isolate, registers()) { } | |
781 | |
782 Handle<Code> CompileLoadNonexistent(Handle<JSObject> object, | |
783 Handle<JSObject> last, | |
784 Handle<Name> name, | |
785 Handle<GlobalObject> global); | |
786 | |
787 static void GenerateLoadViaGetter(MacroAssembler* masm, | |
788 Handle<JSFunction> getter); | |
789 | |
790 Handle<Code> CompileLoadViaGetter(Handle<JSObject> object, | |
791 Handle<JSObject> holder, | |
792 Handle<Name> name, | |
793 Handle<JSFunction> getter); | |
794 | |
795 Handle<Code> CompileLoadGlobal(Handle<JSObject> object, | |
796 Handle<GlobalObject> holder, | |
797 Handle<PropertyCell> cell, | |
798 Handle<Name> name, | |
799 bool is_dont_delete); | |
800 | |
801 private: | |
802 static Register* registers(); | |
803 virtual Code::Kind kind() { return Code::LOAD_IC; } | |
804 virtual Logger::LogEventsAndTags log_kind(Handle<Code> code) { | |
805 if (!code->is_inline_cache_stub()) return Logger::STUB_TAG; | |
806 return code->ic_state() == MONOMORPHIC | |
807 ? Logger::LOAD_IC_TAG : Logger::LOAD_POLYMORPHIC_IC_TAG; | |
808 } | |
809 virtual void JitEvent(Handle<Name> name, Handle<Code> code); | |
810 }; | |
811 | |
812 | |
813 class KeyedLoadStubCompiler: public BaseLoadStubCompiler { | |
814 public: | 737 public: |
815 explicit KeyedLoadStubCompiler(Isolate* isolate) | 738 explicit KeyedLoadStubCompiler(Isolate* isolate) |
816 : BaseLoadStubCompiler(isolate, registers()) { } | 739 : LoadStubCompiler(isolate, Code::KEYED_LOAD_IC) { } |
817 | 740 |
818 Handle<Code> CompileLoadElement(Handle<Map> receiver_map); | 741 Handle<Code> CompileLoadElement(Handle<Map> receiver_map); |
819 | 742 |
820 void CompileElementHandlers(MapHandleList* receiver_maps, | 743 void CompileElementHandlers(MapHandleList* receiver_maps, |
821 CodeHandleList* handlers); | 744 CodeHandleList* handlers); |
822 | 745 |
823 static void GenerateLoadDictionaryElement(MacroAssembler* masm); | 746 static void GenerateLoadDictionaryElement(MacroAssembler* masm); |
824 | 747 |
| 748 protected: |
| 749 static Register* registers(); |
| 750 |
825 private: | 751 private: |
826 static Register* registers(); | |
827 virtual Code::Kind kind() { return Code::KEYED_LOAD_IC; } | |
828 virtual Logger::LogEventsAndTags log_kind(Handle<Code> code) { | |
829 if (!code->is_inline_cache_stub()) return Logger::STUB_TAG; | |
830 return code->ic_state() == MONOMORPHIC | |
831 ? Logger::KEYED_LOAD_IC_TAG : Logger::KEYED_LOAD_POLYMORPHIC_IC_TAG; | |
832 } | |
833 virtual void JitEvent(Handle<Name> name, Handle<Code> code); | |
834 virtual void GenerateNameCheck(Handle<Name> name, | 752 virtual void GenerateNameCheck(Handle<Name> name, |
835 Register name_reg, | 753 Register name_reg, |
836 Label* miss); | 754 Label* miss); |
| 755 friend class BaseLoadStoreStubCompiler; |
837 }; | 756 }; |
838 | 757 |
839 | 758 |
840 class BaseStoreStubCompiler: public BaseLoadStoreStubCompiler { | 759 class StoreStubCompiler: public BaseLoadStoreStubCompiler { |
841 public: | 760 public: |
842 BaseStoreStubCompiler(Isolate* isolate, | 761 StoreStubCompiler(Isolate* isolate, |
843 StrictModeFlag strict_mode, | 762 StrictModeFlag strict_mode, |
844 Register* registers) | 763 Code::Kind kind = Code::STORE_IC) |
845 : BaseLoadStoreStubCompiler(isolate, registers), | 764 : BaseLoadStoreStubCompiler(isolate, kind), |
846 strict_mode_(strict_mode) { } | 765 strict_mode_(strict_mode) { } |
847 | 766 |
848 virtual ~BaseStoreStubCompiler() { } | 767 virtual ~StoreStubCompiler() { } |
849 | 768 |
850 Handle<Code> CompileStoreTransition(Handle<JSObject> object, | 769 Handle<Code> CompileStoreTransition(Handle<JSObject> object, |
851 LookupResult* lookup, | 770 LookupResult* lookup, |
852 Handle<Map> transition, | 771 Handle<Map> transition, |
853 Handle<Name> name); | 772 Handle<Name> name); |
854 | 773 |
855 Handle<Code> CompileStoreField(Handle<JSObject> object, | 774 Handle<Code> CompileStoreField(Handle<JSObject> object, |
856 LookupResult* lookup, | 775 LookupResult* lookup, |
857 Handle<Name> name); | 776 Handle<Name> name); |
858 | 777 |
(...skipping 20 matching lines...) Expand all Loading... |
879 void GenerateStoreField(MacroAssembler* masm, | 798 void GenerateStoreField(MacroAssembler* masm, |
880 Handle<JSObject> object, | 799 Handle<JSObject> object, |
881 LookupResult* lookup, | 800 LookupResult* lookup, |
882 Register receiver_reg, | 801 Register receiver_reg, |
883 Register name_reg, | 802 Register name_reg, |
884 Register value_reg, | 803 Register value_reg, |
885 Register scratch1, | 804 Register scratch1, |
886 Register scratch2, | 805 Register scratch2, |
887 Label* miss_label); | 806 Label* miss_label); |
888 | 807 |
889 static Builtins::Name MissBuiltin(Code::Kind kind) { | 808 Handle<Code> CompileStoreCallback(Handle<JSObject> object, |
890 switch (kind) { | 809 Handle<JSObject> holder, |
891 case Code::LOAD_IC: return Builtins::kLoadIC_Miss; | 810 Handle<Name> name, |
892 case Code::STORE_IC: return Builtins::kStoreIC_Miss; | 811 Handle<ExecutableAccessorInfo> callback); |
893 case Code::KEYED_LOAD_IC: return Builtins::kKeyedLoadIC_Miss; | 812 |
894 case Code::KEYED_STORE_IC: return Builtins::kKeyedStoreIC_Miss; | 813 Handle<Code> CompileStoreCallback(Handle<JSObject> object, |
895 default: UNREACHABLE(); | 814 Handle<JSObject> holder, |
896 } | 815 Handle<Name> name, |
897 return Builtins::kLoadIC_Miss; | 816 const CallOptimization& call_optimization); |
898 } | 817 |
| 818 static void GenerateStoreViaSetter(MacroAssembler* masm, |
| 819 Handle<JSFunction> setter); |
| 820 |
| 821 Handle<Code> CompileStoreViaSetter(Handle<JSObject> object, |
| 822 Handle<JSObject> holder, |
| 823 Handle<Name> name, |
| 824 Handle<JSFunction> setter); |
| 825 |
| 826 Handle<Code> CompileStoreInterceptor(Handle<JSObject> object, |
| 827 Handle<Name> name); |
| 828 |
899 static Builtins::Name SlowBuiltin(Code::Kind kind) { | 829 static Builtins::Name SlowBuiltin(Code::Kind kind) { |
900 switch (kind) { | 830 switch (kind) { |
901 case Code::STORE_IC: return Builtins::kStoreIC_Slow; | 831 case Code::STORE_IC: return Builtins::kStoreIC_Slow; |
902 case Code::KEYED_STORE_IC: return Builtins::kKeyedStoreIC_Slow; | 832 case Code::KEYED_STORE_IC: return Builtins::kKeyedStoreIC_Slow; |
903 default: UNREACHABLE(); | 833 default: UNREACHABLE(); |
904 } | 834 } |
905 return Builtins::kStoreIC_Slow; | 835 return Builtins::kStoreIC_Slow; |
906 } | 836 } |
907 | 837 |
908 protected: | 838 protected: |
(...skipping 12 matching lines...) Expand all Loading... |
921 | 851 |
922 virtual Register receiver() { return registers_[0]; } | 852 virtual Register receiver() { return registers_[0]; } |
923 virtual Register name() { return registers_[1]; } | 853 virtual Register name() { return registers_[1]; } |
924 Register value() { return registers_[2]; } | 854 Register value() { return registers_[2]; } |
925 virtual Register scratch1() { return registers_[3]; } | 855 virtual Register scratch1() { return registers_[3]; } |
926 virtual Register scratch2() { return registers_[4]; } | 856 virtual Register scratch2() { return registers_[4]; } |
927 virtual Register scratch3() { return registers_[5]; } | 857 virtual Register scratch3() { return registers_[5]; } |
928 StrictModeFlag strict_mode() { return strict_mode_; } | 858 StrictModeFlag strict_mode() { return strict_mode_; } |
929 virtual Code::ExtraICState extra_state() { return strict_mode_; } | 859 virtual Code::ExtraICState extra_state() { return strict_mode_; } |
930 | 860 |
| 861 protected: |
| 862 static Register* registers(); |
| 863 |
931 private: | 864 private: |
932 StrictModeFlag strict_mode_; | 865 StrictModeFlag strict_mode_; |
| 866 friend class BaseLoadStoreStubCompiler; |
933 }; | 867 }; |
934 | 868 |
935 | 869 |
936 class StoreStubCompiler: public BaseStoreStubCompiler { | 870 class KeyedStoreStubCompiler: public StoreStubCompiler { |
937 public: | |
938 StoreStubCompiler(Isolate* isolate, StrictModeFlag strict_mode) | |
939 : BaseStoreStubCompiler(isolate, strict_mode, registers()) { } | |
940 | |
941 | |
942 Handle<Code> CompileStoreCallback(Handle<JSObject> object, | |
943 Handle<JSObject> holder, | |
944 Handle<Name> name, | |
945 Handle<ExecutableAccessorInfo> callback); | |
946 | |
947 Handle<Code> CompileStoreCallback(Handle<JSObject> object, | |
948 Handle<JSObject> holder, | |
949 Handle<Name> name, | |
950 const CallOptimization& call_optimization); | |
951 | |
952 static void GenerateStoreViaSetter(MacroAssembler* masm, | |
953 Handle<JSFunction> setter); | |
954 | |
955 Handle<Code> CompileStoreViaSetter(Handle<JSObject> object, | |
956 Handle<JSObject> holder, | |
957 Handle<Name> name, | |
958 Handle<JSFunction> setter); | |
959 | |
960 Handle<Code> CompileStoreInterceptor(Handle<JSObject> object, | |
961 Handle<Name> name); | |
962 | |
963 private: | |
964 static Register* registers(); | |
965 virtual Code::Kind kind() { return Code::STORE_IC; } | |
966 virtual Logger::LogEventsAndTags log_kind(Handle<Code> code) { | |
967 if (!code->is_inline_cache_stub()) return Logger::STUB_TAG; | |
968 return code->ic_state() == MONOMORPHIC | |
969 ? Logger::STORE_IC_TAG : Logger::STORE_POLYMORPHIC_IC_TAG; | |
970 } | |
971 virtual void JitEvent(Handle<Name> name, Handle<Code> code); | |
972 }; | |
973 | |
974 | |
975 class KeyedStoreStubCompiler: public BaseStoreStubCompiler { | |
976 public: | 871 public: |
977 KeyedStoreStubCompiler(Isolate* isolate, | 872 KeyedStoreStubCompiler(Isolate* isolate, |
978 StrictModeFlag strict_mode, | 873 StrictModeFlag strict_mode, |
979 KeyedAccessStoreMode store_mode) | 874 KeyedAccessStoreMode store_mode) |
980 : BaseStoreStubCompiler(isolate, strict_mode, registers()), | 875 : StoreStubCompiler(isolate, strict_mode, Code::KEYED_STORE_IC), |
981 store_mode_(store_mode) { } | 876 store_mode_(store_mode) { } |
982 | 877 |
983 Handle<Code> CompileStoreElement(Handle<Map> receiver_map); | 878 Handle<Code> CompileStoreElement(Handle<Map> receiver_map); |
984 | 879 |
985 Handle<Code> CompileStorePolymorphic(MapHandleList* receiver_maps, | 880 Handle<Code> CompileStorePolymorphic(MapHandleList* receiver_maps, |
986 CodeHandleList* handler_stubs, | 881 CodeHandleList* handler_stubs, |
987 MapHandleList* transitioned_maps); | 882 MapHandleList* transitioned_maps); |
988 | 883 |
989 Handle<Code> CompileStoreElementPolymorphic(MapHandleList* receiver_maps); | 884 Handle<Code> CompileStoreElementPolymorphic(MapHandleList* receiver_maps); |
990 | 885 |
991 static void GenerateStoreDictionaryElement(MacroAssembler* masm); | 886 static void GenerateStoreDictionaryElement(MacroAssembler* masm); |
992 | 887 |
993 protected: | 888 protected: |
994 virtual Code::ExtraICState extra_state() { | 889 virtual Code::ExtraICState extra_state() { |
995 return Code::ComputeExtraICState(store_mode_, strict_mode()); | 890 return Code::ComputeExtraICState(store_mode_, strict_mode()); |
996 } | 891 } |
| 892 static Register* registers(); |
997 | 893 |
998 private: | 894 private: |
999 Register transition_map() { | 895 Register transition_map() { |
1000 return registers()[3]; | 896 return registers()[3]; |
1001 } | 897 } |
1002 | 898 |
1003 static Register* registers(); | |
1004 virtual Code::Kind kind() { return Code::KEYED_STORE_IC; } | |
1005 virtual Logger::LogEventsAndTags log_kind(Handle<Code> code) { | |
1006 if (!code->is_inline_cache_stub()) return Logger::STUB_TAG; | |
1007 return code->ic_state() == MONOMORPHIC | |
1008 ? Logger::KEYED_STORE_IC_TAG : Logger::KEYED_STORE_POLYMORPHIC_IC_TAG; | |
1009 } | |
1010 virtual void JitEvent(Handle<Name> name, Handle<Code> code); | |
1011 virtual void GenerateNameCheck(Handle<Name> name, | 899 virtual void GenerateNameCheck(Handle<Name> name, |
1012 Register name_reg, | 900 Register name_reg, |
1013 Label* miss); | 901 Label* miss); |
1014 KeyedAccessStoreMode store_mode_; | 902 KeyedAccessStoreMode store_mode_; |
| 903 friend class BaseLoadStoreStubCompiler; |
1015 }; | 904 }; |
1016 | 905 |
1017 | 906 |
1018 // Subset of FUNCTIONS_WITH_ID_LIST with custom constant/global call | 907 // Subset of FUNCTIONS_WITH_ID_LIST with custom constant/global call |
1019 // IC stubs. | 908 // IC stubs. |
1020 #define CUSTOM_CALL_IC_GENERATORS(V) \ | 909 #define CUSTOM_CALL_IC_GENERATORS(V) \ |
1021 V(ArrayPush) \ | 910 V(ArrayPush) \ |
1022 V(ArrayPop) \ | 911 V(ArrayPop) \ |
1023 V(StringCharCodeAt) \ | 912 V(StringCharCodeAt) \ |
1024 V(StringCharAt) \ | 913 V(StringCharAt) \ |
(...skipping 154 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1179 Handle<JSFunction> constant_function_; | 1068 Handle<JSFunction> constant_function_; |
1180 bool is_simple_api_call_; | 1069 bool is_simple_api_call_; |
1181 Handle<FunctionTemplateInfo> expected_receiver_type_; | 1070 Handle<FunctionTemplateInfo> expected_receiver_type_; |
1182 Handle<CallHandlerInfo> api_call_info_; | 1071 Handle<CallHandlerInfo> api_call_info_; |
1183 }; | 1072 }; |
1184 | 1073 |
1185 | 1074 |
1186 } } // namespace v8::internal | 1075 } } // namespace v8::internal |
1187 | 1076 |
1188 #endif // V8_STUB_CACHE_H_ | 1077 #endif // V8_STUB_CACHE_H_ |
OLD | NEW |