[turbofan] Initial support for Array constructor specialization.

src/compiler/js-generic-lowering.cc

 // Copyright 2014 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-factory.h"
 #include "src/code-stubs.h"
 #include "src/compiler/common-operator.h"
 #include "src/compiler/js-generic-lowering.h"
 #include "src/compiler/js-graph.h"
 #include "src/compiler/machine-operator.h"
@@ skipping 411 matching lines @@
                             graph()->start()));
   }
   node->ReplaceInput(2, NodeProperties::GetValueInput(node, 1));
   node->ReplaceInput(1, jsgraph()->Int32Constant(Context::SlotOffset(
                             static_cast<int>(access.index()))));
   NodeProperties::ChangeOp(node, machine()->Store(StoreRepresentation(
                                      kMachAnyTagged, kFullWriteBarrier)));
 }
 
 
+void JSGenericLowering::LowerJSLoadNativeContext(Node* node) {
+  node->ReplaceInput(
+      1, jsgraph()->IntPtrConstant(JSGlobalObject::kNativeContextOffset -
+                                   kHeapObjectTag));
+  node->AppendInput(zone(), graph()->start());
+  NodeProperties::ChangeOp(node, machine()->Load(kMachAnyTagged));
+}
+
+
 void JSGenericLowering::LowerJSLoadDynamic(Node* node) {
   const DynamicAccess& access = DynamicAccessOf(node->op());
   Runtime::FunctionId function_id =
       (access.typeof_mode() == NOT_INSIDE_TYPEOF)
           ? Runtime::kLoadLookupSlot
           : Runtime::kLoadLookupSlotNoReferenceError;
   Node* projection = graph()->NewNode(common()->Projection(0), node);
   NodeProperties::ReplaceUses(node, projection, node, node, node);
   node->RemoveInput(NodeProperties::FirstValueIndex(node));
   node->InsertInput(zone(), 1, jsgraph()->Constant(access.name()));
@@ skipping 16 matching lines @@
     case CreateArgumentsParameters::kUnmappedArguments:
       ReplaceWithRuntimeCall(node, Runtime::kNewStrictArguments_Generic);
       break;
     case CreateArgumentsParameters::kRestArray:
       UNIMPLEMENTED();
       break;
   }
 }
 
 
+void JSGenericLowering::LowerJSCreateArray(Node* node) {
+  CreateArrayParameters const& p = CreateArrayParametersOf(node->op());
+  int const arity = static_cast<int>(p.arity());
+  Node* new_target = node->InputAt(1);
+  // TODO(turbofan): We embed the AllocationSite from the Operator at this
+  // point, which we should not do once we want to both consume the feedback
+  // but at the same time shared the optimized code across native contexts,
+  // as the AllocationSite is associated with a single native context (it's
+  // stored in the type feedback vector after all). Once we go for cross
+  // context code generation, we should somehow find a way to get to the
+  // allocation site for the actual native context at runtime.
+  Node* type_info = p.site().is_null() ? jsgraph()->UndefinedConstant()
+                                       : jsgraph()->HeapConstant(p.site());
+  node->RemoveInput(1);
+  node->InsertInput(zone(), 1 + arity, new_target);
+  node->InsertInput(zone(), 2 + arity, type_info);
+  ReplaceWithRuntimeCall(node, Runtime::kNewArray, arity + 3);
+}
+
+
 void JSGenericLowering::LowerJSCreateClosure(Node* node) {
   CreateClosureParameters p = CreateClosureParametersOf(node->op());
   node->InsertInput(zone(), 0, jsgraph()->HeapConstant(p.shared_info()));
   ReplaceWithRuntimeCall(node, (p.pretenure() == TENURED)
                                    ? Runtime::kNewClosure_Tenured
                                    : Runtime::kNewClosure);
 }
 
 
 void JSGenericLowering::LowerJSCreateLiteralArray(Node* node) {
@@ skipping 25 matching lines @@
 
 
 void JSGenericLowering::LowerJSCreateScriptContext(Node* node) {
   Handle<ScopeInfo> scope_info = OpParameter<Handle<ScopeInfo>>(node);
   node->InsertInput(zone(), 1, jsgraph()->HeapConstant(scope_info));
   ReplaceWithRuntimeCall(node, Runtime::kNewScriptContext);
 }
 
 
 void JSGenericLowering::LowerJSCallConstruct(Node* node) {
+  CallConstructParameters const& p = CallConstructParametersOf(node->op());
+  int const arity = static_cast<int>(p.arity());
   // TODO(bmeurer): Use the Construct builtin here.
-  int arity = OpParameter<int>(node);
   CallConstructStub stub(isolate(), SUPER_CONSTRUCTOR_CALL);
   CallInterfaceDescriptor d = stub.GetCallInterfaceDescriptor();
   CallDescriptor::Flags flags = AdjustFrameStatesForCall(node);
   CallDescriptor* desc =
       Linkage::GetStubCallDescriptor(isolate(), zone(), d, arity - 1, flags);
   Node* stub_code = jsgraph()->HeapConstant(stub.GetCode());
   Node* target = NodeProperties::GetValueInput(node, 0);
   Node* new_target = NodeProperties::GetValueInput(node, arity - 1);
   node->RemoveInput(arity - 1);  // Drop new target.
   node->InsertInput(zone(), 0, stub_code);
@@ skipping 318 matching lines @@
 }
 
 
 MachineOperatorBuilder* JSGenericLowering::machine() const {
   return jsgraph()->machine();
 }
 
 }  // namespace compiler
 }  // namespace internal
 }  // namespace v8