[flags] adding --trace_for_in_enumerate

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 26 matching lines @@
   // |string_properties_| and |symbol_properties_| set.
   Handle<FixedArray> result = isolate_->factory()->NewFixedArray(length_);
   int insertion_index = 0;
   int string_properties_index = 0;
   int symbol_properties_index = 0;
   // String and Symbol lengths always come in pairs:
   size_t max_level = level_lengths_.size() / 2;
   for (size_t level = 0; level < max_level; level++) {
     int num_string_properties = level_lengths_[level * 2];
     int num_symbol_properties = level_lengths_[level * 2 + 1];
+    int num_elements = 0;
     if (num_string_properties < 0) {
       // If the |num_string_properties| is negative, the current level contains
       // properties from a proxy, hence we skip the integer keys in |elements_|
       // since proxies define the complete ordering.
       num_string_properties = -num_string_properties;
     } else if (level < elements_.size()) {
       // Add the element indices for this prototype level.
       std::vector<uint32_t>* elements = elements_[level];
-      int num_elements = static_cast<int>(elements->size());
+      num_elements = static_cast<int>(elements->size());
       for (int i = 0; i < num_elements; i++) {
         Handle<Object> key;
         if (convert == KEEP_NUMBERS) {
           key = isolate_->factory()->NewNumberFromUint(elements->at(i));
         } else {
           key = isolate_->factory()->Uint32ToString(elements->at(i));
         }
         result->set(insertion_index, *key);
         insertion_index++;
       }
     }
     // Add the string property keys for this prototype level.
     for (int i = 0; i < num_string_properties; i++) {
       Object* key = string_properties_->KeyAt(string_properties_index);
       result->set(insertion_index, key);
       insertion_index++;
       string_properties_index++;
     }
     // Add the symbol property keys for this prototype level.
     for (int i = 0; i < num_symbol_properties; i++) {
       Object* key = symbol_properties_->KeyAt(symbol_properties_index);
       result->set(insertion_index, key);
       insertion_index++;
       symbol_properties_index++;
     }
+    if (FLAG_trace_for_in_enumerate) {
+      PrintF("| strings=%d symbols=%d elements=%i ", num_string_properties,
+             num_symbol_properties, num_elements);
+    }
+  }
+  if (FLAG_trace_for_in_enumerate) {
+    PrintF("|| prototypes=%zu ||\n", max_level);
   }
 
   DCHECK_EQ(insertion_index, length_);
   return result;
 }
 
 namespace {
 
 bool AccumulatorHasKey(std::vector<uint32_t>* sub_elements, uint32_t key) {
   return std::binary_search(sub_elements->begin(), sub_elements->end(), key);
@@ skipping 260 matching lines @@
       receiver_->map()->EnumLength() != kInvalidEnumCacheSentinel &&
       !JSObject::cast(*receiver_)->HasEnumerableElements();
 }
 
 namespace {
 Handle<FixedArray> GetOwnKeysWithElements(Isolate* isolate,
                                           Handle<JSObject> object,
                                           GetKeysConversion convert) {
   Handle<FixedArray> keys = JSObject::GetFastEnumPropertyKeys(isolate, object);
   ElementsAccessor* accessor = object->GetElementsAccessor();
-  return accessor->PrependElementIndices(object, keys, convert,
-                                         ONLY_ENUMERABLE);
+  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>();
@@ skipping 27 matching lines @@
 
   Handle<FixedArray> keys;
   DCHECK(receiver_->IsJSObject());
   Handle<JSObject> object = Handle<JSObject>::cast(receiver_);
 
   int enum_length = receiver_->map()->EnumLength();
   if (enum_length == kInvalidEnumCacheSentinel) {
     // 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);
 }
 
 MaybeHandle<FixedArray> FastKeyAccumulator::GetKeysSlow(
     GetKeysConversion convert) {
   return JSReceiver::GetKeys(receiver_, type_, ENUMERABLE_STRINGS);
 }
 
 }  // namespace internal
 }  // namespace v8