[Interpreter] Use FastCloneShallowObjectStub in CreateObjectLiteral bytecode.

src/code-stubs.cc

 // Copyright 2012 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/code-stubs.h"
 
 #include <sstream>
 
 #include "src/bootstrapper.h"
 #include "src/code-factory.h"
@@ skipping 3789 matching lines @@
                     &if_keyisinvalid);
   assembler->Bind(&if_keyispositivesmi);
   assembler->TailCallRuntime(Runtime::kLoadElementWithInterceptor, context,
                              receiver, key);
 
   assembler->Bind(&if_keyisinvalid);
   assembler->TailCallRuntime(Runtime::kKeyedLoadIC_Miss, context, receiver, key,
                              slot, vector);
 }
 
-void FastCloneShallowObjectStub::GenerateAssembly(
-    CodeStubAssembler* assembler) const {
-  typedef CodeStubAssembler::Label Label;
+// static
+bool FastCloneShallowObjectStub::IsSupported(ObjectLiteral* expr) {
+  // FastCloneShallowObjectStub doesn't copy elements, and object literals don't
+  // support copy-on-write (COW) elements for now.
+  // TODO(mvstanton): make object literals support COW elements.
+  return expr->fast_elements() && expr->has_shallow_properties() &&
+         expr->properties_count() <= kMaximumClonedProperties;
+}
+
+// static
+int FastCloneShallowObjectStub::PropertiesCount(int literal_length) {

[Michael Starzinger, 2016/04/29 08:37:31]

Non-actionable question just for my understanding: This properties count looks
specific to the fast-clone stub. Is the runtime using the same heuristic for
choosing the initial properties count? If so, is there a plan to eventually
unify these heuristics or will this computation always be specific to the
fast-clone stub?

[Toon Verwaest, 2016/04/29 09:07:10]

Yes, they are the same; and they have to be the same. This is what we discussed
before. We should unify them indeed.

[Michael Starzinger, 2016/04/29 09:51:36]

Acknowledged. Thanks, makes sense. +1 on eventual unification.

[rmcilroy, 2016/04/29 13:53:21]

Ack. Added a TODO towards unification.

+  return literal_length == 0
+             ? JSObject::kInitialGlobalObjectUnusedPropertiesCount
+             : literal_length;
+}
+
+// static
+compiler::Node* FastCloneShallowObjectStub::GenerateFastPath(
+    CodeStubAssembler* assembler, compiler::CodeAssembler::Label* call_runtime,
+    compiler::Node* closure, compiler::Node* literals_index,
+    compiler::Node* properties_count) {
   typedef compiler::Node Node;
-  Label call_runtime(assembler);
-  Node* closure = assembler->Parameter(0);
-  Node* literals_index = assembler->Parameter(1);
+  typedef compiler::CodeAssembler::Label Label;
+  typedef compiler::CodeAssembler::Variable Variable;
 
   Node* undefined = assembler->UndefinedConstant();
   Node* literals_array =
       assembler->LoadObjectField(closure, JSFunction::kLiteralsOffset);
   Node* allocation_site = assembler->LoadFixedArrayElementSmiIndex(
       literals_array, literals_index,
       LiteralsArray::kFirstLiteralIndex * kPointerSize);
   assembler->GotoIf(assembler->WordEqual(allocation_site, undefined),
-                    &call_runtime);
+                    call_runtime);
 
+  // Calculate the object and allocation size based on the properties count.
+  Node* object_size = assembler->IntPtrAdd(
+      assembler->WordShl(properties_count, kPointerSizeLog2),
+      assembler->IntPtrConstant(JSObject::kHeaderSize));
+  Node* allocation_size = object_size;
+  if (FLAG_allocation_site_pretenuring) {
+    allocation_size = assembler->IntPtrAdd(
+        object_size, assembler->IntPtrConstant(AllocationMemento::kSize));
+  }
   Node* boilerplate = assembler->LoadObjectField(
       allocation_site, AllocationSite::kTransitionInfoOffset);
-
-  int length = this->length();
-  if (length == 0) {
-    length = JSObject::kInitialGlobalObjectUnusedPropertiesCount;
-  }
-  int allocation_size = JSObject::kHeaderSize + length * kPointerSize;
-  int object_size = allocation_size;
-  if (FLAG_allocation_site_pretenuring) {
-    allocation_size += AllocationMemento::kSize;
-  }
-
   Node* boilerplate_map = assembler->LoadMap(boilerplate);
   Node* instance_size = assembler->LoadMapInstanceSize(boilerplate_map);
-  Node* size_in_words =
-      assembler->Int32Constant(object_size >> kPointerSizeLog2);
+  Node* size_in_words = assembler->WordShr(object_size, kPointerSizeLog2);
   assembler->GotoUnless(assembler->Word32Equal(instance_size, size_in_words),
-                        &call_runtime);
+                        call_runtime);
 
   Node* copy = assembler->Allocate(allocation_size);
 
