Revision f230a1cf deps/v8/src/stub-cache.h
| deps/v8/src/stub-cache.h | ||
|---|---|---|
| 83 | 83 |
Handle<Code> FindIC(Handle<Name> name, |
| 84 | 84 |
Handle<Map> stub_holder_map, |
| 85 | 85 |
Code::Kind kind, |
| 86 |
Code::StubType type, |
|
| 87 | 86 |
Code::ExtraICState extra_state = Code::kNoExtraICState); |
| 88 | 87 |
|
| 89 | 88 |
Handle<Code> FindIC(Handle<Name> name, |
| 90 | 89 |
Handle<JSObject> stub_holder, |
| 91 | 90 |
Code::Kind kind, |
| 92 |
Code::StubType type, |
|
| 93 | 91 |
Code::ExtraICState extra_state = Code::kNoExtraICState); |
| 94 | 92 |
|
| 95 |
Handle<Code> FindLoadHandler(Handle<Name> name, |
|
| 96 |
Handle<JSObject> receiver, |
|
| 97 |
Handle<JSObject> stub_holder, |
|
| 98 |
Code::Kind kind, |
|
| 99 |
Code::StubType type); |
|
| 100 |
|
|
| 101 |
Handle<Code> FindStoreHandler(Handle<Name> name, |
|
| 102 |
Handle<JSObject> receiver, |
|
| 103 |
Code::Kind kind, |
|
| 104 |
Code::StubType type, |
|
| 105 |
StrictModeFlag strict_mode); |
|
| 106 |
|
|
| 107 |
Handle<Code> ComputeMonomorphicLoadIC(Handle<HeapObject> receiver, |
|
| 108 |
Handle<Code> handler, |
|
| 109 |
Handle<Name> name); |
|
| 110 |
|
|
| 111 |
Handle<Code> ComputeMonomorphicKeyedLoadIC(Handle<HeapObject> receiver, |
|
| 112 |
Handle<Code> handler, |
|
| 113 |
Handle<Name> name); |
|
| 93 |
Handle<Code> FindHandler(Handle<Name> name, |
|
| 94 |
Handle<JSObject> receiver, |
|
| 95 |
Code::Kind kind, |
|
| 96 |
StrictModeFlag strict_mode = kNonStrictMode); |
|
| 114 | 97 |
|
| 115 |
Handle<Code> ComputeMonomorphicStoreIC(Handle<HeapObject> receiver, |
|
| 116 |
Handle<Code> handler, |
|
| 117 |
Handle<Name> name, |
|
| 118 |
StrictModeFlag strict_mode); |
|
| 119 |
|
|
| 120 |
Handle<Code> ComputeMonomorphicKeyedStoreIC(Handle<HeapObject> receiver, |
|
| 121 |
Handle<Code> handler, |
|
| 122 |
Handle<Name> name, |
|
| 123 |
StrictModeFlag strict_mode); |
|
| 98 |
Handle<Code> ComputeMonomorphicIC(Handle<HeapObject> receiver, |
|
| 99 |
Handle<Code> handler, |
|
| 100 |
Handle<Name> name, |
|
| 101 |
StrictModeFlag strict_mode); |
|
| 124 | 102 |
|
| 125 | 103 |
// Computes the right stub matching. Inserts the result in the |
| 126 | 104 |
// cache before returning. This might compile a stub if needed. |
| 127 | 105 |
Handle<Code> ComputeLoadNonexistent(Handle<Name> name, |
| 128 | 106 |
Handle<JSObject> object); |
| 129 | 107 |
|
| 130 |
Handle<Code> ComputeLoadField(Handle<Name> name, |
|
| 131 |
Handle<JSObject> object, |
|
| 132 |
Handle<JSObject> holder, |
|
| 133 |
PropertyIndex field_index, |
|
| 134 |
Representation representation); |
|
| 135 |
|
|
| 136 |
Handle<Code> ComputeLoadCallback(Handle<Name> name, |
|
| 137 |
Handle<JSObject> object, |
|
| 138 |
Handle<JSObject> holder, |
|
| 139 |
Handle<ExecutableAccessorInfo> callback); |
|
| 140 |
|
|
| 141 |
Handle<Code> ComputeLoadCallback(Handle<Name> name, |
|
| 142 |
Handle<JSObject> object, |
|
| 143 |
Handle<JSObject> holder, |
|
| 144 |
const CallOptimization& call_optimization); |
|
| 145 |
|
|
| 146 |
Handle<Code> ComputeLoadViaGetter(Handle<Name> name, |
|
| 147 |
Handle<JSObject> object, |
|
| 148 |
Handle<JSObject> holder, |
|
| 149 |
Handle<JSFunction> getter); |
|
| 150 |
|
|
| 151 |
Handle<Code> ComputeLoadConstant(Handle<Name> name, |
|
| 152 |
Handle<JSObject> object, |
|
| 153 |
Handle<JSObject> holder, |
|
| 154 |
Handle<Object> value); |
|
| 155 |
|
|
| 156 |
Handle<Code> ComputeLoadInterceptor(Handle<Name> name, |
|
| 157 |
Handle<JSObject> object, |
|
| 158 |
Handle<JSObject> holder); |
|
| 159 |
|
|
| 160 |
Handle<Code> ComputeLoadNormal(Handle<Name> name, |
|
| 161 |
Handle<JSObject> object); |
|
| 162 |
|
|
| 163 | 108 |
Handle<Code> ComputeLoadGlobal(Handle<Name> name, |
| 164 | 109 |
Handle<JSObject> object, |
| 165 | 110 |
Handle<GlobalObject> holder, |
| ... | ... | |
| 195 | 140 |
Handle<JSObject> object, |
| 196 | 141 |
Handle<JSObject> holder); |
| 197 | 142 |
|
| 198 |
// --- |
|
| 199 |
|
|
| 200 |
Handle<Code> ComputeStoreField(Handle<Name> name, |
|
| 201 |
Handle<JSObject> object, |
|
| 202 |
LookupResult* lookup, |
|
| 203 |
StrictModeFlag strict_mode); |
|
| 204 |
|
|
| 205 |
Handle<Code> ComputeStoreTransition(Handle<Name> name, |
|
| 206 |
Handle<JSObject> object, |
|
| 207 |
LookupResult* lookup, |
|
| 208 |
Handle<Map> transition, |
|
| 209 |
StrictModeFlag strict_mode); |
|
| 210 |
|
|
| 211 |
Handle<Code> ComputeStoreNormal(StrictModeFlag strict_mode); |
|
| 212 |
|
|
| 213 | 143 |
Handle<Code> ComputeStoreGlobal(Handle<Name> name, |
| 214 | 144 |
Handle<GlobalObject> object, |
| 215 | 145 |
Handle<PropertyCell> cell, |
| 216 | 146 |
Handle<Object> value, |
| 217 | 147 |
StrictModeFlag strict_mode); |
| 218 | 148 |
|
| 219 |
Handle<Code> ComputeStoreCallback(Handle<Name> name, |
|
| 220 |
Handle<JSObject> object, |
|
| 221 |
Handle<JSObject> holder, |
|
| 222 |
Handle<ExecutableAccessorInfo> callback, |
|
| 223 |
StrictModeFlag strict_mode); |
|
| 224 |
|
|
| 225 |
Handle<Code> ComputeStoreCallback(Handle<Name> name, |
|
| 226 |
Handle<JSObject> object, |
|
| 227 |
Handle<JSObject> holder, |
|
| 228 |
const CallOptimization& call_optimation, |
|
| 229 |
StrictModeFlag strict_mode); |
|
| 230 |
|
|
| 231 |
Handle<Code> ComputeStoreViaSetter(Handle<Name> name, |
|
| 232 |
Handle<JSObject> object, |
|
| 233 |
Handle<JSObject> holder, |
|
| 234 |
Handle<JSFunction> setter, |
|
| 235 |
StrictModeFlag strict_mode); |
|
| 236 |
|
|
| 237 |
Handle<Code> ComputeStoreInterceptor(Handle<Name> name, |
|
| 238 |
Handle<JSObject> object, |
|
| 239 |
StrictModeFlag strict_mode); |
|
| 240 |
|
|
| 241 |
// --- |
|
| 242 |
|
|
| 243 |
Handle<Code> ComputeKeyedStoreField(Handle<Name> name, |
|
| 244 |
Handle<JSObject> object, |
|
| 245 |
LookupResult* lookup, |
|
| 246 |
StrictModeFlag strict_mode); |
|
| 247 |
Handle<Code> ComputeKeyedStoreTransition(Handle<Name> name, |
|
| 248 |
Handle<JSObject> object, |
|
| 249 |
LookupResult* lookup, |
|
| 250 |
Handle<Map> transition, |
|
| 251 |
StrictModeFlag strict_mode); |
|
| 252 |
|
|
| 253 | 149 |
Handle<Code> ComputeKeyedLoadElement(Handle<Map> receiver_map); |
| 254 | 150 |
|
| 255 | 151 |
Handle<Code> ComputeKeyedStoreElement(Handle<Map> receiver_map, |
| 256 | 152 |
StrictModeFlag strict_mode, |
| 257 | 153 |
KeyedAccessStoreMode store_mode); |
| 258 | 154 |
|
| 259 |
// --- |
|
| 260 |
|
|
| 261 | 155 |
Handle<Code> ComputeCallField(int argc, |
| 262 | 156 |
Code::Kind, |
| 263 | 157 |
Code::ExtraICState extra_state, |
| ... | ... | |
| 326 | 220 |
KeyedAccessStoreMode store_mode, |
| 327 | 221 |
StrictModeFlag strict_mode); |
| 328 | 222 |
|
| 329 |
Handle<Code> ComputePolymorphicLoadIC(MapHandleList* receiver_maps, |
|
| 330 |
CodeHandleList* handlers, |
|
| 331 |
int number_of_valid_maps, |
|
| 332 |
Handle<Name> name); |
|
| 333 |
|
|
| 334 |
Handle<Code> ComputePolymorphicStoreIC(MapHandleList* receiver_maps, |
|
| 335 |
CodeHandleList* handlers, |
|
| 336 |
int number_of_valid_maps, |
|
| 337 |
Handle<Name> name, |
|
| 338 |
StrictModeFlag strict_mode); |
|
| 223 |
Handle<Code> ComputePolymorphicIC(MapHandleList* receiver_maps, |
|
| 224 |
CodeHandleList* handlers, |
|
| 225 |
int number_of_valid_maps, |
|
| 226 |
Handle<Name> name, |
|
| 227 |
StrictModeFlag strict_mode); |
|
| 339 | 228 |
|
| 340 | 229 |
// Finds the Code object stored in the Heap::non_monomorphic_cache(). |
| 341 | 230 |
Code* FindCallInitialize(int argc, RelocInfo::Mode mode, Code::Kind kind); |
| ... | ... | |
| 572 | 461 |
Register receiver, |
| 573 | 462 |
Register scratch1, |
| 574 | 463 |
Register scratch2, |
| 575 |
Label* miss_label, |
|
| 576 |
bool support_wrappers); |
|
| 464 |
Label* miss_label); |
|
| 577 | 465 |
|
| 578 | 466 |
static void GenerateLoadFunctionPrototype(MacroAssembler* masm, |
| 579 | 467 |
Register receiver, |
| ... | ... | |
| 652 | 540 |
|
| 653 | 541 |
class BaseLoadStoreStubCompiler: public StubCompiler {
|
| 654 | 542 |
public: |
| 655 |
BaseLoadStoreStubCompiler(Isolate* isolate, Register* registers) |
|
| 656 |
: StubCompiler(isolate), registers_(registers) { }
|
|
| 543 |
BaseLoadStoreStubCompiler(Isolate* isolate, Code::Kind kind) |
|
| 544 |
: StubCompiler(isolate), kind_(kind) {
|
|
| 545 |
InitializeRegisters(); |
|
| 546 |
} |
|
| 657 | 547 |
virtual ~BaseLoadStoreStubCompiler() { }
|
| 658 | 548 |
|
| 659 | 549 |
Handle<Code> CompileMonomorphicIC(Handle<Map> receiver_map, |
| ... | ... | |
| 698 | 588 |
Handle<Name> name, |
| 699 | 589 |
Label* success); |
| 700 | 590 |
|
| 591 |
Handle<Code> GetCode(Code::Kind kind, |
|
| 592 |
Code::StubType type, |
|
| 593 |
Handle<Name> name); |
|
| 594 |
|
|
| 701 | 595 |
Handle<Code> GetICCode(Code::Kind kind, |
| 702 | 596 |
Code::StubType type, |
| 703 | 597 |
Handle<Name> name, |
| 704 | 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); |
|
| 705 | 618 |
|
| 706 | 619 |
virtual Code::ExtraICState extra_state() { return Code::kNoExtraICState; }
|
| 707 |
virtual Logger::LogEventsAndTags log_kind(Handle<Code> code) = 0; |
|
| 708 |
virtual void JitEvent(Handle<Name> name, Handle<Code> code) = 0; |
|
| 709 |
virtual Code::Kind kind() = 0; |
|
| 710 | 620 |
virtual Register receiver() = 0; |
| 711 | 621 |
virtual Register name() = 0; |
| 712 | 622 |
virtual Register scratch1() = 0; |
| 713 | 623 |
virtual Register scratch2() = 0; |
| 714 | 624 |
virtual Register scratch3() = 0; |
| 715 | 625 |
|
| 626 |
void InitializeRegisters(); |
|
| 627 |
|
|
| 628 |
Code::Kind kind_; |
|
| 716 | 629 |
Register* registers_; |
| 717 | 630 |
}; |
| 718 | 631 |
|
| 719 | 632 |
|
| 720 |
class BaseLoadStubCompiler: public BaseLoadStoreStubCompiler {
|
|
| 633 |
class LoadStubCompiler: public BaseLoadStoreStubCompiler {
|
|
| 721 | 634 |
public: |
| 722 |
BaseLoadStubCompiler(Isolate* isolate, Register* registers)
|
|
| 723 |
: BaseLoadStoreStubCompiler(isolate, registers) { }
|
|
| 724 |
virtual ~BaseLoadStubCompiler() { }
|
|
| 635 |
LoadStubCompiler(Isolate* isolate, Code::Kind kind = Code::LOAD_IC)
|
|
| 636 |
: BaseLoadStoreStubCompiler(isolate, kind) { }
|
|
| 637 |
virtual ~LoadStubCompiler() { }
|
|
| 725 | 638 |
|
| 726 | 639 |
Handle<Code> CompileLoadField(Handle<JSObject> object, |
| 727 | 640 |
Handle<JSObject> holder, |
| ... | ... | |
| 748 | 661 |
Handle<JSObject> holder, |
| 749 | 662 |
Handle<Name> name); |
| 750 | 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 |
|
|
| 751 | 686 |
protected: |
| 752 | 687 |
virtual Register HandlerFrontendHeader(Handle<JSObject> object, |
| 753 | 688 |
Register object_reg, |
| ... | ... | |
| 789 | 724 |
Handle<Name> name, |
| 790 | 725 |
LookupResult* lookup); |
| 791 | 726 |
|
| 792 |
Handle<Code> GetCode(Code::Kind kind, |
|
| 793 |
Code::StubType type, |
|
| 794 |
Handle<Name> name); |
|
| 795 |
|
|
| 796 | 727 |
virtual Register receiver() { return registers_[0]; }
|
| 797 | 728 |
virtual Register name() { return registers_[1]; }
|
| 798 | 729 |
virtual Register scratch1() { return registers_[2]; }
|
| ... | ... | |
| 802 | 733 |
}; |
| 803 | 734 |
|
| 804 | 735 |
|
| 805 |
class LoadStubCompiler: public BaseLoadStubCompiler {
|
|
| 806 |
public: |
|
| 807 |
explicit LoadStubCompiler(Isolate* isolate) |
|
| 808 |
: BaseLoadStubCompiler(isolate, registers()) { }
|
|
| 809 |
|
|
| 810 |
Handle<Code> CompileLoadNonexistent(Handle<JSObject> object, |
|
| 811 |
Handle<JSObject> last, |
|
| 812 |
Handle<Name> name, |
|
| 813 |
Handle<GlobalObject> global); |
|
| 814 |
|
|
| 815 |
static void GenerateLoadViaGetter(MacroAssembler* masm, |
|
| 816 |
Handle<JSFunction> getter); |
|
| 817 |
|
|
| 818 |
Handle<Code> CompileLoadViaGetter(Handle<JSObject> object, |
|
| 819 |
Handle<JSObject> holder, |
|
| 820 |
Handle<Name> name, |
|
| 821 |
Handle<JSFunction> getter); |
|
| 822 |
|
|
| 823 |
Handle<Code> CompileLoadGlobal(Handle<JSObject> object, |
|
| 824 |
Handle<GlobalObject> holder, |
|
| 825 |
Handle<PropertyCell> cell, |
|
| 826 |
Handle<Name> name, |
|
| 827 |
bool is_dont_delete); |
|
| 828 |
|
|
| 829 |
private: |
|
| 830 |
static Register* registers(); |
|
| 831 |
virtual Code::Kind kind() { return Code::LOAD_IC; }
|
|
| 832 |
virtual Logger::LogEventsAndTags log_kind(Handle<Code> code) {
|
|
| 833 |
if (!code->is_inline_cache_stub()) return Logger::STUB_TAG; |
|
| 834 |
return code->ic_state() == MONOMORPHIC |
|
| 835 |
? Logger::LOAD_IC_TAG : Logger::LOAD_POLYMORPHIC_IC_TAG; |
|
| 836 |
} |
|
| 837 |
virtual void JitEvent(Handle<Name> name, Handle<Code> code); |
|
| 838 |
}; |
|
| 839 |
|
|
| 840 |
|
|
| 841 |
class KeyedLoadStubCompiler: public BaseLoadStubCompiler {
|
|
| 736 |
class KeyedLoadStubCompiler: public LoadStubCompiler {
|
|
| 842 | 737 |
public: |
| 843 | 738 |
explicit KeyedLoadStubCompiler(Isolate* isolate) |
| 844 |
: BaseLoadStubCompiler(isolate, registers()) { }
|
|
| 739 |
: LoadStubCompiler(isolate, Code::KEYED_LOAD_IC) { }
|
|
| 845 | 740 |
|
| 846 | 741 |
Handle<Code> CompileLoadElement(Handle<Map> receiver_map); |
| 847 | 742 |
|
| ... | ... | |
| 850 | 745 |
|
| 851 | 746 |
static void GenerateLoadDictionaryElement(MacroAssembler* masm); |
| 852 | 747 |
|
| 853 |
private:
|
|
| 748 |
protected:
|
|
| 854 | 749 |
static Register* registers(); |
| 855 |
virtual Code::Kind kind() { return Code::KEYED_LOAD_IC; }
|
|
| 856 |
virtual Logger::LogEventsAndTags log_kind(Handle<Code> code) {
|
|
| 857 |
if (!code->is_inline_cache_stub()) return Logger::STUB_TAG; |
|
| 858 |
return code->ic_state() == MONOMORPHIC |
|
| 859 |
? Logger::KEYED_LOAD_IC_TAG : Logger::KEYED_LOAD_POLYMORPHIC_IC_TAG; |
|
| 860 |
} |
|
| 861 |
virtual void JitEvent(Handle<Name> name, Handle<Code> code); |
|
| 750 |
|
|
| 751 |
private: |
|
| 862 | 752 |
virtual void GenerateNameCheck(Handle<Name> name, |
| 863 | 753 |
Register name_reg, |
| 864 | 754 |
Label* miss); |
| 755 |
friend class BaseLoadStoreStubCompiler; |
|
| 865 | 756 |
}; |
| 866 | 757 |
|
| 867 | 758 |
|
| 868 |
class BaseStoreStubCompiler: public BaseLoadStoreStubCompiler {
|
|
| 759 |
class StoreStubCompiler: public BaseLoadStoreStubCompiler {
|
|
| 869 | 760 |
public: |
| 870 |
BaseStoreStubCompiler(Isolate* isolate,
|
|
| 871 |
StrictModeFlag strict_mode,
|
|
| 872 |
Register* registers)
|
|
| 873 |
: BaseLoadStoreStubCompiler(isolate, registers),
|
|
| 761 |
StoreStubCompiler(Isolate* isolate, |
|
| 762 |
StrictModeFlag strict_mode, |
|
| 763 |
Code::Kind kind = Code::STORE_IC)
|
|
| 764 |
: BaseLoadStoreStubCompiler(isolate, kind),
|
|
| 874 | 765 |
strict_mode_(strict_mode) { }
|
| 875 | 766 |
|
| 876 |
virtual ~BaseStoreStubCompiler() { }
|
|
| 767 |
virtual ~StoreStubCompiler() { }
|
|
| 877 | 768 |
|
| 878 | 769 |
Handle<Code> CompileStoreTransition(Handle<JSObject> object, |
| 879 | 770 |
LookupResult* lookup, |
| ... | ... | |
| 914 | 805 |
Register scratch2, |
| 915 | 806 |
Label* miss_label); |
| 916 | 807 |
|
| 917 |
static Builtins::Name MissBuiltin(Code::Kind kind) {
|
|
| 918 |
switch (kind) {
|
|
| 919 |
case Code::LOAD_IC: return Builtins::kLoadIC_Miss; |
|
| 920 |
case Code::STORE_IC: return Builtins::kStoreIC_Miss; |
|
| 921 |
case Code::KEYED_LOAD_IC: return Builtins::kKeyedLoadIC_Miss; |
|
| 922 |
case Code::KEYED_STORE_IC: return Builtins::kKeyedStoreIC_Miss; |
|
| 923 |
default: UNREACHABLE(); |
|
| 924 |
} |
|
| 925 |
return Builtins::kLoadIC_Miss; |
|
| 926 |
} |
|
| 808 |
Handle<Code> CompileStoreCallback(Handle<JSObject> object, |
|
| 809 |
Handle<JSObject> holder, |
|
| 810 |
Handle<Name> name, |
|
| 811 |
Handle<ExecutableAccessorInfo> callback); |
|
| 812 |
|
|
| 813 |
Handle<Code> CompileStoreCallback(Handle<JSObject> object, |
|
| 814 |
Handle<JSObject> holder, |
|
| 815 |
Handle<Name> name, |
|
| 816 |
const CallOptimization& call_optimization); |
|
| 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 |
|
|
| 927 | 829 |
static Builtins::Name SlowBuiltin(Code::Kind kind) {
|
| 928 | 830 |
switch (kind) {
|
| 929 | 831 |
case Code::STORE_IC: return Builtins::kStoreIC_Slow; |
| ... | ... | |
| 943 | 845 |
virtual void HandlerFrontendFooter(Handle<Name> name, |
| 944 | 846 |
Label* success, |
| 945 | 847 |
Label* miss); |
| 946 |
Handle<Code> GetCode(Code::Kind kind, |
|
| 947 |
Code::StubType type, |
|
| 948 |
Handle<Name> name); |
|
| 949 |
|
|
| 950 | 848 |
void GenerateRestoreName(MacroAssembler* masm, |
| 951 | 849 |
Label* label, |
| 952 | 850 |
Handle<Name> name); |
| ... | ... | |
| 960 | 858 |
StrictModeFlag strict_mode() { return strict_mode_; }
|
| 961 | 859 |
virtual Code::ExtraICState extra_state() { return strict_mode_; }
|
| 962 | 860 |
|
| 963 |
private: |
|
| 964 |
StrictModeFlag strict_mode_; |
|
| 965 |
}; |
|
| 966 |
|
|
| 967 |
|
|
| 968 |
class StoreStubCompiler: public BaseStoreStubCompiler {
|
|
| 969 |
public: |
|
| 970 |
StoreStubCompiler(Isolate* isolate, StrictModeFlag strict_mode) |
|
| 971 |
: BaseStoreStubCompiler(isolate, strict_mode, registers()) { }
|
|
| 972 |
|
|
| 973 |
|
|
| 974 |
Handle<Code> CompileStoreCallback(Handle<JSObject> object, |
|
| 975 |
Handle<JSObject> holder, |
|
| 976 |
Handle<Name> name, |
|
| 977 |
Handle<ExecutableAccessorInfo> callback); |
|
| 978 |
|
|
| 979 |
Handle<Code> CompileStoreCallback(Handle<JSObject> object, |
|
| 980 |
Handle<JSObject> holder, |
|
| 981 |
Handle<Name> name, |
|
| 982 |
const CallOptimization& call_optimization); |
|
| 983 |
|
|
| 984 |
static void GenerateStoreViaSetter(MacroAssembler* masm, |
|
| 985 |
Handle<JSFunction> setter); |
|
| 986 |
|
|
| 987 |
Handle<Code> CompileStoreViaSetter(Handle<JSObject> object, |
|
| 988 |
Handle<JSObject> holder, |
|
| 989 |
Handle<Name> name, |
|
| 990 |
Handle<JSFunction> setter); |
|
| 991 |
|
|
| 992 |
Handle<Code> CompileStoreInterceptor(Handle<JSObject> object, |
|
| 993 |
Handle<Name> name); |
|
| 861 |
protected: |
|
| 862 |
static Register* registers(); |
|
| 994 | 863 |
|
| 995 | 864 |
private: |
| 996 |
static Register* registers(); |
|
| 997 |
virtual Code::Kind kind() { return Code::STORE_IC; }
|
|
| 998 |
virtual Logger::LogEventsAndTags log_kind(Handle<Code> code) {
|
|
| 999 |
if (!code->is_inline_cache_stub()) return Logger::STUB_TAG; |
|
| 1000 |
return code->ic_state() == MONOMORPHIC |
|
| 1001 |
? Logger::STORE_IC_TAG : Logger::STORE_POLYMORPHIC_IC_TAG; |
|
| 1002 |
} |
|
| 1003 |
virtual void JitEvent(Handle<Name> name, Handle<Code> code); |
|
| 865 |
StrictModeFlag strict_mode_; |
|
| 866 |
friend class BaseLoadStoreStubCompiler; |
|
| 1004 | 867 |
}; |
| 1005 | 868 |
|
| 1006 | 869 |
|
| 1007 |
class KeyedStoreStubCompiler: public BaseStoreStubCompiler {
|
|
| 870 |
class KeyedStoreStubCompiler: public StoreStubCompiler {
|
|
| 1008 | 871 |
public: |
| 1009 | 872 |
KeyedStoreStubCompiler(Isolate* isolate, |
| 1010 | 873 |
StrictModeFlag strict_mode, |
| 1011 | 874 |
KeyedAccessStoreMode store_mode) |
| 1012 |
: BaseStoreStubCompiler(isolate, strict_mode, registers()),
|
|
| 875 |
: StoreStubCompiler(isolate, strict_mode, Code::KEYED_STORE_IC),
|
|
| 1013 | 876 |
store_mode_(store_mode) { }
|
| 1014 | 877 |
|
| 1015 | 878 |
Handle<Code> CompileStoreElement(Handle<Map> receiver_map); |
| ... | ... | |
| 1026 | 889 |
virtual Code::ExtraICState extra_state() {
|
| 1027 | 890 |
return Code::ComputeExtraICState(store_mode_, strict_mode()); |
| 1028 | 891 |
} |
| 892 |
static Register* registers(); |
|
| 1029 | 893 |
|
| 1030 | 894 |
private: |
| 1031 | 895 |
Register transition_map() {
|
| 1032 | 896 |
return registers()[3]; |
| 1033 | 897 |
} |
| 1034 | 898 |
|
| 1035 |
static Register* registers(); |
|
| 1036 |
virtual Code::Kind kind() { return Code::KEYED_STORE_IC; }
|
|
| 1037 |
virtual Logger::LogEventsAndTags log_kind(Handle<Code> code) {
|
|
| 1038 |
if (!code->is_inline_cache_stub()) return Logger::STUB_TAG; |
|
| 1039 |
return code->ic_state() == MONOMORPHIC |
|
| 1040 |
? Logger::KEYED_STORE_IC_TAG : Logger::KEYED_STORE_POLYMORPHIC_IC_TAG; |
|
| 1041 |
} |
|
| 1042 |
virtual void JitEvent(Handle<Name> name, Handle<Code> code); |
|
| 1043 | 899 |
virtual void GenerateNameCheck(Handle<Name> name, |
| 1044 | 900 |
Register name_reg, |
| 1045 | 901 |
Label* miss); |
| 1046 | 902 |
KeyedAccessStoreMode store_mode_; |
| 903 |
friend class BaseLoadStoreStubCompiler; |
|
| 1047 | 904 |
}; |
| 1048 | 905 |
|
| 1049 | 906 |
|
| ... | ... | |
| 1070 | 927 |
int argc, |
| 1071 | 928 |
Code::Kind kind, |
| 1072 | 929 |
Code::ExtraICState extra_state, |
| 1073 |
InlineCacheHolderFlag cache_holder); |
|
| 930 |
InlineCacheHolderFlag cache_holder = OWN_MAP);
|
|
| 1074 | 931 |
|
| 1075 | 932 |
Handle<Code> CompileCallField(Handle<JSObject> object, |
| 1076 | 933 |
Handle<JSObject> holder, |
Also available in: Unified diff