[key-accumulator] Starting to reimplement the key-accumulator

src/objects.cc

 // Copyright 2015 the V8 project authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "src/objects.h"
 
 #include <cmath>
 #include <iomanip>
 #include <sstream>
 
@@ skipping 8318 matching lines @@
       if (result->IsPrimitive()) return result;
     }
   }
   THROW_NEW_ERROR(isolate,
                   NewTypeError(MessageTemplate::kCannotConvertToPrimitive),
                   Object);
 }
 
 
 // TODO(cbruni/jkummerow): Consider moving this into elements.cc.
-bool HasEnumerableElements(JSObject* object) {
+bool JSObject::HasEnumerableElements() {
+  // TODO(cbruni): cleanup
+  JSObject* object = this;
   switch (object->GetElementsKind()) {
     case FAST_SMI_ELEMENTS:
     case FAST_ELEMENTS:
     case FAST_DOUBLE_ELEMENTS: {
       int length = object->IsJSArray()
                        ? Smi::cast(JSArray::cast(object)->length())->value()
                        : object->elements()->length();
       return length > 0;
     }
     case FAST_HOLEY_SMI_ELEMENTS:
     case FAST_HOLEY_ELEMENTS: {
       FixedArray* elements = FixedArray::cast(object->elements());
       int length = object->IsJSArray()
                        ? Smi::cast(JSArray::cast(object)->length())->value()
                        : elements->length();
       for (int i = 0; i < length; i++) {
         if (!elements->is_the_hole(i)) return true;

[Toon Verwaest, 2016/02/24 15:07:06]

is it really worthwhile to find the first non-hole element? Once you have a
fast-non-empty backing store, I'd just assume there might be one and fall to the
slow path. This precheck probably just makes the common case of the slow path
even more slow.

       }
       return false;
     }
     case FAST_HOLEY_DOUBLE_ELEMENTS: {
       int length = object->IsJSArray()
                        ? Smi::cast(JSArray::cast(object)->length())->value()
                        : object->elements()->length();
       // Zero-length arrays would use the empty FixedArray...
       if (length == 0) return false;
       // ...so only cast to FixedDoubleArray otherwise.
@@ skipping 27 matching lines @@
         return true;
       }
       return object->elements()->length() > 0;
     case NO_ELEMENTS:
       return false;
   }
   UNREACHABLE();
   return true;
 }
 
-
 // Tests for the fast common case for property enumeration:
 // - This object and all prototypes has an enum cache (which means that
 //   it is no proxy, has no interceptors and needs no access checks).
 // - This object has no elements.
 // - No prototype has enumerable properties/elements.
 bool JSReceiver::IsSimpleEnum() {
   for (PrototypeIterator iter(GetIsolate(), this,
                               PrototypeIterator::START_AT_RECEIVER);
        !iter.IsAtEnd(); iter.Advance()) {
     if (!iter.GetCurrent()->IsJSObject()) return false;
     JSObject* current = iter.GetCurrent<JSObject>();
     int enum_length = current->map()->EnumLength();
     if (enum_length == kInvalidEnumCacheSentinel) return false;
     if (current->IsAccessCheckNeeded()) return false;
     DCHECK(!current->HasNamedInterceptor());
     DCHECK(!current->HasIndexedInterceptor());
-    if (HasEnumerableElements(current)) return false;
+    if (current->HasEnumerableElements()) return false;
     if (current != this && enum_length != 0) return false;
   }
   return true;
 }
 
 
 int Map::NumberOfDescribedProperties(DescriptorFlag which,
                                      PropertyFilter filter) {
   int result = 0;
   DescriptorArray* descs = instance_descriptors();
@@ skipping 44 matching lines @@
 
 bool Map::OnlyHasSimpleProperties() {
   // Wrapped string elements aren't explicitly stored in the elements backing
   // store, but are loaded indirectly from the underlying string.
   return !IsStringWrapperElementsKind(elements_kind()) &&
          !is_access_check_needed() && !has_named_interceptor() &&
          !has_indexed_interceptor() && !has_hidden_prototype() &&
          !is_dictionary_map();
 }
 
-namespace {
-
-Handle<FixedArray> GetFastEnumPropertyKeys(Isolate* isolate,
-                                           Handle<JSObject> object) {
+// stati

[Toon Verwaest, 2016/02/24 15:07:06]

static

+Handle<FixedArray> JSObject::GetFastEnumPropertyKeys(Isolate* isolate,
+                                                     Handle<JSObject> object) {
   Handle<Map> map(object->map());
   bool cache_enum_length = map->OnlyHasSimpleProperties();
 
   Handle<DescriptorArray> descs =
       Handle<DescriptorArray>(map->instance_descriptors(), isolate);
   int own_property_count = map->EnumLength();
   // If the enum length of the given map is set to kInvalidEnumCache, this
   // means that the map itself has never used the present enum cache. The
   // first step to using the cache is to set the enum length of the map by
   // counting the number of own descriptors that are ENUMERABLE_STRINGS.
@@ skipping 30 matching lines @@
   Handle<FixedArray> storage =
       isolate->factory()->NewFixedArray(own_property_count);
   Handle<FixedArray> indices =
       isolate->factory()->NewFixedArray(own_property_count);
 
   int size = map->NumberOfOwnDescriptors();
   int index = 0;
 
   for (int i = 0; i < size; i++) {
     PropertyDetails details = descs->GetDetails(i);
+    if (details.IsDontEnum()) continue;
     Object* key = descs->GetKey(i);
-    if (details.IsDontEnum() || key->IsSymbol()) continue;
+    if (key->IsSymbol()) continue;
     storage->set(index, key);
     if (!indices.is_null()) {
       if (details.type() != DATA) {
         indices = Handle<FixedArray>();
       } else {
         FieldIndex field_index = FieldIndex::ForDescriptor(*map, i);
         int load_by_field_index = field_index.GetLoadByFieldIndex();
         indices->set(index, Smi::FromInt(load_by_field_index));
       }
     }
     index++;
   }
   DCHECK(index == storage->length());
 
   DescriptorArray::SetEnumCache(descs, isolate, storage, indices);
   if (cache_enum_length) {
     map->SetEnumLength(own_property_count);
   }
   return storage;
 }
 
-}  // namespace
 
 Handle<FixedArray> JSObject::GetEnumPropertyKeys(Handle<JSObject> object) {
   Isolate* isolate = object->GetIsolate();
   if (object->HasFastProperties()) {
     return GetFastEnumPropertyKeys(isolate, object);
   } else if (object->IsJSGlobalObject()) {
     Handle<GlobalDictionary> dictionary(object->global_dictionary());
     int length = dictionary->NumberOfEnumElements();
     if (length == 0) {
       return Handle<FixedArray>(isolate->heap()->empty_fixed_array());
@@ skipping 2259 matching lines @@
   array = EnsureSpace(array, length + 1);
   if (mode == kReloadLengthAfterAllocation) {
     DCHECK(array->Length() <= length);
     length = array->Length();
   }
   array->Set(length, *obj);
   array->SetLength(length + 1);
   return array;
 }
 
+Handle<ArrayList> ArrayList::Add(Handle<ArrayList> array, Smi* smi,
+                                 AddMode mode) {
+  int length = array->Length();
+  array = EnsureSpace(array, length + 1);
+  if (mode == kReloadLengthAfterAllocation) {
+    DCHECK(array->Length() <= length);
+    length = array->Length();
+  }
+  array->Set(length, smi);
+  array->SetLength(length + 1);
+  return array;
+}
 
 Handle<ArrayList> ArrayList::Add(Handle<ArrayList> array, Handle<Object> obj1,
                                  Handle<Object> obj2, AddMode mode) {
   int length = array->Length();
   array = EnsureSpace(array, length + 2);
   if (mode == kReloadLengthAfterAllocation) {
     length = array->Length();
   }
   array->Set(length, *obj1);
   array->Set(length + 1, *obj2);
@@ skipping 5739 matching lines @@
              j++ < len) {
         SwapPairs(numbers, i, p);
       }
     }
   } else {
     HeapSortPairs(this, numbers, len);
     return;
   }
 }
 
-
 void JSObject::CollectOwnPropertyNames(KeyAccumulator* keys,
                                        PropertyFilter filter) {
   if (HasFastProperties()) {
     int real_size = map()->NumberOfOwnDescriptors();
     Handle<DescriptorArray> descs(map()->instance_descriptors());
     for (int i = 0; i < real_size; i++) {
       PropertyDetails details = descs->GetDetails(i);
       if ((details.attributes() & filter) != 0) continue;
       if (filter & ONLY_ALL_CAN_READ) {
         if (details.kind() != kAccessor) continue;
@@ skipping 20 matching lines @@
         IsJSArray()
             ? static_cast<uint32_t>(
                   Smi::cast(JSArray::cast(this)->length())->value())
             : static_cast<uint32_t>(FixedArrayBase::cast(elements())->length());
     if (length == 0) return 0;
   }
   // Compute the number of enumerable elements.
   return GetOwnElementKeys(NULL, filter);
 }
 
-
 void JSObject::CollectOwnElementKeys(Handle<JSObject> object,
                                      KeyAccumulator* keys,
                                      PropertyFilter filter) {
   if (filter & SKIP_STRINGS) return;
   ElementsAccessor* accessor = object->GetElementsAccessor();
   accessor->CollectElementIndices(object, keys, kMaxUInt32, filter, 0);
 }
 
 
 int JSObject::GetOwnElementKeys(FixedArray* storage, PropertyFilter filter) {
@@ skipping 1979 matching lines @@
     if ((attr & filter) != 0) continue;
     storage->set(index++, k);
   }
   if (sort_mode == Dictionary::SORTED) {
     storage->SortPairs(storage, index);
   }
   DCHECK(storage->length() >= index);
   return index - start_index;
 }
 
-
 template <typename Derived, typename Shape, typename Key>
 void Dictionary<Derived, Shape, Key>::CollectKeysTo(
     Handle<Dictionary<Derived, Shape, Key> > dictionary, KeyAccumulator* keys,
     PropertyFilter filter) {
   int capacity = dictionary->Capacity();
   Handle<FixedArray> array =
       keys->isolate()->factory()->NewFixedArray(dictionary->NumberOfElements());
   int array_size = 0;
 
   {
@@ skipping 1266 matching lines @@
   if (cell->value() != *new_value) {
     cell->set_value(*new_value);
     Isolate* isolate = cell->GetIsolate();
     cell->dependent_code()->DeoptimizeDependentCodeGroup(
         isolate, DependentCode::kPropertyCellChangedGroup);
   }
 }
 
 }  // namespace internal
 }  // namespace v8