Lines Matching defs:elements
5 #include "src/objects/elements.h"
182 WriteBarrierMode GetWriteBarrierMode(FixedArrayBase elements, ElementsKind kind,
186 return elements.GetWriteBarrierMode(promise);
190 // CopyElements, it copies all of elements from source after source_start to
191 // destination array, padding any remaining uninitialized elements in the
580 FixedArrayBase fixed_array_base = holder.elements();
618 return Subclass::HasEntryImpl(holder.GetIsolate(), holder.elements(),
628 return Subclass::HasAccessorsImpl(holder, holder.elements());
641 return Subclass::GetImpl(holder->GetIsolate(), holder->elements(), entry);
719 handle(array->elements(), array->GetIsolate()));
746 if (array->elements() != *backing_store) {
747 backing_store = handle(array->elements(), isolate);
751 // If more than half the elements won't be used, trim the array.
759 // Fill the non-trimmed elements with holes.
780 return Subclass::NumberOfElementsImpl(receiver, receiver.elements());
788 static size_t GetMaxIndex(JSObject receiver, FixedArrayBase elements) {
794 return Subclass::GetCapacityImpl(receiver, elements);
798 FixedArrayBase elements) {
799 return Subclass::GetMaxIndex(receiver, elements);
860 Handle<FixedArrayBase> from_elements(object->elements(), isolate);
861 if (object->elements() == ReadOnlyRoots(isolate).empty_fixed_array() ||
863 // No change is needed to the elements() buffer, the transition
870 uint32_t capacity = static_cast<uint32_t>(object->elements().length());
871 Handle<FixedArrayBase> elements;
873 object->GetIsolate(), elements,
877 JSObject::SetMapAndElements(object, to_map, elements);
882 handle(object->elements(), isolate));
897 Handle<FixedArrayBase> old_elements(object->elements(),
900 // elements.
911 Handle<FixedArrayBase> elements;
913 object->GetIsolate(), elements,
921 JSObject::SetMapAndElements(object, new_map, elements);
928 to_kind, elements);
950 Handle<FixedArrayBase> old_elements(object->elements(),
954 Handle<FixedArrayBase> elements;
956 object->GetIsolate(), elements,
967 object->set_elements(*elements);
994 FixedArrayBase from = from_holder.elements();
1001 // copying from object with fast double elements to object with object
1002 // elements. In all the other cases there are no allocations performed and
1041 object, handle(object->elements(), object->GetIsolate()));
1045 Handle<JSObject> object, Handle<FixedArrayBase> elements) {
1065 object, handle(object->elements(), isolate), &accumulator));
1079 isolate, *object, object->elements(), index, filter);
1087 // This might modify the elements and/or change the elements kind.
1097 // Slow path caused by changes in elements kind during iteration.
1108 isolate, *object, object->elements(), index);
1138 // Non-dictionary elements can't have all-can-read accessors.
1237 // Indices from dictionary elements should only be converted after
1253 // For holey elements and arguments we might have to shrink the collected
1397 static uint32_t GetMaxIndex(JSObject receiver, FixedArrayBase elements) {
1425 // Find last non-deletable element in range of elements to be
1443 // Remove elements that should be deleted.
1457 // Update the number of elements.
1477 Handle<NumberDictionary> dict(NumberDictionary::cast(obj->elements()),
1510 SetImpl(holder->elements(), entry, value);
1542 : handle(NumberDictionary::cast(object->elements()),
1580 return GetDetailsImpl(holder.elements(), entry);
1616 Handle<FixedArray> elements = isolate->factory()->NewFixedArray(
1631 elements->set(insertion_index, raw_key);
1634 SortIndices(isolate, elements, insertion_index);
1636 RETURN_FAILURE_IF_NOT_SUCCESSFUL(keys->AddKey(elements->get(i)));
1667 NumberDictionary::cast(receiver->elements()), isolate);
1685 NumberDictionary dictionary = NumberDictionary::cast(receiver->elements());
1689 // Scan for accessor properties. If accessors are present, then elements
1733 NumberDictionary::cast(receiver->elements()), isolate);
1734 // Iterate through the entire range, as accessing elements out of order is
1765 // Bailout to slow path if elements on prototype changed
1771 // Continue if elements unchanged
1772 if (*dictionary == receiver->elements()) continue;
1774 // Otherwise, bailout or update elements
1776 // If switched to initial elements, return true if searching for
1778 if (receiver->map().GetInitialElements() == receiver->elements()) {
1782 // If switched to fast elements, continue with the correct accessor.
1789 handle(NumberDictionary::cast(receiver->elements()), isolate);
1806 NumberDictionary::cast(receiver->elements()), isolate);
1807 // Iterate through entire range, as accessing elements out of order is
1839 // Bailout to slow path if elements on prototype changed.
1845 // Continue if elements unchanged.
1846 if (*dictionary == receiver->elements()) continue;
1848 // Otherwise, bailout or update elements.
1855 handle(NumberDictionary::cast(receiver->elements()), isolate);
1869 NumberDictionary dictionary = NumberDictionary::cast(holder.elements());
1945 // Dynamically ask for the elements kind here since we manually redirect
1948 SloppyArgumentsElements::cast(obj->elements()).set_arguments(empty);
1973 // TODO(verwaest): Move this out of elements.cc.
1989 // enough to reliably hit the "window" of remaining elements count where
2048 Subclass::GetCapacityImpl(*object, object->elements()) !=
2076 handle(obj->elements(), obj->GetIsolate()));
2106 Handle<FixedArrayBase> elements(receiver->elements(), isolate);
2107 size_t length = Subclass::GetMaxNumberOfEntries(*receiver, *elements);
2110 HasEntryImpl(isolate, *elements, InternalIndex(i))) {
2112 Subclass::GetImpl(isolate, *elements, InternalIndex(i)), convert));
2122 FixedArrayBase elements = holder.elements();
2123 Map map = elements.map();
2135 BackingStore backing_store = BackingStore::cast(elements);
2167 Handle<FixedArrayBase> backing_store(receiver->elements(),
2176 Handle<FixedArrayBase> backing_store(receiver->elements(),
2223 if (end > Subclass::GetCapacityImpl(*receiver, receiver->elements())) {
2228 DCHECK_LE(end, Subclass::GetCapacityImpl(*receiver, receiver->elements()));
2242 FixedArrayBase elements_base = receiver->elements();
2268 FixedArray elements = FixedArray::cast(receiver->elements());
2271 Object element_k = elements.get(static_cast<int>(k));
2282 FixedDoubleArray elements =
2283 FixedDoubleArray::cast(receiver->elements());
2286 if (elements.is_the_hole(static_cast<int>(k))) return Just(true);
2295 // elements kinds can only contain Number values or undefined.
2302 FixedArray elements = FixedArray::cast(receiver->elements());
2305 Object element_k = elements.get(static_cast<int>(k));
2318 FixedDoubleArray elements =
2319 FixedDoubleArray::cast(receiver->elements());
2322 if (elements.is_the_hole(static_cast<int>(k))) continue;
2323 if (elements.get_scalar(static_cast<int>(k)) == search_number) {
2332 FixedArray elements = FixedArray::cast(receiver->elements());
2335 Object element_k = elements.get(static_cast<int>(k));
2343 // Search for NaN --- NaN cannot be represented with Smi elements, so
2351 FixedDoubleArray elements =
2352 FixedDoubleArray::cast(receiver->elements());
2355 if (elements.is_the_hole(static_cast<int>(k))) continue;
2356 if (std::isnan(elements.get_scalar(static_cast<int>(k)))) {
2366 FixedArray elements = FixedArray::cast(receiver->elements());
2369 if (elements.get(static_cast<int>(k)).IsNaN()) return Just(true);
2381 Handle<FixedArrayBase> elements(object->elements(), isolate);
2384 if (!Subclass::HasEntryImpl(isolate, *elements, entry)) continue;
2386 value = Subclass::GetImpl(isolate, *elements, entry);
2403 Handle<FixedArrayBase> backing_store(receiver->elements(), isolate);
2449 // If the backing store has enough capacity and we add elements to the
2486 SetImpl(holder->elements(), entry, value);
2506 // This method could actually allocate if copying from double elements to
2507 // object elements.
2564 Handle<FixedArray> elements(FixedArray::cast(object->elements()),
2566 uint32_t length = elements->length();
2569 if (!Subclass::HasEntryImpl(isolate, *elements, entry)) continue;
2570 Handle<Object> value = Subclass::GetImpl(isolate, *elements, entry);
2577 FixedArray elements = FixedArray::cast(object->elements());
2578 uint32_t length = elements.length();
2581 if (!Subclass::HasEntryImpl(isolate, elements, entry)) continue;
2582 Object value = GetRaw(elements, entry);
2596 FixedArrayBase elements_base = receiver->elements();
2613 // elements->get(k) can return the hole, for which the StrictEquals will
2615 FixedArray elements = FixedArray::cast(receiver->elements());
2619 if (value.StrictEquals(elements.get(static_cast<uint32_t>(k)))) {
2690 if (array->elements() !=
2701 Handle<FixedArrayBase> new_backing_store(array->elements(), isolate);
2788 if (array->elements() !=
2799 Handle<FixedArrayBase> new_backing_store(array->elements(), isolate);
2912 SetImpl(holder->elements(), entry, value);
2976 Handle<FixedDoubleArray> elements(
2977 FixedDoubleArray::cast(object->elements()), isolate);
2979 uint32_t length = elements->length();
2982 if (!Subclass::HasEntryImpl(isolate, *elements, entry)) continue;
2983 Handle<Object> value = Subclass::GetImpl(isolate, *elements, entry);
2999 FixedArrayBase elements_base = receiver->elements();
3013 FixedDoubleArray elements = FixedDoubleArray::cast(receiver->elements());
3019 if (elements.is_the_hole(k_int)) {
3022 if (elements.get_scalar(k_int) == numeric_search_value) {
3241 // TypedArray elements are configurable to explain detaching, but cannot be
3268 Handle<FixedArrayBase> elements(receiver->elements(), isolate);
3269 size_t length = AccessorClass::GetCapacityImpl(*receiver, *elements);
3284 Handle<FixedArrayBase> elements(object->elements(), isolate);
3285 size_t length = AccessorClass::GetCapacityImpl(*object, *elements);
3350 // Prototype has no elements, and not searching for the hole --- limit
3421 // Prototype has no elements, and not searching for the hole --- limit
3635 // side-effects, as the source elements will always be a number.
3777 FixedArray source_store = FixedArray::cast(source.elements());
3786 FixedArray source_store = FixedArray::cast(source.elements());
3800 FixedDoubleArray source_store = FixedDoubleArray::cast(source.elements());
3810 FixedDoubleArray source_store = FixedDoubleArray::cast(source.elements());
3898 // If we have to copy more elements than we have in the source, we need to
4360 Handle<SloppyArgumentsElements> elements, Handle<Object> result) {
4366 Handle<SloppyArgumentsElements> elements(
4368 uint32_t length = elements->length();
4372 Object probe = elements->mapped_entries(entry.as_uint32(), kRelaxedLoad);
4374 Context context = elements->context();
4381 isolate, elements->arguments(), entry.adjust_down(length));
4382 return Subclass::ConvertArgumentsStoreResult(isolate, elements, result);
4398 SetImpl(holder->elements(), entry, value);
4403 SloppyArgumentsElements elements = SloppyArgumentsElements::cast(store);
4404 uint32_t length = elements.length();
4408 Object probe = elements.mapped_entries(entry.as_uint32(), kRelaxedLoad);
4410 Context context = Context::cast(elements.context());
4416 FixedArray arguments = elements.arguments();
4421 Context context = Context::cast(elements.context());
4439 SloppyArgumentsElements elements = SloppyArgumentsElements::cast(store);
4440 FixedArray arguments = elements.arguments();
4441 return elements.length() +
4447 SloppyArgumentsElements elements =
4449 FixedArrayBase arguments = elements.arguments();
4453 return elements.length() + static_cast<uint32_t>(max_entries);
4459 SloppyArgumentsElements elements =
4461 FixedArrayBase arguments = elements.arguments();
4463 uint32_t length = elements.length();
4465 if (HasParameterMapArg(isolate, elements, index)) nof_elements++;
4475 Handle<FixedArrayBase> elements(receiver->elements(), isolate);
4476 uint32_t length = GetCapacityImpl(*receiver, *elements);
4479 if (!HasEntryImpl(isolate, *elements, entry)) continue;
4480 Handle<Object> value = GetImpl(isolate, *elements, entry);
4488 SloppyArgumentsElements elements =
4490 uint32_t length = elements.length();
4492 return HasParameterMapArg(isolate, elements, entry.raw_value());
4494 FixedArrayBase arguments = elements.arguments();
4500 SloppyArgumentsElements elements =
4502 FixedArray arguments = elements.arguments();
4510 SloppyArgumentsElements elements =
4512 if (HasParameterMapArg(isolate, elements, index)) {
4515 FixedArray arguments = elements.arguments();
4521 return entry.adjust_up(elements.length());
4525 SloppyArgumentsElements elements =
4526 SloppyArgumentsElements::cast(holder.elements());
4527 uint32_t length = elements.length();
4532 FixedArray arguments = elements.arguments();
4538 SloppyArgumentsElements elements,
4540 uint32_t length = elements.length();
4542 return !elements.mapped_entries(static_cast<uint32_t>(index), kRelaxedLoad)
4547 Handle<SloppyArgumentsElements> elements(
4548 SloppyArgumentsElements::cast(obj->elements()), obj->GetIsolate());
4549 uint32_t length = elements->length();
4554 Subclass::SloppyDeleteImpl(obj, elements, delete_or_entry);
4555 // SloppyDeleteImpl allocates a new dictionary elements store. For making
4558 elements->set_mapped_entries(entry.as_uint32(),
4564 Handle<SloppyArgumentsElements> elements,
4592 Handle<SloppyArgumentsElements> elements =
4594 uint32_t length = elements->length();
4597 if (elements->mapped_entries(i, kRelaxedLoad).IsTheHole(isolate))
4608 Handle<FixedArray> store(elements->arguments(), isolate);
4620 Handle<SloppyArgumentsElements> elements(
4621 SloppyArgumentsElements::cast(object->elements()), isolate);
4627 GetEntryForIndexImpl(isolate, *object, *elements, k, ALL_PROPERTIES);
4633 Handle<Object> element_k = Subclass::GetImpl(isolate, *elements, entry);
4662 Handle<SloppyArgumentsElements> elements(
4663 SloppyArgumentsElements::cast(object->elements()), isolate);
4668 GetEntryForIndexImpl(isolate, *object, *elements, k, ALL_PROPERTIES);
4673 Handle<Object> element_k = Subclass::GetImpl(isolate, *elements, entry);
4705 Isolate* isolate, Handle<SloppyArgumentsElements> elements,
4711 Context context = elements->context();
4719 Handle<SloppyArgumentsElements> elements,
4721 // No need to delete a context mapped entry from the arguments elements.
4724 Handle<NumberDictionary> dict(NumberDictionary::cast(elements->arguments()),
4726 uint32_t length = elements->length();
4729 elements->set_arguments(*dict);
4736 Handle<SloppyArgumentsElements> elements(
4737 SloppyArgumentsElements::cast(object->elements()), isolate);
4739 FixedArrayBase::cast(elements->arguments()), isolate);
4750 elements->set_arguments(*new_dictionary);
4760 Handle<SloppyArgumentsElements> elements =
4762 uint32_t length = elements->length();
4764 Object probe = elements->mapped_entries(entry.as_uint32(), kRelaxedLoad);
4766 Context context = elements->context();
4772 elements->set_mapped_entries(entry.as_uint32(),
4774 // For elements that are still writable we re-establish slow aliasing.
4782 NumberDictionary::cast(elements->arguments()), isolate);
4789 elements->set_arguments(*arguments);
4791 Handle<FixedArrayBase> arguments(elements->arguments(), isolate);
4812 SloppyArgumentsElements elements = SloppyArgumentsElements::cast(store);
4813 return Handle<FixedArray>(elements.arguments(), isolate);
4817 Handle<JSObject> object, Handle<FixedArrayBase> elements) {
4819 GetArguments(object->GetIsolate(), *elements);
4824 Handle<JSObject> object, Handle<SloppyArgumentsElements> elements,
4827 elements->set_arguments(*dictionary);
4829 // case we only normalize the elements (aka. migrate to SLOW_SLOPPY).
4831 uint32_t length = elements->length();
4842 Handle<SloppyArgumentsElements> elements,
4845 NormalizeArgumentsElements(obj, elements, &entry);
4846 SlowSloppyArgumentsElementsAccessor::SloppyDeleteImpl(obj, elements, entry);
4855 Handle<SloppyArgumentsElements> elements(
4856 SloppyArgumentsElements::cast(object->elements()), isolate);
4857 Handle<FixedArray> old_arguments(elements->arguments(), isolate);
4863 FixedArray arguments = elements->arguments();
4878 DCHECK_EQ(object->elements(), *store);
4879 Handle<SloppyArgumentsElements> elements(
4881 NormalizeArgumentsElements(object, elements, &entry);
4904 Handle<SloppyArgumentsElements> elements(
4905 SloppyArgumentsElements::cast(object->elements()), isolate);
4906 Handle<FixedArray> old_arguments(FixedArray::cast(elements->arguments()),
4910 // elements.
4921 elements->set_arguments(FixedArray::cast(*arguments));
4944 return BackingStoreAccessor::GetImpl(isolate, holder->elements(),
4948 static Handle<Object> GetImpl(Isolate* isolate, FixedArrayBase elements,
4992 BackingStoreAccessor::SetImpl(holder->elements(), entry.adjust_down(length),
5005 BackingStoreAccessor::GetCapacityImpl(*object, object->elements()) !=
5059 Handle<FixedArrayBase> old_elements(object->elements(),
5070 // elements.
5115 Handle<JSObject> object, Handle<FixedArrayBase> elements) {
5116 return FastHoleyObjectElementsAccessor::NormalizeImpl(object, elements);
5167 // Set length and elements on the array.
5172 // Allocate an appropriately typed elements array.
5316 // If a double array is concatted into a fast elements array, the fast
5317 // elements array needs to be initialized to contain proper holes, since
5329 Handle<FixedArrayBase> storage(result_array->elements(), isolate);