-  for (int i = 0; i < object_size; i += kPointerSize) {
+  // Copy boilerplate elements.
+  Variable offset(assembler, MachineType::PointerRepresentation());
+  offset.Bind(assembler->IntPtrConstant(-kHeapObjectTag));
+  Node* end_offset = assembler->IntPtrAdd(object_size, offset.value());
+  Label loop_body(assembler, &offset), loop_check(assembler, &offset);
+  // We should always have an object size greater than zero.
+  assembler->Goto(&loop_body);
+  assembler->Bind(&loop_body);
+  {
     // The Allocate above guarantees that the copy lies in new space. This
     // allows us to skip write barriers. This is necessary since we may also be
     // copying unboxed doubles.
     Node* field =
-        assembler->LoadObjectField(boilerplate, i, MachineType::IntPtr());
-    assembler->StoreObjectFieldNoWriteBarrier(
-        copy, i, field, MachineType::PointerRepresentation());
+        assembler->Load(MachineType::IntPtr(), boilerplate, offset.value());
+    assembler->StoreNoWriteBarrier(MachineType::PointerRepresentation(), copy,
+                                   offset.value(), field);
+    assembler->Goto(&loop_check);
+  }
+  assembler->Bind(&loop_check);
+  {
+    offset.Bind(assembler->IntPtrAdd(offset.value(),
+                                     assembler->IntPtrConstant(kPointerSize)));
+    assembler->GotoUnless(
+        assembler->IntPtrGreaterThanOrEqual(offset.value(), end_offset),
+        &loop_body);
   }
 
   if (FLAG_allocation_site_pretenuring) {
     Node* memento = assembler->InnerAllocate(copy, object_size);
     assembler->StoreObjectFieldNoWriteBarrier(
         memento, HeapObject::kMapOffset,
         assembler->LoadRoot(Heap::kAllocationMementoMapRootIndex));
     assembler->StoreObjectFieldNoWriteBarrier(
         memento, AllocationMemento::kAllocationSiteOffset, allocation_site);
     Node* memento_create_count = assembler->LoadObjectField(
         allocation_site, AllocationSite::kPretenureCreateCountOffset);
     memento_create_count = assembler->SmiAdd(
         memento_create_count, assembler->SmiConstant(Smi::FromInt(1)));
     assembler->StoreObjectFieldNoWriteBarrier(
         allocation_site, AllocationSite::kPretenureCreateCountOffset,
         memento_create_count);
   }
 
   // TODO(verwaest): Allocate and fill in double boxes.
+  return copy;
+}
+
+void FastCloneShallowObjectStub::GenerateAssembly(
+    CodeStubAssembler* assembler) const {
+  typedef CodeStubAssembler::Label Label;
+  typedef compiler::Node Node;
+  Label call_runtime(assembler);
+  Node* closure = assembler->Parameter(0);
+  Node* literals_index = assembler->Parameter(1);
+
+  Node* properties_count =
+      assembler->IntPtrConstant(PropertiesCount(this->length()));
+  Node* copy = GenerateFastPath(assembler, &call_runtime, closure,
+                                literals_index, properties_count);
   assembler->Return(copy);
 
   assembler->Bind(&call_runtime);
   Node* constant_properties = assembler->Parameter(2);
   Node* flags = assembler->Parameter(3);
   Node* context = assembler->Parameter(4);
   assembler->TailCallRuntime(Runtime::kCreateObjectLiteral, context, closure,
                              literals_index, constant_properties, flags);
 }
 
@@ skipping 420 matching lines @@
   if (type->Is(Type::UntaggedPointer())) {
     return Representation::External();
   }
 
   DCHECK(!type->Is(Type::Untagged()));
   return Representation::Tagged();
 }
 
 }  // namespace internal
 }  // namespace v8