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 232 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
243 return Handle<Code>::null(); | 243 return Handle<Code>::null(); |
244 } | 244 } |
245 virtual Handle<Code> megamorphic_stub() { | 245 virtual Handle<Code> megamorphic_stub() { |
246 UNREACHABLE(); | 246 UNREACHABLE(); |
247 return Handle<Code>::null(); | 247 return Handle<Code>::null(); |
248 } | 248 } |
249 virtual Handle<Code> generic_stub() const { | 249 virtual Handle<Code> generic_stub() const { |
250 UNREACHABLE(); | 250 UNREACHABLE(); |
251 return Handle<Code>::null(); | 251 return Handle<Code>::null(); |
252 } | 252 } |
253 virtual StrictModeFlag strict_mode() const { return kNonStrictMode; } | 253 |
254 bool TryRemoveInvalidPrototypeDependentStub(Handle<Object> receiver, | 254 bool TryRemoveInvalidPrototypeDependentStub(Handle<Object> receiver, |
255 Handle<String> name); | 255 Handle<String> name); |
256 void TryRemoveInvalidHandlers(Handle<Map> map, Handle<String> name); | 256 void TryRemoveInvalidHandlers(Handle<Map> map, Handle<String> name); |
257 | 257 |
| 258 virtual ExtraICState extra_ic_state() { return kNoExtraICState; } |
| 259 |
258 private: | 260 private: |
259 Code* raw_target() const { return GetTargetAtAddress(address()); } | 261 Code* raw_target() const { return GetTargetAtAddress(address()); } |
260 | 262 |
261 // Frame pointer for the frame that uses (calls) the IC. | 263 // Frame pointer for the frame that uses (calls) the IC. |
262 Address fp_; | 264 Address fp_; |
263 | 265 |
264 // All access to the program counter of an IC structure is indirect | 266 // All access to the program counter of an IC structure is indirect |
265 // to make the code GC safe. This feature is crucial since | 267 // to make the code GC safe. This feature is crucial since |
266 // GetProperty and SetProperty are called and they in turn might | 268 // GetProperty and SetProperty are called and they in turn might |
267 // invoke the garbage collector. | 269 // invoke the garbage collector. |
(...skipping 21 matching lines...) Expand all Loading... |
289 | 291 |
290 IC::UtilityId id() const { return id_; } | 292 IC::UtilityId id() const { return id_; } |
291 private: | 293 private: |
292 Address address_; | 294 Address address_; |
293 IC::UtilityId id_; | 295 IC::UtilityId id_; |
294 }; | 296 }; |
295 | 297 |
296 | 298 |
297 class CallICBase: public IC { | 299 class CallICBase: public IC { |
298 public: | 300 public: |
299 class Contextual: public BitField<bool, 0, 1> {}; | 301 // ExtraICState bits |
| 302 class Contextual: public BitField<ContextualMode, 0, 1> {}; |
300 class StringStubState: public BitField<StringStubFeedback, 1, 1> {}; | 303 class StringStubState: public BitField<StringStubFeedback, 1, 1> {}; |
| 304 static ExtraICState ComputeExtraICState(ContextualMode mode, |
| 305 StringStubFeedback feedback) { |
| 306 return Contextual::encode(mode) | StringStubState::encode(feedback); |
| 307 } |
301 | 308 |
302 // Returns a JSFunction or a Failure. | 309 // Returns a JSFunction or a Failure. |
303 MUST_USE_RESULT MaybeObject* LoadFunction(Handle<Object> object, | 310 MUST_USE_RESULT MaybeObject* LoadFunction(Handle<Object> object, |
304 Handle<String> name); | 311 Handle<String> name); |
305 | 312 |
306 protected: | 313 protected: |
307 CallICBase(Code::Kind kind, Isolate* isolate) | 314 CallICBase(Code::Kind kind, Isolate* isolate) |
308 : IC(EXTRA_CALL_FRAME, isolate), kind_(kind) {} | 315 : IC(EXTRA_CALL_FRAME, isolate), kind_(kind) {} |
309 | 316 |
310 virtual Code::ExtraICState extra_ic_state() { return Code::kNoExtraICState; } | |
311 | |
312 // Compute a monomorphic stub if possible, otherwise return a null handle. | 317 // Compute a monomorphic stub if possible, otherwise return a null handle. |
313 Handle<Code> ComputeMonomorphicStub(LookupResult* lookup, | 318 Handle<Code> ComputeMonomorphicStub(LookupResult* lookup, |
314 Handle<Object> object, | 319 Handle<Object> object, |
315 Handle<String> name); | 320 Handle<String> name); |
316 | 321 |
317 // Update the inline cache and the global stub cache based on the lookup | 322 // Update the inline cache and the global stub cache based on the lookup |
318 // result. | 323 // result. |
319 void UpdateCaches(LookupResult* lookup, | 324 void UpdateCaches(LookupResult* lookup, |
320 Handle<Object> object, | 325 Handle<Object> object, |
321 Handle<String> name); | 326 Handle<String> name); |
322 | 327 |
323 // Returns a JSFunction if the object can be called as a function, and | 328 // Returns a JSFunction if the object can be called as a function, and |
324 // patches the stack to be ready for the call. Otherwise, it returns the | 329 // patches the stack to be ready for the call. Otherwise, it returns the |
325 // undefined value. | 330 // undefined value. |
326 Handle<Object> TryCallAsFunction(Handle<Object> object); | 331 Handle<Object> TryCallAsFunction(Handle<Object> object); |
327 | 332 |
328 void ReceiverToObjectIfRequired(Handle<Object> callee, Handle<Object> object); | 333 void ReceiverToObjectIfRequired(Handle<Object> callee, Handle<Object> object); |
329 | 334 |
330 static void Clear(Address address, Code* target); | 335 static void Clear(Address address, Code* target); |
331 | 336 |
332 // Platform-specific code generation functions used by both call and | 337 // Platform-specific code generation functions used by both call and |
333 // keyed call. | 338 // keyed call. |
334 static void GenerateMiss(MacroAssembler* masm, | 339 static void GenerateMiss(MacroAssembler* masm, |
335 int argc, | 340 int argc, |
336 IC::UtilityId id, | 341 IC::UtilityId id, |
337 Code::ExtraICState extra_state); | 342 ExtraICState extra_state); |
338 | 343 |
339 static void GenerateNormal(MacroAssembler* masm, int argc); | 344 static void GenerateNormal(MacroAssembler* masm, int argc); |
340 | 345 |
341 static void GenerateMonomorphicCacheProbe(MacroAssembler* masm, | 346 static void GenerateMonomorphicCacheProbe(MacroAssembler* masm, |
342 int argc, | 347 int argc, |
343 Code::Kind kind, | 348 Code::Kind kind, |
344 Code::ExtraICState extra_state); | 349 ExtraICState extra_state); |
345 | 350 |
346 virtual Handle<Code> megamorphic_stub(); | 351 virtual Handle<Code> megamorphic_stub(); |
347 virtual Handle<Code> pre_monomorphic_stub(); | 352 virtual Handle<Code> pre_monomorphic_stub(); |
348 | 353 |
349 Code::Kind kind_; | 354 Code::Kind kind_; |
350 | 355 |
351 friend class IC; | 356 friend class IC; |
352 }; | 357 }; |
353 | 358 |
354 | 359 |
355 class CallIC: public CallICBase { | 360 class CallIC: public CallICBase { |
356 public: | 361 public: |
357 explicit CallIC(Isolate* isolate) | 362 explicit CallIC(Isolate* isolate) |
358 : CallICBase(Code::CALL_IC, isolate), | 363 : CallICBase(Code::CALL_IC, isolate), |
359 extra_ic_state_(target()->extra_ic_state()) { | 364 extra_ic_state_(target()->extra_ic_state()) { |
360 ASSERT(target()->is_call_stub()); | 365 ASSERT(target()->is_call_stub()); |
361 } | 366 } |
362 | 367 |
363 // Code generator routines. | 368 // Code generator routines. |
364 static void GenerateInitialize(MacroAssembler* masm, | 369 static void GenerateInitialize(MacroAssembler* masm, |
365 int argc, | 370 int argc, |
366 Code::ExtraICState extra_state) { | 371 ExtraICState extra_state) { |
367 GenerateMiss(masm, argc, extra_state); | 372 GenerateMiss(masm, argc, extra_state); |
368 } | 373 } |
369 | 374 |
370 static void GenerateMiss(MacroAssembler* masm, | 375 static void GenerateMiss(MacroAssembler* masm, |
371 int argc, | 376 int argc, |
372 Code::ExtraICState extra_state) { | 377 ExtraICState extra_state) { |
373 CallICBase::GenerateMiss(masm, argc, IC::kCallIC_Miss, extra_state); | 378 CallICBase::GenerateMiss(masm, argc, IC::kCallIC_Miss, extra_state); |
374 } | 379 } |
375 | 380 |
376 static void GenerateMegamorphic(MacroAssembler* masm, | 381 static void GenerateMegamorphic(MacroAssembler* masm, |
377 int argc, | 382 int argc, |
378 Code::ExtraICState extra_ic_state); | 383 ExtraICState extra_ic_state); |
379 | 384 |
380 static void GenerateNormal(MacroAssembler* masm, int argc) { | 385 static void GenerateNormal(MacroAssembler* masm, int argc) { |
381 CallICBase::GenerateNormal(masm, argc); | 386 CallICBase::GenerateNormal(masm, argc); |
382 GenerateMiss(masm, argc, Code::kNoExtraICState); | 387 GenerateMiss(masm, argc, kNoExtraICState); |
383 } | 388 } |
384 bool TryUpdateExtraICState(LookupResult* lookup, Handle<Object> object); | 389 bool TryUpdateExtraICState(LookupResult* lookup, Handle<Object> object); |
385 | 390 |
386 protected: | 391 protected: |
387 virtual Code::ExtraICState extra_ic_state() { return extra_ic_state_; } | 392 virtual ExtraICState extra_ic_state() { return extra_ic_state_; } |
388 | 393 |
389 private: | 394 private: |
390 Code::ExtraICState extra_ic_state_; | 395 ExtraICState extra_ic_state_; |
391 }; | 396 }; |
392 | 397 |
393 | 398 |
394 class KeyedCallIC: public CallICBase { | 399 class KeyedCallIC: public CallICBase { |
395 public: | 400 public: |
396 explicit KeyedCallIC(Isolate* isolate) | 401 explicit KeyedCallIC(Isolate* isolate) |
397 : CallICBase(Code::KEYED_CALL_IC, isolate) { | 402 : CallICBase(Code::KEYED_CALL_IC, isolate) { |
398 ASSERT(target()->is_keyed_call_stub()); | 403 ASSERT(target()->is_keyed_call_stub()); |
399 } | 404 } |
400 | 405 |
401 MUST_USE_RESULT MaybeObject* LoadFunction(Handle<Object> object, | 406 MUST_USE_RESULT MaybeObject* LoadFunction(Handle<Object> object, |
402 Handle<Object> key); | 407 Handle<Object> key); |
403 | 408 |
404 // Code generator routines. | 409 // Code generator routines. |
405 static void GenerateInitialize(MacroAssembler* masm, int argc) { | 410 static void GenerateInitialize(MacroAssembler* masm, int argc) { |
406 GenerateMiss(masm, argc); | 411 GenerateMiss(masm, argc); |
407 } | 412 } |
408 | 413 |
409 static void GenerateMiss(MacroAssembler* masm, int argc) { | 414 static void GenerateMiss(MacroAssembler* masm, int argc) { |
410 CallICBase::GenerateMiss(masm, argc, IC::kKeyedCallIC_Miss, | 415 CallICBase::GenerateMiss(masm, argc, IC::kKeyedCallIC_Miss, |
411 Code::kNoExtraICState); | 416 kNoExtraICState); |
412 } | 417 } |
413 | 418 |
414 static void GenerateMegamorphic(MacroAssembler* masm, int argc); | 419 static void GenerateMegamorphic(MacroAssembler* masm, int argc); |
415 static void GenerateNormal(MacroAssembler* masm, int argc); | 420 static void GenerateNormal(MacroAssembler* masm, int argc); |
416 static void GenerateNonStrictArguments(MacroAssembler* masm, int argc); | 421 static void GenerateNonStrictArguments(MacroAssembler* masm, int argc); |
417 }; | 422 }; |
418 | 423 |
419 | 424 |
420 class LoadIC: public IC { | 425 class LoadIC: public IC { |
421 public: | 426 public: |
(...skipping 130 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
552 } | 557 } |
553 | 558 |
554 static void Clear(Isolate* isolate, Address address, Code* target); | 559 static void Clear(Isolate* isolate, Address address, Code* target); |
555 | 560 |
556 friend class IC; | 561 friend class IC; |
557 }; | 562 }; |
558 | 563 |
559 | 564 |
560 class StoreIC: public IC { | 565 class StoreIC: public IC { |
561 public: | 566 public: |
| 567 // ExtraICState bits |
| 568 class StrictModeState: public BitField<StrictModeFlag, 0, 1> {}; |
| 569 static ExtraICState ComputeExtraICState(StrictModeFlag flag) { |
| 570 return StrictModeState::encode(flag); |
| 571 } |
| 572 |
| 573 static StrictModeFlag GetStrictMode(ExtraICState state) { |
| 574 return StrictModeState::decode(state); |
| 575 } |
| 576 |
| 577 // For convenience, a statically declared encoding of strict mode extra |
| 578 // IC state. |
| 579 static const ExtraICState kStrictModeState = |
| 580 1 << StrictModeState::kShift; |
| 581 |
562 StoreIC(FrameDepth depth, Isolate* isolate) | 582 StoreIC(FrameDepth depth, Isolate* isolate) |
563 : IC(depth, isolate), | 583 : IC(depth, isolate), |
564 strict_mode_(Code::GetStrictMode(target()->extra_ic_state())) { | 584 strict_mode_(GetStrictMode(target()->extra_ic_state())) { |
565 ASSERT(IsStoreStub()); | 585 ASSERT(IsStoreStub()); |
566 } | 586 } |
567 | 587 |
568 virtual StrictModeFlag strict_mode() const { return strict_mode_; } | 588 StrictModeFlag strict_mode() const { return strict_mode_; } |
569 | 589 |
570 // Code generators for stub routines. Only called once at startup. | 590 // Code generators for stub routines. Only called once at startup. |
571 static void GenerateSlow(MacroAssembler* masm); | 591 static void GenerateSlow(MacroAssembler* masm); |
572 static void GenerateInitialize(MacroAssembler* masm) { GenerateMiss(masm); } | 592 static void GenerateInitialize(MacroAssembler* masm) { GenerateMiss(masm); } |
573 static void GeneratePreMonomorphic(MacroAssembler* masm) { | 593 static void GeneratePreMonomorphic(MacroAssembler* masm) { |
574 GenerateMiss(masm); | 594 GenerateMiss(masm); |
575 } | 595 } |
576 static void GenerateMiss(MacroAssembler* masm); | 596 static void GenerateMiss(MacroAssembler* masm); |
577 static void GenerateMegamorphic(MacroAssembler* masm, | 597 static void GenerateMegamorphic(MacroAssembler* masm, |
578 StrictModeFlag strict_mode); | 598 StrictModeFlag strict_mode); |
(...skipping 56 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
635 void UpdateCaches(LookupResult* lookup, | 655 void UpdateCaches(LookupResult* lookup, |
636 Handle<JSObject> receiver, | 656 Handle<JSObject> receiver, |
637 Handle<String> name, | 657 Handle<String> name, |
638 Handle<Object> value); | 658 Handle<Object> value); |
639 virtual Handle<Code> CompileHandler(LookupResult* lookup, | 659 virtual Handle<Code> CompileHandler(LookupResult* lookup, |
640 Handle<Object> object, | 660 Handle<Object> object, |
641 Handle<String> name, | 661 Handle<String> name, |
642 Handle<Object> value, | 662 Handle<Object> value, |
643 InlineCacheHolderFlag cache_holder); | 663 InlineCacheHolderFlag cache_holder); |
644 | 664 |
| 665 virtual ExtraICState extra_ic_state() { |
| 666 return ComputeExtraICState(strict_mode()); |
| 667 } |
| 668 |
645 private: | 669 private: |
646 void set_target(Code* code) { | 670 void set_target(Code* code) { |
647 // Strict mode must be preserved across IC patching. | 671 // Strict mode must be preserved across IC patching. |
648 ASSERT(Code::GetStrictMode(code->extra_ic_state()) == | 672 ASSERT(GetStrictMode(code->extra_ic_state()) == |
649 Code::GetStrictMode(target()->extra_ic_state())); | 673 GetStrictMode(target()->extra_ic_state())); |
650 IC::set_target(code); | 674 IC::set_target(code); |
651 } | 675 } |
652 | 676 |
653 static Handle<Code> initialize_stub(Isolate* isolate, | 677 static Handle<Code> initialize_stub(Isolate* isolate, |
654 StrictModeFlag strict_mode) { | 678 StrictModeFlag strict_mode) { |
655 if (strict_mode == kStrictMode) { | 679 if (strict_mode == kStrictMode) { |
656 return isolate->builtins()->StoreIC_Initialize_Strict(); | 680 return isolate->builtins()->StoreIC_Initialize_Strict(); |
657 } else { | 681 } else { |
658 return isolate->builtins()->StoreIC_Initialize(); | 682 return isolate->builtins()->StoreIC_Initialize(); |
659 } | 683 } |
(...skipping 14 matching lines...) Expand all Loading... |
674 | 698 |
675 | 699 |
676 enum KeyedStoreIncrementLength { | 700 enum KeyedStoreIncrementLength { |
677 kDontIncrementLength, | 701 kDontIncrementLength, |
678 kIncrementLength | 702 kIncrementLength |
679 }; | 703 }; |
680 | 704 |
681 | 705 |
682 class KeyedStoreIC: public StoreIC { | 706 class KeyedStoreIC: public StoreIC { |
683 public: | 707 public: |
| 708 // ExtraICState bits (building on IC) |
| 709 // ExtraICState bits |
| 710 class ExtraICStateKeyedAccessStoreMode: |
| 711 public BitField<KeyedAccessStoreMode, 1, 4> {}; // NOLINT |
| 712 |
| 713 static ExtraICState ComputeExtraICState(StrictModeFlag flag, |
| 714 KeyedAccessStoreMode mode) { |
| 715 return StrictModeState::encode(flag) | |
| 716 ExtraICStateKeyedAccessStoreMode::encode(mode); |
| 717 } |
| 718 |
| 719 static KeyedAccessStoreMode GetKeyedAccessStoreMode( |
| 720 ExtraICState extra_state) { |
| 721 return ExtraICStateKeyedAccessStoreMode::decode(extra_state); |
| 722 } |
| 723 |
684 KeyedStoreIC(FrameDepth depth, Isolate* isolate) | 724 KeyedStoreIC(FrameDepth depth, Isolate* isolate) |
685 : StoreIC(depth, isolate) { | 725 : StoreIC(depth, isolate) { |
686 ASSERT(target()->is_keyed_store_stub()); | 726 ASSERT(target()->is_keyed_store_stub()); |
687 } | 727 } |
688 | 728 |
689 MUST_USE_RESULT MaybeObject* Store(Handle<Object> object, | 729 MUST_USE_RESULT MaybeObject* Store(Handle<Object> object, |
690 Handle<Object> name, | 730 Handle<Object> name, |
691 Handle<Object> value); | 731 Handle<Object> value); |
692 | 732 |
693 // Code generators for stub routines. Only called once at startup. | 733 // Code generators for stub routines. Only called once at startup. |
694 static void GenerateInitialize(MacroAssembler* masm) { GenerateMiss(masm); } | 734 static void GenerateInitialize(MacroAssembler* masm) { GenerateMiss(masm); } |
695 static void GeneratePreMonomorphic(MacroAssembler* masm) { | 735 static void GeneratePreMonomorphic(MacroAssembler* masm) { |
696 GenerateMiss(masm); | 736 GenerateMiss(masm); |
697 } | 737 } |
698 static void GenerateMiss(MacroAssembler* masm); | 738 static void GenerateMiss(MacroAssembler* masm); |
699 static void GenerateSlow(MacroAssembler* masm); | 739 static void GenerateSlow(MacroAssembler* masm); |
700 static void GenerateRuntimeSetProperty(MacroAssembler* masm, | 740 static void GenerateRuntimeSetProperty(MacroAssembler* masm, |
701 StrictModeFlag strict_mode); | 741 StrictModeFlag strict_mode); |
702 static void GenerateGeneric(MacroAssembler* masm, StrictModeFlag strict_mode); | 742 static void GenerateGeneric(MacroAssembler* masm, StrictModeFlag strict_mode); |
703 static void GenerateNonStrictArguments(MacroAssembler* masm); | 743 static void GenerateNonStrictArguments(MacroAssembler* masm); |
704 | 744 |
705 protected: | 745 protected: |
706 virtual Code::Kind kind() const { return Code::KEYED_STORE_IC; } | 746 virtual Code::Kind kind() const { return Code::KEYED_STORE_IC; } |
707 | 747 |
708 virtual void UpdateMegamorphicCache(Type* type, Name* name, Code* code) { } | 748 virtual void UpdateMegamorphicCache(Type* type, Name* name, Code* code) { } |
709 | 749 |
| 750 virtual ExtraICState extra_ic_state() { |
| 751 return ComputeExtraICState(strict_mode(), STANDARD_STORE); |
| 752 } |
| 753 |
710 virtual Handle<Code> pre_monomorphic_stub() { | 754 virtual Handle<Code> pre_monomorphic_stub() { |
711 return pre_monomorphic_stub(isolate(), strict_mode()); | 755 return pre_monomorphic_stub(isolate(), strict_mode()); |
712 } | 756 } |
713 static Handle<Code> pre_monomorphic_stub(Isolate* isolate, | 757 static Handle<Code> pre_monomorphic_stub(Isolate* isolate, |
714 StrictModeFlag strict_mode) { | 758 StrictModeFlag strict_mode) { |
715 if (strict_mode == kStrictMode) { | 759 if (strict_mode == kStrictMode) { |
716 return isolate->builtins()->KeyedStoreIC_PreMonomorphic_Strict(); | 760 return isolate->builtins()->KeyedStoreIC_PreMonomorphic_Strict(); |
717 } else { | 761 } else { |
718 return isolate->builtins()->KeyedStoreIC_PreMonomorphic(); | 762 return isolate->builtins()->KeyedStoreIC_PreMonomorphic(); |
719 } | 763 } |
720 } | 764 } |
721 virtual Handle<Code> slow_stub() const { | 765 virtual Handle<Code> slow_stub() const { |
722 return isolate()->builtins()->KeyedStoreIC_Slow(); | 766 return isolate()->builtins()->KeyedStoreIC_Slow(); |
723 } | 767 } |
724 virtual Handle<Code> megamorphic_stub() { | 768 virtual Handle<Code> megamorphic_stub() { |
725 if (strict_mode() == kStrictMode) { | 769 if (strict_mode() == kStrictMode) { |
726 return isolate()->builtins()->KeyedStoreIC_Generic_Strict(); | 770 return isolate()->builtins()->KeyedStoreIC_Generic_Strict(); |
727 } else { | 771 } else { |
728 return isolate()->builtins()->KeyedStoreIC_Generic(); | 772 return isolate()->builtins()->KeyedStoreIC_Generic(); |
729 } | 773 } |
730 } | 774 } |
731 | 775 |
732 Handle<Code> StoreElementStub(Handle<JSObject> receiver, | 776 Handle<Code> StoreElementStub(Handle<JSObject> receiver, |
733 KeyedAccessStoreMode store_mode); | 777 KeyedAccessStoreMode store_mode); |
734 | 778 |
735 private: | 779 private: |
736 void set_target(Code* code) { | 780 void set_target(Code* code) { |
737 // Strict mode must be preserved across IC patching. | 781 // Strict mode must be preserved across IC patching. |
738 ASSERT(Code::GetStrictMode(code->extra_ic_state()) == strict_mode()); | 782 ASSERT(GetStrictMode(code->extra_ic_state()) == strict_mode()); |
739 IC::set_target(code); | 783 IC::set_target(code); |
740 } | 784 } |
741 | 785 |
742 // Stub accessors. | 786 // Stub accessors. |
743 static Handle<Code> initialize_stub(Isolate* isolate, | 787 static Handle<Code> initialize_stub(Isolate* isolate, |
744 StrictModeFlag strict_mode) { | 788 StrictModeFlag strict_mode) { |
745 if (strict_mode == kStrictMode) { | 789 if (strict_mode == kStrictMode) { |
746 return isolate->builtins()->KeyedStoreIC_Initialize_Strict(); | 790 return isolate->builtins()->KeyedStoreIC_Initialize_Strict(); |
747 } else { | 791 } else { |
748 return isolate->builtins()->KeyedStoreIC_Initialize(); | 792 return isolate->builtins()->KeyedStoreIC_Initialize(); |
(...skipping 154 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
903 DECLARE_RUNTIME_FUNCTION(MaybeObject*, KeyedCallIC_MissFromStubFailure); | 947 DECLARE_RUNTIME_FUNCTION(MaybeObject*, KeyedCallIC_MissFromStubFailure); |
904 DECLARE_RUNTIME_FUNCTION(MaybeObject*, ElementsTransitionAndStoreIC_Miss); | 948 DECLARE_RUNTIME_FUNCTION(MaybeObject*, ElementsTransitionAndStoreIC_Miss); |
905 DECLARE_RUNTIME_FUNCTION(MaybeObject*, BinaryOpIC_Miss); | 949 DECLARE_RUNTIME_FUNCTION(MaybeObject*, BinaryOpIC_Miss); |
906 DECLARE_RUNTIME_FUNCTION(MaybeObject*, CompareNilIC_Miss); | 950 DECLARE_RUNTIME_FUNCTION(MaybeObject*, CompareNilIC_Miss); |
907 DECLARE_RUNTIME_FUNCTION(MaybeObject*, ToBooleanIC_Miss); | 951 DECLARE_RUNTIME_FUNCTION(MaybeObject*, ToBooleanIC_Miss); |
908 | 952 |
909 | 953 |
910 } } // namespace v8::internal | 954 } } // namespace v8::internal |
911 | 955 |
912 #endif // V8_IC_H_ | 956 #endif // V8_IC_H_ |
OLD | NEW |