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;
+  HValue* size = Add<HConstant>(
+      FixedArray::kHeaderSize + CollectionType::kHashTableStartIndex +
+      kInitialNumBuckets + (kInitialCapacity * CollectionType::kEntrySize));
+  HValue* table =
+      Add<HAllocate>(size, HType::HeapObject(), NOT_TENURED, FIXED_ARRAY_TYPE);

[adamk, 2014/12/08 21:41:14]

One question about HAllocate: do I need to add code here to fill the rest of
this space with undefineds, to mirror what Heap::AllocateFixedArray() does?

[Dmitry Lomov (no reviews), 2014/12/09 12:05:39]

Yes. See HOGB::BuildAllocateFixedTypedArray for inspiration: 
https://code.google.com/p/chromium/codesearch#chromium/src/v8/src/hydrogen.cc...

[adamk, 2014/12/09 19:24:23]

Added a bunch of proper initialization. Now the code's a bit funny, since I have
one "unrolled" loop (using a C++ for loop) and one "proper" loop (using
LoopBuilder). But these loops are 2 and 4 (constant) iterations each. I figure
they should either both be "unrolled" or both use LoopBuilder. Thoughts?

+  Add<HStoreNamedField>(
+      table, HObjectAccess::ForMap(),
+      Add<HConstant>(isolate()->factory()->ordered_hash_table_map()));
+  HValue* not_found = Add<HConstant>(CollectionType::kNotFound);
+  for (int i = 0; i < kInitialNumBuckets; ++i) {
+    Add<HStoreKeyed>(table,
+                     Add<HConstant>(CollectionType::kHashTableStartIndex + i),
+                     not_found, FAST_ELEMENTS);
+  }
+  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());
+  return table;
+}
+
+
+void HOptimizedGraphBuilder::GenerateSetInitialize(CallRuntime* call) {
+  DCHECK(call->arguments()->length() == 1);
+  CHECK_ALIVE(VisitForValue(call->arguments()->at(0)));
+  HValue* receiver = Pop();
+  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();
+  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