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/builtins.h" | 5 #include "src/builtins.h" |
6 | 6 |
7 #include "src/api.h" | 7 #include "src/api.h" |
8 #include "src/api-arguments.h" | 8 #include "src/api-arguments.h" |
9 #include "src/api-natives.h" | 9 #include "src/api-natives.h" |
10 #include "src/base/once.h" | 10 #include "src/base/once.h" |
(...skipping 755 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
766 } | 766 } |
767 | 767 |
768 private: | 768 private: |
769 // Convert storage to dictionary mode. | 769 // Convert storage to dictionary mode. |
770 void SetDictionaryMode() { | 770 void SetDictionaryMode() { |
771 DCHECK(fast_elements() && is_fixed_array()); | 771 DCHECK(fast_elements() && is_fixed_array()); |
772 Handle<FixedArray> current_storage = storage_fixed_array(); | 772 Handle<FixedArray> current_storage = storage_fixed_array(); |
773 Handle<SeededNumberDictionary> slow_storage( | 773 Handle<SeededNumberDictionary> slow_storage( |
774 SeededNumberDictionary::New(isolate_, current_storage->length())); | 774 SeededNumberDictionary::New(isolate_, current_storage->length())); |
775 uint32_t current_length = static_cast<uint32_t>(current_storage->length()); | 775 uint32_t current_length = static_cast<uint32_t>(current_storage->length()); |
776 for (uint32_t i = 0; i < current_length; i++) { | 776 FOR_WITH_HANDLE_SCOPE( |
777 HandleScope loop_scope(isolate_); | 777 isolate_, uint32_t, i = 0, i, i < current_length, i++, { |
778 Handle<Object> element(current_storage->get(i), isolate_); | 778 Handle<Object> element(current_storage->get(i), isolate_); |
779 if (!element->IsTheHole()) { | 779 if (!element->IsTheHole()) { |
780 // The object holding this backing store has just been allocated, so | 780 // The object holding this backing store has just been allocated, so |
781 // it cannot yet be used as a prototype. | 781 // it cannot yet be used as a prototype. |
782 Handle<SeededNumberDictionary> new_storage = | 782 Handle<SeededNumberDictionary> new_storage = |
783 SeededNumberDictionary::AtNumberPut(slow_storage, i, element, | 783 SeededNumberDictionary::AtNumberPut(slow_storage, i, element, |
784 false); | 784 false); |
785 if (!new_storage.is_identical_to(slow_storage)) { | 785 if (!new_storage.is_identical_to(slow_storage)) { |
786 slow_storage = loop_scope.CloseAndEscape(new_storage); | 786 slow_storage = loop_scope.CloseAndEscape(new_storage); |
787 } | 787 } |
788 } | 788 } |
789 } | 789 }); |
790 clear_storage(); | 790 clear_storage(); |
791 set_storage(*slow_storage); | 791 set_storage(*slow_storage); |
792 set_fast_elements(false); | 792 set_fast_elements(false); |
793 } | 793 } |
794 | 794 |
795 inline void clear_storage() { | 795 inline void clear_storage() { |
796 GlobalHandles::Destroy(Handle<Object>::cast(storage_).location()); | 796 GlobalHandles::Destroy(Handle<Object>::cast(storage_).location()); |
797 } | 797 } |
798 | 798 |
799 inline void set_storage(FixedArray* storage) { | 799 inline void set_storage(FixedArray* storage) { |
(...skipping 132 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
932 if (!elements->is_the_hole(i)) { | 932 if (!elements->is_the_hole(i)) { |
933 indices->Add(i); | 933 indices->Add(i); |
934 } | 934 } |
935 } | 935 } |
936 break; | 936 break; |
937 } | 937 } |
938 case DICTIONARY_ELEMENTS: { | 938 case DICTIONARY_ELEMENTS: { |
939 Handle<SeededNumberDictionary> dict( | 939 Handle<SeededNumberDictionary> dict( |
940 SeededNumberDictionary::cast(object->elements())); | 940 SeededNumberDictionary::cast(object->elements())); |
941 uint32_t capacity = dict->Capacity(); | 941 uint32_t capacity = dict->Capacity(); |
942 for (uint32_t j = 0; j < capacity; j++) { | 942 FOR_WITH_HANDLE_SCOPE(isolate, uint32_t, j = 0, j, j < capacity, j++, { |
943 HandleScope loop_scope(isolate); | |
944 Handle<Object> k(dict->KeyAt(j), isolate); | 943 Handle<Object> k(dict->KeyAt(j), isolate); |
945 if (dict->IsKey(*k)) { | 944 if (dict->IsKey(*k)) { |
946 DCHECK(k->IsNumber()); | 945 DCHECK(k->IsNumber()); |
947 uint32_t index = static_cast<uint32_t>(k->Number()); | 946 uint32_t index = static_cast<uint32_t>(k->Number()); |
948 if (index < range) { | 947 if (index < range) { |
949 indices->Add(index); | 948 indices->Add(index); |
950 } | 949 } |
951 } | 950 } |
952 } | 951 }); |
953 break; | 952 break; |
954 } | 953 } |
955 #define TYPED_ARRAY_CASE(Type, type, TYPE, ctype, size) case TYPE##_ELEMENTS: | 954 #define TYPED_ARRAY_CASE(Type, type, TYPE, ctype, size) case TYPE##_ELEMENTS: |
956 | 955 |
957 TYPED_ARRAYS(TYPED_ARRAY_CASE) | 956 TYPED_ARRAYS(TYPED_ARRAY_CASE) |
958 #undef TYPED_ARRAY_CASE | 957 #undef TYPED_ARRAY_CASE |
959 { | 958 { |
960 uint32_t length = static_cast<uint32_t>( | 959 uint32_t length = static_cast<uint32_t>( |
961 FixedArrayBase::cast(object->elements())->length()); | 960 FixedArrayBase::cast(object->elements())->length()); |
962 if (range <= length) { | 961 if (range <= length) { |
(...skipping 47 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
1010 // The prototype will usually have no inherited element indices, | 1009 // The prototype will usually have no inherited element indices, |
1011 // but we have to check. | 1010 // but we have to check. |
1012 CollectElementIndices(PrototypeIterator::GetCurrent<JSObject>(iter), range, | 1011 CollectElementIndices(PrototypeIterator::GetCurrent<JSObject>(iter), range, |
1013 indices); | 1012 indices); |
1014 } | 1013 } |
1015 } | 1014 } |
1016 | 1015 |
1017 | 1016 |
1018 bool IterateElementsSlow(Isolate* isolate, Handle<JSReceiver> receiver, | 1017 bool IterateElementsSlow(Isolate* isolate, Handle<JSReceiver> receiver, |
1019 uint32_t length, ArrayConcatVisitor* visitor) { | 1018 uint32_t length, ArrayConcatVisitor* visitor) { |
1020 for (uint32_t i = 0; i < length; ++i) { | 1019 FOR_WITH_HANDLE_SCOPE(isolate, uint32_t, i = 0, i, i < length, ++i, { |
1021 HandleScope loop_scope(isolate); | |
1022 Maybe<bool> maybe = JSReceiver::HasElement(receiver, i); | 1020 Maybe<bool> maybe = JSReceiver::HasElement(receiver, i); |
1023 if (!maybe.IsJust()) return false; | 1021 if (!maybe.IsJust()) return false; |
1024 if (maybe.FromJust()) { | 1022 if (maybe.FromJust()) { |
1025 Handle<Object> element_value; | 1023 Handle<Object> element_value; |
1026 ASSIGN_RETURN_ON_EXCEPTION_VALUE( | 1024 ASSIGN_RETURN_ON_EXCEPTION_VALUE( |
1027 isolate, element_value, JSReceiver::GetElement(isolate, receiver, i), | 1025 isolate, element_value, JSReceiver::GetElement(isolate, receiver, i), |
1028 false); | 1026 false); |
1029 if (!visitor->visit(i, element_value)) return false; | 1027 if (!visitor->visit(i, element_value)) return false; |
1030 } | 1028 } |
1031 } | 1029 }); |
1032 visitor->increase_index_offset(length); | 1030 visitor->increase_index_offset(length); |
1033 return true; | 1031 return true; |
1034 } | 1032 } |
1035 | 1033 |
1036 | 1034 |
1037 /** | 1035 /** |
1038 * A helper function that visits "array" elements of a JSReceiver in numerical | 1036 * A helper function that visits "array" elements of a JSReceiver in numerical |
1039 * order. | 1037 * order. |
1040 * | 1038 * |
1041 * The visitor argument called for each existing element in the array | 1039 * The visitor argument called for each existing element in the array |
(...skipping 33 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
1075 switch (array->GetElementsKind()) { | 1073 switch (array->GetElementsKind()) { |
1076 case FAST_SMI_ELEMENTS: | 1074 case FAST_SMI_ELEMENTS: |
1077 case FAST_ELEMENTS: | 1075 case FAST_ELEMENTS: |
1078 case FAST_HOLEY_SMI_ELEMENTS: | 1076 case FAST_HOLEY_SMI_ELEMENTS: |
1079 case FAST_HOLEY_ELEMENTS: { | 1077 case FAST_HOLEY_ELEMENTS: { |
1080 // Run through the elements FixedArray and use HasElement and GetElement | 1078 // Run through the elements FixedArray and use HasElement and GetElement |
1081 // to check the prototype for missing elements. | 1079 // to check the prototype for missing elements. |
1082 Handle<FixedArray> elements(FixedArray::cast(array->elements())); | 1080 Handle<FixedArray> elements(FixedArray::cast(array->elements())); |
1083 int fast_length = static_cast<int>(length); | 1081 int fast_length = static_cast<int>(length); |
1084 DCHECK(fast_length <= elements->length()); | 1082 DCHECK(fast_length <= elements->length()); |
1085 for (int j = 0; j < fast_length; j++) { | 1083 FOR_WITH_HANDLE_SCOPE(isolate, int, j = 0, j, j < fast_length, j++, { |
1086 HandleScope loop_scope(isolate); | |
1087 Handle<Object> element_value(elements->get(j), isolate); | 1084 Handle<Object> element_value(elements->get(j), isolate); |
1088 if (!element_value->IsTheHole()) { | 1085 if (!element_value->IsTheHole()) { |
1089 if (!visitor->visit(j, element_value)) return false; | 1086 if (!visitor->visit(j, element_value)) return false; |
1090 } else { | 1087 } else { |
1091 Maybe<bool> maybe = JSReceiver::HasElement(array, j); | 1088 Maybe<bool> maybe = JSReceiver::HasElement(array, j); |
1092 if (!maybe.IsJust()) return false; | 1089 if (!maybe.IsJust()) return false; |
1093 if (maybe.FromJust()) { | 1090 if (maybe.FromJust()) { |
1094 // Call GetElement on array, not its prototype, or getters won't | 1091 // Call GetElement on array, not its prototype, or getters won't |
1095 // have the correct receiver. | 1092 // have the correct receiver. |
1096 ASSIGN_RETURN_ON_EXCEPTION_VALUE( | 1093 ASSIGN_RETURN_ON_EXCEPTION_VALUE( |
1097 isolate, element_value, | 1094 isolate, element_value, |
1098 JSReceiver::GetElement(isolate, array, j), false); | 1095 JSReceiver::GetElement(isolate, array, j), false); |
1099 if (!visitor->visit(j, element_value)) return false; | 1096 if (!visitor->visit(j, element_value)) return false; |
1100 } | 1097 } |
1101 } | 1098 } |
1102 } | 1099 }); |
1103 break; | 1100 break; |
1104 } | 1101 } |
1105 case FAST_HOLEY_DOUBLE_ELEMENTS: | 1102 case FAST_HOLEY_DOUBLE_ELEMENTS: |
1106 case FAST_DOUBLE_ELEMENTS: { | 1103 case FAST_DOUBLE_ELEMENTS: { |
1107 // Empty array is FixedArray but not FixedDoubleArray. | 1104 // Empty array is FixedArray but not FixedDoubleArray. |
1108 if (length == 0) break; | 1105 if (length == 0) break; |
1109 // Run through the elements FixedArray and use HasElement and GetElement | 1106 // Run through the elements FixedArray and use HasElement and GetElement |
1110 // to check the prototype for missing elements. | 1107 // to check the prototype for missing elements. |
1111 if (array->elements()->IsFixedArray()) { | 1108 if (array->elements()->IsFixedArray()) { |
1112 DCHECK(array->elements()->length() == 0); | 1109 DCHECK(array->elements()->length() == 0); |
1113 break; | 1110 break; |
1114 } | 1111 } |
1115 Handle<FixedDoubleArray> elements( | 1112 Handle<FixedDoubleArray> elements( |
1116 FixedDoubleArray::cast(array->elements())); | 1113 FixedDoubleArray::cast(array->elements())); |
1117 int fast_length = static_cast<int>(length); | 1114 int fast_length = static_cast<int>(length); |
1118 DCHECK(fast_length <= elements->length()); | 1115 DCHECK(fast_length <= elements->length()); |
1119 for (int j = 0; j < fast_length; j++) { | 1116 FOR_WITH_HANDLE_SCOPE(isolate, int, j = 0, j, j < fast_length, j++, { |
1120 HandleScope loop_scope(isolate); | |
1121 if (!elements->is_the_hole(j)) { | 1117 if (!elements->is_the_hole(j)) { |
1122 double double_value = elements->get_scalar(j); | 1118 double double_value = elements->get_scalar(j); |
1123 Handle<Object> element_value = | 1119 Handle<Object> element_value = |
1124 isolate->factory()->NewNumber(double_value); | 1120 isolate->factory()->NewNumber(double_value); |
1125 if (!visitor->visit(j, element_value)) return false; | 1121 if (!visitor->visit(j, element_value)) return false; |
1126 } else { | 1122 } else { |
1127 Maybe<bool> maybe = JSReceiver::HasElement(array, j); | 1123 Maybe<bool> maybe = JSReceiver::HasElement(array, j); |
1128 if (!maybe.IsJust()) return false; | 1124 if (!maybe.IsJust()) return false; |
1129 if (maybe.FromJust()) { | 1125 if (maybe.FromJust()) { |
1130 // Call GetElement on array, not its prototype, or getters won't | 1126 // Call GetElement on array, not its prototype, or getters won't |
1131 // have the correct receiver. | 1127 // have the correct receiver. |
1132 Handle<Object> element_value; | 1128 Handle<Object> element_value; |
1133 ASSIGN_RETURN_ON_EXCEPTION_VALUE( | 1129 ASSIGN_RETURN_ON_EXCEPTION_VALUE( |
1134 isolate, element_value, | 1130 isolate, element_value, |
1135 JSReceiver::GetElement(isolate, array, j), false); | 1131 JSReceiver::GetElement(isolate, array, j), false); |
1136 if (!visitor->visit(j, element_value)) return false; | 1132 if (!visitor->visit(j, element_value)) return false; |
1137 } | 1133 } |
1138 } | 1134 } |
1139 } | 1135 }); |
1140 break; | 1136 break; |
1141 } | 1137 } |
1142 | 1138 |
1143 case DICTIONARY_ELEMENTS: { | 1139 case DICTIONARY_ELEMENTS: { |
1144 // CollectElementIndices() can't be called when there's a JSProxy | 1140 // CollectElementIndices() can't be called when there's a JSProxy |
1145 // on the prototype chain. | 1141 // on the prototype chain. |
1146 for (PrototypeIterator iter(isolate, array); !iter.IsAtEnd(); | 1142 for (PrototypeIterator iter(isolate, array); !iter.IsAtEnd(); |
1147 iter.Advance()) { | 1143 iter.Advance()) { |
1148 if (PrototypeIterator::GetCurrent(iter)->IsJSProxy()) { | 1144 if (PrototypeIterator::GetCurrent(iter)->IsJSProxy()) { |
1149 return IterateElementsSlow(isolate, array, length, visitor); | 1145 return IterateElementsSlow(isolate, array, length, visitor); |
1150 } | 1146 } |
1151 } | 1147 } |
1152 Handle<SeededNumberDictionary> dict(array->element_dictionary()); | 1148 Handle<SeededNumberDictionary> dict(array->element_dictionary()); |
1153 List<uint32_t> indices(dict->Capacity() / 2); | 1149 List<uint32_t> indices(dict->Capacity() / 2); |
1154 // Collect all indices in the object and the prototypes less | 1150 // Collect all indices in the object and the prototypes less |
1155 // than length. This might introduce duplicates in the indices list. | 1151 // than length. This might introduce duplicates in the indices list. |
1156 CollectElementIndices(array, length, &indices); | 1152 CollectElementIndices(array, length, &indices); |
1157 indices.Sort(&compareUInt32); | 1153 indices.Sort(&compareUInt32); |
1158 int j = 0; | |
1159 int n = indices.length(); | 1154 int n = indices.length(); |
1160 while (j < n) { | 1155 FOR_WITH_HANDLE_SCOPE(isolate, int, j = 0, j, j < n, j = j, { |
Igor Sheludko
2016/03/14 08:36:16
I think something like (void)0 is better than j =
| |
1161 HandleScope loop_scope(isolate); | |
1162 uint32_t index = indices[j]; | 1156 uint32_t index = indices[j]; |
1163 Handle<Object> element; | 1157 Handle<Object> element; |
1164 ASSIGN_RETURN_ON_EXCEPTION_VALUE( | 1158 ASSIGN_RETURN_ON_EXCEPTION_VALUE( |
1165 isolate, element, JSReceiver::GetElement(isolate, array, index), | 1159 isolate, element, JSReceiver::GetElement(isolate, array, index), |
1166 false); | 1160 false); |
1167 if (!visitor->visit(index, element)) return false; | 1161 if (!visitor->visit(index, element)) return false; |
1168 // Skip to next different index (i.e., omit duplicates). | 1162 // Skip to next different index (i.e., omit duplicates). |
1169 do { | 1163 do { |
1170 j++; | 1164 j++; |
1171 } while (j < n && indices[j] == index); | 1165 } while (j < n && indices[j] == index); |
1172 } | 1166 }); |
1173 break; | 1167 break; |
1174 } | 1168 } |
1175 case FAST_SLOPPY_ARGUMENTS_ELEMENTS: | 1169 case FAST_SLOPPY_ARGUMENTS_ELEMENTS: |
1176 case SLOW_SLOPPY_ARGUMENTS_ELEMENTS: { | 1170 case SLOW_SLOPPY_ARGUMENTS_ELEMENTS: { |
1177 for (uint32_t index = 0; index < length; index++) { | 1171 FOR_WITH_HANDLE_SCOPE( |
1178 HandleScope loop_scope(isolate); | 1172 isolate, uint32_t, index = 0, index, index < length, index++, { |
1179 Handle<Object> element; | 1173 Handle<Object> element; |
1180 ASSIGN_RETURN_ON_EXCEPTION_VALUE( | 1174 ASSIGN_RETURN_ON_EXCEPTION_VALUE( |
1181 isolate, element, JSReceiver::GetElement(isolate, array, index), | 1175 isolate, element, JSReceiver::GetElement(isolate, array, index), |
1182 false); | 1176 false); |
1183 if (!visitor->visit(index, element)) return false; | 1177 if (!visitor->visit(index, element)) return false; |
1184 } | 1178 }); |
1185 break; | 1179 break; |
1186 } | 1180 } |
1187 case NO_ELEMENTS: | 1181 case NO_ELEMENTS: |
1188 break; | 1182 break; |
1189 #define TYPED_ARRAY_CASE(Type, type, TYPE, ctype, size) case TYPE##_ELEMENTS: | 1183 #define TYPED_ARRAY_CASE(Type, type, TYPE, ctype, size) case TYPE##_ELEMENTS: |
1190 TYPED_ARRAYS(TYPED_ARRAY_CASE) | 1184 TYPED_ARRAYS(TYPED_ARRAY_CASE) |
1191 #undef TYPED_ARRAY_CASE | 1185 #undef TYPED_ARRAY_CASE |
1192 case FAST_STRING_WRAPPER_ELEMENTS: | 1186 case FAST_STRING_WRAPPER_ELEMENTS: |
1193 case SLOW_STRING_WRAPPER_ELEMENTS: | 1187 case SLOW_STRING_WRAPPER_ELEMENTS: |
1194 // |array| is guaranteed to be an array or typed array. | 1188 // |array| is guaranteed to be an array or typed array. |
(...skipping 34 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
1229 | 1223 |
1230 // Pass 1: estimate the length and number of elements of the result. | 1224 // Pass 1: estimate the length and number of elements of the result. |
1231 // The actual length can be larger if any of the arguments have getters | 1225 // The actual length can be larger if any of the arguments have getters |
1232 // that mutate other arguments (but will otherwise be precise). | 1226 // that mutate other arguments (but will otherwise be precise). |
1233 // The number of elements is precise if there are no inherited elements. | 1227 // The number of elements is precise if there are no inherited elements. |
1234 | 1228 |
1235 ElementsKind kind = FAST_SMI_ELEMENTS; | 1229 ElementsKind kind = FAST_SMI_ELEMENTS; |
1236 | 1230 |
1237 uint32_t estimate_result_length = 0; | 1231 uint32_t estimate_result_length = 0; |
1238 uint32_t estimate_nof_elements = 0; | 1232 uint32_t estimate_nof_elements = 0; |
1239 for (int i = 0; i < argument_count; i++) { | 1233 FOR_WITH_HANDLE_SCOPE(isolate, int, i = 0, i, i < argument_count, i++, { |
1240 HandleScope loop_scope(isolate); | |
1241 Handle<Object> obj((*args)[i], isolate); | 1234 Handle<Object> obj((*args)[i], isolate); |
1242 uint32_t length_estimate; | 1235 uint32_t length_estimate; |
1243 uint32_t element_estimate; | 1236 uint32_t element_estimate; |
1244 if (obj->IsJSArray()) { | 1237 if (obj->IsJSArray()) { |
1245 Handle<JSArray> array(Handle<JSArray>::cast(obj)); | 1238 Handle<JSArray> array(Handle<JSArray>::cast(obj)); |
1246 length_estimate = static_cast<uint32_t>(array->length()->Number()); | 1239 length_estimate = static_cast<uint32_t>(array->length()->Number()); |
1247 if (length_estimate != 0) { | 1240 if (length_estimate != 0) { |
1248 ElementsKind array_kind = | 1241 ElementsKind array_kind = |
1249 GetPackedElementsKind(array->map()->elements_kind()); | 1242 GetPackedElementsKind(array->map()->elements_kind()); |
1250 kind = GetMoreGeneralElementsKind(kind, array_kind); | 1243 kind = GetMoreGeneralElementsKind(kind, array_kind); |
(...skipping 14 matching lines...) Expand all Loading... | |
1265 if (JSObject::kMaxElementCount - estimate_result_length < length_estimate) { | 1258 if (JSObject::kMaxElementCount - estimate_result_length < length_estimate) { |
1266 estimate_result_length = JSObject::kMaxElementCount; | 1259 estimate_result_length = JSObject::kMaxElementCount; |
1267 } else { | 1260 } else { |
1268 estimate_result_length += length_estimate; | 1261 estimate_result_length += length_estimate; |
1269 } | 1262 } |
1270 if (JSObject::kMaxElementCount - estimate_nof_elements < element_estimate) { | 1263 if (JSObject::kMaxElementCount - estimate_nof_elements < element_estimate) { |
1271 estimate_nof_elements = JSObject::kMaxElementCount; | 1264 estimate_nof_elements = JSObject::kMaxElementCount; |
1272 } else { | 1265 } else { |
1273 estimate_nof_elements += element_estimate; | 1266 estimate_nof_elements += element_estimate; |
1274 } | 1267 } |
1275 } | 1268 }); |
1276 | 1269 |
1277 // If estimated number of elements is more than half of length, a | 1270 // If estimated number of elements is more than half of length, a |
1278 // fixed array (fast case) is more time and space-efficient than a | 1271 // fixed array (fast case) is more time and space-efficient than a |
1279 // dictionary. | 1272 // dictionary. |
1280 bool fast_case = | 1273 bool fast_case = |
1281 is_array_species && (estimate_nof_elements * 2) >= estimate_result_length; | 1274 is_array_species && (estimate_nof_elements * 2) >= estimate_result_length; |
1282 | 1275 |
1283 if (fast_case && kind == FAST_DOUBLE_ELEMENTS) { | 1276 if (fast_case && kind == FAST_DOUBLE_ELEMENTS) { |
1284 Handle<FixedArrayBase> storage = | 1277 Handle<FixedArrayBase> storage = |
1285 isolate->factory()->NewFixedDoubleArray(estimate_result_length); | 1278 isolate->factory()->NewFixedDoubleArray(estimate_result_length); |
(...skipping 3248 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
4534 BUILTIN_LIST_C(DEFINE_BUILTIN_ACCESSOR_C) | 4527 BUILTIN_LIST_C(DEFINE_BUILTIN_ACCESSOR_C) |
4535 BUILTIN_LIST_A(DEFINE_BUILTIN_ACCESSOR_A) | 4528 BUILTIN_LIST_A(DEFINE_BUILTIN_ACCESSOR_A) |
4536 BUILTIN_LIST_H(DEFINE_BUILTIN_ACCESSOR_H) | 4529 BUILTIN_LIST_H(DEFINE_BUILTIN_ACCESSOR_H) |
4537 BUILTIN_LIST_DEBUG_A(DEFINE_BUILTIN_ACCESSOR_A) | 4530 BUILTIN_LIST_DEBUG_A(DEFINE_BUILTIN_ACCESSOR_A) |
4538 #undef DEFINE_BUILTIN_ACCESSOR_C | 4531 #undef DEFINE_BUILTIN_ACCESSOR_C |
4539 #undef DEFINE_BUILTIN_ACCESSOR_A | 4532 #undef DEFINE_BUILTIN_ACCESSOR_A |
4540 | 4533 |
4541 | 4534 |
4542 } // namespace internal | 4535 } // namespace internal |
4543 } // namespace v8 | 4536 } // namespace v8 |
OLD | NEW |