Optimize Map/Set.prototype.forEach

src/objects.cc

Index: src/objects.cc
diff --git a/src/objects.cc b/src/objects.cc
index f852f4d7c8197df97e26d6f041056c8a5af408e5..8a98ca73bf288f029ba25b5ee732f657a11a6a3f 100644
--- a/src/objects.cc
+++ b/src/objects.cc
@@ -16241,30 +16241,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++;
-    }
+  Factory* factory = iterator->GetIsolate()->factory();
 
-    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);
-    }
-
-    iterator->set_table(iterator->GetHeap()->undefined_value());
+  if (iterator->HasMore()) {
+    Handle<Object> value = Derived::CurrentIteratorResultValue(iterator);
+    iterator->MoveNext();
+    return factory->NewIteratorResultObject(value, false);
   }
 
   return factory->NewIteratorResultObject(factory->undefined_value(), true);
@@ -16273,13 +16255,13 @@ Handle<JSObject> OrderedHashTableIterator<Derived, TableType>::Next(
 
 template<class Derived, class TableType>
 void OrderedHashTableIterator<Derived, TableType>::Transition() {
-  Isolate* isolate = GetIsolate();
-  Handle<TableType> table(TableType::cast(this->table()), isolate);
+  DisallowHeapAllocation no_allocation;
+  TableType* table = TableType::cast(this->table());
   if (!table->IsObsolete()) return;
 
   int index = Smi::cast(this->index())->value();
   while (table->IsObsolete()) {
-    Handle<TableType> next_table(table->NextTable(), isolate);
+    TableType* next_table = table->NextTable();
 
     if (index > 0) {
       int nod = table->NumberOfDeletedElements();
@@ -16300,8 +16282,32 @@ void OrderedHashTableIterator<Derived, TableType>::Transition() {
     table = next_table;
   }
 
-  set_table(*table);
+  set_table(table);
+  set_index(Smi::FromInt(index));
+}
+
+
+template<class Derived, class TableType>
+bool OrderedHashTableIterator<Derived, TableType>::HasMore() {
+  DisallowHeapAllocation no_allocation;
+  if (this->table()->IsUndefined()) return false;
+
+  Transition();
+
+  TableType* table = TableType::cast(this->table());
+  int index = Smi::cast(this->index())->value();
+  int used_capacity = table->UsedCapacity();
+
+  while (index < used_capacity && table->KeyAt(index)->IsTheHole()) {
+    index++;
+  }
+
   set_index(Smi::FromInt(index));
+
+  if (index < used_capacity) return true;
+
+  set_table(GetHeap()->undefined_value());
+  return false;
 }
 
 
@@ -16309,6 +16315,15 @@ template Handle<JSObject>
 OrderedHashTableIterator<JSSetIterator, OrderedHashSet>::Next(
     Handle<JSSetIterator> iterator);
 
+template bool
+OrderedHashTableIterator<JSSetIterator, OrderedHashSet>::HasMore();
+
+template void
+OrderedHashTableIterator<JSSetIterator, OrderedHashSet>::MoveNext();
+
+template Object*
+OrderedHashTableIterator<JSSetIterator, OrderedHashSet>::CurrentKey();
+
 template void
 OrderedHashTableIterator<JSSetIterator, OrderedHashSet>::Transition();
 
@@ -16317,63 +16332,63 @@ template Handle<JSObject>
 OrderedHashTableIterator<JSMapIterator, OrderedHashMap>::Next(
     Handle<JSMapIterator> iterator);
 
+template bool
+OrderedHashTableIterator<JSMapIterator, OrderedHashMap>::HasMore();
+
 template void
-OrderedHashTableIterator<JSMapIterator, OrderedHashMap>::Transition();
+OrderedHashTableIterator<JSMapIterator, OrderedHashMap>::MoveNext();
+
+template Object*
+OrderedHashTableIterator<JSMapIterator, OrderedHashMap>::CurrentKey();
 
+template void
+OrderedHashTableIterator<JSMapIterator, OrderedHashMap>::Transition();
 
-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);
 
+Handle<Object> JSSetIterator::CurrentIteratorResultValue(
+    Handle<JSSetIterator> iterator) {
   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);
+  int kind = Smi::cast(iterator->kind())->value();
+  Handle<Object> value(iterator->CurrentKey(), isolate);
 
   if (kind == kKindEntries) {
+    Factory* factory = isolate->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);
-
+Handle<Object> JSMapIterator::CurrentIteratorResultValue(
+    Handle<JSMapIterator> iterator) {
   Isolate* isolate = iterator->GetIsolate();
   Factory* factory = isolate->factory();
 
-  Handle<OrderedHashMap> table(
-      OrderedHashMap::cast(iterator->table()), isolate);
-
+  int kind = Smi::cast(iterator->kind())->value();
   switch (kind) {
     case kKindKeys:
-      return Handle<Object>(table->get(entry_index), isolate);
+      return handle(iterator->CurrentKey(), isolate);
 
     case kKindValues:
-      return Handle<Object>(table->get(entry_index + 1), isolate);
+      return handle(iterator->CurrentValue(), isolate);
 
     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, iterator->CurrentKey());
+      array->set(1, iterator->CurrentValue());
       return factory->NewJSArrayWithElements(array);
     }
   }
 
   UNREACHABLE();
+
   return factory->undefined_value();
 }