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/elements.h" | 5 #include "src/elements.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/factory.h" | 9 #include "src/factory.h" |
10 #include "src/isolate-inl.h" | 10 #include "src/isolate-inl.h" |
(...skipping 682 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
693 uint32_t unshift_size) final { | 693 uint32_t unshift_size) final { |
694 return Subclass::UnshiftImpl(receiver, args, unshift_size); | 694 return Subclass::UnshiftImpl(receiver, args, unshift_size); |
695 } | 695 } |
696 | 696 |
697 static uint32_t UnshiftImpl(Handle<JSArray> receiver, Arguments* args, | 697 static uint32_t UnshiftImpl(Handle<JSArray> receiver, Arguments* args, |
698 uint32_t unshift_size) { | 698 uint32_t unshift_size) { |
699 UNREACHABLE(); | 699 UNREACHABLE(); |
700 return 0; | 700 return 0; |
701 } | 701 } |
702 | 702 |
703 Handle<JSArray> Slice(Handle<JSObject> receiver, uint32_t start, | 703 Handle<JSObject> Slice(Handle<JSObject> receiver, uint32_t start, |
704 uint32_t end) final { | 704 uint32_t end) final { |
705 return Subclass::SliceImpl(receiver, start, end); | 705 return Subclass::SliceImpl(receiver, start, end); |
706 } | 706 } |
707 | 707 |
708 static Handle<JSArray> SliceImpl(Handle<JSObject> receiver, | 708 Handle<JSObject> Slice(Handle<JSObject> receiver, uint32_t start, |
709 uint32_t start, uint32_t end) { | 709 uint32_t end, Handle<JSObject> result) final { |
710 return Subclass::SliceWithResultImpl(receiver, start, end, result); | |
711 } | |
712 | |
713 static Handle<JSObject> SliceImpl(Handle<JSObject> receiver, uint32_t start, | |
714 uint32_t end) { | |
710 UNREACHABLE(); | 715 UNREACHABLE(); |
711 return Handle<JSArray>(); | 716 return Handle<JSObject>(); |
717 } | |
718 | |
719 static Handle<JSObject> SliceWithResultImpl(Handle<JSObject> receiver, | |
720 uint32_t start, uint32_t end, | |
721 Handle<JSObject> result) { | |
722 return Subclass::SliceImpl(receiver, start, end); | |
Camillo Bruni
2017/03/27 08:59:01
This should be UNREACHABLE(); since it is not poss
Choongwoo Han
2017/03/27 12:36:33
Done.
| |
712 } | 723 } |
713 | 724 |
714 Handle<JSArray> Splice(Handle<JSArray> receiver, uint32_t start, | 725 Handle<JSArray> Splice(Handle<JSArray> receiver, uint32_t start, |
715 uint32_t delete_count, Arguments* args, | 726 uint32_t delete_count, Arguments* args, |
716 uint32_t add_count) final { | 727 uint32_t add_count) final { |
717 return Subclass::SpliceImpl(receiver, start, delete_count, args, add_count); | 728 return Subclass::SpliceImpl(receiver, start, delete_count, args, add_count); |
718 } | 729 } |
719 | 730 |
720 static Handle<JSArray> SpliceImpl(Handle<JSArray> receiver, | 731 static Handle<JSArray> SpliceImpl(Handle<JSArray> receiver, |
721 uint32_t start, uint32_t delete_count, | 732 uint32_t start, uint32_t delete_count, |
(...skipping 1320 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
2042 AT_END); | 2053 AT_END); |
2043 } | 2054 } |
2044 | 2055 |
2045 static uint32_t UnshiftImpl(Handle<JSArray> receiver, | 2056 static uint32_t UnshiftImpl(Handle<JSArray> receiver, |
2046 Arguments* args, uint32_t unshift_size) { | 2057 Arguments* args, uint32_t unshift_size) { |
2047 Handle<FixedArrayBase> backing_store(receiver->elements()); | 2058 Handle<FixedArrayBase> backing_store(receiver->elements()); |
2048 return Subclass::AddArguments(receiver, backing_store, args, unshift_size, | 2059 return Subclass::AddArguments(receiver, backing_store, args, unshift_size, |
2049 AT_START); | 2060 AT_START); |
2050 } | 2061 } |
2051 | 2062 |
2052 static Handle<JSArray> SliceImpl(Handle<JSObject> receiver, | 2063 static Handle<JSObject> SliceImpl(Handle<JSObject> receiver, uint32_t start, |
2053 uint32_t start, uint32_t end) { | 2064 uint32_t end) { |
2054 Isolate* isolate = receiver->GetIsolate(); | 2065 Isolate* isolate = receiver->GetIsolate(); |
2055 Handle<FixedArrayBase> backing_store(receiver->elements(), isolate); | 2066 Handle<FixedArrayBase> backing_store(receiver->elements(), isolate); |
2056 int result_len = end < start ? 0u : end - start; | 2067 int result_len = end < start ? 0u : end - start; |
2057 Handle<JSArray> result_array = isolate->factory()->NewJSArray( | 2068 Handle<JSArray> result_array = isolate->factory()->NewJSArray( |
2058 KindTraits::Kind, result_len, result_len); | 2069 KindTraits::Kind, result_len, result_len); |
2059 DisallowHeapAllocation no_gc; | 2070 DisallowHeapAllocation no_gc; |
2060 Subclass::CopyElementsImpl(*backing_store, start, result_array->elements(), | 2071 Subclass::CopyElementsImpl(*backing_store, start, result_array->elements(), |
2061 KindTraits::Kind, 0, kPackedSizeNotKnown, | 2072 KindTraits::Kind, 0, kPackedSizeNotKnown, |
2062 result_len); | 2073 result_len); |
2063 Subclass::TryTransitionResultArrayToPacked(result_array); | 2074 Subclass::TryTransitionResultArrayToPacked(result_array); |
(...skipping 981 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
3045 DCHECK(!WasNeutered(receiver)); | 3056 DCHECK(!WasNeutered(receiver)); |
3046 | 3057 |
3047 BackingStore* elements = BackingStore::cast(receiver->elements()); | 3058 BackingStore* elements = BackingStore::cast(receiver->elements()); |
3048 | 3059 |
3049 uint32_t len = elements->length(); | 3060 uint32_t len = elements->length(); |
3050 if (len == 0) return; | 3061 if (len == 0) return; |
3051 | 3062 |
3052 ctype* data = static_cast<ctype*>(elements->DataPtr()); | 3063 ctype* data = static_cast<ctype*>(elements->DataPtr()); |
3053 std::reverse(data, data + len); | 3064 std::reverse(data, data + len); |
3054 } | 3065 } |
3066 | |
3067 static Handle<JSObject> SliceWithResultImpl(Handle<JSObject> receiver, | |
3068 uint32_t start, uint32_t end, | |
3069 Handle<JSObject> result) { | |
3070 Isolate* isolate = receiver->GetIsolate(); | |
3071 DCHECK(!WasNeutered(*receiver)); | |
3072 DCHECK(result->IsJSTypedArray()); | |
3073 DCHECK(!WasNeutered(*result)); | |
3074 DCHECK_LE(start, end); | |
3075 | |
3076 Handle<JSTypedArray> array = Handle<JSTypedArray>::cast(receiver); | |
3077 Handle<JSTypedArray> result_array = Handle<JSTypedArray>::cast(result); | |
3078 DCHECK_LE(end, array->length_value()); | |
3079 | |
3080 // Fast path for the same type result array | |
3081 if (result_array->type() == array->type()) { | |
3082 int64_t element_size = array->element_size(); | |
3083 int64_t count = std::max<int64_t>(end - start, 0); | |
3084 | |
3085 DisallowHeapAllocation no_gc; | |
3086 BackingStore* src_elements = BackingStore::cast(receiver->elements()); | |
3087 BackingStore* result_elements = | |
3088 BackingStore::cast(result_array->elements()); | |
3089 | |
3090 DCHECK_LE(count, result_elements->length()); | |
3091 | |
3092 uint8_t* src = static_cast<uint8_t*>(src_elements->DataPtr()); | |
3093 uint8_t* result = static_cast<uint8_t*>(result_elements->DataPtr()); | |
3094 std::memcpy(result, src + start * element_size, count * element_size); | |
3095 return result_array; | |
3096 } | |
3097 | |
3098 // If the types of the two typed arrays are different, properly convert | |
3099 // elements | |
3100 Handle<BackingStore> from(BackingStore::cast(array->elements()), isolate); | |
3101 ElementsAccessor* result_accessor = result_array->GetElementsAccessor(); | |
3102 for (uint32_t k = start; k < end; k++) { | |
Camillo Bruni
2017/03/27 08:59:01
nit: please use "i" as iteration index.
Choongwoo Han
2017/03/27 12:36:33
Done.
| |
3103 Handle<Object> elem = AccessorClass::GetImpl(isolate, *from, k); | |
3104 result_accessor->Set(result_array, k, *elem); | |
3105 } | |
3106 return result_array; | |
3107 } | |
3055 }; | 3108 }; |
3056 | 3109 |
3057 #define FIXED_ELEMENTS_ACCESSOR(Type, type, TYPE, ctype, size) \ | 3110 #define FIXED_ELEMENTS_ACCESSOR(Type, type, TYPE, ctype, size) \ |
3058 typedef TypedElementsAccessor<TYPE##_ELEMENTS, ctype> \ | 3111 typedef TypedElementsAccessor<TYPE##_ELEMENTS, ctype> \ |
3059 Fixed##Type##ElementsAccessor; | 3112 Fixed##Type##ElementsAccessor; |
3060 | 3113 |
3061 TYPED_ARRAYS(FIXED_ELEMENTS_ACCESSOR) | 3114 TYPED_ARRAYS(FIXED_ELEMENTS_ACCESSOR) |
3062 #undef FIXED_ELEMENTS_ACCESSOR | 3115 #undef FIXED_ELEMENTS_ACCESSOR |
3063 | 3116 |
3064 template <typename Subclass, typename ArgumentsAccessor, typename KindTraits> | 3117 template <typename Subclass, typename ArgumentsAccessor, typename KindTraits> |
(...skipping 417 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
3482 FastSloppyArgumentsElementsAccessor, | 3535 FastSloppyArgumentsElementsAccessor, |
3483 FastHoleyObjectElementsAccessor, | 3536 FastHoleyObjectElementsAccessor, |
3484 ElementsKindTraits<FAST_SLOPPY_ARGUMENTS_ELEMENTS> >(name) {} | 3537 ElementsKindTraits<FAST_SLOPPY_ARGUMENTS_ELEMENTS> >(name) {} |
3485 | 3538 |
3486 static Handle<FixedArray> GetArguments(Isolate* isolate, | 3539 static Handle<FixedArray> GetArguments(Isolate* isolate, |
3487 FixedArrayBase* backing_store) { | 3540 FixedArrayBase* backing_store) { |
3488 FixedArray* parameter_map = FixedArray::cast(backing_store); | 3541 FixedArray* parameter_map = FixedArray::cast(backing_store); |
3489 return Handle<FixedArray>(FixedArray::cast(parameter_map->get(1)), isolate); | 3542 return Handle<FixedArray>(FixedArray::cast(parameter_map->get(1)), isolate); |
3490 } | 3543 } |
3491 | 3544 |
3492 static Handle<JSArray> SliceImpl(Handle<JSObject> receiver, uint32_t start, | 3545 static Handle<JSObject> SliceImpl(Handle<JSObject> receiver, uint32_t start, |
3493 uint32_t end) { | 3546 uint32_t end) { |
3494 Isolate* isolate = receiver->GetIsolate(); | 3547 Isolate* isolate = receiver->GetIsolate(); |
3495 uint32_t result_len = end < start ? 0u : end - start; | 3548 uint32_t result_len = end < start ? 0u : end - start; |
3496 Handle<JSArray> result_array = isolate->factory()->NewJSArray( | 3549 Handle<JSArray> result_array = isolate->factory()->NewJSArray( |
3497 FAST_HOLEY_ELEMENTS, result_len, result_len); | 3550 FAST_HOLEY_ELEMENTS, result_len, result_len); |
3498 DisallowHeapAllocation no_gc; | 3551 DisallowHeapAllocation no_gc; |
3499 FixedArray* elements = FixedArray::cast(result_array->elements()); | 3552 FixedArray* elements = FixedArray::cast(result_array->elements()); |
3500 FixedArray* parameters = FixedArray::cast(receiver->elements()); | 3553 FixedArray* parameters = FixedArray::cast(receiver->elements()); |
3501 uint32_t insertion_index = 0; | 3554 uint32_t insertion_index = 0; |
3502 for (uint32_t i = start; i < end; i++) { | 3555 for (uint32_t i = start; i < end; i++) { |
3503 uint32_t entry = GetEntryForIndexImpl(isolate, *receiver, parameters, i, | 3556 uint32_t entry = GetEntryForIndexImpl(isolate, *receiver, parameters, i, |
(...skipping 496 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
4000 insertion_index += len; | 4053 insertion_index += len; |
4001 } | 4054 } |
4002 | 4055 |
4003 DCHECK_EQ(insertion_index, result_len); | 4056 DCHECK_EQ(insertion_index, result_len); |
4004 return result_array; | 4057 return result_array; |
4005 } | 4058 } |
4006 | 4059 |
4007 ElementsAccessor** ElementsAccessor::elements_accessors_ = NULL; | 4060 ElementsAccessor** ElementsAccessor::elements_accessors_ = NULL; |
4008 } // namespace internal | 4061 } // namespace internal |
4009 } // namespace v8 | 4062 } // namespace v8 |
OLD | NEW |