OLD | NEW |
1 // Copyright 2011 the V8 project authors. All rights reserved. | 1 // Copyright 2011 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 1027 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1038 ExternalIntArray::cast(this)->length()); | 1038 ExternalIntArray::cast(this)->length()); |
1039 break; | 1039 break; |
1040 case EXTERNAL_UNSIGNED_INT_ARRAY_TYPE: | 1040 case EXTERNAL_UNSIGNED_INT_ARRAY_TYPE: |
1041 accumulator->Add("<ExternalUnsignedIntArray[%u]>", | 1041 accumulator->Add("<ExternalUnsignedIntArray[%u]>", |
1042 ExternalUnsignedIntArray::cast(this)->length()); | 1042 ExternalUnsignedIntArray::cast(this)->length()); |
1043 break; | 1043 break; |
1044 case EXTERNAL_FLOAT_ARRAY_TYPE: | 1044 case EXTERNAL_FLOAT_ARRAY_TYPE: |
1045 accumulator->Add("<ExternalFloatArray[%u]>", | 1045 accumulator->Add("<ExternalFloatArray[%u]>", |
1046 ExternalFloatArray::cast(this)->length()); | 1046 ExternalFloatArray::cast(this)->length()); |
1047 break; | 1047 break; |
| 1048 case EXTERNAL_DOUBLE_ARRAY_TYPE: |
| 1049 accumulator->Add("<ExternalDoubleArray[%u]>", |
| 1050 ExternalDoubleArray::cast(this)->length()); |
| 1051 break; |
1048 case SHARED_FUNCTION_INFO_TYPE: | 1052 case SHARED_FUNCTION_INFO_TYPE: |
1049 accumulator->Add("<SharedFunctionInfo>"); | 1053 accumulator->Add("<SharedFunctionInfo>"); |
1050 break; | 1054 break; |
1051 case JS_MESSAGE_OBJECT_TYPE: | 1055 case JS_MESSAGE_OBJECT_TYPE: |
1052 accumulator->Add("<JSMessageObject>"); | 1056 accumulator->Add("<JSMessageObject>"); |
1053 break; | 1057 break; |
1054 #define MAKE_STRUCT_CASE(NAME, Name, name) \ | 1058 #define MAKE_STRUCT_CASE(NAME, Name, name) \ |
1055 case NAME##_TYPE: \ | 1059 case NAME##_TYPE: \ |
1056 accumulator->Put('<'); \ | 1060 accumulator->Put('<'); \ |
1057 accumulator->Add(#Name); \ | 1061 accumulator->Add(#Name); \ |
(...skipping 109 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1167 case FILLER_TYPE: | 1171 case FILLER_TYPE: |
1168 case BYTE_ARRAY_TYPE: | 1172 case BYTE_ARRAY_TYPE: |
1169 case EXTERNAL_PIXEL_ARRAY_TYPE: | 1173 case EXTERNAL_PIXEL_ARRAY_TYPE: |
1170 case EXTERNAL_BYTE_ARRAY_TYPE: | 1174 case EXTERNAL_BYTE_ARRAY_TYPE: |
1171 case EXTERNAL_UNSIGNED_BYTE_ARRAY_TYPE: | 1175 case EXTERNAL_UNSIGNED_BYTE_ARRAY_TYPE: |
1172 case EXTERNAL_SHORT_ARRAY_TYPE: | 1176 case EXTERNAL_SHORT_ARRAY_TYPE: |
1173 case EXTERNAL_UNSIGNED_SHORT_ARRAY_TYPE: | 1177 case EXTERNAL_UNSIGNED_SHORT_ARRAY_TYPE: |
1174 case EXTERNAL_INT_ARRAY_TYPE: | 1178 case EXTERNAL_INT_ARRAY_TYPE: |
1175 case EXTERNAL_UNSIGNED_INT_ARRAY_TYPE: | 1179 case EXTERNAL_UNSIGNED_INT_ARRAY_TYPE: |
1176 case EXTERNAL_FLOAT_ARRAY_TYPE: | 1180 case EXTERNAL_FLOAT_ARRAY_TYPE: |
| 1181 case EXTERNAL_DOUBLE_ARRAY_TYPE: |
1177 break; | 1182 break; |
1178 case SHARED_FUNCTION_INFO_TYPE: | 1183 case SHARED_FUNCTION_INFO_TYPE: |
1179 SharedFunctionInfo::BodyDescriptor::IterateBody(this, v); | 1184 SharedFunctionInfo::BodyDescriptor::IterateBody(this, v); |
1180 break; | 1185 break; |
1181 | 1186 |
1182 #define MAKE_STRUCT_CASE(NAME, Name, name) \ | 1187 #define MAKE_STRUCT_CASE(NAME, Name, name) \ |
1183 case NAME##_TYPE: | 1188 case NAME##_TYPE: |
1184 STRUCT_LIST(MAKE_STRUCT_CASE) | 1189 STRUCT_LIST(MAKE_STRUCT_CASE) |
1185 #undef MAKE_STRUCT_CASE | 1190 #undef MAKE_STRUCT_CASE |
1186 StructBodyDescriptor::IterateBody(this, object_size, v); | 1191 StructBodyDescriptor::IterateBody(this, object_size, v); |
(...skipping 1654 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
2841 break; | 2846 break; |
2842 } | 2847 } |
2843 case EXTERNAL_PIXEL_ELEMENTS: | 2848 case EXTERNAL_PIXEL_ELEMENTS: |
2844 case EXTERNAL_BYTE_ELEMENTS: | 2849 case EXTERNAL_BYTE_ELEMENTS: |
2845 case EXTERNAL_UNSIGNED_BYTE_ELEMENTS: | 2850 case EXTERNAL_UNSIGNED_BYTE_ELEMENTS: |
2846 case EXTERNAL_SHORT_ELEMENTS: | 2851 case EXTERNAL_SHORT_ELEMENTS: |
2847 case EXTERNAL_UNSIGNED_SHORT_ELEMENTS: | 2852 case EXTERNAL_UNSIGNED_SHORT_ELEMENTS: |
2848 case EXTERNAL_INT_ELEMENTS: | 2853 case EXTERNAL_INT_ELEMENTS: |
2849 case EXTERNAL_UNSIGNED_INT_ELEMENTS: | 2854 case EXTERNAL_UNSIGNED_INT_ELEMENTS: |
2850 case EXTERNAL_FLOAT_ELEMENTS: | 2855 case EXTERNAL_FLOAT_ELEMENTS: |
| 2856 case EXTERNAL_DOUBLE_ELEMENTS: |
2851 // Pixel and external array elements cannot be deleted. Just | 2857 // Pixel and external array elements cannot be deleted. Just |
2852 // silently ignore here. | 2858 // silently ignore here. |
2853 break; | 2859 break; |
2854 case DICTIONARY_ELEMENTS: { | 2860 case DICTIONARY_ELEMENTS: { |
2855 NumberDictionary* dictionary = element_dictionary(); | 2861 NumberDictionary* dictionary = element_dictionary(); |
2856 int entry = dictionary->FindEntry(index); | 2862 int entry = dictionary->FindEntry(index); |
2857 if (entry != NumberDictionary::kNotFound) { | 2863 if (entry != NumberDictionary::kNotFound) { |
2858 Object* result = dictionary->DeleteProperty(entry, mode); | 2864 Object* result = dictionary->DeleteProperty(entry, mode); |
2859 if (mode == STRICT_DELETION && result == | 2865 if (mode == STRICT_DELETION && result == |
2860 isolate->heap()->false_value()) { | 2866 isolate->heap()->false_value()) { |
(...skipping 99 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
2960 // Check if the object is among the indexed properties. | 2966 // Check if the object is among the indexed properties. |
2961 switch (GetElementsKind()) { | 2967 switch (GetElementsKind()) { |
2962 case EXTERNAL_PIXEL_ELEMENTS: | 2968 case EXTERNAL_PIXEL_ELEMENTS: |
2963 case EXTERNAL_BYTE_ELEMENTS: | 2969 case EXTERNAL_BYTE_ELEMENTS: |
2964 case EXTERNAL_UNSIGNED_BYTE_ELEMENTS: | 2970 case EXTERNAL_UNSIGNED_BYTE_ELEMENTS: |
2965 case EXTERNAL_SHORT_ELEMENTS: | 2971 case EXTERNAL_SHORT_ELEMENTS: |
2966 case EXTERNAL_UNSIGNED_SHORT_ELEMENTS: | 2972 case EXTERNAL_UNSIGNED_SHORT_ELEMENTS: |
2967 case EXTERNAL_INT_ELEMENTS: | 2973 case EXTERNAL_INT_ELEMENTS: |
2968 case EXTERNAL_UNSIGNED_INT_ELEMENTS: | 2974 case EXTERNAL_UNSIGNED_INT_ELEMENTS: |
2969 case EXTERNAL_FLOAT_ELEMENTS: | 2975 case EXTERNAL_FLOAT_ELEMENTS: |
| 2976 case EXTERNAL_DOUBLE_ELEMENTS: |
2970 // Raw pixels and external arrays do not reference other | 2977 // Raw pixels and external arrays do not reference other |
2971 // objects. | 2978 // objects. |
2972 break; | 2979 break; |
2973 case FAST_ELEMENTS: { | 2980 case FAST_ELEMENTS: { |
2974 int length = IsJSArray() ? | 2981 int length = IsJSArray() ? |
2975 Smi::cast(JSArray::cast(this)->length())->value() : | 2982 Smi::cast(JSArray::cast(this)->length())->value() : |
2976 FixedArray::cast(elements())->length(); | 2983 FixedArray::cast(elements())->length(); |
2977 for (int i = 0; i < length; i++) { | 2984 for (int i = 0; i < length; i++) { |
2978 Object* element = FixedArray::cast(elements())->get(i); | 2985 Object* element = FixedArray::cast(elements())->get(i); |
2979 if (!element->IsTheHole() && element == obj) { | 2986 if (!element->IsTheHole() && element == obj) { |
(...skipping 251 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
3231 case FAST_ELEMENTS: | 3238 case FAST_ELEMENTS: |
3232 break; | 3239 break; |
3233 case EXTERNAL_PIXEL_ELEMENTS: | 3240 case EXTERNAL_PIXEL_ELEMENTS: |
3234 case EXTERNAL_BYTE_ELEMENTS: | 3241 case EXTERNAL_BYTE_ELEMENTS: |
3235 case EXTERNAL_UNSIGNED_BYTE_ELEMENTS: | 3242 case EXTERNAL_UNSIGNED_BYTE_ELEMENTS: |
3236 case EXTERNAL_SHORT_ELEMENTS: | 3243 case EXTERNAL_SHORT_ELEMENTS: |
3237 case EXTERNAL_UNSIGNED_SHORT_ELEMENTS: | 3244 case EXTERNAL_UNSIGNED_SHORT_ELEMENTS: |
3238 case EXTERNAL_INT_ELEMENTS: | 3245 case EXTERNAL_INT_ELEMENTS: |
3239 case EXTERNAL_UNSIGNED_INT_ELEMENTS: | 3246 case EXTERNAL_UNSIGNED_INT_ELEMENTS: |
3240 case EXTERNAL_FLOAT_ELEMENTS: | 3247 case EXTERNAL_FLOAT_ELEMENTS: |
| 3248 case EXTERNAL_DOUBLE_ELEMENTS: |
3241 // Ignore getters and setters on pixel and external array | 3249 // Ignore getters and setters on pixel and external array |
3242 // elements. | 3250 // elements. |
3243 return heap->undefined_value(); | 3251 return heap->undefined_value(); |
3244 case DICTIONARY_ELEMENTS: { | 3252 case DICTIONARY_ELEMENTS: { |
3245 // Lookup the index. | 3253 // Lookup the index. |
3246 NumberDictionary* dictionary = element_dictionary(); | 3254 NumberDictionary* dictionary = element_dictionary(); |
3247 int entry = dictionary->FindEntry(index); | 3255 int entry = dictionary->FindEntry(index); |
3248 if (entry != NumberDictionary::kNotFound) { | 3256 if (entry != NumberDictionary::kNotFound) { |
3249 Object* result = dictionary->ValueAt(entry); | 3257 Object* result = dictionary->ValueAt(entry); |
3250 PropertyDetails details = dictionary->DetailsAt(entry); | 3258 PropertyDetails details = dictionary->DetailsAt(entry); |
(...skipping 206 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
3457 case FAST_ELEMENTS: | 3465 case FAST_ELEMENTS: |
3458 break; | 3466 break; |
3459 case EXTERNAL_PIXEL_ELEMENTS: | 3467 case EXTERNAL_PIXEL_ELEMENTS: |
3460 case EXTERNAL_BYTE_ELEMENTS: | 3468 case EXTERNAL_BYTE_ELEMENTS: |
3461 case EXTERNAL_UNSIGNED_BYTE_ELEMENTS: | 3469 case EXTERNAL_UNSIGNED_BYTE_ELEMENTS: |
3462 case EXTERNAL_SHORT_ELEMENTS: | 3470 case EXTERNAL_SHORT_ELEMENTS: |
3463 case EXTERNAL_UNSIGNED_SHORT_ELEMENTS: | 3471 case EXTERNAL_UNSIGNED_SHORT_ELEMENTS: |
3464 case EXTERNAL_INT_ELEMENTS: | 3472 case EXTERNAL_INT_ELEMENTS: |
3465 case EXTERNAL_UNSIGNED_INT_ELEMENTS: | 3473 case EXTERNAL_UNSIGNED_INT_ELEMENTS: |
3466 case EXTERNAL_FLOAT_ELEMENTS: | 3474 case EXTERNAL_FLOAT_ELEMENTS: |
| 3475 case EXTERNAL_DOUBLE_ELEMENTS: |
3467 // Ignore getters and setters on pixel and external array | 3476 // Ignore getters and setters on pixel and external array |
3468 // elements. | 3477 // elements. |
3469 return isolate->heap()->undefined_value(); | 3478 return isolate->heap()->undefined_value(); |
3470 case DICTIONARY_ELEMENTS: | 3479 case DICTIONARY_ELEMENTS: |
3471 break; | 3480 break; |
3472 default: | 3481 default: |
3473 UNREACHABLE(); | 3482 UNREACHABLE(); |
3474 break; | 3483 break; |
3475 } | 3484 } |
3476 | 3485 |
(...skipping 3390 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
6867 { MaybeObject* maybe_obj = GetHeap()->AllocateFixedArray(1); | 6876 { MaybeObject* maybe_obj = GetHeap()->AllocateFixedArray(1); |
6868 if (!maybe_obj->ToObject(&obj)) return maybe_obj; | 6877 if (!maybe_obj->ToObject(&obj)) return maybe_obj; |
6869 } | 6878 } |
6870 FixedArray::cast(obj)->set(0, len); | 6879 FixedArray::cast(obj)->set(0, len); |
6871 if (IsJSArray()) JSArray::cast(this)->set_length(Smi::FromInt(1)); | 6880 if (IsJSArray()) JSArray::cast(this)->set_length(Smi::FromInt(1)); |
6872 set_elements(FixedArray::cast(obj)); | 6881 set_elements(FixedArray::cast(obj)); |
6873 return this; | 6882 return this; |
6874 } | 6883 } |
6875 | 6884 |
6876 | 6885 |
| 6886 Object* Map::GetPrototypeTransition(Object* prototype) { |
| 6887 FixedArray* cache = prototype_transitions(); |
| 6888 int capacity = cache->length(); |
| 6889 if (capacity == 0) return NULL; |
| 6890 int finger = Smi::cast(cache->get(0))->value(); |
| 6891 for (int i = 1; i < finger; i += 2) { |
| 6892 if (cache->get(i) == prototype) return cache->get(i + 1); |
| 6893 } |
| 6894 return NULL; |
| 6895 } |
| 6896 |
| 6897 |
| 6898 MaybeObject* Map::PutPrototypeTransition(Object* prototype, Map* map) { |
| 6899 // Don't cache prototype transition if this map is shared. |
| 6900 if (is_shared() || !FLAG_cache_prototype_transitions) return this; |
| 6901 |
| 6902 FixedArray* cache = prototype_transitions(); |
| 6903 |
| 6904 int capacity = cache->length(); |
| 6905 |
| 6906 int finger = (capacity == 0) ? 1 : Smi::cast(cache->get(0))->value(); |
| 6907 |
| 6908 if (finger >= capacity) { |
| 6909 if (capacity > kMaxCachedPrototypeTransitions) return this; |
| 6910 |
| 6911 FixedArray* new_cache; |
| 6912 { MaybeObject* maybe_cache = heap()->AllocateFixedArray(finger * 2 + 1); |
| 6913 if (!maybe_cache->To<FixedArray>(&new_cache)) return maybe_cache; |
| 6914 } |
| 6915 |
| 6916 for (int i = 1; i < capacity; i++) new_cache->set(i, cache->get(i)); |
| 6917 cache = new_cache; |
| 6918 set_prototype_transitions(cache); |
| 6919 } |
| 6920 |
| 6921 cache->set(finger, prototype); |
| 6922 cache->set(finger + 1, map); |
| 6923 cache->set(0, Smi::FromInt(finger + 2)); |
| 6924 |
| 6925 return cache; |
| 6926 } |
| 6927 |
| 6928 |
6877 MaybeObject* JSObject::SetPrototype(Object* value, | 6929 MaybeObject* JSObject::SetPrototype(Object* value, |
6878 bool skip_hidden_prototypes) { | 6930 bool skip_hidden_prototypes) { |
6879 Heap* heap = GetHeap(); | 6931 Heap* heap = GetHeap(); |
6880 // Silently ignore the change if value is not a JSObject or null. | 6932 // Silently ignore the change if value is not a JSObject or null. |
6881 // SpiderMonkey behaves this way. | 6933 // SpiderMonkey behaves this way. |
6882 if (!value->IsJSObject() && !value->IsNull()) return value; | 6934 if (!value->IsJSObject() && !value->IsNull()) return value; |
6883 | 6935 |
6884 // From 8.6.2 Object Internal Methods | 6936 // From 8.6.2 Object Internal Methods |
6885 // ... | 6937 // ... |
6886 // In addition, if [[Extensible]] is false the value of the [[Class]] and | 6938 // In addition, if [[Extensible]] is false the value of the [[Class]] and |
(...skipping 30 matching lines...) Expand all Loading... |
6917 // hidden and set the new prototype on that object. | 6969 // hidden and set the new prototype on that object. |
6918 Object* current_proto = real_receiver->GetPrototype(); | 6970 Object* current_proto = real_receiver->GetPrototype(); |
6919 while (current_proto->IsJSObject() && | 6971 while (current_proto->IsJSObject() && |
6920 JSObject::cast(current_proto)->map()->is_hidden_prototype()) { | 6972 JSObject::cast(current_proto)->map()->is_hidden_prototype()) { |
6921 real_receiver = JSObject::cast(current_proto); | 6973 real_receiver = JSObject::cast(current_proto); |
6922 current_proto = current_proto->GetPrototype(); | 6974 current_proto = current_proto->GetPrototype(); |
6923 } | 6975 } |
6924 } | 6976 } |
6925 | 6977 |
6926 // Set the new prototype of the object. | 6978 // Set the new prototype of the object. |
6927 Object* new_map; | 6979 Map* map = real_receiver->map(); |
6928 { MaybeObject* maybe_new_map = real_receiver->map()->CopyDropTransitions(); | 6980 |
6929 if (!maybe_new_map->ToObject(&new_map)) return maybe_new_map; | 6981 // Nothing to do if prototype is already set. |
| 6982 if (map->prototype() == value) return value; |
| 6983 |
| 6984 Object* new_map = map->GetPrototypeTransition(value); |
| 6985 if (new_map == NULL) { |
| 6986 { MaybeObject* maybe_new_map = map->CopyDropTransitions(); |
| 6987 if (!maybe_new_map->ToObject(&new_map)) return maybe_new_map; |
| 6988 } |
| 6989 |
| 6990 { MaybeObject* maybe_new_cache = |
| 6991 map->PutPrototypeTransition(value, Map::cast(new_map)); |
| 6992 if (maybe_new_cache->IsFailure()) return maybe_new_cache; |
| 6993 } |
| 6994 |
| 6995 Map::cast(new_map)->set_prototype(value); |
6930 } | 6996 } |
6931 Map::cast(new_map)->set_prototype(value); | 6997 ASSERT(Map::cast(new_map)->prototype() == value); |
6932 real_receiver->set_map(Map::cast(new_map)); | 6998 real_receiver->set_map(Map::cast(new_map)); |
6933 | 6999 |
6934 heap->ClearInstanceofCache(); | 7000 heap->ClearInstanceofCache(); |
6935 | 7001 |
6936 return value; | 7002 return value; |
6937 } | 7003 } |
6938 | 7004 |
6939 | 7005 |
6940 bool JSObject::HasElementPostInterceptor(JSObject* receiver, uint32_t index) { | 7006 bool JSObject::HasElementPostInterceptor(JSObject* receiver, uint32_t index) { |
6941 switch (GetElementsKind()) { | 7007 switch (GetElementsKind()) { |
(...skipping 14 matching lines...) Expand all Loading... |
6956 return true; | 7022 return true; |
6957 } | 7023 } |
6958 break; | 7024 break; |
6959 } | 7025 } |
6960 case EXTERNAL_BYTE_ELEMENTS: | 7026 case EXTERNAL_BYTE_ELEMENTS: |
6961 case EXTERNAL_UNSIGNED_BYTE_ELEMENTS: | 7027 case EXTERNAL_UNSIGNED_BYTE_ELEMENTS: |
6962 case EXTERNAL_SHORT_ELEMENTS: | 7028 case EXTERNAL_SHORT_ELEMENTS: |
6963 case EXTERNAL_UNSIGNED_SHORT_ELEMENTS: | 7029 case EXTERNAL_UNSIGNED_SHORT_ELEMENTS: |
6964 case EXTERNAL_INT_ELEMENTS: | 7030 case EXTERNAL_INT_ELEMENTS: |
6965 case EXTERNAL_UNSIGNED_INT_ELEMENTS: | 7031 case EXTERNAL_UNSIGNED_INT_ELEMENTS: |
6966 case EXTERNAL_FLOAT_ELEMENTS: { | 7032 case EXTERNAL_FLOAT_ELEMENTS: |
| 7033 case EXTERNAL_DOUBLE_ELEMENTS: { |
6967 ExternalArray* array = ExternalArray::cast(elements()); | 7034 ExternalArray* array = ExternalArray::cast(elements()); |
6968 if (index < static_cast<uint32_t>(array->length())) { | 7035 if (index < static_cast<uint32_t>(array->length())) { |
6969 return true; | 7036 return true; |
6970 } | 7037 } |
6971 break; | 7038 break; |
6972 } | 7039 } |
6973 case DICTIONARY_ELEMENTS: { | 7040 case DICTIONARY_ELEMENTS: { |
6974 if (element_dictionary()->FindEntry(index) | 7041 if (element_dictionary()->FindEntry(index) |
6975 != NumberDictionary::kNotFound) { | 7042 != NumberDictionary::kNotFound) { |
6976 return true; | 7043 return true; |
(...skipping 101 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
7078 ExternalPixelArray* pixels = ExternalPixelArray::cast(elements()); | 7145 ExternalPixelArray* pixels = ExternalPixelArray::cast(elements()); |
7079 if (index < static_cast<uint32_t>(pixels->length())) return FAST_ELEMENT; | 7146 if (index < static_cast<uint32_t>(pixels->length())) return FAST_ELEMENT; |
7080 break; | 7147 break; |
7081 } | 7148 } |
7082 case EXTERNAL_BYTE_ELEMENTS: | 7149 case EXTERNAL_BYTE_ELEMENTS: |
7083 case EXTERNAL_UNSIGNED_BYTE_ELEMENTS: | 7150 case EXTERNAL_UNSIGNED_BYTE_ELEMENTS: |
7084 case EXTERNAL_SHORT_ELEMENTS: | 7151 case EXTERNAL_SHORT_ELEMENTS: |
7085 case EXTERNAL_UNSIGNED_SHORT_ELEMENTS: | 7152 case EXTERNAL_UNSIGNED_SHORT_ELEMENTS: |
7086 case EXTERNAL_INT_ELEMENTS: | 7153 case EXTERNAL_INT_ELEMENTS: |
7087 case EXTERNAL_UNSIGNED_INT_ELEMENTS: | 7154 case EXTERNAL_UNSIGNED_INT_ELEMENTS: |
7088 case EXTERNAL_FLOAT_ELEMENTS: { | 7155 case EXTERNAL_FLOAT_ELEMENTS: |
| 7156 case EXTERNAL_DOUBLE_ELEMENTS: { |
7089 ExternalArray* array = ExternalArray::cast(elements()); | 7157 ExternalArray* array = ExternalArray::cast(elements()); |
7090 if (index < static_cast<uint32_t>(array->length())) return FAST_ELEMENT; | 7158 if (index < static_cast<uint32_t>(array->length())) return FAST_ELEMENT; |
7091 break; | 7159 break; |
7092 } | 7160 } |
7093 case DICTIONARY_ELEMENTS: { | 7161 case DICTIONARY_ELEMENTS: { |
7094 if (element_dictionary()->FindEntry(index) != | 7162 if (element_dictionary()->FindEntry(index) != |
7095 NumberDictionary::kNotFound) { | 7163 NumberDictionary::kNotFound) { |
7096 return DICTIONARY_ELEMENT; | 7164 return DICTIONARY_ELEMENT; |
7097 } | 7165 } |
7098 break; | 7166 break; |
(...skipping 38 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
7137 return true; | 7205 return true; |
7138 } | 7206 } |
7139 break; | 7207 break; |
7140 } | 7208 } |
7141 case EXTERNAL_BYTE_ELEMENTS: | 7209 case EXTERNAL_BYTE_ELEMENTS: |
7142 case EXTERNAL_UNSIGNED_BYTE_ELEMENTS: | 7210 case EXTERNAL_UNSIGNED_BYTE_ELEMENTS: |
7143 case EXTERNAL_SHORT_ELEMENTS: | 7211 case EXTERNAL_SHORT_ELEMENTS: |
7144 case EXTERNAL_UNSIGNED_SHORT_ELEMENTS: | 7212 case EXTERNAL_UNSIGNED_SHORT_ELEMENTS: |
7145 case EXTERNAL_INT_ELEMENTS: | 7213 case EXTERNAL_INT_ELEMENTS: |
7146 case EXTERNAL_UNSIGNED_INT_ELEMENTS: | 7214 case EXTERNAL_UNSIGNED_INT_ELEMENTS: |
7147 case EXTERNAL_FLOAT_ELEMENTS: { | 7215 case EXTERNAL_FLOAT_ELEMENTS: |
| 7216 case EXTERNAL_DOUBLE_ELEMENTS: { |
7148 ExternalArray* array = ExternalArray::cast(elements()); | 7217 ExternalArray* array = ExternalArray::cast(elements()); |
7149 if (index < static_cast<uint32_t>(array->length())) { | 7218 if (index < static_cast<uint32_t>(array->length())) { |
7150 return true; | 7219 return true; |
7151 } | 7220 } |
7152 break; | 7221 break; |
7153 } | 7222 } |
7154 case DICTIONARY_ELEMENTS: { | 7223 case DICTIONARY_ELEMENTS: { |
7155 if (element_dictionary()->FindEntry(index) | 7224 if (element_dictionary()->FindEntry(index) |
7156 != NumberDictionary::kNotFound) { | 7225 != NumberDictionary::kNotFound) { |
7157 return true; | 7226 return true; |
(...skipping 300 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
7458 } | 7527 } |
7459 case EXTERNAL_UNSIGNED_INT_ELEMENTS: { | 7528 case EXTERNAL_UNSIGNED_INT_ELEMENTS: { |
7460 ExternalUnsignedIntArray* array = | 7529 ExternalUnsignedIntArray* array = |
7461 ExternalUnsignedIntArray::cast(elements()); | 7530 ExternalUnsignedIntArray::cast(elements()); |
7462 return array->SetValue(index, value); | 7531 return array->SetValue(index, value); |
7463 } | 7532 } |
7464 case EXTERNAL_FLOAT_ELEMENTS: { | 7533 case EXTERNAL_FLOAT_ELEMENTS: { |
7465 ExternalFloatArray* array = ExternalFloatArray::cast(elements()); | 7534 ExternalFloatArray* array = ExternalFloatArray::cast(elements()); |
7466 return array->SetValue(index, value); | 7535 return array->SetValue(index, value); |
7467 } | 7536 } |
| 7537 case EXTERNAL_DOUBLE_ELEMENTS: { |
| 7538 ExternalDoubleArray* array = ExternalDoubleArray::cast(elements()); |
| 7539 return array->SetValue(index, value); |
| 7540 } |
7468 case DICTIONARY_ELEMENTS: { | 7541 case DICTIONARY_ELEMENTS: { |
7469 // Insert element in the dictionary. | 7542 // Insert element in the dictionary. |
7470 FixedArray* elms = FixedArray::cast(elements()); | 7543 FixedArray* elms = FixedArray::cast(elements()); |
7471 NumberDictionary* dictionary = NumberDictionary::cast(elms); | 7544 NumberDictionary* dictionary = NumberDictionary::cast(elms); |
7472 | 7545 |
7473 int entry = dictionary->FindEntry(index); | 7546 int entry = dictionary->FindEntry(index); |
7474 if (entry != NumberDictionary::kNotFound) { | 7547 if (entry != NumberDictionary::kNotFound) { |
7475 Object* element = dictionary->ValueAt(entry); | 7548 Object* element = dictionary->ValueAt(entry); |
7476 PropertyDetails details = dictionary->DetailsAt(entry); | 7549 PropertyDetails details = dictionary->DetailsAt(entry); |
7477 if (details.type() == CALLBACKS) { | 7550 if (details.type() == CALLBACKS) { |
(...skipping 121 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
7599 } | 7672 } |
7600 break; | 7673 break; |
7601 } | 7674 } |
7602 case EXTERNAL_PIXEL_ELEMENTS: | 7675 case EXTERNAL_PIXEL_ELEMENTS: |
7603 case EXTERNAL_BYTE_ELEMENTS: | 7676 case EXTERNAL_BYTE_ELEMENTS: |
7604 case EXTERNAL_UNSIGNED_BYTE_ELEMENTS: | 7677 case EXTERNAL_UNSIGNED_BYTE_ELEMENTS: |
7605 case EXTERNAL_SHORT_ELEMENTS: | 7678 case EXTERNAL_SHORT_ELEMENTS: |
7606 case EXTERNAL_UNSIGNED_SHORT_ELEMENTS: | 7679 case EXTERNAL_UNSIGNED_SHORT_ELEMENTS: |
7607 case EXTERNAL_INT_ELEMENTS: | 7680 case EXTERNAL_INT_ELEMENTS: |
7608 case EXTERNAL_UNSIGNED_INT_ELEMENTS: | 7681 case EXTERNAL_UNSIGNED_INT_ELEMENTS: |
7609 case EXTERNAL_FLOAT_ELEMENTS: { | 7682 case EXTERNAL_FLOAT_ELEMENTS: |
| 7683 case EXTERNAL_DOUBLE_ELEMENTS: { |
7610 MaybeObject* maybe_value = GetExternalElement(index); | 7684 MaybeObject* maybe_value = GetExternalElement(index); |
7611 Object* value; | 7685 Object* value; |
7612 if (!maybe_value->ToObject(&value)) return maybe_value; | 7686 if (!maybe_value->ToObject(&value)) return maybe_value; |
7613 if (!value->IsUndefined()) return value; | 7687 if (!value->IsUndefined()) return value; |
7614 break; | 7688 break; |
7615 } | 7689 } |
7616 case DICTIONARY_ELEMENTS: { | 7690 case DICTIONARY_ELEMENTS: { |
7617 NumberDictionary* dictionary = element_dictionary(); | 7691 NumberDictionary* dictionary = element_dictionary(); |
7618 int entry = dictionary->FindEntry(index); | 7692 int entry = dictionary->FindEntry(index); |
7619 if (entry != NumberDictionary::kNotFound) { | 7693 if (entry != NumberDictionary::kNotFound) { |
(...skipping 81 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
7701 } | 7775 } |
7702 break; | 7776 break; |
7703 } | 7777 } |
7704 case EXTERNAL_PIXEL_ELEMENTS: | 7778 case EXTERNAL_PIXEL_ELEMENTS: |
7705 case EXTERNAL_BYTE_ELEMENTS: | 7779 case EXTERNAL_BYTE_ELEMENTS: |
7706 case EXTERNAL_UNSIGNED_BYTE_ELEMENTS: | 7780 case EXTERNAL_UNSIGNED_BYTE_ELEMENTS: |
7707 case EXTERNAL_SHORT_ELEMENTS: | 7781 case EXTERNAL_SHORT_ELEMENTS: |
7708 case EXTERNAL_UNSIGNED_SHORT_ELEMENTS: | 7782 case EXTERNAL_UNSIGNED_SHORT_ELEMENTS: |
7709 case EXTERNAL_INT_ELEMENTS: | 7783 case EXTERNAL_INT_ELEMENTS: |
7710 case EXTERNAL_UNSIGNED_INT_ELEMENTS: | 7784 case EXTERNAL_UNSIGNED_INT_ELEMENTS: |
7711 case EXTERNAL_FLOAT_ELEMENTS: { | 7785 case EXTERNAL_FLOAT_ELEMENTS: |
| 7786 case EXTERNAL_DOUBLE_ELEMENTS: { |
7712 MaybeObject* maybe_value = GetExternalElement(index); | 7787 MaybeObject* maybe_value = GetExternalElement(index); |
7713 Object* value; | 7788 Object* value; |
7714 if (!maybe_value->ToObject(&value)) return maybe_value; | 7789 if (!maybe_value->ToObject(&value)) return maybe_value; |
7715 if (!value->IsUndefined()) return value; | 7790 if (!value->IsUndefined()) return value; |
7716 break; | 7791 break; |
7717 } | 7792 } |
7718 case DICTIONARY_ELEMENTS: { | 7793 case DICTIONARY_ELEMENTS: { |
7719 NumberDictionary* dictionary = element_dictionary(); | 7794 NumberDictionary* dictionary = element_dictionary(); |
7720 int entry = dictionary->FindEntry(index); | 7795 int entry = dictionary->FindEntry(index); |
7721 if (entry != NumberDictionary::kNotFound) { | 7796 if (entry != NumberDictionary::kNotFound) { |
(...skipping 82 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
7804 break; | 7879 break; |
7805 } | 7880 } |
7806 case EXTERNAL_FLOAT_ELEMENTS: { | 7881 case EXTERNAL_FLOAT_ELEMENTS: { |
7807 ExternalFloatArray* array = ExternalFloatArray::cast(elements()); | 7882 ExternalFloatArray* array = ExternalFloatArray::cast(elements()); |
7808 if (index < static_cast<uint32_t>(array->length())) { | 7883 if (index < static_cast<uint32_t>(array->length())) { |
7809 float value = array->get(index); | 7884 float value = array->get(index); |
7810 return GetHeap()->AllocateHeapNumber(value); | 7885 return GetHeap()->AllocateHeapNumber(value); |
7811 } | 7886 } |
7812 break; | 7887 break; |
7813 } | 7888 } |
| 7889 case EXTERNAL_DOUBLE_ELEMENTS: { |
| 7890 ExternalDoubleArray* array = ExternalDoubleArray::cast(elements()); |
| 7891 if (index < static_cast<uint32_t>(array->length())) { |
| 7892 double value = array->get(index); |
| 7893 return GetHeap()->AllocateHeapNumber(value); |
| 7894 } |
| 7895 break; |
| 7896 } |
7814 case FAST_ELEMENTS: | 7897 case FAST_ELEMENTS: |
7815 case DICTIONARY_ELEMENTS: | 7898 case DICTIONARY_ELEMENTS: |
7816 UNREACHABLE(); | 7899 UNREACHABLE(); |
7817 break; | 7900 break; |
7818 } | 7901 } |
7819 return GetHeap()->undefined_value(); | 7902 return GetHeap()->undefined_value(); |
7820 } | 7903 } |
7821 | 7904 |
7822 | 7905 |
7823 bool JSObject::HasDenseElements() { | 7906 bool JSObject::HasDenseElements() { |
7824 int capacity = 0; | 7907 int capacity = 0; |
7825 int number_of_elements = 0; | 7908 int number_of_elements = 0; |
7826 | 7909 |
7827 switch (GetElementsKind()) { | 7910 switch (GetElementsKind()) { |
7828 case FAST_ELEMENTS: { | 7911 case FAST_ELEMENTS: { |
7829 FixedArray* elms = FixedArray::cast(elements()); | 7912 FixedArray* elms = FixedArray::cast(elements()); |
7830 capacity = elms->length(); | 7913 capacity = elms->length(); |
7831 for (int i = 0; i < capacity; i++) { | 7914 for (int i = 0; i < capacity; i++) { |
7832 if (!elms->get(i)->IsTheHole()) number_of_elements++; | 7915 if (!elms->get(i)->IsTheHole()) number_of_elements++; |
7833 } | 7916 } |
7834 break; | 7917 break; |
7835 } | 7918 } |
7836 case EXTERNAL_PIXEL_ELEMENTS: | 7919 case EXTERNAL_PIXEL_ELEMENTS: |
7837 case EXTERNAL_BYTE_ELEMENTS: | 7920 case EXTERNAL_BYTE_ELEMENTS: |
7838 case EXTERNAL_UNSIGNED_BYTE_ELEMENTS: | 7921 case EXTERNAL_UNSIGNED_BYTE_ELEMENTS: |
7839 case EXTERNAL_SHORT_ELEMENTS: | 7922 case EXTERNAL_SHORT_ELEMENTS: |
7840 case EXTERNAL_UNSIGNED_SHORT_ELEMENTS: | 7923 case EXTERNAL_UNSIGNED_SHORT_ELEMENTS: |
7841 case EXTERNAL_INT_ELEMENTS: | 7924 case EXTERNAL_INT_ELEMENTS: |
7842 case EXTERNAL_UNSIGNED_INT_ELEMENTS: | 7925 case EXTERNAL_UNSIGNED_INT_ELEMENTS: |
7843 case EXTERNAL_FLOAT_ELEMENTS: { | 7926 case EXTERNAL_FLOAT_ELEMENTS: |
| 7927 case EXTERNAL_DOUBLE_ELEMENTS: { |
7844 return true; | 7928 return true; |
7845 } | 7929 } |
7846 case DICTIONARY_ELEMENTS: { | 7930 case DICTIONARY_ELEMENTS: { |
7847 NumberDictionary* dictionary = NumberDictionary::cast(elements()); | 7931 NumberDictionary* dictionary = NumberDictionary::cast(elements()); |
7848 capacity = dictionary->Capacity(); | 7932 capacity = dictionary->Capacity(); |
7849 number_of_elements = dictionary->NumberOfElements(); | 7933 number_of_elements = dictionary->NumberOfElements(); |
7850 break; | 7934 break; |
7851 } | 7935 } |
7852 default: | 7936 default: |
7853 UNREACHABLE(); | 7937 UNREACHABLE(); |
(...skipping 216 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
8070 case EXTERNAL_PIXEL_ELEMENTS: { | 8154 case EXTERNAL_PIXEL_ELEMENTS: { |
8071 ExternalPixelArray* pixels = ExternalPixelArray::cast(elements()); | 8155 ExternalPixelArray* pixels = ExternalPixelArray::cast(elements()); |
8072 return index < static_cast<uint32_t>(pixels->length()); | 8156 return index < static_cast<uint32_t>(pixels->length()); |
8073 } | 8157 } |
8074 case EXTERNAL_BYTE_ELEMENTS: | 8158 case EXTERNAL_BYTE_ELEMENTS: |
8075 case EXTERNAL_UNSIGNED_BYTE_ELEMENTS: | 8159 case EXTERNAL_UNSIGNED_BYTE_ELEMENTS: |
8076 case EXTERNAL_SHORT_ELEMENTS: | 8160 case EXTERNAL_SHORT_ELEMENTS: |
8077 case EXTERNAL_UNSIGNED_SHORT_ELEMENTS: | 8161 case EXTERNAL_UNSIGNED_SHORT_ELEMENTS: |
8078 case EXTERNAL_INT_ELEMENTS: | 8162 case EXTERNAL_INT_ELEMENTS: |
8079 case EXTERNAL_UNSIGNED_INT_ELEMENTS: | 8163 case EXTERNAL_UNSIGNED_INT_ELEMENTS: |
8080 case EXTERNAL_FLOAT_ELEMENTS: { | 8164 case EXTERNAL_FLOAT_ELEMENTS: |
| 8165 case EXTERNAL_DOUBLE_ELEMENTS: { |
8081 ExternalArray* array = ExternalArray::cast(elements()); | 8166 ExternalArray* array = ExternalArray::cast(elements()); |
8082 return index < static_cast<uint32_t>(array->length()); | 8167 return index < static_cast<uint32_t>(array->length()); |
8083 } | 8168 } |
8084 case DICTIONARY_ELEMENTS: { | 8169 case DICTIONARY_ELEMENTS: { |
8085 return element_dictionary()->FindEntry(index) | 8170 return element_dictionary()->FindEntry(index) |
8086 != NumberDictionary::kNotFound; | 8171 != NumberDictionary::kNotFound; |
8087 } | 8172 } |
8088 default: | 8173 default: |
8089 UNREACHABLE(); | 8174 UNREACHABLE(); |
8090 break; | 8175 break; |
(...skipping 220 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
8311 } | 8396 } |
8312 ASSERT(!storage || storage->length() >= counter); | 8397 ASSERT(!storage || storage->length() >= counter); |
8313 break; | 8398 break; |
8314 } | 8399 } |
8315 case EXTERNAL_BYTE_ELEMENTS: | 8400 case EXTERNAL_BYTE_ELEMENTS: |
8316 case EXTERNAL_UNSIGNED_BYTE_ELEMENTS: | 8401 case EXTERNAL_UNSIGNED_BYTE_ELEMENTS: |
8317 case EXTERNAL_SHORT_ELEMENTS: | 8402 case EXTERNAL_SHORT_ELEMENTS: |
8318 case EXTERNAL_UNSIGNED_SHORT_ELEMENTS: | 8403 case EXTERNAL_UNSIGNED_SHORT_ELEMENTS: |
8319 case EXTERNAL_INT_ELEMENTS: | 8404 case EXTERNAL_INT_ELEMENTS: |
8320 case EXTERNAL_UNSIGNED_INT_ELEMENTS: | 8405 case EXTERNAL_UNSIGNED_INT_ELEMENTS: |
8321 case EXTERNAL_FLOAT_ELEMENTS: { | 8406 case EXTERNAL_FLOAT_ELEMENTS: |
| 8407 case EXTERNAL_DOUBLE_ELEMENTS: { |
8322 int length = ExternalArray::cast(elements())->length(); | 8408 int length = ExternalArray::cast(elements())->length(); |
8323 while (counter < length) { | 8409 while (counter < length) { |
8324 if (storage != NULL) { | 8410 if (storage != NULL) { |
8325 storage->set(counter, Smi::FromInt(counter)); | 8411 storage->set(counter, Smi::FromInt(counter)); |
8326 } | 8412 } |
8327 counter++; | 8413 counter++; |
8328 } | 8414 } |
8329 ASSERT(!storage || storage->length() >= counter); | 8415 ASSERT(!storage || storage->length() >= counter); |
8330 break; | 8416 break; |
8331 } | 8417 } |
(...skipping 894 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
9226 // Clamp undefined to zero (default). All other types have been | 9312 // Clamp undefined to zero (default). All other types have been |
9227 // converted to a number type further up in the call chain. | 9313 // converted to a number type further up in the call chain. |
9228 ASSERT(value->IsUndefined()); | 9314 ASSERT(value->IsUndefined()); |
9229 } | 9315 } |
9230 set(index, cast_value); | 9316 set(index, cast_value); |
9231 } | 9317 } |
9232 return heap->AllocateHeapNumber(cast_value); | 9318 return heap->AllocateHeapNumber(cast_value); |
9233 } | 9319 } |
9234 | 9320 |
9235 | 9321 |
| 9322 MaybeObject* ExternalDoubleArray::SetValue(uint32_t index, Object* value) { |
| 9323 double double_value = 0; |
| 9324 Heap* heap = GetHeap(); |
| 9325 if (index < static_cast<uint32_t>(length())) { |
| 9326 if (value->IsSmi()) { |
| 9327 int int_value = Smi::cast(value)->value(); |
| 9328 double_value = static_cast<double>(int_value); |
| 9329 } else if (value->IsHeapNumber()) { |
| 9330 double_value = HeapNumber::cast(value)->value(); |
| 9331 } else { |
| 9332 // Clamp undefined to zero (default). All other types have been |
| 9333 // converted to a number type further up in the call chain. |
| 9334 ASSERT(value->IsUndefined()); |
| 9335 } |
| 9336 set(index, double_value); |
| 9337 } |
| 9338 return heap->AllocateHeapNumber(double_value); |
| 9339 } |
| 9340 |
| 9341 |
9236 JSGlobalPropertyCell* GlobalObject::GetPropertyCell(LookupResult* result) { | 9342 JSGlobalPropertyCell* GlobalObject::GetPropertyCell(LookupResult* result) { |
9237 ASSERT(!HasFastProperties()); | 9343 ASSERT(!HasFastProperties()); |
9238 Object* value = property_dictionary()->ValueAt(result->GetDictionaryEntry()); | 9344 Object* value = property_dictionary()->ValueAt(result->GetDictionaryEntry()); |
9239 return JSGlobalPropertyCell::cast(value); | 9345 return JSGlobalPropertyCell::cast(value); |
9240 } | 9346 } |
9241 | 9347 |
9242 | 9348 |
9243 MaybeObject* GlobalObject::EnsurePropertyCell(String* name) { | 9349 MaybeObject* GlobalObject::EnsurePropertyCell(String* name) { |
9244 ASSERT(!HasFastProperties()); | 9350 ASSERT(!HasFastProperties()); |
9245 int entry = property_dictionary()->FindEntry(name); | 9351 int entry = property_dictionary()->FindEntry(name); |
(...skipping 1071 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
10317 if (break_point_objects()->IsUndefined()) return 0; | 10423 if (break_point_objects()->IsUndefined()) return 0; |
10318 // Single beak point. | 10424 // Single beak point. |
10319 if (!break_point_objects()->IsFixedArray()) return 1; | 10425 if (!break_point_objects()->IsFixedArray()) return 1; |
10320 // Multiple break points. | 10426 // Multiple break points. |
10321 return FixedArray::cast(break_point_objects())->length(); | 10427 return FixedArray::cast(break_point_objects())->length(); |
10322 } | 10428 } |
10323 #endif | 10429 #endif |
10324 | 10430 |
10325 | 10431 |
10326 } } // namespace v8::internal | 10432 } } // namespace v8::internal |
OLD | NEW |