Chromium Code Reviews
chromiumcodereview-hr@appspot.gserviceaccount.com (chromiumcodereview-hr) | Please choose your nickname with Settings | Help | Chromium Project | Gerrit Changes | Sign out
(311)

Side by Side Diff: src/builtins.cc

Issue 1785403002: [runtime] split up loops with HandleScopes (Closed) Base URL: https://chromium.googlesource.com/v8/v8.git@master
Patch Set: adding loop var type Created 4 years, 9 months ago
Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.
Jump to:
View unified diff | Download patch
« no previous file with comments | « no previous file | src/d8.cc » ('j') | no next file with comments »
Toggle Intra-line Diffs ('i') | Expand Comments ('e') | Collapse Comments ('c') | Show Comments Hide Comments ('s')
OLDNEW
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
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
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
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
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
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
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
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
OLDNEW
« no previous file with comments | « no previous file | src/d8.cc » ('j') | no next file with comments »

Powered by Google App Engine
This is Rietveld 408576698