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 72 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
83 Code::Kind kind, | 83 Code::Kind kind, |
84 Code::StubType type, | 84 Code::StubType type, |
85 Code::ExtraICState extra_state = Code::kNoExtraICState); | 85 Code::ExtraICState extra_state = Code::kNoExtraICState); |
86 | 86 |
87 Handle<Code> FindIC(Handle<Name> name, | 87 Handle<Code> FindIC(Handle<Name> name, |
88 Handle<JSObject> stub_holder, | 88 Handle<JSObject> stub_holder, |
89 Code::Kind kind, | 89 Code::Kind kind, |
90 Code::StubType type, | 90 Code::StubType type, |
91 Code::ExtraICState extra_state = Code::kNoExtraICState); | 91 Code::ExtraICState extra_state = Code::kNoExtraICState); |
92 | 92 |
93 Handle<Code> FindHandler( | 93 Handle<Code> FindLoadHandler(Handle<Name> name, |
94 Handle<Name> name, | 94 Handle<JSObject> receiver, |
95 Handle<JSObject> receiver, | 95 Handle<JSObject> stub_holder, |
96 Handle<JSObject> stub_holder, | 96 Code::Kind kind, |
97 Code::Kind kind, | 97 Code::StubType type); |
98 Code::StubType type); | |
99 | 98 |
100 Handle<Code> ComputeMonomorphicIC(Handle<JSObject> receiver, | 99 Handle<Code> FindStoreHandler(Handle<Name> name, |
101 Handle<Code> handler, | 100 Handle<JSObject> receiver, |
102 Handle<Name> name); | 101 Code::Kind kind, |
103 Handle<Code> ComputeKeyedMonomorphicIC(Handle<JSObject> receiver, | 102 Code::StubType type, |
| 103 StrictModeFlag strict_mode); |
| 104 |
| 105 Handle<Code> ComputeMonomorphicLoadIC(Handle<JSObject> receiver, |
| 106 Handle<Code> handler, |
| 107 Handle<Name> name); |
| 108 |
| 109 Handle<Code> ComputeMonomorphicKeyedLoadIC(Handle<JSObject> receiver, |
| 110 Handle<Code> handler, |
| 111 Handle<Name> name); |
| 112 |
| 113 Handle<Code> ComputeMonomorphicStoreIC(Handle<JSObject> receiver, |
104 Handle<Code> handler, | 114 Handle<Code> handler, |
105 Handle<Name> name); | 115 Handle<Name> name, |
| 116 StrictModeFlag strict_mode); |
| 117 |
| 118 Handle<Code> ComputeMonomorphicKeyedStoreIC(Handle<JSObject> receiver, |
| 119 Handle<Code> handler, |
| 120 Handle<Name> name, |
| 121 StrictModeFlag strict_mode); |
106 | 122 |
107 // Computes the right stub matching. Inserts the result in the | 123 // Computes the right stub matching. Inserts the result in the |
108 // cache before returning. This might compile a stub if needed. | 124 // cache before returning. This might compile a stub if needed. |
109 Handle<Code> ComputeLoadNonexistent(Handle<Name> name, | 125 Handle<Code> ComputeLoadNonexistent(Handle<Name> name, |
110 Handle<JSObject> object); | 126 Handle<JSObject> object); |
111 | 127 |
112 Handle<Code> ComputeLoadField(Handle<Name> name, | 128 Handle<Code> ComputeLoadField(Handle<Name> name, |
113 Handle<JSObject> object, | 129 Handle<JSObject> object, |
114 Handle<JSObject> holder, | 130 Handle<JSObject> holder, |
115 PropertyIndex field_index, | 131 PropertyIndex field_index, |
(...skipping 168 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
284 Handle<Code> ComputeCompareNil(Handle<Map> receiver_map, | 300 Handle<Code> ComputeCompareNil(Handle<Map> receiver_map, |
285 CompareNilICStub& stub); | 301 CompareNilICStub& stub); |
286 | 302 |
287 // --- | 303 // --- |
288 | 304 |
289 Handle<Code> ComputeLoadElementPolymorphic(MapHandleList* receiver_maps); | 305 Handle<Code> ComputeLoadElementPolymorphic(MapHandleList* receiver_maps); |
290 Handle<Code> ComputeStoreElementPolymorphic(MapHandleList* receiver_maps, | 306 Handle<Code> ComputeStoreElementPolymorphic(MapHandleList* receiver_maps, |
291 KeyedAccessStoreMode store_mode, | 307 KeyedAccessStoreMode store_mode, |
292 StrictModeFlag strict_mode); | 308 StrictModeFlag strict_mode); |
293 | 309 |
294 Handle<Code> ComputePolymorphicIC(MapHandleList* receiver_maps, | 310 Handle<Code> ComputePolymorphicLoadIC(MapHandleList* receiver_maps, |
295 CodeHandleList* handlers, | 311 CodeHandleList* handlers, |
296 int number_of_valid_maps, | 312 int number_of_valid_maps, |
297 Handle<Name> name); | 313 Handle<Name> name); |
| 314 |
| 315 Handle<Code> ComputePolymorphicStoreIC(MapHandleList* receiver_maps, |
| 316 CodeHandleList* handlers, |
| 317 int number_of_valid_maps, |
| 318 Handle<Name> name, |
| 319 StrictModeFlag strict_mode); |
298 | 320 |
299 // Finds the Code object stored in the Heap::non_monomorphic_cache(). | 321 // Finds the Code object stored in the Heap::non_monomorphic_cache(). |
300 Code* FindCallInitialize(int argc, RelocInfo::Mode mode, Code::Kind kind); | 322 Code* FindCallInitialize(int argc, RelocInfo::Mode mode, Code::Kind kind); |
301 | 323 |
302 #ifdef ENABLE_DEBUGGER_SUPPORT | 324 #ifdef ENABLE_DEBUGGER_SUPPORT |
303 Handle<Code> ComputeCallDebugBreak(int argc, Code::Kind kind); | 325 Handle<Code> ComputeCallDebugBreak(int argc, Code::Kind kind); |
304 | 326 |
305 Handle<Code> ComputeCallDebugPrepareStepIn(int argc, Code::Kind kind); | 327 Handle<Code> ComputeCallDebugPrepareStepIn(int argc, Code::Kind kind); |
306 #endif | 328 #endif |
307 | 329 |
(...skipping 215 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
523 Register scratch2, | 545 Register scratch2, |
524 Label* miss_label, | 546 Label* miss_label, |
525 bool support_wrappers); | 547 bool support_wrappers); |
526 | 548 |
527 static void GenerateLoadFunctionPrototype(MacroAssembler* masm, | 549 static void GenerateLoadFunctionPrototype(MacroAssembler* masm, |
528 Register receiver, | 550 Register receiver, |
529 Register scratch1, | 551 Register scratch1, |
530 Register scratch2, | 552 Register scratch2, |
531 Label* miss_label); | 553 Label* miss_label); |
532 | 554 |
533 void GenerateStoreTransition(MacroAssembler* masm, | |
534 Handle<JSObject> object, | |
535 LookupResult* lookup, | |
536 Handle<Map> transition, | |
537 Handle<Name> name, | |
538 Register receiver_reg, | |
539 Register name_reg, | |
540 Register value_reg, | |
541 Register scratch1, | |
542 Register scratch2, | |
543 Register scratch3, | |
544 Label* miss_label, | |
545 Label* miss_restore_name, | |
546 Label* slow); | |
547 | |
548 void GenerateStoreField(MacroAssembler* masm, | |
549 Handle<JSObject> object, | |
550 LookupResult* lookup, | |
551 Register receiver_reg, | |
552 Register name_reg, | |
553 Register value_reg, | |
554 Register scratch1, | |
555 Register scratch2, | |
556 Label* miss_label); | |
557 | |
558 static Builtins::Name MissBuiltin(Code::Kind kind) { | |
559 switch (kind) { | |
560 case Code::LOAD_IC: return Builtins::kLoadIC_Miss; | |
561 case Code::STORE_IC: return Builtins::kStoreIC_Miss; | |
562 case Code::KEYED_LOAD_IC: return Builtins::kKeyedLoadIC_Miss; | |
563 case Code::KEYED_STORE_IC: return Builtins::kKeyedStoreIC_Miss; | |
564 default: UNREACHABLE(); | |
565 } | |
566 return Builtins::kLoadIC_Miss; | |
567 } | |
568 static Builtins::Name SlowBuiltin(Code::Kind kind) { | |
569 switch (kind) { | |
570 case Code::STORE_IC: return Builtins::kStoreIC_Slow; | |
571 case Code::KEYED_STORE_IC: return Builtins::kKeyedStoreIC_Slow; | |
572 default: UNREACHABLE(); | |
573 } | |
574 return Builtins::kStoreIC_Slow; | |
575 } | |
576 static void TailCallBuiltin(MacroAssembler* masm, Builtins::Name name); | 555 static void TailCallBuiltin(MacroAssembler* masm, Builtins::Name name); |
577 | 556 |
578 // Generates code that verifies that the property holder has not changed | 557 // Generates code that verifies that the property holder has not changed |
579 // (checking maps of objects in the prototype chain for fast and global | 558 // (checking maps of objects in the prototype chain for fast and global |
580 // objects or doing negative lookup for slow objects, ensures that the | 559 // objects or doing negative lookup for slow objects, ensures that the |
581 // property cells for global objects are still empty) and checks that the map | 560 // property cells for global objects are still empty) and checks that the map |
582 // of the holder has not changed. If necessary the function also generates | 561 // of the holder has not changed. If necessary the function also generates |
583 // code for security check in case of global object holders. Helps to make | 562 // code for security check in case of global object holders. Helps to make |
584 // sure that the current IC is still valid. | 563 // sure that the current IC is still valid. |
585 // | 564 // |
(...skipping 49 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
635 private: | 614 private: |
636 Isolate* isolate_; | 615 Isolate* isolate_; |
637 MacroAssembler masm_; | 616 MacroAssembler masm_; |
638 Failure* failure_; | 617 Failure* failure_; |
639 }; | 618 }; |
640 | 619 |
641 | 620 |
642 enum FrontendCheckType { PERFORM_INITIAL_CHECKS, SKIP_INITIAL_CHECKS }; | 621 enum FrontendCheckType { PERFORM_INITIAL_CHECKS, SKIP_INITIAL_CHECKS }; |
643 | 622 |
644 | 623 |
645 class BaseLoadStubCompiler: public StubCompiler { | 624 class BaseLoadStoreStubCompiler: public StubCompiler { |
| 625 public: |
| 626 BaseLoadStoreStubCompiler(Isolate* isolate, Register* registers) |
| 627 : StubCompiler(isolate), registers_(registers) { } |
| 628 virtual ~BaseLoadStoreStubCompiler() { } |
| 629 |
| 630 Handle<Code> CompileMonomorphicIC(Handle<Map> receiver_map, |
| 631 Handle<Code> handler, |
| 632 Handle<Name> name); |
| 633 |
| 634 Handle<Code> CompilePolymorphicIC(MapHandleList* receiver_maps, |
| 635 CodeHandleList* handlers, |
| 636 Handle<Name> name, |
| 637 Code::StubType type, |
| 638 IcCheckType check); |
| 639 |
| 640 virtual void GenerateNameCheck(Handle<Name> name, |
| 641 Register name_reg, |
| 642 Label* miss) { } |
| 643 |
| 644 static Builtins::Name MissBuiltin(Code::Kind kind) { |
| 645 switch (kind) { |
| 646 case Code::LOAD_IC: return Builtins::kLoadIC_Miss; |
| 647 case Code::STORE_IC: return Builtins::kStoreIC_Miss; |
| 648 case Code::KEYED_LOAD_IC: return Builtins::kKeyedLoadIC_Miss; |
| 649 case Code::KEYED_STORE_IC: return Builtins::kKeyedStoreIC_Miss; |
| 650 default: UNREACHABLE(); |
| 651 } |
| 652 return Builtins::kLoadIC_Miss; |
| 653 } |
| 654 |
| 655 protected: |
| 656 virtual Register HandlerFrontendHeader(Handle<JSObject> object, |
| 657 Register object_reg, |
| 658 Handle<JSObject> holder, |
| 659 Handle<Name> name, |
| 660 Label* miss) = 0; |
| 661 |
| 662 virtual void HandlerFrontendFooter(Handle<Name> name, |
| 663 Label* success, |
| 664 Label* miss) = 0; |
| 665 |
| 666 Register HandlerFrontend(Handle<JSObject> object, |
| 667 Register object_reg, |
| 668 Handle<JSObject> holder, |
| 669 Handle<Name> name, |
| 670 Label* success); |
| 671 |
| 672 Handle<Code> GetICCode(Code::Kind kind, |
| 673 Code::StubType type, |
| 674 Handle<Name> name, |
| 675 InlineCacheState state = MONOMORPHIC); |
| 676 |
| 677 virtual Code::ExtraICState extra_state() { return Code::kNoExtraICState; } |
| 678 virtual Logger::LogEventsAndTags log_kind(Handle<Code> code) = 0; |
| 679 virtual void JitEvent(Handle<Name> name, Handle<Code> code) = 0; |
| 680 virtual Code::Kind kind() = 0; |
| 681 virtual Register receiver() = 0; |
| 682 virtual Register name() = 0; |
| 683 virtual Register scratch1() = 0; |
| 684 virtual Register scratch2() = 0; |
| 685 virtual Register scratch3() = 0; |
| 686 |
| 687 Register* registers_; |
| 688 }; |
| 689 |
| 690 |
| 691 class BaseLoadStubCompiler: public BaseLoadStoreStubCompiler { |
646 public: | 692 public: |
647 BaseLoadStubCompiler(Isolate* isolate, Register* registers) | 693 BaseLoadStubCompiler(Isolate* isolate, Register* registers) |
648 : StubCompiler(isolate), registers_(registers) { } | 694 : BaseLoadStoreStubCompiler(isolate, registers) { } |
649 virtual ~BaseLoadStubCompiler() { } | 695 virtual ~BaseLoadStubCompiler() { } |
650 | 696 |
651 Handle<Code> CompileLoadField(Handle<JSObject> object, | 697 Handle<Code> CompileLoadField(Handle<JSObject> object, |
652 Handle<JSObject> holder, | 698 Handle<JSObject> holder, |
653 Handle<Name> name, | 699 Handle<Name> name, |
654 PropertyIndex index, | 700 PropertyIndex index, |
655 Representation representation); | 701 Representation representation); |
656 | 702 |
657 Handle<Code> CompileLoadCallback(Handle<JSObject> object, | 703 Handle<Code> CompileLoadCallback(Handle<JSObject> object, |
658 Handle<JSObject> holder, | 704 Handle<JSObject> holder, |
659 Handle<Name> name, | 705 Handle<Name> name, |
660 Handle<ExecutableAccessorInfo> callback); | 706 Handle<ExecutableAccessorInfo> callback); |
661 | 707 |
662 Handle<Code> CompileLoadConstant(Handle<JSObject> object, | 708 Handle<Code> CompileLoadConstant(Handle<JSObject> object, |
663 Handle<JSObject> holder, | 709 Handle<JSObject> holder, |
664 Handle<Name> name, | 710 Handle<Name> name, |
665 Handle<JSFunction> value); | 711 Handle<JSFunction> value); |
666 | 712 |
667 Handle<Code> CompileLoadInterceptor(Handle<JSObject> object, | 713 Handle<Code> CompileLoadInterceptor(Handle<JSObject> object, |
668 Handle<JSObject> holder, | 714 Handle<JSObject> holder, |
669 Handle<Name> name); | 715 Handle<Name> name); |
670 | 716 |
671 Handle<Code> CompileMonomorphicIC(Handle<Map> receiver_map, | 717 protected: |
672 Handle<Code> handler, | 718 virtual Register HandlerFrontendHeader(Handle<JSObject> object, |
673 Handle<Name> name); | 719 Register object_reg, |
674 Handle<Code> CompilePolymorphicIC(MapHandleList* receiver_maps, | 720 Handle<JSObject> holder, |
675 CodeHandleList* handlers, | 721 Handle<Name> name, |
676 Handle<Name> name, | 722 Label* miss); |
677 Code::StubType type, | |
678 IcCheckType check); | |
679 | 723 |
680 protected: | 724 virtual void HandlerFrontendFooter(Handle<Name> name, |
681 Register HandlerFrontendHeader(Handle<JSObject> object, | 725 Label* success, |
682 Register object_reg, | 726 Label* miss); |
683 Handle<JSObject> holder, | |
684 Handle<Name> name, | |
685 Label* success); | |
686 void HandlerFrontendFooter(Label* success, Label* miss); | |
687 | 727 |
688 Register HandlerFrontend(Handle<JSObject> object, | |
689 Register object_reg, | |
690 Handle<JSObject> holder, | |
691 Handle<Name> name, | |
692 Label* success); | |
693 Register CallbackHandlerFrontend(Handle<JSObject> object, | 728 Register CallbackHandlerFrontend(Handle<JSObject> object, |
694 Register object_reg, | 729 Register object_reg, |
695 Handle<JSObject> holder, | 730 Handle<JSObject> holder, |
696 Handle<Name> name, | 731 Handle<Name> name, |
697 Label* success, | 732 Label* success, |
698 Handle<ExecutableAccessorInfo> callback); | 733 Handle<ExecutableAccessorInfo> callback); |
699 void NonexistentHandlerFrontend(Handle<JSObject> object, | 734 void NonexistentHandlerFrontend(Handle<JSObject> object, |
700 Handle<JSObject> last, | 735 Handle<JSObject> last, |
701 Handle<Name> name, | 736 Handle<Name> name, |
702 Label* success, | 737 Label* success, |
703 Handle<GlobalObject> global); | 738 Handle<GlobalObject> global); |
704 | 739 |
705 void GenerateLoadField(Register reg, | 740 void GenerateLoadField(Register reg, |
706 Handle<JSObject> holder, | 741 Handle<JSObject> holder, |
707 PropertyIndex field, | 742 PropertyIndex field, |
708 Representation representation); | 743 Representation representation); |
709 void GenerateLoadConstant(Handle<JSFunction> value); | 744 void GenerateLoadConstant(Handle<JSFunction> value); |
710 void GenerateLoadCallback(Register reg, | 745 void GenerateLoadCallback(Register reg, |
711 Handle<ExecutableAccessorInfo> callback); | 746 Handle<ExecutableAccessorInfo> callback); |
712 void GenerateLoadInterceptor(Register holder_reg, | 747 void GenerateLoadInterceptor(Register holder_reg, |
713 Handle<JSObject> object, | 748 Handle<JSObject> object, |
714 Handle<JSObject> holder, | 749 Handle<JSObject> holder, |
715 LookupResult* lookup, | 750 LookupResult* lookup, |
716 Handle<Name> name); | 751 Handle<Name> name); |
717 void GenerateLoadPostInterceptor(Register reg, | 752 void GenerateLoadPostInterceptor(Register reg, |
718 Handle<JSObject> interceptor_holder, | 753 Handle<JSObject> interceptor_holder, |
719 Handle<Name> name, | 754 Handle<Name> name, |
720 LookupResult* lookup); | 755 LookupResult* lookup); |
721 | 756 |
722 Handle<Code> GetICCode(Code::Kind kind, | |
723 Code::StubType type, | |
724 Handle<Name> name, | |
725 InlineCacheState state = MONOMORPHIC); | |
726 | |
727 Handle<Code> GetCode(Code::Kind kind, | 757 Handle<Code> GetCode(Code::Kind kind, |
728 Code::StubType type, | 758 Code::StubType type, |
729 Handle<Name> name); | 759 Handle<Name> name); |
730 | 760 |
731 Register receiver() { return registers_[0]; } | 761 virtual Register receiver() { return registers_[0]; } |
732 Register name() { return registers_[1]; } | 762 virtual Register name() { return registers_[1]; } |
733 Register scratch1() { return registers_[2]; } | 763 virtual Register scratch1() { return registers_[2]; } |
734 Register scratch2() { return registers_[3]; } | 764 virtual Register scratch2() { return registers_[3]; } |
735 Register scratch3() { return registers_[4]; } | 765 virtual Register scratch3() { return registers_[4]; } |
736 Register scratch4() { return registers_[5]; } | 766 Register scratch4() { return registers_[5]; } |
737 | |
738 private: | |
739 virtual Code::Kind kind() = 0; | |
740 virtual Logger::LogEventsAndTags log_kind(Handle<Code> code) = 0; | |
741 virtual void JitEvent(Handle<Name> name, Handle<Code> code) = 0; | |
742 virtual void GenerateNameCheck(Handle<Name> name, | |
743 Register name_reg, | |
744 Label* miss) { } | |
745 Register* registers_; | |
746 }; | 767 }; |
747 | 768 |
748 | 769 |
749 class LoadStubCompiler: public BaseLoadStubCompiler { | 770 class LoadStubCompiler: public BaseLoadStubCompiler { |
750 public: | 771 public: |
751 explicit LoadStubCompiler(Isolate* isolate) | 772 explicit LoadStubCompiler(Isolate* isolate) |
752 : BaseLoadStubCompiler(isolate, registers()) { } | 773 : BaseLoadStubCompiler(isolate, registers()) { } |
753 | 774 |
754 Handle<Code> CompileLoadNonexistent(Handle<JSObject> object, | 775 Handle<Code> CompileLoadNonexistent(Handle<JSObject> object, |
755 Handle<JSObject> last, | 776 Handle<JSObject> last, |
756 Handle<Name> name, | 777 Handle<Name> name, |
757 Handle<GlobalObject> global); | 778 Handle<GlobalObject> global); |
758 | 779 |
759 static void GenerateLoadViaGetter(MacroAssembler* masm, | 780 static void GenerateLoadViaGetter(MacroAssembler* masm, |
760 Handle<JSFunction> getter); | 781 Handle<JSFunction> getter); |
761 | 782 |
762 Handle<Code> CompileLoadViaGetter(Handle<JSObject> object, | 783 Handle<Code> CompileLoadViaGetter(Handle<JSObject> object, |
763 Handle<JSObject> holder, | 784 Handle<JSObject> holder, |
764 Handle<Name> name, | 785 Handle<Name> name, |
765 Handle<JSFunction> getter); | 786 Handle<JSFunction> getter); |
766 | 787 |
767 Handle<Code> CompileLoadGlobal(Handle<JSObject> object, | 788 Handle<Code> CompileLoadGlobal(Handle<JSObject> object, |
768 Handle<GlobalObject> holder, | 789 Handle<GlobalObject> holder, |
769 Handle<PropertyCell> cell, | 790 Handle<PropertyCell> cell, |
770 Handle<Name> name, | 791 Handle<Name> name, |
771 bool is_dont_delete); | 792 bool is_dont_delete); |
772 | 793 |
773 static Register receiver() { return registers()[0]; } | |
774 | |
775 private: | 794 private: |
776 static Register* registers(); | 795 static Register* registers(); |
777 virtual Code::Kind kind() { return Code::LOAD_IC; } | 796 virtual Code::Kind kind() { return Code::LOAD_IC; } |
778 virtual Logger::LogEventsAndTags log_kind(Handle<Code> code) { | 797 virtual Logger::LogEventsAndTags log_kind(Handle<Code> code) { |
779 if (!code->is_inline_cache_stub()) return Logger::STUB_TAG; | 798 if (!code->is_inline_cache_stub()) return Logger::STUB_TAG; |
780 return code->ic_state() == MONOMORPHIC | 799 return code->ic_state() == MONOMORPHIC |
781 ? Logger::LOAD_IC_TAG : Logger::LOAD_POLYMORPHIC_IC_TAG; | 800 ? Logger::LOAD_IC_TAG : Logger::LOAD_POLYMORPHIC_IC_TAG; |
782 } | 801 } |
783 virtual void JitEvent(Handle<Name> name, Handle<Code> code); | 802 virtual void JitEvent(Handle<Name> name, Handle<Code> code); |
784 }; | 803 }; |
785 | 804 |
786 | 805 |
787 class KeyedLoadStubCompiler: public BaseLoadStubCompiler { | 806 class KeyedLoadStubCompiler: public BaseLoadStubCompiler { |
788 public: | 807 public: |
789 explicit KeyedLoadStubCompiler(Isolate* isolate) | 808 explicit KeyedLoadStubCompiler(Isolate* isolate) |
790 : BaseLoadStubCompiler(isolate, registers()) { } | 809 : BaseLoadStubCompiler(isolate, registers()) { } |
791 | 810 |
792 Handle<Code> CompileLoadElement(Handle<Map> receiver_map); | 811 Handle<Code> CompileLoadElement(Handle<Map> receiver_map); |
793 | 812 |
794 void CompileElementHandlers(MapHandleList* receiver_maps, | 813 void CompileElementHandlers(MapHandleList* receiver_maps, |
795 CodeHandleList* handlers); | 814 CodeHandleList* handlers); |
796 | 815 |
797 static void GenerateLoadDictionaryElement(MacroAssembler* masm); | 816 static void GenerateLoadDictionaryElement(MacroAssembler* masm); |
798 | 817 |
799 static Register receiver() { return registers()[0]; } | |
800 | |
801 private: | 818 private: |
802 static Register* registers(); | 819 static Register* registers(); |
803 virtual Code::Kind kind() { return Code::KEYED_LOAD_IC; } | 820 virtual Code::Kind kind() { return Code::KEYED_LOAD_IC; } |
804 virtual Logger::LogEventsAndTags log_kind(Handle<Code> code) { | 821 virtual Logger::LogEventsAndTags log_kind(Handle<Code> code) { |
805 if (!code->is_inline_cache_stub()) return Logger::STUB_TAG; | 822 if (!code->is_inline_cache_stub()) return Logger::STUB_TAG; |
806 return code->ic_state() == MONOMORPHIC | 823 return code->ic_state() == MONOMORPHIC |
807 ? Logger::KEYED_LOAD_IC_TAG : Logger::KEYED_LOAD_POLYMORPHIC_IC_TAG; | 824 ? Logger::KEYED_LOAD_IC_TAG : Logger::KEYED_LOAD_POLYMORPHIC_IC_TAG; |
808 } | 825 } |
809 virtual void JitEvent(Handle<Name> name, Handle<Code> code); | 826 virtual void JitEvent(Handle<Name> name, Handle<Code> code); |
810 virtual void GenerateNameCheck(Handle<Name> name, | 827 virtual void GenerateNameCheck(Handle<Name> name, |
811 Register name_reg, | 828 Register name_reg, |
812 Label* miss); | 829 Label* miss); |
813 }; | 830 }; |
814 | 831 |
815 | 832 |
816 class BaseStoreStubCompiler: public StubCompiler { | 833 class BaseStoreStubCompiler: public BaseLoadStoreStubCompiler { |
817 public: | 834 public: |
818 BaseStoreStubCompiler(Isolate* isolate, | 835 BaseStoreStubCompiler(Isolate* isolate, |
819 StrictModeFlag strict_mode, | 836 StrictModeFlag strict_mode, |
820 Register* registers) | 837 Register* registers) |
821 : StubCompiler(isolate), | 838 : BaseLoadStoreStubCompiler(isolate, registers), |
822 strict_mode_(strict_mode), | 839 strict_mode_(strict_mode) { } |
823 registers_(registers) { } | |
824 | 840 |
825 virtual ~BaseStoreStubCompiler() { } | 841 virtual ~BaseStoreStubCompiler() { } |
826 | 842 |
827 Handle<Code> CompileStoreTransition(Handle<JSObject> object, | 843 Handle<Code> CompileStoreTransition(Handle<JSObject> object, |
828 LookupResult* lookup, | 844 LookupResult* lookup, |
829 Handle<Map> transition, | 845 Handle<Map> transition, |
830 Handle<Name> name); | 846 Handle<Name> name); |
831 | 847 |
832 Handle<Code> CompileStoreField(Handle<JSObject> object, | 848 Handle<Code> CompileStoreField(Handle<JSObject> object, |
833 LookupResult* lookup, | 849 LookupResult* lookup, |
834 Handle<Name> name); | 850 Handle<Name> name); |
835 | 851 |
| 852 void GenerateNegativeHolderLookup(MacroAssembler* masm, |
| 853 Handle<JSObject> holder, |
| 854 Register holder_reg, |
| 855 Handle<Name> name, |
| 856 Label* miss); |
| 857 |
| 858 void GenerateStoreTransition(MacroAssembler* masm, |
| 859 Handle<JSObject> object, |
| 860 LookupResult* lookup, |
| 861 Handle<Map> transition, |
| 862 Handle<Name> name, |
| 863 Register receiver_reg, |
| 864 Register name_reg, |
| 865 Register value_reg, |
| 866 Register scratch1, |
| 867 Register scratch2, |
| 868 Register scratch3, |
| 869 Label* miss_label, |
| 870 Label* slow); |
| 871 |
| 872 void GenerateStoreField(MacroAssembler* masm, |
| 873 Handle<JSObject> object, |
| 874 LookupResult* lookup, |
| 875 Register receiver_reg, |
| 876 Register name_reg, |
| 877 Register value_reg, |
| 878 Register scratch1, |
| 879 Register scratch2, |
| 880 Label* miss_label); |
| 881 |
| 882 static Builtins::Name MissBuiltin(Code::Kind kind) { |
| 883 switch (kind) { |
| 884 case Code::LOAD_IC: return Builtins::kLoadIC_Miss; |
| 885 case Code::STORE_IC: return Builtins::kStoreIC_Miss; |
| 886 case Code::KEYED_LOAD_IC: return Builtins::kKeyedLoadIC_Miss; |
| 887 case Code::KEYED_STORE_IC: return Builtins::kKeyedStoreIC_Miss; |
| 888 default: UNREACHABLE(); |
| 889 } |
| 890 return Builtins::kLoadIC_Miss; |
| 891 } |
| 892 static Builtins::Name SlowBuiltin(Code::Kind kind) { |
| 893 switch (kind) { |
| 894 case Code::STORE_IC: return Builtins::kStoreIC_Slow; |
| 895 case Code::KEYED_STORE_IC: return Builtins::kKeyedStoreIC_Slow; |
| 896 default: UNREACHABLE(); |
| 897 } |
| 898 return Builtins::kStoreIC_Slow; |
| 899 } |
| 900 |
836 protected: | 901 protected: |
837 Handle<Code> GetICCode(Code::Kind kind, | 902 virtual Register HandlerFrontendHeader(Handle<JSObject> object, |
838 Code::StubType type, | 903 Register object_reg, |
839 Handle<Name> name, | 904 Handle<JSObject> holder, |
840 InlineCacheState state = MONOMORPHIC); | 905 Handle<Name> name, |
| 906 Label* miss); |
841 | 907 |
| 908 virtual void HandlerFrontendFooter(Handle<Name> name, |
| 909 Label* success, |
| 910 Label* miss); |
842 Handle<Code> GetCode(Code::Kind kind, | 911 Handle<Code> GetCode(Code::Kind kind, |
843 Code::StubType type, | 912 Code::StubType type, |
844 Handle<Name> name); | 913 Handle<Name> name); |
845 | 914 |
846 void GenerateRestoreName(MacroAssembler* masm, | 915 void GenerateRestoreName(MacroAssembler* masm, |
847 Label* label, | 916 Label* label, |
848 Handle<Name> name); | 917 Handle<Name> name); |
849 | 918 |
850 Register receiver() { return registers_[0]; } | 919 virtual Register receiver() { return registers_[0]; } |
851 Register name() { return registers_[1]; } | 920 virtual Register name() { return registers_[1]; } |
852 Register value() { return registers_[2]; } | 921 Register value() { return registers_[2]; } |
853 Register scratch1() { return registers_[3]; } | 922 virtual Register scratch1() { return registers_[3]; } |
854 Register scratch2() { return registers_[4]; } | 923 virtual Register scratch2() { return registers_[4]; } |
855 Register scratch3() { return registers_[5]; } | 924 virtual Register scratch3() { return registers_[5]; } |
856 StrictModeFlag strict_mode() { return strict_mode_; } | 925 StrictModeFlag strict_mode() { return strict_mode_; } |
857 virtual Code::ExtraICState extra_state() { return strict_mode_; } | 926 virtual Code::ExtraICState extra_state() { return strict_mode_; } |
858 | 927 |
859 private: | 928 private: |
860 virtual Code::Kind kind() = 0; | |
861 virtual Logger::LogEventsAndTags log_kind(Handle<Code> code) = 0; | |
862 virtual void JitEvent(Handle<Name> name, Handle<Code> code) = 0; | |
863 virtual void GenerateNameCheck(Handle<Name> name, | |
864 Register name_reg, | |
865 Label* miss) { } | |
866 StrictModeFlag strict_mode_; | 929 StrictModeFlag strict_mode_; |
867 Register* registers_; | |
868 }; | 930 }; |
869 | 931 |
870 | 932 |
871 class StoreStubCompiler: public BaseStoreStubCompiler { | 933 class StoreStubCompiler: public BaseStoreStubCompiler { |
872 public: | 934 public: |
873 StoreStubCompiler(Isolate* isolate, StrictModeFlag strict_mode) | 935 StoreStubCompiler(Isolate* isolate, StrictModeFlag strict_mode) |
874 : BaseStoreStubCompiler(isolate, strict_mode, registers()) { } | 936 : BaseStoreStubCompiler(isolate, strict_mode, registers()) { } |
875 | 937 |
876 | 938 |
877 Handle<Code> CompileStoreCallback(Handle<Name> name, | 939 Handle<Code> CompileStoreCallback(Handle<JSObject> object, |
878 Handle<JSObject> object, | |
879 Handle<JSObject> holder, | 940 Handle<JSObject> holder, |
| 941 Handle<Name> name, |
880 Handle<ExecutableAccessorInfo> callback); | 942 Handle<ExecutableAccessorInfo> callback); |
881 | 943 |
882 static void GenerateStoreViaSetter(MacroAssembler* masm, | 944 static void GenerateStoreViaSetter(MacroAssembler* masm, |
883 Handle<JSFunction> setter); | 945 Handle<JSFunction> setter); |
884 | 946 |
885 Handle<Code> CompileStoreViaSetter(Handle<Name> name, | 947 Handle<Code> CompileStoreViaSetter(Handle<JSObject> object, |
886 Handle<JSObject> object, | |
887 Handle<JSObject> holder, | 948 Handle<JSObject> holder, |
| 949 Handle<Name> name, |
888 Handle<JSFunction> setter); | 950 Handle<JSFunction> setter); |
889 | 951 |
890 Handle<Code> CompileStoreInterceptor(Handle<JSObject> object, | 952 Handle<Code> CompileStoreInterceptor(Handle<JSObject> object, |
891 Handle<Name> name); | 953 Handle<Name> name); |
892 | 954 |
893 Handle<Code> CompileStoreGlobal(Handle<GlobalObject> object, | 955 Handle<Code> CompileStoreGlobal(Handle<GlobalObject> object, |
894 Handle<PropertyCell> holder, | 956 Handle<PropertyCell> holder, |
895 Handle<Name> name); | 957 Handle<Name> name); |
896 | 958 |
897 private: | 959 private: |
(...skipping 223 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1121 Handle<JSFunction> constant_function_; | 1183 Handle<JSFunction> constant_function_; |
1122 bool is_simple_api_call_; | 1184 bool is_simple_api_call_; |
1123 Handle<FunctionTemplateInfo> expected_receiver_type_; | 1185 Handle<FunctionTemplateInfo> expected_receiver_type_; |
1124 Handle<CallHandlerInfo> api_call_info_; | 1186 Handle<CallHandlerInfo> api_call_info_; |
1125 }; | 1187 }; |
1126 | 1188 |
1127 | 1189 |
1128 } } // namespace v8::internal | 1190 } } // namespace v8::internal |
1129 | 1191 |
1130 #endif // V8_STUB_CACHE_H_ | 1192 #endif // V8_STUB_CACHE_H_ |
OLD | NEW |