Lines Matching full:descriptors
1551 int descriptors,
1570 PrintF(file, "+%i maps", descriptors - split);
2059 // Allocate new instance descriptors with (name, index) added
2105 // Allocate new instance descriptors with (name, constant) added.
2189 // Normalize the object to prevent very large instance descriptors.
2358 // If smi descriptors were replaced by double descriptors, rewrite.
2422 int descriptors = new_map->NumberOfOwnDescriptors();
2424 for (int i = 0; i < descriptors; i++) {
2504 DescriptorArray* descriptors = instance_descriptors();
2507 if (descriptors->GetDetails(i).type() == FIELD) result++;
2520 DescriptorArray* descriptors = new_map->instance_descriptors();
2521 descriptors->InitializeRepresentations(Representation::Tagged());
2524 PropertyDetails details = descriptors->GetDetails(modify_index);
2526 FieldDescriptor d(descriptors->GetKey(modify_index),
2531 descriptors->Set(modify_index, &d);
2608 DescriptorArray* descriptors) {
2616 Name* name = descriptors->GetKey(i);
2621 PropertyDetails details = descriptors->GetDetails(i);
2627 if (descriptors->GetValue(i) !=
2640 DescriptorArray* descriptors) {
2648 Name* name = descriptors->GetKey(i);
2656 if (next_descriptors->GetValue(i) != descriptors->GetValue(i)) break;
2658 PropertyDetails details = descriptors->GetDetails(i);
2687 // replace its transition tree with a new branch for the updated descriptors.
2707 int descriptors = old_map->NumberOfOwnDescriptors();
2724 verbatim, descriptors, *old_descriptors);
2738 verbatim, valid, descriptors, *old_descriptors) &&
2747 updated_descriptors, verbatim, valid, descriptors, modify_index,
2761 verbatim, descriptors, *new_descriptors));
2766 ASSERT(descriptors != split_descriptors);
2774 stdout, "", modify_index, descriptor, descriptors,
2782 for (; descriptor < descriptors; descriptor++) {
2791 // Generalize the representation of all FIELD descriptors.
2795 Handle<DescriptorArray> descriptors(map->instance_descriptors());
2797 PropertyDetails details = descriptors->GetDetails(i);
2825 int descriptors = map->NumberOfOwnDescriptors();
2833 verbatim, descriptors, old_descriptors);
2839 verbatim, valid, descriptors, old_descriptors)) {
3111 Handle<DescriptorArray> descriptors(map->instance_descriptors());
3112 if (slack <= descriptors->NumberOfSlackDescriptors()) return;
3113 int number_of_descriptors = descriptors->number_of_descriptors();
3120 new_descriptors->CopyFrom(i, *descriptors, i, witness);
3136 // temporarily put the heap in an invalid state while appending descriptors.
3146 // Fill in new callback descriptors. Process the callbacks from
3201 Handle<Object> descriptors) {
3204 NeanderArray callbacks(descriptors);
3211 int AccessorInfo::AppendUnique(Handle<Object> descriptors,
3214 NeanderArray callbacks(descriptors);
3915 DescriptorArray* descriptors = transition_map->instance_descriptors();
3916 PropertyDetails details = descriptors->GetDetails(descriptor);
3933 descriptors->GetValue(descriptor) == *value) {
3948 descriptors = transition_map->instance_descriptors();
3949 representation = descriptors->GetDetails(descriptor).representation();
3952 int field_index = descriptors->GetFieldIndex(descriptor);
4011 DescriptorArray* descriptors = object->map()->instance_descriptors();
4012 int index = descriptors->GetDetails(descriptor_index).field_index();
4972 DescriptorArray* descriptors = this->map()->instance_descriptors();
4973 if (descriptors->number_of_descriptors() > 0) {
4974 int sorted_index = descriptors->GetSortedKeyIndex(0);
4975 if (descriptors->GetKey(sorted_index) == GetHeap()->hidden_string() &&
4977 ASSERT(descriptors->GetType(sorted_index) == FIELD);
4978 ASSERT(descriptors->GetDetails(sorted_index).representation().
4981 descriptors->GetFieldIndex(sorted_index));
5048 DescriptorArray* descriptors = object->map()->instance_descriptors();
5049 if (descriptors->number_of_descriptors() > 0) {
5050 int sorted_index = descriptors->GetSortedKeyIndex(0);
5051 if (descriptors->GetKey(sorted_index) == isolate->heap()->hidden_string()
5053 ASSERT(descriptors->GetType(sorted_index) == FIELD);
5054 object->FastPropertyAtPut(descriptors->GetFieldIndex(sorted_index),
5762 Handle<DescriptorArray> descriptors(copy->map()->instance_descriptors());
5765 PropertyDetails details = descriptors->GetDetails(i);
5767 int index = descriptors->GetFieldIndex(i);
6464 // This works since descriptors are sorted in order of addition.
6749 MaybeObject* Map::ShareDescriptor(DescriptorArray* descriptors,
6753 // descriptors in the descriptor array.
6767 int old_size = descriptors->number_of_descriptors();
6771 if (descriptors->NumberOfSlackDescriptors() > 0) {
6772 new_descriptors = descriptors;
6782 // Copy the descriptors, inserting a descriptor.
6784 new_descriptors->CopyFrom(i, descriptors, i, witness);
6790 // If the source descriptors had an enum cache we copy it. This ensures
6793 // enumerated descriptors than available in the original cache, the cache
6795 if (descriptors->HasEnumCache()) {
6796 descriptors);
6800 // Replace descriptors by new_descriptors in all maps that share it.
6805 if (map->instance_descriptors() != descriptors) break;
6825 Handle<DescriptorArray> descriptors,
6829 map->CopyReplaceDescriptors(*descriptors, flag, *name),
6834 MaybeObject* Map::CopyReplaceDescriptors(DescriptorArray* descriptors,
6838 ASSERT(descriptors->IsSortedNoDuplicates());
6844 result->InitializeDescriptors(descriptors);
6853 descriptors->InitializeRepresentations(Representation::Tagged());
6864 Handle<DescriptorArray> descriptors) {
6865 ASSERT(descriptors->IsSortedNoDuplicates());
6869 result->InitializeDescriptors(*descriptors);
6873 if (descriptors->GetDetails(new_descriptor).type() == FIELD) {
6883 Handle<Name> name = handle(descriptors->GetKey(new_descriptor));
6911 // In case the map owned its own descriptors, share the descriptors and
6927 // In case the map did not own its own descriptors, a split is forced by
6951 // In case the map owned its own descriptors, share the descriptors and
6986 DescriptorArray* descriptors = map->instance_descriptors();
6991 descriptors->CopyUpTo(number_of_own_descriptors);
7004 DescriptorArray* descriptors = instance_descriptors();
7008 descriptors->CopyUpTo(number_of_own_descriptors);
7017 DescriptorArray* descriptors = instance_descriptors();
7029 return ShareDescriptor(descriptors, descriptor);
7039 // Copy the descriptors, inserting a descriptor.
7041 new_descriptors->CopyFrom(i, descriptors, i, witness);
7044 if (old_size != descriptors->number_of_descriptors()) {
7090 DescriptorArray* descriptors;
7092 if (!maybe_descriptors->To(&descriptors)) return maybe_descriptors;
7093 DescriptorArray::WhitenessWitness witness(descriptors);
7107 descriptors->Set(i, &desc, witness);
7111 descriptors->CopyFrom(i, this, i, witness);
7115 if (number_of_descriptors() != enumeration_index) descriptors->Sort();
7117 return descriptors;
7121 MaybeObject* Map::CopyReplaceDescriptor(DescriptorArray* descriptors,
7130 ASSERT(key == descriptors->GetKey(insertion_index));
7147 new_descriptors->CopyFrom(i, descriptors, i, witness);
7151 // Re-sort if descriptors were removed.
7152 if (new_size != descriptors->length()) new_descriptors->Sort();
7155 (insertion_index == descriptors->number_of_descriptors() - 1)
7993 // the descriptors are copied verbatim from |other| up to |new_size|.
8007 // descriptors, with minimally the exact same size as this descriptor array.
9320 static void TrimEnumCache(Heap* heap, Map* map, DescriptorArray* descriptors) {
9325 if (live_enum == 0) return descriptors->ClearEnumCache();
9327 FixedArray* enum_cache = descriptors->GetEnumCache();
9331 RightTrimFixedArray<FROM_GC>(heap, descriptors->GetEnumCache(), to_trim);
9333 if (!descriptors->HasEnumIndicesCache()) return;
9334 FixedArray* enum_indices_cache = descriptors->GetEnumIndicesCache();
9341 DescriptorArray* descriptors,
9343 int number_of_descriptors = descriptors->number_of_descriptors_storage();
9348 heap, descriptors, to_trim * DescriptorArray::kDescriptorSize);
9349 descriptors->SetNumberOfDescriptors(number_of_own_descriptors);
9351 if (descriptors->HasEnumCache()) TrimEnumCache(heap, map, descriptors);
9352 descriptors->Sort();
9379 DescriptorArray* descriptors = instance_descriptors();
9382 // Compact all live descriptors to the left.
9386 if (target->instance_descriptors() == descriptors) {
9411 TrimDescriptorArray(heap, this, descriptors, number_of_own_descriptors);
9412 ASSERT(descriptors->number_of_descriptors() == number_of_own_descriptors);
9415 ASSERT(descriptors == GetHeap()->empty_descriptor_array());
15803 // descriptors.
15852 DescriptorArray* descriptors;
15855 if (!maybe_descriptors->To(&descriptors)) {
15859 DescriptorArray::WhitenessWitness witness(descriptors);
15897 descriptors->Set(enumeration_index - 1, &d, witness);
15912 descriptors->Set(enumeration_index - 1, &d, witness);
15917 descriptors->Set(enumeration_index - 1, &d, witness);
15925 descriptors->Sort();
15927 new_map->InitializeDescriptors(descriptors);
