@@ -77,18 +77,17 @@ class ElementsAccessorBase : public ElementsAccessor {
77
77
uint32_t key,
78
78
JSObject* obj,
79
79
Object* receiver) {
80
- return ElementsAccessorSubclass::Get (
80
+ return ElementsAccessorSubclass::GetImpl (
81
81
BackingStoreClass::cast (backing_store), key, obj, receiver);
82
82
}
83
83
84
- static MaybeObject* Get (BackingStoreClass* backing_store,
85
- uint32_t key,
86
- JSObject* obj,
87
- Object* receiver) {
88
- if (key < ElementsAccessorSubclass::GetCapacity (backing_store)) {
89
- return backing_store->get (key);
90
- }
91
- return backing_store->GetHeap ()->the_hole_value ();
84
+ static MaybeObject* GetImpl (BackingStoreClass* backing_store,
85
+ uint32_t key,
86
+ JSObject* obj,
87
+ Object* receiver) {
88
+ return (key < ElementsAccessorSubclass::GetCapacityImpl (backing_store))
89
+ ? backing_store->get (key)
90
+ : backing_store->GetHeap ()->the_hole_value ();
92
91
}
93
92
94
93
virtual MaybeObject* Delete (JSObject* obj,
@@ -108,7 +107,7 @@ class ElementsAccessorBase : public ElementsAccessor {
108
107
}
109
108
#endif
110
109
BackingStoreClass* backing_store = BackingStoreClass::cast (from);
111
- uint32_t len1 = ElementsAccessorSubclass::GetCapacity (backing_store);
110
+ uint32_t len1 = ElementsAccessorSubclass::GetCapacityImpl (backing_store);
112
111
113
112
// Optimize if 'other' is empty.
114
113
// We cannot optimize if 'this' is empty, as other may have holes.
@@ -117,14 +116,13 @@ class ElementsAccessorBase : public ElementsAccessor {
117
116
// Compute how many elements are not in other.
118
117
int extra = 0 ;
119
118
for (uint32_t y = 0 ; y < len1; y++) {
120
- if (ElementsAccessorSubclass::HasElementAtIndex (backing_store,
121
- y,
122
- holder,
123
- receiver)) {
119
+ if (ElementsAccessorSubclass::HasElementAtIndexImpl (
120
+ backing_store, y, holder, receiver)) {
124
121
uint32_t key =
125
- ElementsAccessorSubclass::GetKeyForIndex (backing_store, y);
122
+ ElementsAccessorSubclass::GetKeyForIndexImpl (backing_store, y);
126
123
MaybeObject* maybe_value =
127
- ElementsAccessorSubclass::Get (backing_store, key, holder, receiver);
124
+ ElementsAccessorSubclass::GetImpl (backing_store, key,
125
+ holder, receiver);
128
126
Object* value;
129
127
if (!maybe_value->ToObject (&value)) return maybe_value;
130
128
ASSERT (!value->IsTheHole ());
@@ -155,14 +153,13 @@ class ElementsAccessorBase : public ElementsAccessor {
155
153
// Fill in the extra values.
156
154
int index = 0 ;
157
155
for (uint32_t y = 0 ; y < len1; y++) {
158
- if (ElementsAccessorSubclass::HasElementAtIndex (backing_store,
159
- y,
160
- holder,
161
- receiver)) {
156
+ if (ElementsAccessorSubclass::HasElementAtIndexImpl (
157
+ backing_store, y, holder, receiver)) {
162
158
uint32_t key =
163
- ElementsAccessorSubclass::GetKeyForIndex (backing_store, y);
159
+ ElementsAccessorSubclass::GetKeyForIndexImpl (backing_store, y);
164
160
MaybeObject* maybe_value =
165
- ElementsAccessorSubclass::Get (backing_store, key, holder, receiver);
161
+ ElementsAccessorSubclass::GetImpl (backing_store, key,
162
+ holder, receiver);
166
163
Object* value;
167
164
if (!maybe_value->ToObject (&value)) return maybe_value;
168
165
if (!value->IsTheHole () && !HasKey (to, value)) {
@@ -176,44 +173,42 @@ class ElementsAccessorBase : public ElementsAccessor {
176
173
}
177
174
178
175
protected:
179
- static uint32_t GetCapacity (BackingStoreClass* backing_store) {
176
+ static uint32_t GetCapacityImpl (BackingStoreClass* backing_store) {
180
177
return backing_store->length ();
181
178
}
182
179
183
180
virtual uint32_t GetCapacity (FixedArrayBase* backing_store) {
184
- return ElementsAccessorSubclass::GetCapacity (
181
+ return ElementsAccessorSubclass::GetCapacityImpl (
185
182
BackingStoreClass::cast (backing_store));
186
183
}
187
184
188
- static bool HasElementAtIndex (BackingStoreClass* backing_store,
189
- uint32_t index,
190
- JSObject* holder,
191
- Object* receiver) {
185
+ static bool HasElementAtIndexImpl (BackingStoreClass* backing_store,
186
+ uint32_t index,
187
+ JSObject* holder,
188
+ Object* receiver) {
192
189
uint32_t key =
193
- ElementsAccessorSubclass::GetKeyForIndex (backing_store, index );
194
- MaybeObject* element = ElementsAccessorSubclass::Get (backing_store,
195
- key,
196
- holder,
197
- receiver);
190
+ ElementsAccessorSubclass::GetKeyForIndexImpl (backing_store, index );
191
+ MaybeObject* element =
192
+ ElementsAccessorSubclass::GetImpl (backing_store, key, holder, receiver);
198
193
return !element->IsTheHole ();
199
194
}
200
195
201
196
virtual bool HasElementAtIndex (FixedArrayBase* backing_store,
202
197
uint32_t index,
203
198
JSObject* holder,
204
199
Object* receiver) {
205
- return ElementsAccessorSubclass::HasElementAtIndex (
200
+ return ElementsAccessorSubclass::HasElementAtIndexImpl (
206
201
BackingStoreClass::cast (backing_store), index , holder, receiver);
207
202
}
208
203
209
- static uint32_t GetKeyForIndex (BackingStoreClass* backing_store,
210
- uint32_t index) {
204
+ static uint32_t GetKeyForIndexImpl (BackingStoreClass* backing_store,
205
+ uint32_t index) {
211
206
return index ;
212
207
}
213
208
214
209
virtual uint32_t GetKeyForIndex (FixedArrayBase* backing_store,
215
210
uint32_t index) {
216
- return ElementsAccessorSubclass::GetKeyForIndex (
211
+ return ElementsAccessorSubclass::GetKeyForIndexImpl (
217
212
BackingStoreClass::cast (backing_store), index );
218
213
}
219
214
@@ -297,10 +292,10 @@ class FastDoubleElementsAccessor
297
292
return obj->GetHeap ()->true_value ();
298
293
}
299
294
300
- static bool HasElementAtIndex (FixedDoubleArray* backing_store,
301
- uint32_t index,
302
- JSObject* holder,
303
- Object* receiver) {
295
+ static bool HasElementAtIndexImpl (FixedDoubleArray* backing_store,
296
+ uint32_t index,
297
+ JSObject* holder,
298
+ Object* receiver) {
304
299
return !backing_store->is_the_hole (index );
305
300
}
306
301
};
@@ -316,15 +311,14 @@ class ExternalElementsAccessor
316
311
friend class ElementsAccessorBase <ExternalElementsAccessorSubclass,
317
312
ExternalArray>;
318
313
319
- static MaybeObject* Get (ExternalArray* backing_store,
320
- uint32_t key,
321
- JSObject* obj,
322
- Object* receiver) {
323
- if (key < ExternalElementsAccessorSubclass::GetCapacity (backing_store)) {
324
- return backing_store->get (key);
325
- } else {
326
- return backing_store->GetHeap ()->undefined_value ();
327
- }
314
+ static MaybeObject* GetImpl (ExternalArray* backing_store,
315
+ uint32_t key,
316
+ JSObject* obj,
317
+ Object* receiver) {
318
+ return
319
+ key < ExternalElementsAccessorSubclass::GetCapacityImpl (backing_store)
320
+ ? backing_store->get (key)
321
+ : backing_store->GetHeap ()->undefined_value ();
328
322
}
329
323
330
324
virtual MaybeObject* Delete (JSObject* obj,
@@ -449,10 +443,10 @@ class DictionaryElementsAccessor
449
443
return DeleteCommon (obj, key, mode);
450
444
}
451
445
452
- static MaybeObject* Get (SeededNumberDictionary* backing_store,
453
- uint32_t key,
454
- JSObject* obj,
455
- Object* receiver) {
446
+ static MaybeObject* GetImpl (SeededNumberDictionary* backing_store,
447
+ uint32_t key,
448
+ JSObject* obj,
449
+ Object* receiver) {
456
450
int entry = backing_store->FindEntry (key);
457
451
if (entry != SeededNumberDictionary::kNotFound ) {
458
452
Object* element = backing_store->ValueAt (entry);
@@ -469,8 +463,8 @@ class DictionaryElementsAccessor
469
463
return obj->GetHeap ()->the_hole_value ();
470
464
}
471
465
472
- static uint32_t GetKeyForIndex (SeededNumberDictionary* dict,
473
- uint32_t index) {
466
+ static uint32_t GetKeyForIndexImpl (SeededNumberDictionary* dict,
467
+ uint32_t index) {
474
468
Object* key = dict->KeyAt (index );
475
469
return Smi::cast (key)->value ();
476
470
}
@@ -484,10 +478,10 @@ class NonStrictArgumentsElementsAccessor
484
478
friend class ElementsAccessorBase <NonStrictArgumentsElementsAccessor,
485
479
FixedArray>;
486
480
487
- static MaybeObject* Get (FixedArray* parameter_map,
488
- uint32_t key,
489
- JSObject* obj,
490
- Object* receiver) {
481
+ static MaybeObject* GetImpl (FixedArray* parameter_map,
482
+ uint32_t key,
483
+ JSObject* obj,
484
+ Object* receiver) {
491
485
Object* probe = GetParameterMapArg (parameter_map, key);
492
486
if (!probe->IsTheHole ()) {
493
487
Context* context = Context::cast (parameter_map->get (0 ));
@@ -526,21 +520,21 @@ class NonStrictArgumentsElementsAccessor
526
520
return obj->GetHeap ()->true_value ();
527
521
}
528
522
529
- static uint32_t GetCapacity (FixedArray* parameter_map) {
523
+ static uint32_t GetCapacityImpl (FixedArray* parameter_map) {
530
524
FixedArrayBase* arguments = FixedArrayBase::cast (parameter_map->get (1 ));
531
525
return Max (static_cast <uint32_t >(parameter_map->length () - 2 ),
532
526
ForArray (arguments)->GetCapacity (arguments));
533
527
}
534
528
535
- static uint32_t GetKeyForIndex (FixedArray* dict,
536
- uint32_t index) {
529
+ static uint32_t GetKeyForIndexImpl (FixedArray* dict,
530
+ uint32_t index) {
537
531
return index ;
538
532
}
539
533
540
- static bool HasElementAtIndex (FixedArray* parameter_map,
541
- uint32_t index,
542
- JSObject* holder,
543
- Object* receiver) {
534
+ static bool HasElementAtIndexImpl (FixedArray* parameter_map,
535
+ uint32_t index,
536
+ JSObject* holder,
537
+ Object* receiver) {
544
538
Object* probe = GetParameterMapArg (parameter_map, index );
545
539
if (!probe->IsTheHole ()) {
546
540
return true ;
0 commit comments