Optimize Map/Set.prototype.forEach

src/objects.cc

Index: src/objects.cc
diff --git a/src/objects.cc b/src/objects.cc
index 274749d568393b95300ba9a666a57e3b4f32c08b..49933bb2605006bb7697947054b86161dd05a73d 100644
--- a/src/objects.cc
+++ b/src/objects.cc
@@ -16386,30 +16386,12 @@ Handle<OrderedHashMap> OrderedHashMap::Put(Handle<OrderedHashMap> table,
 template<class Derived, class TableType>
 Handle<JSObject> OrderedHashTableIterator<Derived, TableType>::Next(
     Handle<Derived> iterator) {
-  Isolate* isolate = iterator->GetIsolate();
-  Factory* factory = isolate->factory();
-
-  Handle<Object> maybe_table(iterator->table(), isolate);
-  if (!maybe_table->IsUndefined()) {
-    iterator->Transition();
-
-    Handle<TableType> table(TableType::cast(iterator->table()), isolate);
-    int index = Smi::cast(iterator->index())->value();
-    int used_capacity = table->UsedCapacity();
-
-    while (index < used_capacity && table->KeyAt(index)->IsTheHole()) {
-      index++;
-    }
-
-    if (index < used_capacity) {
-      int entry_index = table->EntryToIndex(index);
-      Handle<Object> value =
-          Derived::ValueForKind(iterator, entry_index);
-      iterator->set_index(Smi::FromInt(index + 1));
-      return factory->NewIteratorResultObject(value, false);
-    }
+  Factory* factory = iterator->GetIsolate()->factory();
 
-    iterator->set_table(iterator->GetHeap()->undefined_value());
+  if (HasMore(iterator)) {
+    Handle<Object> value = Derived::CurrentIteratorResultValue(iterator);
+    MoveNext(iterator);
+    return factory->NewIteratorResultObject(value, false);
   }
 
   return factory->NewIteratorResultObject(factory->undefined_value(), true);
@@ -16450,10 +16432,52 @@ void OrderedHashTableIterator<Derived, TableType>::Transition() {
 }
 
 
+template<class Derived, class TableType>
+bool OrderedHashTableIterator<Derived, TableType>::HasMore(
+    Handle<Derived> iterator) {
+  Isolate* isolate = iterator->GetIsolate();
+
+  if (iterator->table()->IsUndefined()) {
+    return false;
+  }
+
+  iterator->Transition();
+
+  Handle<TableType> table(TableType::cast(iterator->table()), isolate);
+  int index = Smi::cast(iterator->index())->value();
+  int used_capacity = table->UsedCapacity();
+
+  while (index < used_capacity && table->KeyAt(index)->IsTheHole()) {
+    index++;
+  }
+
+  iterator->set_index(Smi::FromInt(index));
+
+  if (index < used_capacity) {
+    return true;
+  }
+
+  iterator->set_table(iterator->GetHeap()->undefined_value());
+  return false;
+}
+
+
 template Handle<JSObject>
 OrderedHashTableIterator<JSSetIterator, OrderedHashSet>::Next(
     Handle<JSSetIterator> iterator);
 
+template bool
+OrderedHashTableIterator<JSSetIterator, OrderedHashSet>::HasMore(
+    Handle<JSSetIterator> iterator);
+
+template void
+OrderedHashTableIterator<JSSetIterator, OrderedHashSet>::MoveNext(
+    Handle<JSSetIterator> iterator);
+
+template Handle<Object>
+OrderedHashTableIterator<JSSetIterator, OrderedHashSet>::CurrentKey(
+    Handle<JSSetIterator> iterator);
+
 template void
 OrderedHashTableIterator<JSSetIterator, OrderedHashSet>::Transition();
 
@@ -16462,63 +16486,64 @@ template Handle<JSObject>
 OrderedHashTableIterator<JSMapIterator, OrderedHashMap>::Next(
     Handle<JSMapIterator> iterator);
 
+template bool
+OrderedHashTableIterator<JSMapIterator, OrderedHashMap>::HasMore(
+    Handle<JSMapIterator> iterator);
+
 template void
-OrderedHashTableIterator<JSMapIterator, OrderedHashMap>::Transition();
+OrderedHashTableIterator<JSMapIterator, OrderedHashMap>::MoveNext(
+    Handle<JSMapIterator> iterator);
 
+template Handle<Object>
+OrderedHashTableIterator<JSMapIterator, OrderedHashMap>::CurrentKey(
+    Handle<JSMapIterator> iterator);
 
-Handle<Object> JSSetIterator::ValueForKind(
-    Handle<JSSetIterator> iterator, int entry_index) {
-  int kind = iterator->kind()->value();
-  // Set.prototype only has values and entries.
-  ASSERT(kind == kKindValues || kind == kKindEntries);
+template void
+OrderedHashTableIterator<JSMapIterator, OrderedHashMap>::Transition();
 
-  Isolate* isolate = iterator->GetIsolate();
-  Factory* factory = isolate->factory();
 
-  Handle<OrderedHashSet> table(
-      OrderedHashSet::cast(iterator->table()), isolate);
-  Handle<Object> value = Handle<Object>(table->get(entry_index), isolate);
+Handle<Object> JSSetIterator::CurrentIteratorResultValue(
+    Handle<JSSetIterator> iterator) {
+  int kind = Smi::cast(iterator->kind())->value();
+  Handle<Object> value = CurrentKey(iterator);
 
   if (kind == kKindEntries) {
+    Factory* factory = iterator->GetIsolate()->factory();
     Handle<FixedArray> array = factory->NewFixedArray(2);
     array->set(0, *value);
     array->set(1, *value);
     return factory->NewJSArrayWithElements(array);
   }
 
+  // Set.prototype only has values and entries.
+  ASSERT(kind == kKindValues);
+
   return value;
 }
 
 
-Handle<Object> JSMapIterator::ValueForKind(
-    Handle<JSMapIterator> iterator, int entry_index) {
-  int kind = iterator->kind()->value();
-  ASSERT(kind == kKindKeys || kind == kKindValues || kind == kKindEntries);
-
-  Isolate* isolate = iterator->GetIsolate();
-  Factory* factory = isolate->factory();
-
-  Handle<OrderedHashMap> table(
-      OrderedHashMap::cast(iterator->table()), isolate);
+Handle<Object> JSMapIterator::CurrentIteratorResultValue(
+    Handle<JSMapIterator> iterator) {
+  Factory* factory = iterator->GetIsolate()->factory();
 
+  int kind = Smi::cast(iterator->kind())->value();
   switch (kind) {
     case kKindKeys:
-      return Handle<Object>(table->get(entry_index), isolate);
+      return CurrentKey(iterator);
 
     case kKindValues:
-      return Handle<Object>(table->get(entry_index + 1), isolate);
+      return CurrentValue(iterator);
 
     case kKindEntries: {
-      Handle<Object> key(table->get(entry_index), isolate);
-      Handle<Object> value(table->get(entry_index + 1), isolate);
       Handle<FixedArray> array = factory->NewFixedArray(2);
-      array->set(0, *key);
-      array->set(1, *value);
+      array->set(0, *CurrentKey(iterator));
+      array->set(1, *CurrentValue(iterator));
       return factory->NewJSArrayWithElements(array);
     }
   }
 
   UNREACHABLE();
+
   return factory->undefined_value();
 }