OLD | NEW |
1 // Copyright 2012 the V8 project authors. All rights reserved. | 1 // Copyright 2012 the V8 project authors. All rights reserved. |
2 // Use of this source code is governed by a BSD-style license that can be | 2 // Use of this source code is governed by a BSD-style license that can be |
3 // found in the LICENSE file. | 3 // found in the LICENSE file. |
4 | 4 |
5 #ifndef V8_ELEMENTS_H_ | 5 #ifndef V8_ELEMENTS_H_ |
6 #define V8_ELEMENTS_H_ | 6 #define V8_ELEMENTS_H_ |
7 | 7 |
8 #include "src/elements-kind.h" | 8 #include "src/elements-kind.h" |
9 #include "src/heap/heap.h" | 9 #include "src/heap/heap.h" |
10 #include "src/isolate.h" | 10 #include "src/isolate.h" |
(...skipping 11 matching lines...) Expand all Loading... |
22 virtual ~ElementsAccessor() { } | 22 virtual ~ElementsAccessor() { } |
23 | 23 |
24 const char* name() const { return name_; } | 24 const char* name() const { return name_; } |
25 | 25 |
26 // Returns a shared ElementsAccessor for the specified ElementsKind. | 26 // Returns a shared ElementsAccessor for the specified ElementsKind. |
27 static ElementsAccessor* ForKind(ElementsKind elements_kind) { | 27 static ElementsAccessor* ForKind(ElementsKind elements_kind) { |
28 DCHECK(static_cast<int>(elements_kind) < kElementsKindCount); | 28 DCHECK(static_cast<int>(elements_kind) < kElementsKindCount); |
29 return elements_accessors_[elements_kind]; | 29 return elements_accessors_[elements_kind]; |
30 } | 30 } |
31 | 31 |
32 static ElementsAccessor* ForArray(Handle<FixedArrayBase> array); | |
33 | |
34 // Checks the elements of an object for consistency, asserting when a problem | 32 // Checks the elements of an object for consistency, asserting when a problem |
35 // is found. | 33 // is found. |
36 virtual void Validate(Handle<JSObject> obj) = 0; | 34 virtual void Validate(Handle<JSObject> obj) = 0; |
37 | 35 |
38 // Returns true if a holder contains an element with the specified index | 36 // Returns true if a holder contains an element with the specified index |
39 // without iterating up the prototype chain. The caller can optionally pass | 37 // without iterating up the prototype chain. The caller can optionally pass |
40 // in the backing store to use for the check, which must be compatible with | 38 // in the backing store to use for the check, which must be compatible with |
41 // the ElementsKind of the ElementsAccessor. If backing_store is NULL, the | 39 // the ElementsKind of the ElementsAccessor. If backing_store is NULL, the |
42 // holder->elements() is used as the backing store. If a |filter| is | 40 // holder->elements() is used as the backing store. If a |filter| is |
43 // specified the PropertyAttributes of the element at the given index | 41 // specified the PropertyAttributes of the element at the given index |
44 // are compared to the given |filter|. If they match/overlap the given | 42 // are compared to the given |filter|. If they match/overlap the given |
45 // index is ignored. Note that only Dictionary elements have custom | 43 // index is ignored. Note that only Dictionary elements have custom |
46 // PropertyAttributes associated, hence the |filter| argument is ignored for | 44 // PropertyAttributes associated, hence the |filter| argument is ignored for |
47 // all but DICTIONARY_ELEMENTS and SLOW_SLOPPY_ARGUMENTS_ELEMENTS. | 45 // all but DICTIONARY_ELEMENTS and SLOW_SLOPPY_ARGUMENTS_ELEMENTS. |
48 virtual bool HasElement(Handle<JSObject> holder, uint32_t index, | 46 virtual bool HasElement(Handle<JSObject> holder, uint32_t index, |
49 Handle<FixedArrayBase> backing_store, | 47 Handle<FixedArrayBase> backing_store, |
50 PropertyFilter filter = ALL_PROPERTIES) = 0; | 48 PropertyFilter filter = ALL_PROPERTIES) = 0; |
51 | 49 |
52 inline bool HasElement(Handle<JSObject> holder, uint32_t index, | 50 inline bool HasElement(Handle<JSObject> holder, uint32_t index, |
53 PropertyFilter filter = ALL_PROPERTIES) { | 51 PropertyFilter filter = ALL_PROPERTIES) { |
54 return HasElement(holder, index, handle(holder->elements()), filter); | 52 return HasElement(holder, index, handle(holder->elements()), filter); |
55 } | 53 } |
56 | 54 |
57 // Returns true if the backing store is compact in the given range | 55 // Returns true if the backing store is compact in the given range |
58 virtual bool IsPacked(Handle<JSObject> holder, | 56 virtual bool IsPacked(Handle<JSObject> holder, |
59 Handle<FixedArrayBase> backing_store, uint32_t start, | 57 Handle<FixedArrayBase> backing_store, uint32_t start, |
60 uint32_t end) = 0; | 58 uint32_t end) = 0; |
61 | 59 |
62 virtual Handle<Object> Get(Handle<FixedArrayBase> backing_store, | 60 virtual Handle<Object> Get(Handle<JSObject> holder, uint32_t entry) = 0; |
63 uint32_t entry) = 0; | 61 |
| 62 virtual PropertyDetails GetDetails(JSObject* holder, uint32_t entry) = 0; |
64 | 63 |
65 // Modifies the length data property as specified for JSArrays and resizes the | 64 // Modifies the length data property as specified for JSArrays and resizes the |
66 // underlying backing store accordingly. The method honors the semantics of | 65 // underlying backing store accordingly. The method honors the semantics of |
67 // changing array sizes as defined in EcmaScript 5.1 15.4.5.2, i.e. array that | 66 // changing array sizes as defined in EcmaScript 5.1 15.4.5.2, i.e. array that |
68 // have non-deletable elements can only be shrunk to the size of highest | 67 // have non-deletable elements can only be shrunk to the size of highest |
69 // element that is non-deletable. | 68 // element that is non-deletable. |
70 virtual void SetLength(Handle<JSArray> holder, uint32_t new_length) = 0; | 69 virtual void SetLength(Handle<JSArray> holder, uint32_t new_length) = 0; |
71 | 70 |
72 // Deletes an element in an object. | 71 // Deletes an element in an object. |
73 virtual void Delete(Handle<JSObject> holder, uint32_t entry) = 0; | 72 virtual void Delete(Handle<JSObject> holder, uint32_t entry) = 0; |
74 | 73 |
75 // If kCopyToEnd is specified as the copy_size to CopyElements, it copies all | 74 // If kCopyToEnd is specified as the copy_size to CopyElements, it copies all |
76 // of elements from source after source_start to the destination array. | 75 // of elements from source after source_start to the destination array. |
77 static const int kCopyToEnd = -1; | 76 static const int kCopyToEnd = -1; |
78 // If kCopyToEndAndInitializeToHole is specified as the copy_size to | 77 // If kCopyToEndAndInitializeToHole is specified as the copy_size to |
79 // CopyElements, it copies all of elements from source after source_start to | 78 // CopyElements, it copies all of elements from source after source_start to |
80 // destination array, padding any remaining uninitialized elements in the | 79 // destination array, padding any remaining uninitialized elements in the |
81 // destination array with the hole. | 80 // destination array with the hole. |
82 static const int kCopyToEndAndInitializeToHole = -2; | 81 static const int kCopyToEndAndInitializeToHole = -2; |
83 | 82 |
84 // Copy elements from one backing store to another. Typically, callers specify | |
85 // the source JSObject or JSArray in source_holder. If the holder's backing | |
86 // store is available, it can be passed in source and source_holder is | |
87 // ignored. | |
88 virtual void CopyElements( | |
89 Handle<FixedArrayBase> source, | |
90 uint32_t source_start, | |
91 ElementsKind source_kind, | |
92 Handle<FixedArrayBase> destination, | |
93 uint32_t destination_start, | |
94 int copy_size) = 0; | |
95 | |
96 // NOTE: this method violates the handlified function signature convention: | |
97 // raw pointer parameter |source_holder| in the function that allocates. | |
98 // This is done intentionally to avoid ArrayConcat() builtin performance | |
99 // degradation. | |
100 virtual void CopyElements( | |
101 JSObject* source_holder, | |
102 uint32_t source_start, | |
103 ElementsKind source_kind, | |
104 Handle<FixedArrayBase> destination, | |
105 uint32_t destination_start, | |
106 int copy_size) = 0; | |
107 | |
108 inline void CopyElements( | |
109 Handle<JSObject> from_holder, | |
110 Handle<FixedArrayBase> to, | |
111 ElementsKind from_kind) { | |
112 CopyElements( | |
113 *from_holder, 0, from_kind, to, 0, kCopyToEndAndInitializeToHole); | |
114 } | |
115 | |
116 // Copy all indices that have elements from |object| into the given | 83 // Copy all indices that have elements from |object| into the given |
117 // KeyAccumulator. For Dictionary-based element-kinds we filter out elements | 84 // KeyAccumulator. For Dictionary-based element-kinds we filter out elements |
118 // whose PropertyAttribute match |filter|. | 85 // whose PropertyAttribute match |filter|. |
119 virtual void CollectElementIndices(Handle<JSObject> object, | 86 virtual void CollectElementIndices(Handle<JSObject> object, |
120 Handle<FixedArrayBase> backing_store, | 87 Handle<FixedArrayBase> backing_store, |
121 KeyAccumulator* keys, | 88 KeyAccumulator* keys, |
122 uint32_t range = kMaxUInt32, | 89 uint32_t range = kMaxUInt32, |
123 PropertyFilter filter = ALL_PROPERTIES, | 90 PropertyFilter filter = ALL_PROPERTIES, |
124 uint32_t offset = 0) = 0; | 91 uint32_t offset = 0) = 0; |
125 | 92 |
126 inline void CollectElementIndices(Handle<JSObject> object, | 93 inline void CollectElementIndices(Handle<JSObject> object, |
127 KeyAccumulator* keys, | 94 KeyAccumulator* keys, |
128 uint32_t range = kMaxUInt32, | 95 uint32_t range = kMaxUInt32, |
129 PropertyFilter filter = ALL_PROPERTIES, | 96 PropertyFilter filter = ALL_PROPERTIES, |
130 uint32_t offset = 0) { | 97 uint32_t offset = 0) { |
131 CollectElementIndices(object, handle(object->elements()), keys, range, | 98 CollectElementIndices(object, handle(object->elements()), keys, range, |
132 filter, offset); | 99 filter, offset); |
133 } | 100 } |
134 | 101 |
135 virtual void AddElementsToKeyAccumulator(Handle<JSObject> receiver, | 102 virtual void AddElementsToKeyAccumulator(Handle<JSObject> receiver, |
136 KeyAccumulator* accumulator, | 103 KeyAccumulator* accumulator, |
137 AddKeyConversion convert) = 0; | 104 AddKeyConversion convert) = 0; |
138 | 105 |
139 virtual void GrowCapacityAndConvert(Handle<JSObject> object, | 106 virtual void GrowCapacityAndConvert(Handle<JSObject> object, |
140 uint32_t capacity) = 0; | 107 uint32_t capacity) = 0; |
141 | 108 |
142 static void InitializeOncePerProcess(); | 109 static void InitializeOncePerProcess(); |
143 static void TearDown(); | 110 static void TearDown(); |
144 | 111 |
145 virtual void Set(FixedArrayBase* backing_store, uint32_t entry, | 112 virtual void Set(Handle<JSObject> holder, uint32_t entry, Object* value) = 0; |
146 Object* value) = 0; | |
147 | 113 |
148 virtual void Reconfigure(Handle<JSObject> object, | 114 virtual void Reconfigure(Handle<JSObject> object, |
149 Handle<FixedArrayBase> backing_store, uint32_t entry, | 115 Handle<FixedArrayBase> backing_store, uint32_t entry, |
150 Handle<Object> value, | 116 Handle<Object> value, |
151 PropertyAttributes attributes) = 0; | 117 PropertyAttributes attributes) = 0; |
152 | 118 |
153 virtual void Add(Handle<JSObject> object, uint32_t index, | 119 virtual void Add(Handle<JSObject> object, uint32_t index, |
154 Handle<Object> value, PropertyAttributes attributes, | 120 Handle<Object> value, PropertyAttributes attributes, |
155 uint32_t new_capacity) = 0; | 121 uint32_t new_capacity) = 0; |
156 | 122 |
(...skipping 19 matching lines...) Expand all Loading... |
176 | 142 |
177 virtual Handle<Object> Pop(Handle<JSArray> receiver, | 143 virtual Handle<Object> Pop(Handle<JSArray> receiver, |
178 Handle<FixedArrayBase> backing_store) = 0; | 144 Handle<FixedArrayBase> backing_store) = 0; |
179 | 145 |
180 virtual Handle<Object> Shift(Handle<JSArray> receiver, | 146 virtual Handle<Object> Shift(Handle<JSArray> receiver, |
181 Handle<FixedArrayBase> backing_store) = 0; | 147 Handle<FixedArrayBase> backing_store) = 0; |
182 | 148 |
183 protected: | 149 protected: |
184 friend class LookupIterator; | 150 friend class LookupIterator; |
185 | 151 |
186 static ElementsAccessor* ForArray(FixedArrayBase* array); | |
187 | |
188 | |
189 // Element handlers distinguish between entries and indices when they | 152 // Element handlers distinguish between entries and indices when they |
190 // manipulate elements. Entries refer to elements in terms of their location | 153 // manipulate elements. Entries refer to elements in terms of their location |
191 // in the underlying storage's backing store representation, and are between 0 | 154 // in the underlying storage's backing store representation, and are between 0 |
192 // and GetCapacity. Indices refer to elements in terms of the value that would | 155 // and GetCapacity. Indices refer to elements in terms of the value that would |
193 // be specified in JavaScript to access the element. In most implementations, | 156 // be specified in JavaScript to access the element. In most implementations, |
194 // indices are equivalent to entries. In the NumberDictionary | 157 // indices are equivalent to entries. In the NumberDictionary |
195 // ElementsAccessor, entries are mapped to an index using the KeyAt method on | 158 // ElementsAccessor, entries are mapped to an index using the KeyAt method on |
196 // the NumberDictionary. | 159 // the NumberDictionary. |
197 virtual uint32_t GetEntryForIndex(JSObject* holder, | 160 virtual uint32_t GetEntryForIndex(JSObject* holder, |
198 FixedArrayBase* backing_store, | 161 FixedArrayBase* backing_store, |
199 uint32_t index) = 0; | 162 uint32_t index) = 0; |
200 virtual PropertyDetails GetDetails(FixedArrayBase* backing_store, | 163 |
201 uint32_t entry) = 0; | 164 // NOTE: this method violates the handlified function signature convention: |
| 165 // raw pointer parameter |source_holder| in the function that allocates. |
| 166 // This is done intentionally to avoid ArrayConcat() builtin performance |
| 167 // degradation. |
| 168 virtual void CopyElements(JSObject* source_holder, uint32_t source_start, |
| 169 ElementsKind source_kind, |
| 170 Handle<FixedArrayBase> destination, |
| 171 uint32_t destination_start, int copy_size) = 0; |
202 | 172 |
203 private: | 173 private: |
204 virtual uint32_t GetCapacity(JSObject* holder, | 174 virtual uint32_t GetCapacity(JSObject* holder, |
205 FixedArrayBase* backing_store) = 0; | 175 FixedArrayBase* backing_store) = 0; |
206 static ElementsAccessor** elements_accessors_; | 176 static ElementsAccessor** elements_accessors_; |
207 const char* name_; | 177 const char* name_; |
208 | 178 |
209 DISALLOW_COPY_AND_ASSIGN(ElementsAccessor); | 179 DISALLOW_COPY_AND_ASSIGN(ElementsAccessor); |
210 }; | 180 }; |
211 | 181 |
212 void CheckArrayAbuse(Handle<JSObject> obj, const char* op, uint32_t index, | 182 void CheckArrayAbuse(Handle<JSObject> obj, const char* op, uint32_t index, |
213 bool allow_appending = false); | 183 bool allow_appending = false); |
214 | 184 |
215 MUST_USE_RESULT MaybeHandle<Object> ArrayConstructInitializeElements( | 185 MUST_USE_RESULT MaybeHandle<Object> ArrayConstructInitializeElements( |
216 Handle<JSArray> array, | 186 Handle<JSArray> array, |
217 Arguments* args); | 187 Arguments* args); |
218 | 188 |
219 } // namespace internal | 189 } // namespace internal |
220 } // namespace v8 | 190 } // namespace v8 |
221 | 191 |
222 #endif // V8_ELEMENTS_H_ | 192 #endif // V8_ELEMENTS_H_ |
OLD | NEW |