OLD | NEW |
1 // Copyright 2012 the V8 project authors. All rights reserved. | 1 // Copyright 2012 the V8 project authors. All rights reserved. |
2 // Use of this source code is governed by a BSD-style license that can be | 2 // Use of this source code is governed by a BSD-style license that can be |
3 // found in the LICENSE file. | 3 // found in the LICENSE file. |
4 | 4 |
5 #include "src/v8.h" | 5 #include "src/v8.h" |
6 | 6 |
7 #include "src/arguments.h" | 7 #include "src/arguments.h" |
8 #include "src/conversions.h" | 8 #include "src/conversions.h" |
9 #include "src/elements.h" | 9 #include "src/elements.h" |
10 #include "src/objects.h" | 10 #include "src/objects.h" |
(...skipping 536 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
547 template <typename ElementsAccessorSubclass, | 547 template <typename ElementsAccessorSubclass, |
548 typename ElementsTraitsParam> | 548 typename ElementsTraitsParam> |
549 class ElementsAccessorBase : public ElementsAccessor { | 549 class ElementsAccessorBase : public ElementsAccessor { |
550 protected: | 550 protected: |
551 explicit ElementsAccessorBase(const char* name) | 551 explicit ElementsAccessorBase(const char* name) |
552 : ElementsAccessor(name) { } | 552 : ElementsAccessor(name) { } |
553 | 553 |
554 typedef ElementsTraitsParam ElementsTraits; | 554 typedef ElementsTraitsParam ElementsTraits; |
555 typedef typename ElementsTraitsParam::BackingStore BackingStore; | 555 typedef typename ElementsTraitsParam::BackingStore BackingStore; |
556 | 556 |
557 virtual ElementsKind kind() const V8_FINAL V8_OVERRIDE { | 557 virtual ElementsKind kind() const FINAL OVERRIDE { |
558 return ElementsTraits::Kind; | 558 return ElementsTraits::Kind; |
559 } | 559 } |
560 | 560 |
561 static void ValidateContents(Handle<JSObject> holder, int length) { | 561 static void ValidateContents(Handle<JSObject> holder, int length) { |
562 } | 562 } |
563 | 563 |
564 static void ValidateImpl(Handle<JSObject> holder) { | 564 static void ValidateImpl(Handle<JSObject> holder) { |
565 Handle<FixedArrayBase> fixed_array_base(holder->elements()); | 565 Handle<FixedArrayBase> fixed_array_base(holder->elements()); |
566 if (!fixed_array_base->IsHeapObject()) return; | 566 if (!fixed_array_base->IsHeapObject()) return; |
567 // Arrays that have been shifted in place can't be verified. | 567 // Arrays that have been shifted in place can't be verified. |
568 if (fixed_array_base->IsFiller()) return; | 568 if (fixed_array_base->IsFiller()) return; |
569 int length = 0; | 569 int length = 0; |
570 if (holder->IsJSArray()) { | 570 if (holder->IsJSArray()) { |
571 Object* length_obj = Handle<JSArray>::cast(holder)->length(); | 571 Object* length_obj = Handle<JSArray>::cast(holder)->length(); |
572 if (length_obj->IsSmi()) { | 572 if (length_obj->IsSmi()) { |
573 length = Smi::cast(length_obj)->value(); | 573 length = Smi::cast(length_obj)->value(); |
574 } | 574 } |
575 } else { | 575 } else { |
576 length = fixed_array_base->length(); | 576 length = fixed_array_base->length(); |
577 } | 577 } |
578 ElementsAccessorSubclass::ValidateContents(holder, length); | 578 ElementsAccessorSubclass::ValidateContents(holder, length); |
579 } | 579 } |
580 | 580 |
581 virtual void Validate(Handle<JSObject> holder) V8_FINAL V8_OVERRIDE { | 581 virtual void Validate(Handle<JSObject> holder) FINAL OVERRIDE { |
582 DisallowHeapAllocation no_gc; | 582 DisallowHeapAllocation no_gc; |
583 ElementsAccessorSubclass::ValidateImpl(holder); | 583 ElementsAccessorSubclass::ValidateImpl(holder); |
584 } | 584 } |
585 | 585 |
586 static bool HasElementImpl(Handle<Object> receiver, | 586 static bool HasElementImpl(Handle<Object> receiver, |
587 Handle<JSObject> holder, | 587 Handle<JSObject> holder, |
588 uint32_t key, | 588 uint32_t key, |
589 Handle<FixedArrayBase> backing_store) { | 589 Handle<FixedArrayBase> backing_store) { |
590 return ElementsAccessorSubclass::GetAttributesImpl( | 590 return ElementsAccessorSubclass::GetAttributesImpl( |
591 receiver, holder, key, backing_store) != ABSENT; | 591 receiver, holder, key, backing_store) != ABSENT; |
592 } | 592 } |
593 | 593 |
594 virtual bool HasElement( | 594 virtual bool HasElement( |
595 Handle<Object> receiver, | 595 Handle<Object> receiver, |
596 Handle<JSObject> holder, | 596 Handle<JSObject> holder, |
597 uint32_t key, | 597 uint32_t key, |
598 Handle<FixedArrayBase> backing_store) V8_FINAL V8_OVERRIDE { | 598 Handle<FixedArrayBase> backing_store) FINAL OVERRIDE { |
599 return ElementsAccessorSubclass::HasElementImpl( | 599 return ElementsAccessorSubclass::HasElementImpl( |
600 receiver, holder, key, backing_store); | 600 receiver, holder, key, backing_store); |
601 } | 601 } |
602 | 602 |
603 MUST_USE_RESULT virtual MaybeHandle<Object> Get( | 603 MUST_USE_RESULT virtual MaybeHandle<Object> Get( |
604 Handle<Object> receiver, | 604 Handle<Object> receiver, |
605 Handle<JSObject> holder, | 605 Handle<JSObject> holder, |
606 uint32_t key, | 606 uint32_t key, |
607 Handle<FixedArrayBase> backing_store) V8_FINAL V8_OVERRIDE { | 607 Handle<FixedArrayBase> backing_store) FINAL OVERRIDE { |
608 if (!IsExternalArrayElementsKind(ElementsTraits::Kind) && | 608 if (!IsExternalArrayElementsKind(ElementsTraits::Kind) && |
609 FLAG_trace_js_array_abuse) { | 609 FLAG_trace_js_array_abuse) { |
610 CheckArrayAbuse(holder, "elements read", key); | 610 CheckArrayAbuse(holder, "elements read", key); |
611 } | 611 } |
612 | 612 |
613 if (IsExternalArrayElementsKind(ElementsTraits::Kind) && | 613 if (IsExternalArrayElementsKind(ElementsTraits::Kind) && |
614 FLAG_trace_external_array_abuse) { | 614 FLAG_trace_external_array_abuse) { |
615 CheckArrayAbuse(holder, "external elements read", key); | 615 CheckArrayAbuse(holder, "external elements read", key); |
616 } | 616 } |
617 | 617 |
(...skipping 10 matching lines...) Expand all Loading... |
628 return BackingStore::get(Handle<BackingStore>::cast(backing_store), key); | 628 return BackingStore::get(Handle<BackingStore>::cast(backing_store), key); |
629 } else { | 629 } else { |
630 return backing_store->GetIsolate()->factory()->the_hole_value(); | 630 return backing_store->GetIsolate()->factory()->the_hole_value(); |
631 } | 631 } |
632 } | 632 } |
633 | 633 |
634 MUST_USE_RESULT virtual PropertyAttributes GetAttributes( | 634 MUST_USE_RESULT virtual PropertyAttributes GetAttributes( |
635 Handle<Object> receiver, | 635 Handle<Object> receiver, |
636 Handle<JSObject> holder, | 636 Handle<JSObject> holder, |
637 uint32_t key, | 637 uint32_t key, |
638 Handle<FixedArrayBase> backing_store) V8_FINAL V8_OVERRIDE { | 638 Handle<FixedArrayBase> backing_store) FINAL OVERRIDE { |
639 return ElementsAccessorSubclass::GetAttributesImpl( | 639 return ElementsAccessorSubclass::GetAttributesImpl( |
640 receiver, holder, key, backing_store); | 640 receiver, holder, key, backing_store); |
641 } | 641 } |
642 | 642 |
643 MUST_USE_RESULT static PropertyAttributes GetAttributesImpl( | 643 MUST_USE_RESULT static PropertyAttributes GetAttributesImpl( |
644 Handle<Object> receiver, | 644 Handle<Object> receiver, |
645 Handle<JSObject> obj, | 645 Handle<JSObject> obj, |
646 uint32_t key, | 646 uint32_t key, |
647 Handle<FixedArrayBase> backing_store) { | 647 Handle<FixedArrayBase> backing_store) { |
648 if (key >= ElementsAccessorSubclass::GetCapacityImpl(backing_store)) { | 648 if (key >= ElementsAccessorSubclass::GetCapacityImpl(backing_store)) { |
649 return ABSENT; | 649 return ABSENT; |
650 } | 650 } |
651 return | 651 return |
652 Handle<BackingStore>::cast(backing_store)->is_the_hole(key) | 652 Handle<BackingStore>::cast(backing_store)->is_the_hole(key) |
653 ? ABSENT : NONE; | 653 ? ABSENT : NONE; |
654 } | 654 } |
655 | 655 |
656 MUST_USE_RESULT virtual MaybeHandle<AccessorPair> GetAccessorPair( | 656 MUST_USE_RESULT virtual MaybeHandle<AccessorPair> GetAccessorPair( |
657 Handle<Object> receiver, | 657 Handle<Object> receiver, |
658 Handle<JSObject> holder, | 658 Handle<JSObject> holder, |
659 uint32_t key, | 659 uint32_t key, |
660 Handle<FixedArrayBase> backing_store) V8_FINAL V8_OVERRIDE { | 660 Handle<FixedArrayBase> backing_store) FINAL OVERRIDE { |
661 return ElementsAccessorSubclass::GetAccessorPairImpl( | 661 return ElementsAccessorSubclass::GetAccessorPairImpl( |
662 receiver, holder, key, backing_store); | 662 receiver, holder, key, backing_store); |
663 } | 663 } |
664 | 664 |
665 MUST_USE_RESULT static MaybeHandle<AccessorPair> GetAccessorPairImpl( | 665 MUST_USE_RESULT static MaybeHandle<AccessorPair> GetAccessorPairImpl( |
666 Handle<Object> receiver, | 666 Handle<Object> receiver, |
667 Handle<JSObject> obj, | 667 Handle<JSObject> obj, |
668 uint32_t key, | 668 uint32_t key, |
669 Handle<FixedArrayBase> backing_store) { | 669 Handle<FixedArrayBase> backing_store) { |
670 return MaybeHandle<AccessorPair>(); | 670 return MaybeHandle<AccessorPair>(); |
671 } | 671 } |
672 | 672 |
673 MUST_USE_RESULT virtual MaybeHandle<Object> SetLength( | 673 MUST_USE_RESULT virtual MaybeHandle<Object> SetLength( |
674 Handle<JSArray> array, | 674 Handle<JSArray> array, |
675 Handle<Object> length) V8_FINAL V8_OVERRIDE { | 675 Handle<Object> length) FINAL OVERRIDE { |
676 return ElementsAccessorSubclass::SetLengthImpl( | 676 return ElementsAccessorSubclass::SetLengthImpl( |
677 array, length, handle(array->elements())); | 677 array, length, handle(array->elements())); |
678 } | 678 } |
679 | 679 |
680 MUST_USE_RESULT static MaybeHandle<Object> SetLengthImpl( | 680 MUST_USE_RESULT static MaybeHandle<Object> SetLengthImpl( |
681 Handle<JSObject> obj, | 681 Handle<JSObject> obj, |
682 Handle<Object> length, | 682 Handle<Object> length, |
683 Handle<FixedArrayBase> backing_store); | 683 Handle<FixedArrayBase> backing_store); |
684 | 684 |
685 virtual void SetCapacityAndLength( | 685 virtual void SetCapacityAndLength( |
686 Handle<JSArray> array, | 686 Handle<JSArray> array, |
687 int capacity, | 687 int capacity, |
688 int length) V8_FINAL V8_OVERRIDE { | 688 int length) FINAL OVERRIDE { |
689 ElementsAccessorSubclass:: | 689 ElementsAccessorSubclass:: |
690 SetFastElementsCapacityAndLength(array, capacity, length); | 690 SetFastElementsCapacityAndLength(array, capacity, length); |
691 } | 691 } |
692 | 692 |
693 static void SetFastElementsCapacityAndLength( | 693 static void SetFastElementsCapacityAndLength( |
694 Handle<JSObject> obj, | 694 Handle<JSObject> obj, |
695 int capacity, | 695 int capacity, |
696 int length) { | 696 int length) { |
697 UNIMPLEMENTED(); | 697 UNIMPLEMENTED(); |
698 } | 698 } |
699 | 699 |
700 MUST_USE_RESULT virtual MaybeHandle<Object> Delete( | 700 MUST_USE_RESULT virtual MaybeHandle<Object> Delete( |
701 Handle<JSObject> obj, | 701 Handle<JSObject> obj, |
702 uint32_t key, | 702 uint32_t key, |
703 JSReceiver::DeleteMode mode) V8_OVERRIDE = 0; | 703 JSReceiver::DeleteMode mode) OVERRIDE = 0; |
704 | 704 |
705 static void CopyElementsImpl(Handle<FixedArrayBase> from, | 705 static void CopyElementsImpl(Handle<FixedArrayBase> from, |
706 uint32_t from_start, | 706 uint32_t from_start, |
707 Handle<FixedArrayBase> to, | 707 Handle<FixedArrayBase> to, |
708 ElementsKind from_kind, | 708 ElementsKind from_kind, |
709 uint32_t to_start, | 709 uint32_t to_start, |
710 int packed_size, | 710 int packed_size, |
711 int copy_size) { | 711 int copy_size) { |
712 UNREACHABLE(); | 712 UNREACHABLE(); |
713 } | 713 } |
714 | 714 |
715 virtual void CopyElements( | 715 virtual void CopyElements( |
716 Handle<FixedArrayBase> from, | 716 Handle<FixedArrayBase> from, |
717 uint32_t from_start, | 717 uint32_t from_start, |
718 ElementsKind from_kind, | 718 ElementsKind from_kind, |
719 Handle<FixedArrayBase> to, | 719 Handle<FixedArrayBase> to, |
720 uint32_t to_start, | 720 uint32_t to_start, |
721 int copy_size) V8_FINAL V8_OVERRIDE { | 721 int copy_size) FINAL OVERRIDE { |
722 DCHECK(!from.is_null()); | 722 DCHECK(!from.is_null()); |
723 ElementsAccessorSubclass::CopyElementsImpl( | 723 ElementsAccessorSubclass::CopyElementsImpl( |
724 from, from_start, to, from_kind, to_start, kPackedSizeNotKnown, | 724 from, from_start, to, from_kind, to_start, kPackedSizeNotKnown, |
725 copy_size); | 725 copy_size); |
726 } | 726 } |
727 | 727 |
728 virtual void CopyElements( | 728 virtual void CopyElements( |
729 JSObject* from_holder, | 729 JSObject* from_holder, |
730 uint32_t from_start, | 730 uint32_t from_start, |
731 ElementsKind from_kind, | 731 ElementsKind from_kind, |
732 Handle<FixedArrayBase> to, | 732 Handle<FixedArrayBase> to, |
733 uint32_t to_start, | 733 uint32_t to_start, |
734 int copy_size) V8_FINAL V8_OVERRIDE { | 734 int copy_size) FINAL OVERRIDE { |
735 int packed_size = kPackedSizeNotKnown; | 735 int packed_size = kPackedSizeNotKnown; |
736 bool is_packed = IsFastPackedElementsKind(from_kind) && | 736 bool is_packed = IsFastPackedElementsKind(from_kind) && |
737 from_holder->IsJSArray(); | 737 from_holder->IsJSArray(); |
738 if (is_packed) { | 738 if (is_packed) { |
739 packed_size = | 739 packed_size = |
740 Smi::cast(JSArray::cast(from_holder)->length())->value(); | 740 Smi::cast(JSArray::cast(from_holder)->length())->value(); |
741 if (copy_size >= 0 && packed_size > copy_size) { | 741 if (copy_size >= 0 && packed_size > copy_size) { |
742 packed_size = copy_size; | 742 packed_size = copy_size; |
743 } | 743 } |
744 } | 744 } |
745 Handle<FixedArrayBase> from(from_holder->elements()); | 745 Handle<FixedArrayBase> from(from_holder->elements()); |
746 ElementsAccessorSubclass::CopyElementsImpl( | 746 ElementsAccessorSubclass::CopyElementsImpl( |
747 from, from_start, to, from_kind, to_start, packed_size, copy_size); | 747 from, from_start, to, from_kind, to_start, packed_size, copy_size); |
748 } | 748 } |
749 | 749 |
750 virtual MaybeHandle<FixedArray> AddElementsToFixedArray( | 750 virtual MaybeHandle<FixedArray> AddElementsToFixedArray( |
751 Handle<Object> receiver, | 751 Handle<Object> receiver, |
752 Handle<JSObject> holder, | 752 Handle<JSObject> holder, |
753 Handle<FixedArray> to, | 753 Handle<FixedArray> to, |
754 Handle<FixedArrayBase> from) V8_FINAL V8_OVERRIDE { | 754 Handle<FixedArrayBase> from) FINAL OVERRIDE { |
755 int len0 = to->length(); | 755 int len0 = to->length(); |
756 #ifdef ENABLE_SLOW_DCHECKS | 756 #ifdef ENABLE_SLOW_DCHECKS |
757 if (FLAG_enable_slow_asserts) { | 757 if (FLAG_enable_slow_asserts) { |
758 for (int i = 0; i < len0; i++) { | 758 for (int i = 0; i < len0; i++) { |
759 DCHECK(!to->get(i)->IsTheHole()); | 759 DCHECK(!to->get(i)->IsTheHole()); |
760 } | 760 } |
761 } | 761 } |
762 #endif | 762 #endif |
763 | 763 |
764 // Optimize if 'other' is empty. | 764 // Optimize if 'other' is empty. |
(...skipping 58 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
823 DCHECK(extra == index); | 823 DCHECK(extra == index); |
824 return result; | 824 return result; |
825 } | 825 } |
826 | 826 |
827 protected: | 827 protected: |
828 static uint32_t GetCapacityImpl(Handle<FixedArrayBase> backing_store) { | 828 static uint32_t GetCapacityImpl(Handle<FixedArrayBase> backing_store) { |
829 return backing_store->length(); | 829 return backing_store->length(); |
830 } | 830 } |
831 | 831 |
832 virtual uint32_t GetCapacity(Handle<FixedArrayBase> backing_store) | 832 virtual uint32_t GetCapacity(Handle<FixedArrayBase> backing_store) |
833 V8_FINAL V8_OVERRIDE { | 833 FINAL OVERRIDE { |
834 return ElementsAccessorSubclass::GetCapacityImpl(backing_store); | 834 return ElementsAccessorSubclass::GetCapacityImpl(backing_store); |
835 } | 835 } |
836 | 836 |
837 static uint32_t GetKeyForIndexImpl(Handle<FixedArrayBase> backing_store, | 837 static uint32_t GetKeyForIndexImpl(Handle<FixedArrayBase> backing_store, |
838 uint32_t index) { | 838 uint32_t index) { |
839 return index; | 839 return index; |
840 } | 840 } |
841 | 841 |
842 virtual uint32_t GetKeyForIndex(Handle<FixedArrayBase> backing_store, | 842 virtual uint32_t GetKeyForIndex(Handle<FixedArrayBase> backing_store, |
843 uint32_t index) V8_FINAL V8_OVERRIDE { | 843 uint32_t index) FINAL OVERRIDE { |
844 return ElementsAccessorSubclass::GetKeyForIndexImpl(backing_store, index); | 844 return ElementsAccessorSubclass::GetKeyForIndexImpl(backing_store, index); |
845 } | 845 } |
846 | 846 |
847 private: | 847 private: |
848 DISALLOW_COPY_AND_ASSIGN(ElementsAccessorBase); | 848 DISALLOW_COPY_AND_ASSIGN(ElementsAccessorBase); |
849 }; | 849 }; |
850 | 850 |
851 | 851 |
852 // Super class for all fast element arrays. | 852 // Super class for all fast element arrays. |
853 template<typename FastElementsAccessorSubclass, | 853 template<typename FastElementsAccessorSubclass, |
(...skipping 116 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
970 JSObject::NormalizeElements(obj); | 970 JSObject::NormalizeElements(obj); |
971 } | 971 } |
972 } | 972 } |
973 } | 973 } |
974 return isolate->factory()->true_value(); | 974 return isolate->factory()->true_value(); |
975 } | 975 } |
976 | 976 |
977 virtual MaybeHandle<Object> Delete( | 977 virtual MaybeHandle<Object> Delete( |
978 Handle<JSObject> obj, | 978 Handle<JSObject> obj, |
979 uint32_t key, | 979 uint32_t key, |
980 JSReceiver::DeleteMode mode) V8_FINAL V8_OVERRIDE { | 980 JSReceiver::DeleteMode mode) FINAL OVERRIDE { |
981 return DeleteCommon(obj, key, mode); | 981 return DeleteCommon(obj, key, mode); |
982 } | 982 } |
983 | 983 |
984 static bool HasElementImpl( | 984 static bool HasElementImpl( |
985 Handle<Object> receiver, | 985 Handle<Object> receiver, |
986 Handle<JSObject> holder, | 986 Handle<JSObject> holder, |
987 uint32_t key, | 987 uint32_t key, |
988 Handle<FixedArrayBase> backing_store) { | 988 Handle<FixedArrayBase> backing_store) { |
989 if (key >= static_cast<uint32_t>(backing_store->length())) { | 989 if (key >= static_cast<uint32_t>(backing_store->length())) { |
990 return false; | 990 return false; |
(...skipping 302 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1293 Handle<Object> length, | 1293 Handle<Object> length, |
1294 Handle<FixedArrayBase> backing_store) { | 1294 Handle<FixedArrayBase> backing_store) { |
1295 // External arrays do not support changing their length. | 1295 // External arrays do not support changing their length. |
1296 UNREACHABLE(); | 1296 UNREACHABLE(); |
1297 return obj; | 1297 return obj; |
1298 } | 1298 } |
1299 | 1299 |
1300 MUST_USE_RESULT virtual MaybeHandle<Object> Delete( | 1300 MUST_USE_RESULT virtual MaybeHandle<Object> Delete( |
1301 Handle<JSObject> obj, | 1301 Handle<JSObject> obj, |
1302 uint32_t key, | 1302 uint32_t key, |
1303 JSReceiver::DeleteMode mode) V8_FINAL V8_OVERRIDE { | 1303 JSReceiver::DeleteMode mode) FINAL OVERRIDE { |
1304 // External arrays always ignore deletes. | 1304 // External arrays always ignore deletes. |
1305 return obj->GetIsolate()->factory()->true_value(); | 1305 return obj->GetIsolate()->factory()->true_value(); |
1306 } | 1306 } |
1307 | 1307 |
1308 static bool HasElementImpl(Handle<Object> receiver, | 1308 static bool HasElementImpl(Handle<Object> receiver, |
1309 Handle<JSObject> holder, | 1309 Handle<JSObject> holder, |
1310 uint32_t key, | 1310 uint32_t key, |
1311 Handle<FixedArrayBase> backing_store) { | 1311 Handle<FixedArrayBase> backing_store) { |
1312 uint32_t capacity = | 1312 uint32_t capacity = |
1313 AccessorClass::GetCapacityImpl(backing_store); | 1313 AccessorClass::GetCapacityImpl(backing_store); |
(...skipping 136 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1450 } | 1450 } |
1451 | 1451 |
1452 | 1452 |
1453 protected: | 1453 protected: |
1454 friend class ElementsAccessorBase<DictionaryElementsAccessor, | 1454 friend class ElementsAccessorBase<DictionaryElementsAccessor, |
1455 ElementsKindTraits<DICTIONARY_ELEMENTS> >; | 1455 ElementsKindTraits<DICTIONARY_ELEMENTS> >; |
1456 | 1456 |
1457 MUST_USE_RESULT virtual MaybeHandle<Object> Delete( | 1457 MUST_USE_RESULT virtual MaybeHandle<Object> Delete( |
1458 Handle<JSObject> obj, | 1458 Handle<JSObject> obj, |
1459 uint32_t key, | 1459 uint32_t key, |
1460 JSReceiver::DeleteMode mode) V8_FINAL V8_OVERRIDE { | 1460 JSReceiver::DeleteMode mode) FINAL OVERRIDE { |
1461 return DeleteCommon(obj, key, mode); | 1461 return DeleteCommon(obj, key, mode); |
1462 } | 1462 } |
1463 | 1463 |
1464 MUST_USE_RESULT static MaybeHandle<Object> GetImpl( | 1464 MUST_USE_RESULT static MaybeHandle<Object> GetImpl( |
1465 Handle<Object> receiver, | 1465 Handle<Object> receiver, |
1466 Handle<JSObject> obj, | 1466 Handle<JSObject> obj, |
1467 uint32_t key, | 1467 uint32_t key, |
1468 Handle<FixedArrayBase> store) { | 1468 Handle<FixedArrayBase> store) { |
1469 Handle<SeededNumberDictionary> backing_store = | 1469 Handle<SeededNumberDictionary> backing_store = |
1470 Handle<SeededNumberDictionary>::cast(store); | 1470 Handle<SeededNumberDictionary>::cast(store); |
(...skipping 153 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1624 Handle<FixedArrayBase> parameter_map) { | 1624 Handle<FixedArrayBase> parameter_map) { |
1625 // TODO(mstarzinger): This was never implemented but will be used once we | 1625 // TODO(mstarzinger): This was never implemented but will be used once we |
1626 // correctly implement [[DefineOwnProperty]] on arrays. | 1626 // correctly implement [[DefineOwnProperty]] on arrays. |
1627 UNIMPLEMENTED(); | 1627 UNIMPLEMENTED(); |
1628 return obj; | 1628 return obj; |
1629 } | 1629 } |
1630 | 1630 |
1631 MUST_USE_RESULT virtual MaybeHandle<Object> Delete( | 1631 MUST_USE_RESULT virtual MaybeHandle<Object> Delete( |
1632 Handle<JSObject> obj, | 1632 Handle<JSObject> obj, |
1633 uint32_t key, | 1633 uint32_t key, |
1634 JSReceiver::DeleteMode mode) V8_FINAL V8_OVERRIDE { | 1634 JSReceiver::DeleteMode mode) FINAL OVERRIDE { |
1635 Isolate* isolate = obj->GetIsolate(); | 1635 Isolate* isolate = obj->GetIsolate(); |
1636 Handle<FixedArray> parameter_map(FixedArray::cast(obj->elements())); | 1636 Handle<FixedArray> parameter_map(FixedArray::cast(obj->elements())); |
1637 Handle<Object> probe = GetParameterMapArg(obj, parameter_map, key); | 1637 Handle<Object> probe = GetParameterMapArg(obj, parameter_map, key); |
1638 if (!probe->IsTheHole()) { | 1638 if (!probe->IsTheHole()) { |
1639 // TODO(kmillikin): We could check if this was the last aliased | 1639 // TODO(kmillikin): We could check if this was the last aliased |
1640 // parameter, and revert to normal elements in that case. That | 1640 // parameter, and revert to normal elements in that case. That |
1641 // would enable GC of the context. | 1641 // would enable GC of the context. |
1642 parameter_map->set_the_hole(key + 2); | 1642 parameter_map->set_the_hole(key + 2); |
1643 } else { | 1643 } else { |
1644 Handle<FixedArray> arguments(FixedArray::cast(parameter_map->get(1))); | 1644 Handle<FixedArray> arguments(FixedArray::cast(parameter_map->get(1))); |
(...skipping 252 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1897 UNREACHABLE(); | 1897 UNREACHABLE(); |
1898 break; | 1898 break; |
1899 } | 1899 } |
1900 | 1900 |
1901 array->set_elements(*elms); | 1901 array->set_elements(*elms); |
1902 array->set_length(Smi::FromInt(number_of_elements)); | 1902 array->set_length(Smi::FromInt(number_of_elements)); |
1903 return array; | 1903 return array; |
1904 } | 1904 } |
1905 | 1905 |
1906 } } // namespace v8::internal | 1906 } } // namespace v8::internal |
OLD | NEW |