Lines Matching refs:elements
207 // Deep copy local elements.
208 // Pixel elements cannot be created using an object literal.
213 FixedArray* elements = FixedArray::cast(copy->elements());
214 if (elements->map() == heap->fixed_cow_array_map()) {
217 for (int i = 0; i < elements->length(); i++) {
218 ASSERT(!elements->get(i)->IsJSObject());
222 for (int i = 0; i < elements->length(); i++) {
223 Object* value = elements->get(i);
233 elements->set(i, result);
364 // Normalize the elements of the boilerplate to save space if needed.
461 Handle<FixedArray> elements) {
469 static_cast<ElementsKind>(Smi::cast(elements->get(0))->value());
471 FixedArrayBase::cast(elements->get(1)));
542 Handle<FixedArray> elements = CompileTimeValue::GetElements(array);
548 elements,
554 elements,
559 isolate, literals, elements);
624 CONVERT_ARG_HANDLE_CHECKED(FixedArray, elements, 2);
630 Runtime::CreateArrayLiteralBoilerplate(isolate, literals, elements);
644 CONVERT_ARG_HANDLE_CHECKED(FixedArray, elements, 2);
649 ASSERT(*elements != isolate->heap()->empty_fixed_array());
651 Runtime::CreateArrayLiteralBoilerplate(isolate, literals, elements);
656 if (JSObject::cast(*boilerplate)->elements()->map() ==
1016 // 15.5.5.2. Note that this might be a string object with elements
1051 FixedArray* elements = FixedArray::cast(holder->elements());
1053 if (elements->map() == heap->non_strict_arguments_elements_map()) {
1054 dictionary = SeededNumberDictionary::cast(elements->get(1));
1056 dictionary = SeededNumberDictionary::cast(elements);
1763 FixedArray* elements = FixedArray::cast(new_object);
1776 array->set_elements(elements);
1858 // This is necessary to enable fast checks for absence of elements
2313 bool HasCapacity(int elements) {
2315 int required_length = length_ + elements;
2319 void EnsureCapacity(int elements) {
2321 int required_length = length_ + elements;
2432 void EnsureCapacity(int elements) {
2433 array_builder_.EnsureCapacity(elements);
2773 FixedArray* match_info = FixedArray::cast(last_match_info->elements());
3023 // all components to use two elements when encoded as two smis.
3037 FixedArray::cast(last_match_info_handle->elements());
3122 FixedArray::cast(last_match_info_handle->elements());
3191 FixedArray::cast(last_match_info_handle->elements());
3612 FixedArray* elements = FixedArray::cast(regexp_info->elements());
3613 start = Smi::cast(elements->get(RegExpImpl::kFirstCapture))->value();
3614 end = Smi::cast(elements->get(RegExpImpl::kFirstCapture + 1))->value();
3625 Handle<FixedArray> elements = isolate->factory()->NewFixedArray(matches);
3628 elements->set(0, *substring);
3634 elements->set(i, *substring);
3636 Handle<JSArray> result = isolate->factory()->NewJSArrayWithElements(elements);
3653 FixedArray* elements = FixedArray::cast(last_match_info->elements());
3654 RegExpImpl::SetLastCaptureCount(elements, 2);
3655 RegExpImpl::SetLastInput(elements, *subject);
3656 RegExpImpl::SetLastSubject(elements, *subject);
3657 RegExpImpl::SetCapture(elements, 0, match_start);
3658 RegExpImpl::SetCapture(elements, 1, match_end);
3893 Handle<FixedArray> elements =
3905 elements->set(0, *match);
3919 elements->set(i, *substring);
3922 elements->set(i, isolate->heap()->undefined_value());
3925 elements->set(capture_count + 1, Smi::FromInt(match_start));
3926 elements->set(capture_count + 2, *subject);
3927 builder->Add(*isolate->factory()->NewJSArrayWithElements(elements));
3964 FixedArray* elements = FixedArray::cast(last_match_array->elements());
3965 RegExpImpl::SetLastCaptureCount(elements, last_match_capture_count);
3966 RegExpImpl::SetLastSubject(elements, *subject);
3967 RegExpImpl::SetLastInput(elements, *subject);
3969 RegExpImpl::SetCapture(elements, i, prev_register_vector[i]);
3994 Handle<FixedArray>(FixedArray::cast(result_array->elements()));
4292 // definite out-of-bounds access to elements, which is a strong indicator
4294 // transition elements to FAST_ELEMENTS to avoid excessive boxing of
4295 // doubles for those future calls in the case that the elements would
4301 FixedArrayBase* elements = js_object->elements();
4302 if (args.at<Smi>(1)->value() >= elements->length()) {
4686 FixedDoubleArray::cast(object->elements());
4695 FixedArray::cast(object->elements());
4843 FixedArray* elements = FixedArray::cast(object->elements());
4845 if (elements->map() ==
4847 dictionary = SeededNumberDictionary::cast(elements->get(1));
4849 dictionary = SeededNumberDictionary::cast(elements);
5877 FixedArray* elements = FixedArray::cast(array->elements());
5878 int n = elements->length();
5883 Object* elt = elements->get(i);
5903 elements,
5907 elements,
6322 FixedArray::cast(result->elements())->set(0, *subject);
6326 Handle<FixedArray> elements(FixedArray::cast(result->elements()));
6333 elements->set(i, *substring);
6343 *elements);
6357 FixedArray* elements,
6363 WriteBarrierMode mode = elements->GetWriteBarrierMode(no_gc);
6367 elements->set(i, value, mode);
6371 memset(elements->data_start() + i, 0, kPointerSize * (length - i));
6375 Object* element = elements->get(j);
6395 Handle<FixedArray> elements;
6404 elements = Handle<FixedArray>(FixedArray::cast(obj), isolate);
6408 // Note, this will initialize all elements (not only the prefix)
6412 *elements,
6415 MemsetPointer(elements->data_start(),
6420 elements = isolate->factory()->NewFixedArray(length);
6424 elements->set(i, *str);
6429 ASSERT(String::cast(elements->get(i))->length() == 1);
6433 return *isolate->factory()->NewJSArrayWithElements(elements);
6698 FixedArray* fixed_array = FixedArray::cast(array->elements());
6808 FixedArray* fixed_array = FixedArray::cast(array->elements());
6878 static void JoinSparseArrayWithSeparator(FixedArray* elements,
6887 int position = NumberToInt32(elements->get(i));
6888 String* string = String::cast(elements->get(i + 1));
6929 // separator is string to put between elements. Assumed to be non-empty.
6944 FixedArray* elements = FixedArray::cast(elements_array->elements());
6946 RUNTIME_ASSERT(elements->get(i)->IsNumber());
6947 RUNTIME_ASSERT(elements->get(i + 1)->IsString());
6948 String* string = String::cast(elements->get(i + 1));
6990 JoinSparseArrayWithSeparator<char>(elements,
7003 JoinSparseArrayWithSeparator<uc16>(elements,
7599 // Allocate the elements if needed.
7671 // If there is no aliasing, the arguments object elements are not
7673 Handle<FixedArray> elements =
7675 result->set_elements(*elements);
7677 elements->set(i, *(parameters - i - 1));
7698 // Allocate the elements if needed.
9049 FixedArray* output_array = FixedArray::cast(output->elements());
9279 FixedArray* elements = FixedArray::cast(array->elements());
9281 if (elements->get(i) == element) return isolate->heap()->false_value();
9295 * The backend storage can be a fixed array for fast elements case,
9423 // Fast elements can't have lengths that are not representable by
9427 Handle<FixedArray> elements(FixedArray::cast(array->elements()));
9429 if (!elements->get(i)->IsTheHole()) element_count++;
9439 SeededNumberDictionary::cast(array->elements()));
9463 // inherited elements.
9476 ExternalArrayClass::cast(receiver->elements()));
9526 Handle<FixedArray> elements(FixedArray::cast(object->elements()));
9527 uint32_t length = static_cast<uint32_t>(elements->length());
9530 if (!elements->get(i)->IsTheHole()) {
9543 SeededNumberDictionary::cast(object->elements()));
9563 ExternalPixelArray::cast(object->elements())->length();
9568 ExternalByteArray::cast(object->elements())->length();
9573 ExternalUnsignedByteArray::cast(object->elements())->length();
9578 ExternalShortArray::cast(object->elements())->length();
9583 ExternalUnsignedShortArray::cast(object->elements())->length();
9588 ExternalIntArray::cast(object->elements())->length();
9593 ExternalUnsignedIntArray::cast(object->elements())->length();
9598 ExternalFloatArray::cast(object->elements())->length();
9603 ExternalDoubleArray::cast(object->elements())->length();
9636 * A helper function that visits elements of a JSArray in numerical
9652 // Run through the elements FixedArray and use HasElement and GetElement
9653 // to check the prototype for missing elements.
9654 Handle<FixedArray> elements(FixedArray::cast(receiver->elements()));
9656 ASSERT(fast_length <= elements->length());
9659 Handle<Object> element_value(elements->get(j), isolate);
9701 receiver->elements()));
9770 Handle<FixedArray> elements(FixedArray::cast(arguments->elements()));
9772 // Pass 1: estimate the length and number of elements of the result.
9775 // The number of elements is precise if there are no inherited elements.
9782 Handle<Object> obj(elements->get(i));
9818 // If estimated number of elements is more than half of length, a
9825 // The backing storage array must have non-existing elements to
9840 Handle<Object> obj(elements->get(i));
9871 // Moves all own elements of an object, that are below a limit, to positions
9875 // Returns the number of non-undefined elements collected.
9889 FixedArrayBase* new_elements = from->elements();
9916 // How many elements does this object/array have?
9920 HeapObject* elements = object->elements();
9921 if (elements->IsDictionary()) {
9922 int result = SeededNumberDictionary::cast(elements)->NumberOfElements();
9927 return Smi::FromInt(FixedArray::cast(elements)->length());
9933 // might have elements. Can either return keys (positive integers) or
9942 if (array->elements()->IsDictionary()) {
9967 FixedArrayBase* elements = FixedArrayBase::cast(array->elements());
9969 static_cast<uint32_t>(elements->length());
12941 Handle<FixedArray> elements =
12960 if (cursor + 4 > elements->length()) {
12961 int new_capacity = JSObject::NewElementsCapacity(elements->length());
12965 new_elements->set(i, elements->get(i));
12967 elements = new_elements;
12969 ASSERT(cursor + 4 <= elements->length());
12975 elements->set(cursor++, *recv);
12976 elements->set(cursor++, *fun);
12977 elements->set(cursor++, *code);
12978 elements->set(cursor++, *offset);
12983 Handle<JSArray> result = factory->NewJSArrayWithElements(elements);
13163 Handle<FixedArray> elements = factory->NewFixedArray(entry_count);
13182 elements->set(index++, *pair); \
13191 Handle<JSArray> result = factory->NewJSArrayWithElements(elements);
