[keys] adding fast-path for dict-mode objects with own keys only

src/keys.cc

 // Copyright 2013 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/keys.h"
 
 #include "src/elements.h"
 #include "src/factory.h"
 #include "src/isolate-inl.h"
 #include "src/objects-inl.h"
@@ skipping 345 matching lines @@
     USE(first_non_empty_prototype);
     return;
   }
   DCHECK(has_empty_prototype_);
   is_receiver_simple_enum_ =
       receiver_->map()->EnumLength() != kInvalidEnumCacheSentinel &&
       !JSObject::cast(*receiver_)->HasEnumerableElements();
 }
 
 namespace {
+
+template <bool fast_properties>
 Handle<FixedArray> GetOwnKeysWithElements(Isolate* isolate,
                                           Handle<JSObject> object,
                                           GetKeysConversion convert) {
-  Handle<FixedArray> keys = JSObject::GetFastEnumPropertyKeys(isolate, object);
+  Handle<FixedArray> keys;
   ElementsAccessor* accessor = object->GetElementsAccessor();
+  if (fast_properties) {
+    keys = JSObject::GetFastEnumPropertyKeys(isolate, object);
+  } else {
+    // TODO(cbruni): preallocate big enough array to also hold elements.
+    keys = JSObject::GetEnumPropertyKeys(object);
+  }
   Handle<FixedArray> result =
       accessor->PrependElementIndices(object, keys, convert, ONLY_ENUMERABLE);
 
   if (FLAG_trace_for_in_enumerate) {
     PrintF("| strings=%d symbols=0 elements=%u || prototypes>=1 ||\n",
            keys->length(), result->length() - keys->length());
   }
   return result;
 }
 
 MaybeHandle<FixedArray> GetOwnKeysWithUninitializedEnumCache(
     Isolate* isolate, Handle<JSObject> object) {
   // Uninitalized enum cache
   Map* map = object->map();
   if (object->elements() != isolate->heap()->empty_fixed_array() ||
       object->elements() != isolate->heap()->empty_slow_element_dictionary()) {
     // Assume that there are elements.
     return MaybeHandle<FixedArray>();
   }
   int number_of_own_descriptors = map->NumberOfOwnDescriptors();
   if (number_of_own_descriptors == 0) {
     map->SetEnumLength(0);
     return isolate->factory()->empty_fixed_array();
   }
   // We have no elements but possibly enumerable property keys, hence we can
   // directly initialize the enum cache.
   return JSObject::GetFastEnumPropertyKeys(isolate, object);
 }
 
+bool OnlyHasSimpleProperties(Map* map) {
+  return !IsStringWrapperElementsKind(map->elements_kind()) &&

[Toon Verwaest, 2016/03/30 06:51:17]

You can just check for LAST_CUSTOM_ELEMENTS_TYPE, that includes string wrapper
and hidden prototypes.

+         map->instance_type() > LAST_SPECIAL_RECEIVER_TYPE &&
+         !map->has_hidden_prototype();
+}
+
 }  // namespace
 
 MaybeHandle<FixedArray> FastKeyAccumulator::GetKeys(GetKeysConversion convert) {
   Handle<FixedArray> keys;
   if (GetKeysFast(convert).ToHandle(&keys)) {
     return keys;
   }
   return GetKeysSlow(convert);
 }
 
 MaybeHandle<FixedArray> FastKeyAccumulator::GetKeysFast(
     GetKeysConversion convert) {
   bool own_only = has_empty_prototype_ || type_ == OWN_ONLY;
-  if (!own_only || !receiver_->map()->OnlyHasSimpleProperties()) {
+  Map* map = receiver_->map();
+  if (!own_only || !OnlyHasSimpleProperties(map)) {
     return MaybeHandle<FixedArray>();
   }
 
-  Handle<FixedArray> keys;
+  // From this point on we are certiain to only collect own keys.
   DCHECK(receiver_->IsJSObject());
   Handle<JSObject> object = Handle<JSObject>::cast(receiver_);
 
+  // Do not try to use the enum-cache for dict-mode objects.
+  if (map->is_dictionary_map()) {
+    return GetOwnKeysWithElements<false>(isolate_, object, convert);
+  }
   int enum_length = receiver_->map()->EnumLength();
   if (enum_length == kInvalidEnumCacheSentinel) {
+    Handle<FixedArray> keys;
     // Try initializing the enum cache and return own properties.
     if (GetOwnKeysWithUninitializedEnumCache(isolate_, object)
             .ToHandle(&keys)) {
       if (FLAG_trace_for_in_enumerate) {
         PrintF("| strings=%d symbols=0 elements=0 || prototypes>=1 ||\n",
                keys->length());
       }
-
       is_receiver_simple_enum_ =
           object->map()->EnumLength() != kInvalidEnumCacheSentinel;
       return keys;
     }
   }
   // The properties-only case failed because there were probably elements on the
   // receiver.
-  return GetOwnKeysWithElements(isolate_, object, convert);
+  return GetOwnKeysWithElements<true>(isolate_, object, convert);
 }
 
 MaybeHandle<FixedArray> FastKeyAccumulator::GetKeysSlow(
     GetKeysConversion convert) {
   return JSReceiver::GetKeys(receiver_, type_, ENUMERABLE_STRINGS, KEEP_NUMBERS,
                              filter_proxy_keys_);
 }
 
 }  // namespace internal
 }  // namespace v8