Create optimized inline versions of Map and Set initialization

src/hydrogen.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/hydrogen.h"
 
 #include <sstream>
 
 #include "src/v8.h"
 
@@ skipping 12630 matching lines @@
   HValue* receiver = Pop();
   HValue* table = Add<HLoadNamedField>(receiver, static_cast<HValue*>(NULL),
                                        HObjectAccess::ForJSCollectionTable());
   HInstruction* result = New<HLoadNamedField>(
       table, static_cast<HValue*>(NULL),
       HObjectAccess::ForOrderedHashTableNumberOfElements<OrderedHashMap>());
   return ast_context()->ReturnInstruction(result, call->id());
 }
 
 
+template <typename CollectionType>
+HValue* HOptimizedGraphBuilder::BuildAllocateOrderedHashTable() {
+  static const int kInitialCapacity = CollectionType::kMinCapacity;
+  static const int kInitialNumBuckets =
+      kInitialCapacity / CollectionType::kLoadFactor;
+  static const int kInitialFixedArrayLength =
+      CollectionType::kHashTableStartIndex + kInitialNumBuckets +
+      (kInitialCapacity * CollectionType::kEntrySize);
+  static const int kSizeInBytes =
+      FixedArray::kHeaderSize + (kInitialFixedArrayLength * kPointerSize);
+
+  // Allocate the table and add the proper map.
+  HValue* table =
+      Add<HAllocate>(Add<HConstant>(kSizeInBytes), HType::HeapObject(),
+                     NOT_TENURED, FIXED_ARRAY_TYPE);
+  AddStoreMapConstant(table, isolate()->factory()->ordered_hash_table_map());
+
+  // Initialize the FixedArray...
+  HValue* length = Add<HConstant>(kInitialFixedArrayLength);
+  Add<HStoreNamedField>(table, HObjectAccess::ForFixedArrayLength(), length);
+
+  // ...and the OrderedHashTable fields.
+  Add<HStoreNamedField>(
+      table,
+      HObjectAccess::ForOrderedHashTableNumberOfBuckets<CollectionType>(),
+      Add<HConstant>(kInitialNumBuckets));
+  Add<HStoreNamedField>(
+      table,
+      HObjectAccess::ForOrderedHashTableNumberOfElements<CollectionType>(),
+      graph()->GetConstant0());
+  Add<HStoreNamedField>(
+      table, HObjectAccess::ForOrderedHashTableNumberOfDeletedElements<
+                 CollectionType>(),
+      graph()->GetConstant0());
+
+  static const int kDataTableStartIndex =
+      CollectionType::kHashTableStartIndex + kInitialNumBuckets;
+
+  // Fill the buckets with kNotFound.
+  HValue* not_found = Add<HConstant>(CollectionType::kNotFound);
+  for (int i = CollectionType::kHashTableStartIndex; i < kDataTableStartIndex;
+       ++i) {
+    Add<HStoreKeyed>(table, Add<HConstant>(i), not_found, FAST_ELEMENTS);

[Dmitry Lomov (no reviews), 2014/12/09 20:48:51]

This should use HStoreNamedField.

[adamk, 2014/12/09 21:16:59]

What do you have in mind? There's a variety of HObjectAccesses I could add, from
something as simple to ForFixedArrayIndex() to two different methods, like
ForOrderedHashTableBucket() and ForOrderedHashTableDataTableIndex().

[Dmitry Lomov (no reviews), 2014/12/09 21:31:56]

Two different methods sound most semantically clear to me here

+  }
+
+  // Fill the data table with undefined.
+  HValue* undefined = graph()->GetConstantUndefined();
+  for (int i = kDataTableStartIndex; i < kInitialFixedArrayLength; ++i) {
+    Add<HStoreKeyed>(table, Add<HConstant>(i), undefined, FAST_ELEMENTS);

[Dmitry Lomov (no reviews), 2014/12/09 20:48:51]

Ditto.

+  }
+
+  return table;
+}
+
+
+void HOptimizedGraphBuilder::GenerateSetInitialize(CallRuntime* call) {
+  DCHECK(call->arguments()->length() == 1);
+  CHECK_ALIVE(VisitForValue(call->arguments()->at(0)));
+  HValue* receiver = Pop();
+
+  NoObservableSideEffectsScope no_effects(this);
+  HValue* table = BuildAllocateOrderedHashTable<OrderedHashSet>();
+  Add<HStoreNamedField>(receiver, HObjectAccess::ForJSCollectionTable(), table);
+  return ast_context()->ReturnValue(receiver);
+}
+
+
+void HOptimizedGraphBuilder::GenerateMapInitialize(CallRuntime* call) {
+  DCHECK(call->arguments()->length() == 1);
+  CHECK_ALIVE(VisitForValue(call->arguments()->at(0)));
+  HValue* receiver = Pop();
+
+  NoObservableSideEffectsScope no_effects(this);
+  HValue* table = BuildAllocateOrderedHashTable<OrderedHashMap>();
+  Add<HStoreNamedField>(receiver, HObjectAccess::ForJSCollectionTable(), table);
+  return ast_context()->ReturnValue(receiver);
+}
+
+
 void HOptimizedGraphBuilder::GenerateGetCachedArrayIndex(CallRuntime* call) {
   DCHECK(call->arguments()->length() == 1);
   CHECK_ALIVE(VisitForValue(call->arguments()->at(0)));
   HValue* value = Pop();
   HGetCachedArrayIndex* result = New<HGetCachedArrayIndex>(value);
   return ast_context()->ReturnInstruction(result, call->id());
 }
 
 
 void HOptimizedGraphBuilder::GenerateFastOneByteArrayJoin(CallRuntime* call) {
@@ skipping 707 matching lines @@
   if (ShouldProduceTraceOutput()) {
     isolate()->GetHTracer()->TraceHydrogen(name(), graph_);
   }
 
 #ifdef DEBUG
   graph_->Verify(false);  // No full verify.
 #endif
 }
 
 } }  // namespace v8::internal