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 156 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
167 Handle<Object> key); | 167 Handle<Object> key); |
168 Failure* ReferenceError(const char* type, Handle<String> name); | 168 Failure* ReferenceError(const char* type, Handle<String> name); |
169 | 169 |
170 // Access the target code for the given IC address. | 170 // Access the target code for the given IC address. |
171 static inline Code* GetTargetAtAddress(Address address); | 171 static inline Code* GetTargetAtAddress(Address address); |
172 static inline void SetTargetAtAddress(Address address, Code* target); | 172 static inline void SetTargetAtAddress(Address address, Code* target); |
173 static void PostPatching(Address address, Code* target, Code* old_target); | 173 static void PostPatching(Address address, Code* target, Code* old_target); |
174 | 174 |
175 void UpdateMonomorphicIC(Handle<HeapObject> receiver, | 175 void UpdateMonomorphicIC(Handle<HeapObject> receiver, |
176 Handle<Code> handler, | 176 Handle<Code> handler, |
177 Handle<String> name, | 177 Handle<String> name); |
178 StrictModeFlag strict_mode); | |
179 | 178 |
180 bool UpdatePolymorphicIC(State state, | 179 bool UpdatePolymorphicIC(State state, |
181 Handle<HeapObject> receiver, | 180 Handle<HeapObject> receiver, |
182 Handle<String> name, | 181 Handle<String> name, |
183 Handle<Code> code, | 182 Handle<Code> code); |
184 StrictModeFlag strict_mode); | |
185 | 183 |
186 void CopyICToMegamorphicCache(Handle<String> name); | 184 void CopyICToMegamorphicCache(Handle<String> name); |
187 bool IsTransitionedMapOfMonomorphicTarget(Map* receiver_map); | 185 bool IsTransitionedMapOfMonomorphicTarget(Map* receiver_map); |
188 void PatchCache(State state, | 186 void PatchCache(State state, |
189 StrictModeFlag strict_mode, | |
190 Handle<HeapObject> receiver, | 187 Handle<HeapObject> receiver, |
191 Handle<String> name, | 188 Handle<String> name, |
192 Handle<Code> code); | 189 Handle<Code> code); |
193 virtual void UpdateMegamorphicCache(Map* map, Name* name, Code* code); | 190 virtual void UpdateMegamorphicCache(Map* map, Name* name, Code* code); |
194 virtual Handle<Code> megamorphic_stub() { | 191 virtual Handle<Code> megamorphic_stub() { |
195 UNREACHABLE(); | 192 UNREACHABLE(); |
196 return Handle<Code>::null(); | 193 return Handle<Code>::null(); |
197 } | 194 } |
198 virtual Handle<Code> megamorphic_stub_strict() { | |
199 UNREACHABLE(); | |
200 return Handle<Code>::null(); | |
201 } | |
202 virtual Handle<Code> generic_stub() const { | 195 virtual Handle<Code> generic_stub() const { |
203 UNREACHABLE(); | 196 UNREACHABLE(); |
204 return Handle<Code>::null(); | 197 return Handle<Code>::null(); |
205 } | 198 } |
206 virtual Handle<Code> generic_stub_strict() const { | 199 virtual StrictModeFlag strict_mode() const { return kNonStrictMode; } |
207 UNREACHABLE(); | |
208 return Handle<Code>::null(); | |
209 } | |
210 | 200 |
211 private: | 201 private: |
212 // Frame pointer for the frame that uses (calls) the IC. | 202 // Frame pointer for the frame that uses (calls) the IC. |
213 Address fp_; | 203 Address fp_; |
214 | 204 |
215 // All access to the program counter of an IC structure is indirect | 205 // All access to the program counter of an IC structure is indirect |
216 // to make the code GC safe. This feature is crucial since | 206 // to make the code GC safe. This feature is crucial since |
217 // GetProperty and SetProperty are called and they in turn might | 207 // GetProperty and SetProperty are called and they in turn might |
218 // invoke the garbage collector. | 208 // invoke the garbage collector. |
219 Address* pc_address_; | 209 Address* pc_address_; |
(...skipping 180 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
400 | 390 |
401 virtual Handle<Code> ComputeLoadHandler(LookupResult* lookup, | 391 virtual Handle<Code> ComputeLoadHandler(LookupResult* lookup, |
402 Handle<JSObject> receiver, | 392 Handle<JSObject> receiver, |
403 Handle<String> name); | 393 Handle<String> name); |
404 | 394 |
405 private: | 395 private: |
406 // Stub accessors. | 396 // Stub accessors. |
407 static Handle<Code> initialize_stub(Isolate* isolate) { | 397 static Handle<Code> initialize_stub(Isolate* isolate) { |
408 return isolate->builtins()->LoadIC_Initialize(); | 398 return isolate->builtins()->LoadIC_Initialize(); |
409 } | 399 } |
400 | |
410 static Handle<Code> pre_monomorphic_stub(Isolate* isolate) { | 401 static Handle<Code> pre_monomorphic_stub(Isolate* isolate) { |
411 return isolate->builtins()->LoadIC_PreMonomorphic(); | 402 return isolate->builtins()->LoadIC_PreMonomorphic(); |
412 } | 403 } |
404 | |
413 virtual Handle<Code> pre_monomorphic_stub() { | 405 virtual Handle<Code> pre_monomorphic_stub() { |
414 return pre_monomorphic_stub(isolate()); | 406 return pre_monomorphic_stub(isolate()); |
415 } | 407 } |
416 | 408 |
417 static void Clear(Isolate* isolate, Address address, Code* target); | 409 static void Clear(Isolate* isolate, Address address, Code* target); |
418 | 410 |
419 friend class IC; | 411 friend class IC; |
420 }; | 412 }; |
421 | 413 |
422 | 414 |
(...skipping 79 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
502 } | 494 } |
503 | 495 |
504 static void Clear(Isolate* isolate, Address address, Code* target); | 496 static void Clear(Isolate* isolate, Address address, Code* target); |
505 | 497 |
506 friend class IC; | 498 friend class IC; |
507 }; | 499 }; |
508 | 500 |
509 | 501 |
510 class StoreIC: public IC { | 502 class StoreIC: public IC { |
511 public: | 503 public: |
512 StoreIC(FrameDepth depth, Isolate* isolate) : IC(depth, isolate) { | 504 StoreIC(FrameDepth depth, Isolate* isolate) |
505 : IC(depth, isolate), | |
506 strict_mode_(Code::GetStrictMode(target()->extra_ic_state())) { | |
513 ASSERT(target()->is_store_stub() || target()->is_keyed_store_stub()); | 507 ASSERT(target()->is_store_stub() || target()->is_keyed_store_stub()); |
514 } | 508 } |
515 | 509 |
510 virtual StrictModeFlag strict_mode() const { return strict_mode_; } | |
511 | |
516 // Code generators for stub routines. Only called once at startup. | 512 // Code generators for stub routines. Only called once at startup. |
517 static void GenerateSlow(MacroAssembler* masm); | 513 static void GenerateSlow(MacroAssembler* masm); |
518 static void GenerateInitialize(MacroAssembler* masm) { GenerateMiss(masm); } | 514 static void GenerateInitialize(MacroAssembler* masm) { GenerateMiss(masm); } |
519 static void GeneratePreMonomorphic(MacroAssembler* masm) { | 515 static void GeneratePreMonomorphic(MacroAssembler* masm) { |
520 GenerateMiss(masm); | 516 GenerateMiss(masm); |
521 } | 517 } |
522 static void GenerateMiss(MacroAssembler* masm); | 518 static void GenerateMiss(MacroAssembler* masm); |
523 static void GenerateMegamorphic(MacroAssembler* masm, | 519 static void GenerateMegamorphic(MacroAssembler* masm, |
524 StrictModeFlag strict_mode); | 520 StrictModeFlag strict_mode); |
525 static void GenerateNormal(MacroAssembler* masm); | 521 static void GenerateNormal(MacroAssembler* masm); |
526 static void GenerateRuntimeSetProperty(MacroAssembler* masm, | 522 static void GenerateRuntimeSetProperty(MacroAssembler* masm, |
527 StrictModeFlag strict_mode); | 523 StrictModeFlag strict_mode); |
528 | 524 |
529 MUST_USE_RESULT MaybeObject* Store( | 525 MUST_USE_RESULT MaybeObject* Store( |
530 State state, | 526 State state, |
531 StrictModeFlag strict_mode, | |
532 Handle<Object> object, | 527 Handle<Object> object, |
533 Handle<String> name, | 528 Handle<String> name, |
534 Handle<Object> value, | 529 Handle<Object> value, |
535 JSReceiver::StoreFromKeyed store_mode = | 530 JSReceiver::StoreFromKeyed store_mode = |
536 JSReceiver::CERTAINLY_NOT_STORE_FROM_KEYED); | 531 JSReceiver::CERTAINLY_NOT_STORE_FROM_KEYED); |
537 | 532 |
538 protected: | 533 protected: |
539 virtual Code::Kind kind() const { return Code::STORE_IC; } | 534 virtual Code::Kind kind() const { return Code::STORE_IC; } |
540 virtual Handle<Code> megamorphic_stub() { | 535 virtual Handle<Code> megamorphic_stub() { |
541 return isolate()->builtins()->StoreIC_Megamorphic(); | 536 if (strict_mode_ == kStrictMode) { |
537 return isolate()->builtins()->StoreIC_Megamorphic_Strict(); | |
538 } else { | |
539 return isolate()->builtins()->StoreIC_Megamorphic(); | |
540 } | |
542 } | 541 } |
543 // Stub accessors. | 542 // Stub accessors. |
544 virtual Handle<Code> megamorphic_stub_strict() { | 543 virtual Handle<Code> generic_stub() const { |
545 return isolate()->builtins()->StoreIC_Megamorphic_Strict(); | 544 if (strict_mode() == kStrictMode) { |
ulan
2013/10/01 08:38:43
Let's use strict_mode_ to be consistent with other
| |
545 return isolate()->builtins()->StoreIC_Generic_Strict(); | |
546 } else { | |
547 return isolate()->builtins()->StoreIC_Generic(); | |
548 } | |
546 } | 549 } |
547 virtual Handle<Code> generic_stub() const { | 550 |
548 return isolate()->builtins()->StoreIC_Generic(); | 551 virtual Handle<Code> pre_monomorphic_stub() { |
552 return pre_monomorphic_stub(isolate(), strict_mode()); | |
549 } | 553 } |
550 virtual Handle<Code> generic_stub_strict() const { | 554 |
551 return isolate()->builtins()->StoreIC_Generic_Strict(); | 555 static Handle<Code> pre_monomorphic_stub(Isolate* isolate, |
556 StrictModeFlag strict_mode) { | |
557 if (strict_mode == kStrictMode) { | |
558 return isolate->builtins()->StoreIC_PreMonomorphic_Strict(); | |
559 } else { | |
560 return isolate->builtins()->StoreIC_PreMonomorphic(); | |
561 } | |
552 } | 562 } |
553 virtual Handle<Code> pre_monomorphic_stub() { | 563 |
554 return pre_monomorphic_stub(isolate()); | |
555 } | |
556 static Handle<Code> pre_monomorphic_stub(Isolate* isolate) { | |
557 return isolate->builtins()->StoreIC_PreMonomorphic(); | |
558 } | |
559 virtual Handle<Code> pre_monomorphic_stub_strict() { | |
560 return pre_monomorphic_stub_strict(isolate()); | |
561 } | |
562 static Handle<Code> pre_monomorphic_stub_strict(Isolate* isolate) { | |
563 return isolate->builtins()->StoreIC_PreMonomorphic_Strict(); | |
564 } | |
565 virtual Handle<Code> global_proxy_stub() { | 564 virtual Handle<Code> global_proxy_stub() { |
566 return isolate()->builtins()->StoreIC_GlobalProxy(); | 565 if (strict_mode_ == kStrictMode) { |
567 } | 566 return isolate()->builtins()->StoreIC_GlobalProxy_Strict(); |
568 virtual Handle<Code> global_proxy_stub_strict() { | 567 } else { |
569 return isolate()->builtins()->StoreIC_GlobalProxy_Strict(); | 568 return isolate()->builtins()->StoreIC_GlobalProxy(); |
569 } | |
570 } | 570 } |
571 | 571 |
572 // Update the inline cache and the global stub cache based on the | 572 // Update the inline cache and the global stub cache based on the |
573 // lookup result. | 573 // lookup result. |
574 void UpdateCaches(LookupResult* lookup, | 574 void UpdateCaches(LookupResult* lookup, |
575 State state, | 575 State state, |
576 StrictModeFlag strict_mode, | |
577 Handle<JSObject> receiver, | 576 Handle<JSObject> receiver, |
578 Handle<String> name, | 577 Handle<String> name, |
579 Handle<Object> value); | 578 Handle<Object> value); |
580 // Compute the code stub for this store; used for rewriting to | 579 // Compute the code stub for this store; used for rewriting to |
581 // monomorphic state and making sure that the code stub is in the | 580 // monomorphic state and making sure that the code stub is in the |
582 // stub cache. | 581 // stub cache. |
583 virtual Handle<Code> ComputeStoreMonomorphic(LookupResult* lookup, | 582 virtual Handle<Code> ComputeStoreMonomorphic(LookupResult* lookup, |
584 StrictModeFlag strict_mode, | |
585 Handle<JSObject> receiver, | 583 Handle<JSObject> receiver, |
586 Handle<String> name, | 584 Handle<String> name, |
587 Handle<Object> value); | 585 Handle<Object> value); |
588 | 586 |
589 private: | 587 private: |
590 void set_target(Code* code) { | 588 void set_target(Code* code) { |
591 // Strict mode must be preserved across IC patching. | 589 // Strict mode must be preserved across IC patching. |
592 ASSERT(Code::GetStrictMode(code->extra_ic_state()) == | 590 ASSERT(Code::GetStrictMode(code->extra_ic_state()) == |
593 Code::GetStrictMode(target()->extra_ic_state())); | 591 Code::GetStrictMode(target()->extra_ic_state())); |
594 IC::set_target(code); | 592 IC::set_target(code); |
595 } | 593 } |
596 | 594 |
597 static Handle<Code> initialize_stub(Isolate* isolate) { | 595 static Handle<Code> initialize_stub(Isolate* isolate, |
598 return isolate->builtins()->StoreIC_Initialize(); | 596 StrictModeFlag strict_mode) { |
597 if (strict_mode == kStrictMode) { | |
598 return isolate->builtins()->StoreIC_Initialize_Strict(); | |
599 } else { | |
600 return isolate->builtins()->StoreIC_Initialize(); | |
601 } | |
599 } | 602 } |
600 static Handle<Code> initialize_stub_strict(Isolate* isolate) { | 603 |
601 return isolate->builtins()->StoreIC_Initialize_Strict(); | |
602 } | |
603 static void Clear(Isolate* isolate, Address address, Code* target); | 604 static void Clear(Isolate* isolate, Address address, Code* target); |
604 | 605 |
606 StrictModeFlag strict_mode_; | |
607 | |
605 friend class IC; | 608 friend class IC; |
606 }; | 609 }; |
607 | 610 |
608 | 611 |
609 enum KeyedStoreCheckMap { | 612 enum KeyedStoreCheckMap { |
610 kDontCheckMap, | 613 kDontCheckMap, |
611 kCheckMap | 614 kCheckMap |
612 }; | 615 }; |
613 | 616 |
614 | 617 |
615 enum KeyedStoreIncrementLength { | 618 enum KeyedStoreIncrementLength { |
616 kDontIncrementLength, | 619 kDontIncrementLength, |
617 kIncrementLength | 620 kIncrementLength |
618 }; | 621 }; |
619 | 622 |
620 | 623 |
621 class KeyedStoreIC: public StoreIC { | 624 class KeyedStoreIC: public StoreIC { |
622 public: | 625 public: |
623 KeyedStoreIC(FrameDepth depth, Isolate* isolate) | 626 KeyedStoreIC(FrameDepth depth, Isolate* isolate) |
624 : StoreIC(depth, isolate) { | 627 : StoreIC(depth, isolate) { |
625 ASSERT(target()->is_keyed_store_stub()); | 628 ASSERT(target()->is_keyed_store_stub()); |
626 } | 629 } |
627 | 630 |
628 MUST_USE_RESULT MaybeObject* Store(State state, | 631 MUST_USE_RESULT MaybeObject* Store(State state, |
629 StrictModeFlag strict_mode, | |
630 Handle<Object> object, | 632 Handle<Object> object, |
631 Handle<Object> name, | 633 Handle<Object> name, |
632 Handle<Object> value, | 634 Handle<Object> value, |
633 ICMissMode force_generic); | 635 ICMissMode force_generic); |
634 | 636 |
635 // Code generators for stub routines. Only called once at startup. | 637 // Code generators for stub routines. Only called once at startup. |
636 static void GenerateInitialize(MacroAssembler* masm) { | 638 static void GenerateInitialize(MacroAssembler* masm) { |
637 GenerateMiss(masm, MISS); | 639 GenerateMiss(masm, MISS); |
638 } | 640 } |
639 static void GeneratePreMonomorphic(MacroAssembler* masm) { | 641 static void GeneratePreMonomorphic(MacroAssembler* masm) { |
640 GenerateMiss(masm, MISS); | 642 GenerateMiss(masm, MISS); |
641 } | 643 } |
642 static void GenerateMiss(MacroAssembler* masm, ICMissMode force_generic); | 644 static void GenerateMiss(MacroAssembler* masm, ICMissMode force_generic); |
643 static void GenerateSlow(MacroAssembler* masm); | 645 static void GenerateSlow(MacroAssembler* masm); |
644 static void GenerateRuntimeSetProperty(MacroAssembler* masm, | 646 static void GenerateRuntimeSetProperty(MacroAssembler* masm, |
645 StrictModeFlag strict_mode); | 647 StrictModeFlag strict_mode); |
646 static void GenerateGeneric(MacroAssembler* masm, StrictModeFlag strict_mode); | 648 static void GenerateGeneric(MacroAssembler* masm, StrictModeFlag strict_mode); |
647 static void GenerateNonStrictArguments(MacroAssembler* masm); | 649 static void GenerateNonStrictArguments(MacroAssembler* masm); |
648 | 650 |
649 protected: | 651 protected: |
650 virtual Code::Kind kind() const { return Code::KEYED_STORE_IC; } | 652 virtual Code::Kind kind() const { return Code::KEYED_STORE_IC; } |
651 | 653 |
652 virtual Handle<Code> ComputeStoreMonomorphic(LookupResult* lookup, | 654 virtual Handle<Code> ComputeStoreMonomorphic(LookupResult* lookup, |
653 StrictModeFlag strict_mode, | |
654 Handle<JSObject> receiver, | 655 Handle<JSObject> receiver, |
655 Handle<String> name, | 656 Handle<String> name, |
656 Handle<Object> value); | 657 Handle<Object> value); |
657 virtual void UpdateMegamorphicCache(Map* map, Name* name, Code* code) { } | 658 virtual void UpdateMegamorphicCache(Map* map, Name* name, Code* code) { } |
658 | 659 |
659 virtual Handle<Code> pre_monomorphic_stub() { | 660 virtual Handle<Code> pre_monomorphic_stub() { |
660 return pre_monomorphic_stub(isolate()); | 661 return pre_monomorphic_stub(isolate(), strict_mode()); |
661 } | 662 } |
662 static Handle<Code> pre_monomorphic_stub(Isolate* isolate) { | 663 static Handle<Code> pre_monomorphic_stub(Isolate* isolate, |
663 return isolate->builtins()->KeyedStoreIC_PreMonomorphic(); | 664 StrictModeFlag strict_mode) { |
664 } | 665 if (strict_mode == kStrictMode) { |
665 virtual Handle<Code> pre_monomorphic_stub_strict() { | 666 return isolate->builtins()->KeyedStoreIC_PreMonomorphic_Strict(); |
666 return pre_monomorphic_stub_strict(isolate()); | 667 } else { |
667 } | 668 return isolate->builtins()->KeyedStoreIC_PreMonomorphic(); |
668 static Handle<Code> pre_monomorphic_stub_strict(Isolate* isolate) { | 669 } |
669 return isolate->builtins()->KeyedStoreIC_PreMonomorphic_Strict(); | |
670 } | 670 } |
671 virtual Handle<Code> megamorphic_stub() { | 671 virtual Handle<Code> megamorphic_stub() { |
672 return isolate()->builtins()->KeyedStoreIC_Generic(); | 672 if (strict_mode() == kStrictMode) { |
673 } | 673 return isolate()->builtins()->KeyedStoreIC_Generic_Strict(); |
674 virtual Handle<Code> megamorphic_stub_strict() { | 674 } else { |
675 return isolate()->builtins()->KeyedStoreIC_Generic_Strict(); | 675 return isolate()->builtins()->KeyedStoreIC_Generic(); |
676 } | |
676 } | 677 } |
677 | 678 |
678 Handle<Code> StoreElementStub(Handle<JSObject> receiver, | 679 Handle<Code> StoreElementStub(Handle<JSObject> receiver, |
679 KeyedAccessStoreMode store_mode, | 680 KeyedAccessStoreMode store_mode); |
680 StrictModeFlag strict_mode); | |
681 | 681 |
682 private: | 682 private: |
683 void set_target(Code* code) { | 683 void set_target(Code* code) { |
684 // Strict mode must be preserved across IC patching. | 684 // Strict mode must be preserved across IC patching. |
685 ASSERT(Code::GetStrictMode(code->extra_ic_state()) == | 685 ASSERT(Code::GetStrictMode(code->extra_ic_state()) == strict_mode()); |
686 Code::GetStrictMode(target()->extra_ic_state())); | |
687 IC::set_target(code); | 686 IC::set_target(code); |
688 } | 687 } |
689 | 688 |
690 // Stub accessors. | 689 // Stub accessors. |
691 static Handle<Code> initialize_stub(Isolate* isolate) { | 690 static Handle<Code> initialize_stub(Isolate* isolate, |
692 return isolate->builtins()->KeyedStoreIC_Initialize(); | 691 StrictModeFlag strict_mode) { |
692 if (strict_mode == kStrictMode) { | |
693 return isolate->builtins()->KeyedStoreIC_Initialize_Strict(); | |
694 } else { | |
695 return isolate->builtins()->KeyedStoreIC_Initialize(); | |
696 } | |
693 } | 697 } |
694 static Handle<Code> initialize_stub_strict(Isolate* isolate) { | 698 |
695 return isolate->builtins()->KeyedStoreIC_Initialize_Strict(); | 699 virtual Handle<Code> generic_stub() const { |
700 if (strict_mode() == kStrictMode) { | |
701 return isolate()->builtins()->KeyedStoreIC_Generic_Strict(); | |
702 } else { | |
703 return isolate()->builtins()->KeyedStoreIC_Generic(); | |
704 } | |
696 } | 705 } |
697 Handle<Code> generic_stub() const { | 706 |
698 return isolate()->builtins()->KeyedStoreIC_Generic(); | |
699 } | |
700 Handle<Code> generic_stub_strict() const { | |
701 return isolate()->builtins()->KeyedStoreIC_Generic_Strict(); | |
702 } | |
703 Handle<Code> non_strict_arguments_stub() { | 707 Handle<Code> non_strict_arguments_stub() { |
704 return isolate()->builtins()->KeyedStoreIC_NonStrictArguments(); | 708 return isolate()->builtins()->KeyedStoreIC_NonStrictArguments(); |
705 } | 709 } |
706 | 710 |
707 static void Clear(Isolate* isolate, Address address, Code* target); | 711 static void Clear(Isolate* isolate, Address address, Code* target); |
708 | 712 |
709 KeyedAccessStoreMode GetStoreMode(Handle<JSObject> receiver, | 713 KeyedAccessStoreMode GetStoreMode(Handle<JSObject> receiver, |
710 Handle<Object> key, | 714 Handle<Object> key, |
711 Handle<Object> value); | 715 Handle<Object> value); |
712 | 716 |
(...skipping 139 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
852 DECLARE_RUNTIME_FUNCTION(MaybeObject*, UnaryOpIC_Miss); | 856 DECLARE_RUNTIME_FUNCTION(MaybeObject*, UnaryOpIC_Miss); |
853 DECLARE_RUNTIME_FUNCTION(MaybeObject*, StoreIC_MissFromStubFailure); | 857 DECLARE_RUNTIME_FUNCTION(MaybeObject*, StoreIC_MissFromStubFailure); |
854 DECLARE_RUNTIME_FUNCTION(MaybeObject*, ElementsTransitionAndStoreIC_Miss); | 858 DECLARE_RUNTIME_FUNCTION(MaybeObject*, ElementsTransitionAndStoreIC_Miss); |
855 DECLARE_RUNTIME_FUNCTION(MaybeObject*, CompareNilIC_Miss); | 859 DECLARE_RUNTIME_FUNCTION(MaybeObject*, CompareNilIC_Miss); |
856 DECLARE_RUNTIME_FUNCTION(MaybeObject*, ToBooleanIC_Miss); | 860 DECLARE_RUNTIME_FUNCTION(MaybeObject*, ToBooleanIC_Miss); |
857 | 861 |
858 | 862 |
859 } } // namespace v8::internal | 863 } } // namespace v8::internal |
860 | 864 |
861 #endif // V8_IC_H_ | 865 #endif // V8_IC_H_ |
OLD | NEW |