Lines Matching refs:isolate
11 #include "src/execution/isolate.h"
31 inline bool IsJSArrayFastElementMovingAllowed(Isolate* isolate,
33 return JSObject::PrototypeHasNoElements(isolate, receiver);
41 inline bool HasOnlySimpleReceiverElements(Isolate* isolate, JSObject receiver) {
44 return JSObject::PrototypeHasNoElements(isolate, receiver);
47 inline bool HasOnlySimpleElements(Isolate* isolate, JSReceiver receiver) {
49 PrototypeIterator iter(isolate, receiver, kStartAtReceiver);
61 void MatchArrayElementsKindToArguments(Isolate* isolate, Handle<JSArray> array,
91 HandleScope scope(isolate);
100 inline bool EnsureJSArrayWithWritableFastElements(Isolate* isolate,
114 if (!IsJSArrayFastElementMovingAllowed(isolate, *array)) return false;
118 if (isolate->IsAnyInitialArrayPrototype(*array)) return false;
122 MatchArrayElementsKindToArguments(isolate, array, args, first_arg_index,
131 V8_WARN_UNUSED_RESULT Maybe<double> GetRelativeIndex(Isolate* isolate,
138 ASSIGN_RETURN_ON_EXCEPTION_VALUE(isolate, relative_index_obj,
139 Object::ToInteger(isolate, index),
153 Isolate* isolate, Handle<JSReceiver> receiver) {
164 isolate, raw_length_number,
165 Object::GetLengthFromArrayLike(isolate, receiver), Nothing<double>());
172 Isolate* isolate, Handle<JSReceiver> receiver, double length) {
184 isolate, receiver, isolate->factory()->length_string(),
185 isolate->factory()->NewNumber(length), StoreOrigin::kMaybeKeyed,
189 V8_WARN_UNUSED_RESULT Object GenericArrayFill(Isolate* isolate,
196 Handle<String> index = isolate->factory()->NumberToString(
197 isolate->factory()->NewNumber(start));
200 RETURN_FAILURE_ON_EXCEPTION(isolate, Object::SetPropertyOrElement(
201 isolate, receiver, index, value,
213 Isolate* isolate, BuiltinArguments* args, Handle<JSReceiver> receiver,
220 if (!EnsureJSArrayWithWritableFastElements(isolate, receiver, args, 1, 1)) {
233 HandleScope scope(isolate);
245 RETURN_ON_EXCEPTION_VALUE(isolate, accessor->Fill(array, value, start, end),
252 HandleScope scope(isolate);
253 if (isolate->debug_execution_mode() == DebugInfo::kSideEffects) {
254 if (!isolate->debug()->PerformSideEffectCheckForObject(args.receiver())) {
255 return ReadOnlyRoots(isolate).exception();
262 isolate, receiver, Object::ToObject(isolate, args.receiver()));
267 isolate, length, GetLengthProperty(isolate, receiver));
272 Handle<Object> start = args.atOrUndefined(isolate, 2);
276 isolate, start_index, GetRelativeIndex(isolate, length, start, 0));
282 Handle<Object> end = args.atOrUndefined(isolate, 3);
286 isolate, end_index, GetRelativeIndex(isolate, length, end, length));
295 Handle<Object> value = args.atOrUndefined(isolate, 1);
299 isolate, success,
300 TryFastArrayFill(isolate, &args, receiver, value, start_index,
303 return GenericArrayFill(isolate, receiver, value, start_index, end_index);
307 V8_WARN_UNUSED_RESULT Object GenericArrayPush(Isolate* isolate,
312 isolate, receiver, Object::ToObject(isolate, args->receiver()));
317 isolate, raw_length_number,
318 Object::GetLengthFromArrayLike(isolate, receiver));
329 isolate, NewTypeError(MessageTemplate::kPushPastSafeLength,
330 isolate->factory()->NewNumberFromInt(arg_count),
343 isolate, Object::SetElement(isolate, receiver, length, element,
346 PropertyKey key(isolate, length);
347 LookupIterator it(isolate, receiver, key);
350 ReadOnlyRoots(isolate).exception());
358 Handle<Object> final_length = isolate->factory()->NewNumber(length);
360 isolate, Object::SetProperty(isolate, receiver,
361 isolate->factory()->length_string(),
371 HandleScope scope(isolate);
373 if (!EnsureJSArrayWithWritableFastElements(isolate, receiver, &args, 1,
375 return GenericArrayPush(isolate, &args);
382 if (to_add == 0) return *isolate->factory()->NewNumberFromUint(len);
388 return GenericArrayPush(isolate, &args);
394 isolate, new_length, accessor->Push(array, &args, to_add));
395 return *isolate->factory()->NewNumberFromUint((new_length));
400 V8_WARN_UNUSED_RESULT Object GenericArrayPop(Isolate* isolate,
405 isolate, receiver, Object::ToObject(isolate, args->receiver()));
410 isolate, raw_length_number,
411 Object::GetLengthFromArrayLike(isolate, receiver));
418 isolate, Object::SetProperty(isolate, receiver,
419 isolate->factory()->length_string(),
420 Handle<Smi>(Smi::zero(), isolate),
425 return ReadOnlyRoots(isolate).undefined_value();
430 Handle<Object> new_length = isolate->factory()->NewNumber(length - 1);
433 Handle<String> index = isolate->factory()->NumberToString(new_length);
438 isolate, element, Object::GetPropertyOrElement(isolate, receiver, index));
443 ReadOnlyRoots(isolate).exception());
447 isolate, Object::SetProperty(isolate, receiver,
448 isolate->factory()->length_string(),
459 HandleScope scope(isolate);
461 if (!EnsureJSArrayWithWritableFastElements(isolate, receiver, nullptr, 0,
463 return GenericArrayPop(isolate, &args);
470 return GenericArrayPop(isolate, &args);
472 if (len == 0) return ReadOnlyRoots(isolate).undefined_value();
475 if (IsJSArrayFastElementMovingAllowed(isolate, JSArray::cast(*receiver))) {
478 isolate, result, array->GetElementsAccessor()->Pop(array));
483 isolate, result, JSReceiver::GetElement(isolate, array, new_length));
489 isolate, NewTypeError(MessageTemplate::kStrictReadOnlyProperty,
490 isolate->factory()->length_string(),
491 Object::TypeOf(isolate, array), array));
495 isolate, set_len_ok, JSArray::SetLength(array, new_length));
504 V8_WARN_UNUSED_RESULT bool CanUseFastArrayShift(Isolate* isolate,
506 if (!EnsureJSArrayWithWritableFastElements(isolate, receiver, nullptr, 0,
508 !IsJSArrayFastElementMovingAllowed(isolate, JSArray::cast(*receiver))) {
516 V8_WARN_UNUSED_RESULT Object GenericArrayShift(Isolate* isolate,
521 ASSIGN_RETURN_FAILURE_ON_EXCEPTION(isolate, first,
522 Object::GetElement(isolate, receiver, 0));
531 isolate->factory()->NumberToString(isolate->factory()->NewNumber(k));
534 Handle<String> to = isolate->factory()->NumberToString(
535 isolate->factory()->NewNumber(k - 1));
540 isolate, from_present,
541 JSReceiver::HasProperty(isolate, receiver, from));
548 isolate, from_val,
549 Object::GetPropertyOrElement(isolate, receiver, from));
553 isolate,
554 Object::SetPropertyOrElement(isolate, receiver, to, from_val,
560 ReadOnlyRoots(isolate).exception());
568 Handle<String> new_length = isolate->factory()->NumberToString(
569 isolate->factory()->NewNumber(length - 1));
572 ReadOnlyRoots(isolate).exception());
575 RETURN_FAILURE_ON_EXCEPTION(isolate,
576 SetLengthProperty(isolate, receiver, length - 1));
584 HandleScope scope(isolate);
589 isolate, receiver, Object::ToObject(isolate, args.receiver()));
594 isolate, length, GetLengthProperty(isolate, receiver));
599 RETURN_FAILURE_ON_EXCEPTION(isolate,
600 SetLengthProperty(isolate, receiver, length));
603 return ReadOnlyRoots(isolate).undefined_value();
606 if (CanUseFastArrayShift(isolate, receiver)) {
608 RETURN_RESULT_OR_FAILURE(isolate,
612 return GenericArrayShift(isolate, receiver, length);
616 HandleScope scope(isolate);
623 DCHECK(IsJSArrayFastElementMovingAllowed(isolate, *array));
624 DCHECK(!isolate->IsAnyInitialArrayPrototype(*array));
626 MatchArrayElementsKindToArguments(isolate, array, &args, 1,
639 isolate, new_length, accessor->Unshift(array, &args, to_add));
660 ArrayConcatVisitor(Isolate* isolate, Handle<HeapObject> storage,
662 : isolate_(isolate),
663 storage_(isolate->global_handles()->Create(*storage)),
667 IsFixedArrayField::encode(storage->IsFixedArray(isolate)) |
669 storage->IsFixedArray(isolate) ||
672 (!storage->map(isolate).IsCustomElementsReceiverMap() &&
673 !storage->IsJSTypedArray(isolate)))) {
841 uint32_t EstimateElementCount(Isolate* isolate, Handle<JSArray> array) {
862 if (!elements.get(i).IsTheHole(isolate)) element_count++;
884 ReadOnlyRoots roots(isolate);
915 void CollectElementIndices(Isolate* isolate, Handle<JSObject> object,
934 if (!elements.get(i).IsTheHole(isolate)) {
947 FixedDoubleArray::cast(object->elements()), isolate);
961 ReadOnlyRoots roots(isolate);
962 FOR_WITH_HANDLE_SCOPE(isolate, uint32_t, j = 0, j, j < capacity, j++, {
1016 Handle<String> string(String::cast(js_value->value()), isolate);
1038 PrototypeIterator iter(isolate, object);
1043 isolate, PrototypeIterator::GetCurrent<JSObject>(iter), range, indices);
1047 bool IterateElementsSlow(Isolate* isolate, Handle<JSReceiver> receiver,
1049 FOR_WITH_HANDLE_SCOPE(isolate, uint32_t, i = 0, i, i < length, ++i, {
1050 Maybe<bool> maybe = JSReceiver::HasElement(isolate, receiver, i);
1055 isolate, element_value, JSReceiver::GetElement(isolate, receiver, i),
1073 bool IterateElements(Isolate* isolate, Handle<JSReceiver> receiver,
1083 isolate, val, Object::GetLengthFromArrayLike(isolate, receiver), false);
1085 isolate->Throw(*isolate->factory()->NewTypeError(
1094 return IterateElementsSlow(isolate, receiver, length, visitor);
1098 !HasOnlySimpleElements(isolate, *receiver)) {
1099 return IterateElementsSlow(isolate, receiver, length, visitor);
1115 DisallowJavascriptExecution no_js(isolate);
1119 Handle<FixedArray> elements(FixedArray::cast(array->elements()), isolate);
1122 FOR_WITH_HANDLE_SCOPE(isolate, int, j = 0, j, j < fast_length, j++, {
1123 Handle<Object> element_value(elements->get(j), isolate);
1124 if (!element_value->IsTheHole(isolate)) {
1127 Maybe<bool> maybe = JSReceiver::HasElement(isolate, array, j);
1133 isolate, element_value,
1134 JSReceiver::GetElement(isolate, array, j), false);
1144 DisallowJavascriptExecution no_js(isolate);
1155 FixedDoubleArray::cast(array->elements()), isolate);
1158 FOR_WITH_HANDLE_SCOPE(isolate, int, j = 0, j, j < fast_length, j++, {
1162 isolate->factory()->NewNumber(double_value);
1165 Maybe<bool> maybe = JSReceiver::HasElement(isolate, array, j);
1172 isolate, element_value,
1173 JSReceiver::GetElement(isolate, array, j), false);
1183 DisallowJavascriptExecution no_js(isolate);
1185 Handle<NumberDictionary> dict(array->element_dictionary(), isolate);
1191 CollectElementIndices(isolate, array, length, &indices);
1194 FOR_WITH_HANDLE_SCOPE(isolate, size_t, j = 0, j, j < n, (void)0, {
1198 isolate, element, JSReceiver::GetElement(isolate, array, index),
1211 isolate, uint32_t, index = 0, index, index < length, index++, {
1214 isolate, element, JSReceiver::GetElement(isolate, array, index),
1227 return IterateElementsSlow(isolate, receiver, length, visitor);
1241 static Maybe<bool> IsConcatSpreadable(Isolate* isolate, Handle<Object> obj) {
1242 HandleScope handle_scope(isolate);
1244 if (!Protectors::IsIsConcatSpreadableLookupChainIntact(isolate) ||
1245 JSReceiver::cast(*obj).HasProxyInPrototype(isolate)) {
1247 Handle<Symbol> key(isolate->factory()->is_concat_spreadable_symbol());
1250 i::Runtime::GetObjectProperty(isolate, obj, key);
1252 if (!value->IsUndefined(isolate)) return Just(value->BooleanValue(isolate));
1258 Isolate* isolate) {
1261 bool is_array_species = *species == isolate->context().array_function();
1272 FOR_WITH_HANDLE_SCOPE(isolate, int, i = 0, i, i < argument_count, i++, {
1287 element_estimate = EstimateElementCount(isolate, array);
1314 Protectors::IsIsConcatSpreadableLookupChainIntact(isolate);
1318 isolate->factory()->NewFixedDoubleArray(estimate_result_length);
1361 Object the_hole = ReadOnlyRoots(isolate).the_hole_value();
1395 return *isolate->factory()->NewJSArrayWithElements(storage, kind, j);
1405 isolate->factory()->NewFixedArrayWithHoles(estimate_result_length);
1407 storage = NumberDictionary::New(isolate, estimate_nof);
1410 Handle<Object> length(Smi::zero(), isolate);
1413 isolate, storage_object,
1414 Execution::New(isolate, species, species, 1, &length));
1418 ArrayConcatVisitor visitor(isolate, storage, fast_case);
1422 Maybe<bool> spreadable = IsConcatSpreadable(isolate, obj);
1423 MAYBE_RETURN(spreadable, ReadOnlyRoots(isolate).exception());
1426 if (!IterateElements(isolate, object, &visitor)) {
1427 return ReadOnlyRoots(isolate).exception();
1430 if (!visitor.visit(0, obj)) return ReadOnlyRoots(isolate).exception();
1437 isolate, NewRangeError(MessageTemplate::kInvalidArrayLength));
1443 RETURN_RESULT_OR_FAILURE(isolate, visitor.ToJSReceiver());
1447 bool IsSimpleArray(Isolate* isolate, Handle<JSArray> obj) {
1451 if (map.prototype() == isolate->native_context()->initial_array_prototype() &&
1460 MaybeHandle<JSArray> Fast_ArrayConcat(Isolate* isolate,
1462 if (!Protectors::IsIsConcatSpreadableLookupChainIntact(isolate)) {
1480 if (!HasOnlySimpleReceiverElements(isolate, JSObject::cast(arg))) {
1487 Handle<JSArray> array(JSArray::cast(arg), isolate);
1488 if (!IsSimpleArray(isolate, array)) {
1499 THROW_NEW_ERROR(isolate,
1505 return ElementsAccessor::Concat(isolate, args, n_arguments, result_len);
1512 HandleScope scope(isolate);
1516 isolate, receiver,
1517 Object::ToObject(isolate, args.receiver(), "Array.prototype.concat"));
1524 Handle<JSArray>::cast(receiver)->HasArrayPrototype(isolate) &&
1525 Protectors::IsArraySpeciesLookupChainIntact(isolate))) {
1526 if (Fast_ArrayConcat(isolate, &args).ToHandle(&result_array)) {
1529 if (isolate->has_pending_exception())
1530 return ReadOnlyRoots(isolate).exception();
1536 isolate, species, Object::ArraySpeciesConstructor(isolate, receiver));
1537 if (*species == *isolate->array_function()) {
1538 if (Fast_ArrayConcat(isolate, &args).ToHandle(&result_array)) {
1541 if (isolate->has_pending_exception())
1542 return ReadOnlyRoots(isolate).exception();
1544 return Slow_ArrayConcat(&args, species, isolate);
1552 Isolate* isolate, Handle<OrderedHashMap> groups, Handle<Object> key,
1554 InternalIndex entry = groups->FindEntry(isolate, *key);
1556 Handle<ArrayList> array = ArrayList::New(isolate, 1);
1557 array = ArrayList::Add(isolate, array, value);
1558 return OrderedHashMap::Add(isolate, groups, key, array).ToHandleChecked();
1561 Handle<ArrayList>(ArrayList::cast(groups->ValueAt(entry)), isolate);
1562 array = ArrayList::Add(isolate, array, value);
1568 Isolate* isolate = object->GetIsolate();
1569 if (isolate->force_slow_path()) return false;
1572 if (!array->HasFastElements(isolate)) return false;
1574 Context context = isolate->context();
1580 return Protectors::IsNoElementsIntact(isolate);
1595 Isolate* isolate, Handle<JSReceiver> O, Handle<Object> callbackfn,
1602 isolate, Pk, Object::ToName(isolate, isolate->factory()->NewNumber(k)),
1606 ASSIGN_RETURN_ON_EXCEPTION(isolate, kValue,
1607 Object::GetPropertyOrElement(isolate, O, Pk),
1613 Handle<Object> argv[] = {kValue, isolate->factory()->NewNumber(k), O};
1614 ASSIGN_RETURN_ON_EXCEPTION(isolate, propertyKey,
1615 Execution::Call(isolate, callbackfn, O, 3, argv),
1621 propertyKey = Handle<Smi>(Smi::FromInt(0), isolate);
1627 ASSIGN_RETURN_ON_EXCEPTION(isolate, propertyKeyName,
1628 Object::ToName(isolate, propertyKey),
1630 propertyKey = isolate->factory()->InternalizeName(propertyKeyName);
1634 groups = AddValueToKeyedGroup(isolate, groups, propertyKey, kValue);
1645 Isolate* isolate, Handle<JSArray> array, Handle<Object> callbackfn,
1650 Handle<Map> original_map = Handle<Map>(array->map(), isolate);
1659 return GenericArrayGroupBy<mode>(isolate, array, callbackfn, groups,
1666 kValue = isolate->factory()->undefined_value();
1673 kValue, isolate->factory()->NewNumber(k.as_uint32()), array};
1675 isolate, propertyKey,
1676 Execution::Call(isolate, callbackfn, array, 3, argv), OrderedHashMap);
1681 propertyKey = Handle<Smi>(Smi::FromInt(0), isolate);
1687 ASSIGN_RETURN_ON_EXCEPTION(isolate, propertyKeyName,
1688 Object::ToName(isolate, propertyKey),
1690 propertyKey = isolate->factory()->InternalizeName(propertyKeyName);
1694 groups = AddValueToKeyedGroup(isolate, groups, propertyKey, kValue);
1719 HandleScope scope(isolate);
1724 isolate, O, Object::ToObject(isolate, args.receiver(), kMethodName));
1728 MAYBE_ASSIGN_RETURN_FAILURE_ON_EXCEPTION(isolate, len,
1729 GetLengthProperty(isolate, O));
1732 Handle<Object> callbackfn = args.atOrUndefined(isolate, 1);
1735 isolate, NewTypeError(MessageTemplate::kCalledNonCallable, callbackfn));
1739 Handle<OrderedHashMap> groups = isolate->factory()->NewOrderedHashMap();
1744 isolate, groups,
1746 isolate, array, callbackfn, groups, len, &result_elements_kind));
1750 isolate, groups,
1751 GenericArrayGroupBy<GroupByMode::kToObject>(isolate, O, callbackfn,
1756 Handle<JSObject> obj = isolate->factory()->NewJSObjectWithNullProto();
1760 Handle<Name> key = Handle<Name>(Name::cast(groups->KeyAt(entry)), isolate);
1763 Handle<ArrayList>(ArrayList::cast(groups->ValueAt(entry)), isolate);
1764 Handle<FixedArray> elements = ArrayList::Elements(isolate, array_list);
1765 Handle<JSArray> array = isolate->factory()->NewJSArrayWithElements(
1769 JSReceiver::CreateDataProperty(isolate, obj, key, array,
1781 HandleScope scope(isolate);
1786 isolate, O, Object::ToObject(isolate, args.receiver(), kMethodName));
1790 MAYBE_ASSIGN_RETURN_FAILURE_ON_EXCEPTION(isolate, len,
1791 GetLengthProperty(isolate, O));
1794 Handle<Object> callbackfn = args.atOrUndefined(isolate, 1);
1797 isolate, NewTypeError(MessageTemplate::kCalledNonCallable, callbackfn));
1801 Handle<OrderedHashMap> groups = isolate->factory()->NewOrderedHashMap();
1806 isolate, groups,
1808 isolate, array, callbackfn, groups, len, &result_elements_kind));
1812 isolate, groups,
1813 GenericArrayGroupBy<GroupByMode::kToMap>(isolate, O, callbackfn, groups,
1818 Handle<JSMap> map = isolate->factory()->NewJSMap();
1819 Handle<OrderedHashMap> map_table = isolate->factory()->NewOrderedHashMap();
1822 Handle<Object> key = Handle<Object>(groups->KeyAt(entry), isolate);
1825 Handle<ArrayList>(ArrayList::cast(groups->ValueAt(entry)), isolate);
1826 Handle<FixedArray> elements = ArrayList::Elements(isolate, array_list);
1827 Handle<JSArray> array = isolate->factory()->NewJSArrayWithElements(
1833 OrderedHashMap::Add(isolate, map_table, key, array).ToHandleChecked();