Line data Source code
1 : // Copyright 2018 the V8 project authors. All rights reserved.
2 : // Use of this source code is governed by a BSD-style license that can be
3 : // found in the LICENSE file.
4 :
5 : #ifndef V8_OBJECTS_DESCRIPTOR_ARRAY_INL_H_
6 : #define V8_OBJECTS_DESCRIPTOR_ARRAY_INL_H_
7 :
8 : #include "src/objects/descriptor-array.h"
9 :
10 : #include "src/field-type.h"
11 : #include "src/heap/heap-write-barrier.h"
12 : #include "src/heap/heap.h"
13 : #include "src/isolate.h"
14 : #include "src/lookup-cache-inl.h"
15 : #include "src/maybe-handles-inl.h"
16 : #include "src/objects/heap-object-inl.h"
17 : #include "src/objects/maybe-object.h"
18 : #include "src/objects/struct-inl.h"
19 : #include "src/property.h"
20 :
21 : // Has to be the last include (doesn't have include guards):
22 : #include "src/objects/object-macros.h"
23 :
24 : namespace v8 {
25 : namespace internal {
26 :
27 1714244863 : OBJECT_CONSTRUCTORS_IMPL(DescriptorArray, HeapObject)
28 5365586 : OBJECT_CONSTRUCTORS_IMPL(EnumCache, Tuple2)
29 :
30 857505867 : CAST_ACCESSOR(DescriptorArray)
31 2682877 : CAST_ACCESSOR(EnumCache)
32 :
33 688118 : ACCESSORS(EnumCache, keys, FixedArray, kKeysOffset)
34 4298 : ACCESSORS(EnumCache, indices, FixedArray, kIndicesOffset)
35 :
36 104350487 : ACCESSORS(DescriptorArray, enum_cache, EnumCache, kEnumCacheOffset)
37 117834670 : RELAXED_INT16_ACCESSORS(DescriptorArray, number_of_all_descriptors,
38 : kNumberOfAllDescriptorsOffset)
39 189220793 : RELAXED_INT16_ACCESSORS(DescriptorArray, number_of_descriptors,
40 : kNumberOfDescriptorsOffset)
41 63813827 : RELAXED_INT16_ACCESSORS(DescriptorArray, raw_number_of_marked_descriptors,
42 : kRawNumberOfMarkedDescriptorsOffset)
43 16961968 : RELAXED_INT16_ACCESSORS(DescriptorArray, filler16bits, kFiller16BitsOffset)
44 :
45 8390883 : inline int16_t DescriptorArray::number_of_slack_descriptors() const {
46 8390883 : return number_of_all_descriptors() - number_of_descriptors();
47 : }
48 :
49 : inline int DescriptorArray::number_of_entries() const {
50 15074918 : return number_of_descriptors();
51 : }
52 :
53 23559481 : inline int16_t DescriptorArray::CompareAndSwapRawNumberOfMarkedDescriptors(
54 : int16_t expected, int16_t value) {
55 : return base::Relaxed_CompareAndSwap(
56 : reinterpret_cast<base::Atomic16*>(
57 23559481 : FIELD_ADDR(*this, kRawNumberOfMarkedDescriptorsOffset)),
58 47118962 : expected, value);
59 : }
60 :
61 2279618 : void DescriptorArray::CopyEnumCacheFrom(DescriptorArray array) {
62 2279618 : set_enum_cache(array->enum_cache());
63 2279618 : }
64 :
65 : int DescriptorArray::Search(Name name, int valid_descriptors) {
66 : DCHECK(name->IsUniqueName());
67 : return internal::Search<VALID_ENTRIES>(this, name, valid_descriptors,
68 40459425 : nullptr);
69 : }
70 :
71 : int DescriptorArray::Search(Name name, Map map) {
72 : DCHECK(name->IsUniqueName());
73 2962793 : int number_of_own_descriptors = map->NumberOfOwnDescriptors();
74 2962793 : if (number_of_own_descriptors == 0) return kNotFound;
75 : return Search(name, number_of_own_descriptors);
76 : }
77 :
78 89768149 : int DescriptorArray::SearchWithCache(Isolate* isolate, Name name, Map map) {
79 : DCHECK(name->IsUniqueName());
80 108280242 : int number_of_own_descriptors = map->NumberOfOwnDescriptors();
81 108280244 : if (number_of_own_descriptors == 0) return kNotFound;
82 :
83 89768149 : DescriptorLookupCache* cache = isolate->descriptor_lookup_cache();
84 89768147 : int number = cache->Lookup(map, name);
85 :
86 89768155 : if (number == DescriptorLookupCache::kAbsent) {
87 : number = Search(name, number_of_own_descriptors);
88 37286218 : cache->Update(map, name, number);
89 : }
90 :
91 : return number;
92 : }
93 :
94 11088155 : ObjectSlot DescriptorArray::GetFirstPointerSlot() {
95 11088155 : return RawField(DescriptorArray::kPointersStartOffset);
96 : }
97 :
98 31336947 : ObjectSlot DescriptorArray::GetDescriptorSlot(int descriptor) {
99 : // Allow descriptor == number_of_all_descriptors() for computing the slot
100 : // address that comes after the last descriptor (for iterating).
101 : DCHECK_LE(descriptor, number_of_all_descriptors());
102 31336947 : return RawField(OffsetOfDescriptorAt(descriptor));
103 : }
104 :
105 : ObjectSlot DescriptorArray::GetKeySlot(int descriptor) {
106 : DCHECK_LE(descriptor, number_of_all_descriptors());
107 : ObjectSlot slot = GetDescriptorSlot(descriptor) + kEntryKeyIndex;
108 : DCHECK((*slot)->IsObject());
109 : return slot;
110 : }
111 :
112 1057472992 : Name DescriptorArray::GetKey(int descriptor_number) const {
113 : DCHECK(descriptor_number < number_of_descriptors());
114 : return Name::cast(
115 2114945671 : get(ToKeyIndex(descriptor_number))->GetHeapObjectAssumeStrong());
116 : }
117 :
118 : int DescriptorArray::GetSortedKeyIndex(int descriptor_number) {
119 2936390383 : return GetDetails(descriptor_number).pointer();
120 : }
121 :
122 822691136 : Name DescriptorArray::GetSortedKey(int descriptor_number) {
123 822690819 : return GetKey(GetSortedKeyIndex(descriptor_number));
124 : }
125 :
126 864299034 : void DescriptorArray::SetSortedKey(int descriptor_index, int pointer) {
127 864299034 : PropertyDetails details = GetDetails(descriptor_index);
128 : set(ToDetailsIndex(descriptor_index),
129 864298481 : MaybeObject::FromObject(details.set_pointer(pointer).AsSmi()));
130 864298686 : }
131 :
132 : MaybeObjectSlot DescriptorArray::GetValueSlot(int descriptor) {
133 : DCHECK_LT(descriptor, number_of_descriptors());
134 : return MaybeObjectSlot(GetDescriptorSlot(descriptor) + kEntryValueIndex);
135 : }
136 :
137 : Object DescriptorArray::GetStrongValue(int descriptor_number) {
138 : DCHECK(descriptor_number < number_of_descriptors());
139 8188357 : return get(ToValueIndex(descriptor_number))->cast<Object>();
140 : }
141 :
142 : void DescriptorArray::SetValue(int descriptor_index, Object value) {
143 3892190 : set(ToValueIndex(descriptor_index), MaybeObject::FromObject(value));
144 : }
145 :
146 : MaybeObject DescriptorArray::GetValue(int descriptor_number) {
147 : DCHECK_LT(descriptor_number, number_of_descriptors());
148 151588773 : return get(ToValueIndex(descriptor_number));
149 : }
150 :
151 4366359688 : PropertyDetails DescriptorArray::GetDetails(int descriptor_number) {
152 : DCHECK(descriptor_number < number_of_descriptors());
153 4366359688 : MaybeObject details = get(ToDetailsIndex(descriptor_number));
154 8732721981 : return PropertyDetails(details->ToSmi());
155 : }
156 :
157 : int DescriptorArray::GetFieldIndex(int descriptor_number) {
158 : DCHECK_EQ(GetDetails(descriptor_number).location(), kField);
159 168103810 : return GetDetails(descriptor_number).field_index();
160 : }
161 :
162 41001778 : FieldType DescriptorArray::GetFieldType(int descriptor_number) {
163 : DCHECK_EQ(GetDetails(descriptor_number).location(), kField);
164 41001778 : MaybeObject wrapped_type = GetValue(descriptor_number);
165 41001778 : return Map::UnwrapFieldType(wrapped_type);
166 : }
167 :
168 129790412 : void DescriptorArray::Set(int descriptor_number, Name key, MaybeObject value,
169 : PropertyDetails details) {
170 : // Range check.
171 : DCHECK(descriptor_number < number_of_descriptors());
172 129790412 : set(ToKeyIndex(descriptor_number), MaybeObject::FromObject(key));
173 129790414 : set(ToValueIndex(descriptor_number), value);
174 : set(ToDetailsIndex(descriptor_number),
175 129790423 : MaybeObject::FromObject(details.AsSmi()));
176 129790427 : }
177 :
178 18726495 : void DescriptorArray::Set(int descriptor_number, Descriptor* desc) {
179 18726494 : Name key = *desc->GetKey();
180 18726494 : MaybeObject value = *desc->GetValue();
181 18726500 : Set(descriptor_number, key, value, desc->GetDetails());
182 18726510 : }
183 :
184 16707233 : void DescriptorArray::Append(Descriptor* desc) {
185 : DisallowHeapAllocation no_gc;
186 16707233 : int descriptor_number = number_of_descriptors();
187 : DCHECK_LE(descriptor_number + 1, number_of_all_descriptors());
188 16707233 : set_number_of_descriptors(descriptor_number + 1);
189 16707233 : Set(descriptor_number, desc);
190 :
191 16707242 : uint32_t hash = desc->GetKey()->Hash();
192 :
193 : int insertion;
194 :
195 288042411 : for (insertion = descriptor_number; insertion > 0; --insertion) {
196 264392477 : Name key = GetSortedKey(insertion - 1);
197 264392475 : if (key->Hash() <= hash) break;
198 254627937 : SetSortedKey(insertion, GetSortedKeyIndex(insertion - 1));
199 : }
200 :
201 16707237 : SetSortedKey(insertion, descriptor_number);
202 16707235 : }
203 :
204 250355198 : void DescriptorArray::SwapSortedKeys(int first, int second) {
205 : int first_key = GetSortedKeyIndex(first);
206 250354731 : SetSortedKey(first, GetSortedKeyIndex(second));
207 250354614 : SetSortedKey(second, first_key);
208 250353996 : }
209 :
210 : int DescriptorArray::length() const {
211 : return number_of_all_descriptors() * kEntrySize;
212 : }
213 :
214 5579560674 : MaybeObject DescriptorArray::get(int index) const {
215 : DCHECK(index >= 0 && index < this->length());
216 5579560674 : return RELAXED_READ_WEAK_FIELD(*this, offset(index));
217 : }
218 :
219 1262123707 : void DescriptorArray::set(int index, MaybeObject value) {
220 : DCHECK(index >= 0 && index < this->length());
221 1262123707 : RELAXED_WRITE_WEAK_FIELD(*this, offset(index), value);
222 2524247645 : WEAK_WRITE_BARRIER(*this, offset(index), value);
223 1262123888 : }
224 :
225 : } // namespace internal
226 : } // namespace v8
227 :
228 : #include "src/objects/object-macros-undef.h"
229 :
230 : #endif // V8_OBJECTS_DESCRIPTOR_ARRAY_INL_H_
|
