← Back to branch summary

~ubuntu-branches/ubuntu/saucy/libv8/saucy

« back to all changes in this revision

Viewing changes to src/elements.cc

  • Committer: Package Import Robot
  • Author(s): Jérémy Lal
  • Date: 2012-04-07 16:26:13 UTC
  • mfrom: (15.1.27 sid)
  • Revision ID: package-import@ubuntu.com-20120407162613-dqo1m6w9r3fh8tst
Tags: 3.8.9.16-3
* mipsel build fixes :
  + v8_use_mips_abi_hardfloat=false, this lowers EABI requirements.
  + v8_can_use_fpu_instructions=false, detect if FPU is present.
  + set -Wno-unused-but-set-variable only on mipsel.

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/elements.cc
109
109
                           uint32_t key,
110
110
                           JSObject* obj,
111
111
                           Object* receiver) {
112
 
    return ElementsAccessorSubclass::Get(
 
112
    return ElementsAccessorSubclass::GetImpl(
113
113
        BackingStoreClass::cast(backing_store), key, obj, receiver);
114
114
  }
115
115
 
116
 
  static MaybeObject* Get(BackingStoreClass* backing_store,
117
 
                          uint32_t key,
118
 
                          JSObject* obj,
119
 
                          Object* receiver) {
120
 
    if (key < ElementsAccessorSubclass::GetCapacity(backing_store)) {
121
 
      return backing_store->get(key);
122
 
    }
123
 
    return backing_store->GetHeap()->the_hole_value();
 
116
  static MaybeObject* GetImpl(BackingStoreClass* backing_store,
 
117
                              uint32_t key,
 
118
                              JSObject* obj,
 
119
                              Object* receiver) {
 
120
    return (key < ElementsAccessorSubclass::GetCapacityImpl(backing_store))
 
121
           ? backing_store->get(key)
 
122
           : backing_store->GetHeap()->the_hole_value();
124
123
  }
125
124
 
126
125
  virtual MaybeObject* SetLength(JSObject* obj,
127
126
                                 Object* length) {
128
127
    ASSERT(obj->IsJSArray());
129
 
    return ElementsAccessorSubclass::SetLength(
 
128
    return ElementsAccessorSubclass::SetLengthImpl(
130
129
        BackingStoreClass::cast(obj->elements()), obj, length);
131
130
  }
132
131
 
133
 
  static MaybeObject* SetLength(BackingStoreClass* backing_store,
134
 
                                JSObject* obj,
135
 
                                Object* length);
 
132
  static MaybeObject* SetLengthImpl(BackingStoreClass* backing_store,
 
133
                                    JSObject* obj,
 
134
                                    Object* length);
 
135
 
 
136
  virtual MaybeObject* SetCapacityAndLength(JSArray* array,
 
137
                                            int capacity,
 
138
                                            int length) {
 
139
    return ElementsAccessorSubclass::SetFastElementsCapacityAndLength(
 
140
        array,
 
141
        capacity,
 
142
        length);
 
143
  }
 
144
 
 
145
  static MaybeObject* SetFastElementsCapacityAndLength(JSObject* obj,
 
146
                                                       int capacity,
 
147
                                                       int length) {
 
148
    UNIMPLEMENTED();
 
149
    return obj;
 
150
  }
136
151
 
137
152
  virtual MaybeObject* Delete(JSObject* obj,
138
153
                              uint32_t key,
151
166
    }
152
167
#endif
153
168
    BackingStoreClass* backing_store = BackingStoreClass::cast(from);
154
 
    uint32_t len1 = ElementsAccessorSubclass::GetCapacity(backing_store);
 
169
    uint32_t len1 = ElementsAccessorSubclass::GetCapacityImpl(backing_store);
155
170
 
156
171
    // Optimize if 'other' is empty.
157
172
    // We cannot optimize if 'this' is empty, as other may have holes.
160
175
    // Compute how many elements are not in other.
161
176
    int extra = 0;
162
177
    for (uint32_t y = 0; y < len1; y++) {
163
 
      if (ElementsAccessorSubclass::HasElementAtIndex(backing_store,
164
 
                                                      y,
165
 
                                                      holder,
166
 
                                                      receiver)) {
 
178
      if (ElementsAccessorSubclass::HasElementAtIndexImpl(
 
179
          backing_store, y, holder, receiver)) {
167
180
        uint32_t key =
168
 
            ElementsAccessorSubclass::GetKeyForIndex(backing_store, y);
 
181
            ElementsAccessorSubclass::GetKeyForIndexImpl(backing_store, y);
169
182
        MaybeObject* maybe_value =
170
 
            ElementsAccessorSubclass::Get(backing_store, key, holder, receiver);
 
183
            ElementsAccessorSubclass::GetImpl(backing_store, key,
 
184
                                              holder, receiver);
171
185
        Object* value;
172
186
        if (!maybe_value->ToObject(&value)) return maybe_value;
173
187
        ASSERT(!value->IsTheHole());
198
212
    // Fill in the extra values.
199
213
    int index = 0;
200
214
    for (uint32_t y = 0; y < len1; y++) {
201
 
      if (ElementsAccessorSubclass::HasElementAtIndex(backing_store,
202
 
                                                      y,
203
 
                                                      holder,
204
 
                                                      receiver)) {
 
215
      if (ElementsAccessorSubclass::HasElementAtIndexImpl(
 
216
          backing_store, y, holder, receiver)) {
205
217
        uint32_t key =
206
 
            ElementsAccessorSubclass::GetKeyForIndex(backing_store, y);
 
218
            ElementsAccessorSubclass::GetKeyForIndexImpl(backing_store, y);
207
219
        MaybeObject* maybe_value =
208
 
            ElementsAccessorSubclass::Get(backing_store, key, holder, receiver);
 
220
            ElementsAccessorSubclass::GetImpl(backing_store, key,
 
221
                                              holder, receiver);
209
222
        Object* value;
210
223
        if (!maybe_value->ToObject(&value)) return maybe_value;
211
224
        if (!value->IsTheHole() && !HasKey(to, value)) {
219
232
  }
220
233
 
221
234
 protected:
222
 
  static uint32_t GetCapacity(BackingStoreClass* backing_store) {
 
235
  static uint32_t GetCapacityImpl(BackingStoreClass* backing_store) {
223
236
    return backing_store->length();
224
237
  }
225
238
 
226
239
  virtual uint32_t GetCapacity(FixedArrayBase* backing_store) {
227
 
    return ElementsAccessorSubclass::GetCapacity(
 
240
    return ElementsAccessorSubclass::GetCapacityImpl(
228
241
        BackingStoreClass::cast(backing_store));
229
242
  }
230
243
 
231
 
  static bool HasElementAtIndex(BackingStoreClass* backing_store,
232
 
                                uint32_t index,
233
 
                                JSObject* holder,
234
 
                                Object* receiver) {
 
244
  static bool HasElementAtIndexImpl(BackingStoreClass* backing_store,
 
245
                                    uint32_t index,
 
246
                                    JSObject* holder,
 
247
                                    Object* receiver) {
235
248
    uint32_t key =
236
 
        ElementsAccessorSubclass::GetKeyForIndex(backing_store, index);
237
 
    MaybeObject* element = ElementsAccessorSubclass::Get(backing_store,
238
 
                                                         key,
239
 
                                                         holder,
240
 
                                                         receiver);
 
249
        ElementsAccessorSubclass::GetKeyForIndexImpl(backing_store, index);
 
250
    MaybeObject* element =
 
251
        ElementsAccessorSubclass::GetImpl(backing_store, key, holder, receiver);
241
252
    return !element->IsTheHole();
242
253
  }
243
254
 
245
256
                                 uint32_t index,
246
257
                                 JSObject* holder,
247
258
                                 Object* receiver) {
248
 
    return ElementsAccessorSubclass::HasElementAtIndex(
 
259
    return ElementsAccessorSubclass::HasElementAtIndexImpl(
249
260
        BackingStoreClass::cast(backing_store), index, holder, receiver);
250
261
  }
251
262
 
252
 
  static uint32_t GetKeyForIndex(BackingStoreClass* backing_store,
253
 
                                 uint32_t index) {
 
263
  static uint32_t GetKeyForIndexImpl(BackingStoreClass* backing_store,
 
264
                                     uint32_t index) {
254
265
    return index;
255
266
  }
256
267
 
257
268
  virtual uint32_t GetKeyForIndex(FixedArrayBase* backing_store,
258
269
                                              uint32_t index) {
259
 
    return ElementsAccessorSubclass::GetKeyForIndex(
 
270
    return ElementsAccessorSubclass::GetKeyForIndexImpl(
260
271
        BackingStoreClass::cast(backing_store), index);
261
272
  }
262
273
 
376
387
    return heap->true_value();
377
388
  }
378
389
 
379
 
 protected:
380
 
  friend class FastElementsAccessor<FastObjectElementsAccessor,
381
 
                                    FixedArray,
382
 
                                    kPointerSize>;
383
 
 
384
390
  static MaybeObject* SetFastElementsCapacityAndLength(JSObject* obj,
385
391
                                                       uint32_t capacity,
386
392
                                                       uint32_t length) {
393
399
                                                 set_capacity_mode);
394
400
  }
395
401
 
 
402
 protected:
 
403
  friend class FastElementsAccessor<FastObjectElementsAccessor,
 
404
                                    FixedArray,
 
405
                                    kPointerSize>;
 
406
 
396
407
  virtual MaybeObject* Delete(JSObject* obj,
397
408
                              uint32_t key,
398
409
                              JSReceiver::DeleteMode mode) {
405
416
    : public FastElementsAccessor<FastDoubleElementsAccessor,
406
417
                                  FixedDoubleArray,
407
418
                                  kDoubleSize> {
 
419
  static MaybeObject* SetFastElementsCapacityAndLength(JSObject* obj,
 
420
                                                       uint32_t capacity,
 
421
                                                       uint32_t length) {
 
422
    return obj->SetFastDoubleElementsCapacityAndLength(capacity, length);
 
423
  }
 
424
 
408
425
 protected:
409
426
  friend class ElementsAccessorBase<FastDoubleElementsAccessor,
410
427
                                    FixedDoubleArray>;
412
429
                                    FixedDoubleArray,
413
430
                                    kDoubleSize>;
414
431
 
415
 
  static MaybeObject* SetFastElementsCapacityAndLength(JSObject* obj,
416
 
                                                       uint32_t capacity,
417
 
                                                       uint32_t length) {
418
 
    return obj->SetFastDoubleElementsCapacityAndLength(capacity, length);
419
 
  }
420
 
 
421
432
  virtual MaybeObject* Delete(JSObject* obj,
422
433
                              uint32_t key,
423
434
                              JSReceiver::DeleteMode mode) {
430
441
    return obj->GetHeap()->true_value();
431
442
  }
432
443
 
433
 
  static bool HasElementAtIndex(FixedDoubleArray* backing_store,
434
 
                                uint32_t index,
435
 
                                JSObject* holder,
436
 
                                Object* receiver) {
 
444
  static bool HasElementAtIndexImpl(FixedDoubleArray* backing_store,
 
445
                                    uint32_t index,
 
446
                                    JSObject* holder,
 
447
                                    Object* receiver) {
437
448
    return !backing_store->is_the_hole(index);
438
449
  }
439
450
};
449
460
  friend class ElementsAccessorBase<ExternalElementsAccessorSubclass,
450
461
                                    ExternalArray>;
451
462
 
452
 
  static MaybeObject* Get(ExternalArray* backing_store,
453
 
                          uint32_t key,
454
 
                          JSObject* obj,
455
 
                          Object* receiver) {
456
 
    if (key < ExternalElementsAccessorSubclass::GetCapacity(backing_store)) {
457
 
      return backing_store->get(key);
458
 
    } else {
459
 
      return backing_store->GetHeap()->undefined_value();
460
 
    }
 
463
  static MaybeObject* GetImpl(ExternalArray* backing_store,
 
464
                              uint32_t key,
 
465
                              JSObject* obj,
 
466
                              Object* receiver) {
 
467
    return
 
468
        key < ExternalElementsAccessorSubclass::GetCapacityImpl(backing_store)
 
469
        ? backing_store->get(key)
 
470
        : backing_store->GetHeap()->undefined_value();
461
471
  }
462
472
 
463
 
  static MaybeObject* SetLength(ExternalArray* backing_store,
464
 
                                JSObject* obj,
465
 
                                Object* length) {
 
473
  static MaybeObject* SetLengthImpl(ExternalArray* backing_store,
 
474
                                    JSObject* obj,
 
475
                                    Object* length) {
466
476
    // External arrays do not support changing their length.
467
477
    UNREACHABLE();
468
478
    return obj;
533
543
 
534
544
class DictionaryElementsAccessor
535
545
    : public ElementsAccessorBase<DictionaryElementsAccessor,
536
 
                                  NumberDictionary> {
 
546
                                  SeededNumberDictionary> {
537
547
 public:
538
548
  // Adjusts the length of the dictionary backing store and returns the new
539
549
  // length according to ES5 section 15.4.5.2 behavior.
540
 
  static MaybeObject* SetLengthWithoutNormalize(NumberDictionary* dict,
 
550
  static MaybeObject* SetLengthWithoutNormalize(SeededNumberDictionary* dict,
541
551
                                                JSArray* array,
542
552
                                                Object* length_object,
543
553
                                                uint32_t length) {
603
613
    if (is_arguments) {
604
614
      backing_store = FixedArray::cast(backing_store->get(1));
605
615
    }
606
 
    NumberDictionary* dictionary = NumberDictionary::cast(backing_store);
 
616
    SeededNumberDictionary* dictionary =
 
617
        SeededNumberDictionary::cast(backing_store);
607
618
    int entry = dictionary->FindEntry(key);
608
 
    if (entry != NumberDictionary::kNotFound) {
 
619
    if (entry != SeededNumberDictionary::kNotFound) {
609
620
      Object* result = dictionary->DeleteProperty(entry, mode);
610
621
      if (result == heap->true_value()) {
611
622
        MaybeObject* maybe_elements = dictionary->Shrink(key);
638
649
 
639
650
 protected:
640
651
  friend class ElementsAccessorBase<DictionaryElementsAccessor,
641
 
                                    NumberDictionary>;
 
652
                                    SeededNumberDictionary>;
642
653
 
643
654
  virtual MaybeObject* Delete(JSObject* obj,
644
655
                              uint32_t key,
646
657
    return DeleteCommon(obj, key, mode);
647
658
  }
648
659
 
649
 
  static MaybeObject* Get(NumberDictionary* backing_store,
650
 
                          uint32_t key,
651
 
                          JSObject* obj,
652
 
                          Object* receiver) {
 
660
  static MaybeObject* GetImpl(SeededNumberDictionary* backing_store,
 
661
                              uint32_t key,
 
662
                              JSObject* obj,
 
663
                              Object* receiver) {
653
664
    int entry = backing_store->FindEntry(key);
654
 
    if (entry != NumberDictionary::kNotFound) {
 
665
    if (entry != SeededNumberDictionary::kNotFound) {
655
666
      Object* element = backing_store->ValueAt(entry);
656
667
      PropertyDetails details = backing_store->DetailsAt(entry);
657
668
      if (details.type() == CALLBACKS) {
666
677
    return obj->GetHeap()->the_hole_value();
667
678
  }
668
679
 
669
 
  static uint32_t GetKeyForIndex(NumberDictionary* dict,
670
 
                                 uint32_t index) {
 
680
  static uint32_t GetKeyForIndexImpl(SeededNumberDictionary* dict,
 
681
                                     uint32_t index) {
671
682
    Object* key = dict->KeyAt(index);
672
683
    return Smi::cast(key)->value();
673
684
  }
681
692
  friend class ElementsAccessorBase<NonStrictArgumentsElementsAccessor,
682
693
                                    FixedArray>;
683
694
 
684
 
  static MaybeObject* Get(FixedArray* parameter_map,
685
 
                          uint32_t key,
686
 
                          JSObject* obj,
687
 
                          Object* receiver) {
 
695
  static MaybeObject* GetImpl(FixedArray* parameter_map,
 
696
                              uint32_t key,
 
697
                              JSObject* obj,
 
698
                              Object* receiver) {
688
699
    Object* probe = GetParameterMapArg(parameter_map, key);
689
700
    if (!probe->IsTheHole()) {
690
701
      Context* context = Context::cast(parameter_map->get(0));
701
712
    }
702
713
  }
703
714
 
704
 
  static MaybeObject* SetLength(FixedArray* parameter_map,
705
 
                                JSObject* obj,
706
 
                                Object* length) {
 
715
  static MaybeObject* SetLengthImpl(FixedArray* parameter_map,
 
716
                                    JSObject* obj,
 
717
                                    Object* length) {
707
718
    // TODO(mstarzinger): This was never implemented but will be used once we
708
719
    // correctly implement [[DefineOwnProperty]] on arrays.
709
720
    UNIMPLEMENTED();
731
742
    return obj->GetHeap()->true_value();
732
743
  }
733
744
 
734
 
  static uint32_t GetCapacity(FixedArray* parameter_map) {
 
745
  static uint32_t GetCapacityImpl(FixedArray* parameter_map) {
735
746
    FixedArrayBase* arguments = FixedArrayBase::cast(parameter_map->get(1));
736
747
    return Max(static_cast<uint32_t>(parameter_map->length() - 2),
737
748
               ForArray(arguments)->GetCapacity(arguments));
738
749
  }
739
750
 
740
 
  static uint32_t GetKeyForIndex(FixedArray* dict,
741
 
                                 uint32_t index) {
 
751
  static uint32_t GetKeyForIndexImpl(FixedArray* dict,
 
752
                                     uint32_t index) {
742
753
    return index;
743
754
  }
744
755
 
745
 
  static bool HasElementAtIndex(FixedArray* parameter_map,
746
 
                                uint32_t index,
747
 
                                JSObject* holder,
748
 
                                Object* receiver) {
 
756
  static bool HasElementAtIndexImpl(FixedArray* parameter_map,
 
757
                                    uint32_t index,
 
758
                                    JSObject* holder,
 
759
                                    Object* receiver) {
749
760
    Object* probe = GetParameterMapArg(parameter_map, index);
750
761
    if (!probe->IsTheHole()) {
751
762
      return true;
849
860
 
850
861
template <typename ElementsAccessorSubclass, typename BackingStoreClass>
851
862
MaybeObject* ElementsAccessorBase<ElementsAccessorSubclass, BackingStoreClass>::
852
 
    SetLength(BackingStoreClass* backing_store,
853
 
              JSObject* obj,
854
 
              Object* length) {
 
863
    SetLengthImpl(BackingStoreClass* backing_store,
 
864
                  JSObject* obj,
 
865
                  Object* length) {
855
866
  JSArray* array = JSArray::cast(obj);
856
867
 
857
868
  // Fast case: The new length fits into a Smi.
879
890
  if (length->IsNumber()) {
880
891
    uint32_t value;
881
892
    if (length->ToArrayIndex(&value)) {
882
 
      NumberDictionary* dictionary;
 
893
      SeededNumberDictionary* dictionary;
883
894
      MaybeObject* maybe_object = array->NormalizeElements();
884
895
      if (!maybe_object->To(&dictionary)) return maybe_object;
885
896
      Object* new_length;