Chromium Code Reviews
chromiumcodereview-hr@appspot.gserviceaccount.com (chromiumcodereview-hr) | Please choose your nickname with Settings | Help | Chromium Project | Gerrit Changes | Sign out
(171)

Side by Side Diff: src/elements.h

Issue 1612323003: Introduce {FAST,SLOW}_STRING_WRAPPER_ELEMENTS (Closed) Base URL: https://chromium.googlesource.com/v8/v8.git@master
Patch Set: one more DCHECK fix Created 4 years, 10 months ago
Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.
Jump to:
View unified diff | Download patch
« no previous file with comments | « src/debug/liveedit.cc ('k') | src/elements.cc » ('j') | no next file with comments »
Toggle Intra-line Diffs ('i') | Expand Comments ('e') | Collapse Comments ('c') | Show Comments Hide Comments ('s')
OLDNEW
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
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
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_
OLDNEW
« no previous file with comments | « src/debug/liveedit.cc ('k') | src/elements.cc » ('j') | no next file with comments »

Powered by Google App Engine
This is Rietveld 408576698