Lines Matching defs:Array
1434 accumulator->Add("<JS Array[%u]>", static_cast<uint32_t>(length));
2176 // Ensure the descriptor array does not get too big.
2339 // The array may not be moved during GC,
2389 // - Otherwise, allocate a fixed array large enough to hold all fields, in
2418 Handle<FixedArray> array = isolate->factory()->NewFixedArray(total_size);
2451 array->set(target_index, *value);
2461 object->FastPropertyAtPut(i, array->get(external + i));
2474 RightTrimFixedArray<FROM_MUTATOR>(isolate->heap(), *array, inobject);
2475 object->set_properties(*array);
2578 // Don't overwrite the empty descriptor array.
2678 // FindUpdatedMap. This uses the keys in the own map's descriptor array to
2680 // - Merge/generalize the descriptor array of the current map and |updated|.
2683 // |split_map|, the first map who's descriptor array does not match the merged
2684 // descriptor array.
3129 Handle<typename T::Array> array,
3133 Isolate* isolate = array->GetIsolate();
3153 if (!T::Contains(key, entry, valid_descriptors, array)) {
3154 T::Insert(key, entry, valid_descriptors, array);
3163 typedef DescriptorArray Array;
3167 Handle<DescriptorArray> array) {
3168 return array->Search(key, valid_descriptors) != DescriptorArray::kNotFound;
3173 array) {
3175 array->Append(&desc);
3181 typedef FixedArray Array;
3185 Handle<FixedArray> array) {
3187 if (key == AccessorInfo::cast(array->get(i))->name()) return true;
3194 Handle<FixedArray> array) {
3195 array->set(valid_descriptors, entry);
3203 Handle<DescriptorArray> array(map->instance_descriptors());
3205 ASSERT(array->NumberOfSlackDescriptors() >= callbacks.length());
3206 nof = AppendUniqueCallbacks<DescriptorArrayAppender>(&callbacks, array, nof);
3212 Handle<FixedArray> array,
3215 ASSERT(array->length() >= callbacks.length() + valid_descriptors);
3217 array,
4403 // Check whether the name is an array index.
4682 FixedArrayBase* array,
4686 bool has_double_elements = array->IsFixedDoubleArray();
4690 FixedDoubleArray* double_array = FixedDoubleArray::cast(array);
4703 value = FixedArray::cast(array)->get(i);
4717 Handle<FixedArrayBase> array,
4720 Isolate* isolate = array->GetIsolate();
4723 isolate, *array, length, *dict),
4740 FixedArrayBase* array = FixedArrayBase::cast(elements());
4741 Map* old_map = array->map();
4745 array = FixedArrayBase::cast(FixedArray::cast(array)->get(1));
4747 if (array->IsDictionary()) return array;
4755 : array->length();
4765 GetIsolate(), array, length, dictionary);
4969 // in the descriptor array matches the hidden string. Since the
5045 // in the descriptor array matches the hidden string. Since the
5416 // Get the constructor function for arguments array.
5435 array check the content.
5478 // It's not possible to seal objects with external array elements
5558 // It's not possible to freeze objects with external array elements
5601 // Create a new descriptor array with fully-frozen properties
5791 // an array.
6095 // Ignore getters and setters on pixel and external array elements.
6553 // Ignore getters and setters on pixel and external array
6752 // array, implying that its NumberOfOwnDescriptors equals the number of
6753 // descriptors in the descriptor array.
6791 // that the maps to which we push the new descriptor array back can rely
6928 // copying the map; creating a new descriptor array cell.
6982 // array describing these properties.
7213 // An iterator over all map transitions in an descriptor array, reusing the map
7214 // field of the contens array while it is running.
7252 // underlying array while it is running.
7317 // array's contents, and restore it to the fixed array map afterwards.
7322 // transitions, and restore it to the fixed array map afterwards.
7541 FixedArray* array = default_cache();
7542 int len = array->length();
7544 if (array->get(i + kCodeCacheEntryCodeOffset) == code) return i + 1;
7557 FixedArray* array = default_cache();
7558 ASSERT(array->length() >= index && array->get(index)->IsCode());
7563 array->set_null(index - 1); // Name.
7564 array->set_null(index); // Code.
7845 MaybeObject* FixedArray::AddKeysFromJSArray(JSArray* array) {
7846 ElementsAccessor* accessor = array->GetElementsAccessor();
7848 accessor->AddElementsToFixedArray(array, array, this);
7893 // We are taking the map from the old fixed array so the map is sure to
7932 // Allocate the array of keys.
7987 // Generalize the |other| descriptor array by merging it into the (at least
7988 // partly) updated |this| descriptor array.
7989 // The method merges two descriptor array in three parts. Both descriptor arrays
8006 // Allocate a new descriptor array large enough to hold the required
8007 // descriptors, with minimally the exact same size as this descriptor array.
8098 // descriptor array. If the descriptor array were to be black, the shuffling
8104 // Reset sorting since the descriptor array might contain invalid pointers.
8129 // Extract elements and create sorted array.
8131 // Put max element at the back of the array.
9111 // of it to be a legal array index.
9117 // Convert string to uint32 array index; character by character.
9139 // Isolate the array index form the full hash field.
9225 // For array indexes mix the length into the hash as an array index could
9675 // Always trim even when array is cleared because of heap verifier.
9688 // Always trim even when array is cleared because of heap verifier.
9753 // Replace all of the cached initial array maps in the native context with
9816 // If the function is used as the global Array function, cache the
11252 // We should never end in here with a pixel or external array.
11262 // The resized array has FAST_*_SMI_ELEMENTS if the capacity mode forces it,
11263 // or if it's allowed and the old elements array contained only SMIs.
11346 // We should never end in here with a pixel or external array.
11478 // We should never end in here with a pixel or external array.
11596 // Grow array by factor 2 over and above what we need.
11709 // If the old fixed array was empty, we need to reset counters of the
11710 // new array.
11823 // Compact the array by moving all subsequent groups to fill in the new holes.
11827 // Now the holes are at the end of the array, zap them for heap-verifier.
12165 // Array optimizations rely on the prototype lookups of Array objects always
12207 // If the array is growing, and it's not growth by a single element at the
12385 // Update the array length if this JSObject is an array.
12437 // If storing to an element that isn't in the array, pass the store request
12475 // If the array is growing, and it's not growth by a single element at the
12483 // Check whether there is extra space in the fixed array.
12488 // Update the length of the array if needed.
12621 // Store old array length in case adding an element grows the array.
12715 Handle<ExternalByteArray> array(
12717 return ExternalByteArray::SetValue(array, index, value);
12720 Handle<ExternalUnsignedByteArray> array(
12722 return ExternalUnsignedByteArray::SetValue(array, index, value);
12725 Handle<ExternalShortArray> array(ExternalShortArray::cast(
12727 return ExternalShortArray::SetValue(array, index, value);
12730 Handle<ExternalUnsignedShortArray> array(
12732 return ExternalUnsignedShortArray::SetValue(array, index, value);
12735 Handle<ExternalIntArray> array(
12737 return ExternalIntArray::SetValue(array, index, value);
12740 Handle<ExternalUnsignedIntArray> array(
12742 return ExternalUnsignedIntArray::SetValue(array, index, value);
12745 Handle<ExternalFloatArray> array(
12747 return ExternalFloatArray::SetValue(array, index, value);
12750 Handle<ExternalDoubleArray> array(
12752 return ExternalDoubleArray::SetValue(array, index, value);
12832 // If the array is huge, it's not likely to be defined in a local
13004 void JSArray::JSArrayUpdateLengthFromIndex(Handle<JSArray> array,
13007 CALL_HEAP_FUNCTION_VOID(array->GetIsolate(),
13008 array->JSArrayUpdateLengthFromIndex(index, *value));
13493 // Extract elements and create sorted array.
13495 // Put max element at the back of the array.
13519 // Sort this array and the numbers as pairs wrt. the (distinct) numbers.
14165 // Copy prefix to new array.
14501 // Bail out and do the sorting of undefineds and array holes in JS.
14559 // Collects all defined (non-hole) and non-undefined (array) elements at
14560 // the start of the elements array.
14801 Handle<Object> ExternalByteArray::SetValue(Handle<ExternalByteArray> array,
14804 CALL_HEAP_FUNCTION(array->GetIsolate(),
14805 array->SetValue(index, *value),
14817 Handle<ExternalUnsignedByteArray> array,
14820 CALL_HEAP_FUNCTION(array->GetIsolate(),
14821 array->SetValue(index, *value),
14834 Handle<ExternalShortArray> array,
14837 CALL_HEAP_FUNCTION(array->GetIsolate(),
14838 array->SetValue(index, *value),
14851 Handle<ExternalUnsignedShortArray> array,
14854 CALL_HEAP_FUNCTION(array->GetIsolate(),
14855 array->SetValue(index, *value),
14867 Handle<Object> ExternalIntArray::SetValue(Handle<ExternalIntArray> array,
14870 CALL_HEAP_FUNCTION(array->GetIsolate(),
14871 array->SetValue(index, *value),
14883 Handle<ExternalUnsignedIntArray> array,
14886 CALL_HEAP_FUNCTION(array->GetIsolate(),
14887 array->SetValue(index, *value),
14913 Handle<Object> ExternalFloatArray::SetValue(Handle<ExternalFloatArray> array,
14916 CALL_HEAP_FUNCTION(array->GetIsolate(),
14917 array->SetValue(index, *value),
14943 Handle<Object> ExternalDoubleArray::SetValue(Handle<ExternalDoubleArray> array,
14946 CALL_HEAP_FUNCTION(array->GetIsolate(),
14947 array->SetValue(index, *value),
15301 // StringsKey used for HashTable where key is array of internalized strings.
15335 Object* MapCache::Lookup(FixedArray* array) {
15336 StringsKey key(array);
15343 MaybeObject* MapCache::Put(FixedArray* array, Map* value) {
15344 StringsKey key(array);
15352 cache->set(EntryToIndex(entry), array);
15390 // Allocate and initialize iteration order array.
15400 // Allocate array with enumeration order.
15406 // Fill the enumeration order array with property details.
15722 // Fill in the enumeration array by assigning enumerable keys at their
15723 // enumeration index. This will leave holes in the array if there are keys
15736 // There are holes in the enumeration array if less properties were assigned
15737 // than the length of the array. If so, crunch all the existing properties
15739 // and trimming of the right side of the array.
15869 // Allocate the fixed array for the fields.
16172 uint8_t* array = serialized_descriptor->GetDataStartAddress();
16176 OS::MemCopy(array, previous_array, previous_length);
16177 array += previous_length;
16179 ASSERT(reinterpret_cast<uintptr_t>(array) % sizeof(uintptr_t) == 0);
16181 reinterpret_cast<DeclaredAccessorDescriptorData*>(array);
16250 // No free slot - extend break point info array.
16355 // If there are multiple break points shrink the array
16388 // If there was one break point object before replace with array.
16390 Handle<FixedArray> array = isolate->factory()->NewFixedArray(2);
16391 array->set(0, break_point_info->break_point_objects());
16392 array->set(1, *break_point_object);
16393 break_point_info->set_break_point_objects(*array);
16396 // If there was more than one break point before extend array.
16423 FixedArray* array = FixedArray::cast(break_point_info->break_point_objects());
16424 for (int i = 0; i < array->length(); i++) {
16425 if (array->get(i) == *break_point_object) {
