[contexts] Place the initial JSArray maps on the native context directly.

src/compiler/js-typed-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/compilation-dependencies.h"
 #include "src/compiler/access-builder.h"
 #include "src/compiler/js-graph.h"
 #include "src/compiler/js-typed-lowering.h"
 #include "src/compiler/linkage.h"
@@ skipping 1542 matching lines @@
   }
 
   return NoChange();
 }
 
 
 Reduction JSTypedLowering::ReduceNewArray(Node* node, Node* length,
                                           int capacity,
                                           Handle<AllocationSite> site) {
   DCHECK_EQ(IrOpcode::kJSCreateArray, node->opcode());
-  Node* target = NodeProperties::GetValueInput(node, 0);
-  Type* target_type = NodeProperties::GetType(target);
   Node* context = NodeProperties::GetContextInput(node);
   Node* effect = NodeProperties::GetEffectInput(node);
   Node* control = NodeProperties::GetControlInput(node);
 
   // Extract transition and tenuring feedback from the {site} and add
   // appropriate code dependencies on the {site} if deoptimization is
   // enabled.
   PretenureFlag pretenure = site->GetPretenureMode();
   ElementsKind elements_kind = site->GetElementsKind();
+  DCHECK(IsFastElementsKind(elements_kind));
   if (flags() & kDeoptimizationEnabled) {
     dependencies()->AssumeTenuringDecision(site);
     dependencies()->AssumeTransitionStable(site);
   }
 
   // Retrieve the initial map for the array from the appropriate native context.
-  Node* js_array_map;
-  if (target_type->IsConstant()) {
-    Handle<JSFunction> target_function =
-        Handle<JSFunction>::cast(target_type->AsConstant()->Value());
-    Handle<FixedArray> js_array_maps(
-        FixedArray::cast(target_function->native_context()->js_array_maps()),
-        isolate());
-    js_array_map = jsgraph()->Constant(
-        handle(js_array_maps->get(elements_kind), isolate()));
-  } else {
-    Node* native_context = effect = graph()->NewNode(
-        javascript()->LoadContext(0, Context::NATIVE_CONTEXT_INDEX, true),
-        context, context, effect);
-    Node* js_array_maps = effect = graph()->NewNode(
-        javascript()->LoadContext(0, Context::JS_ARRAY_MAPS_INDEX, true),
-        native_context, native_context, effect);
-    js_array_map = effect =
-        graph()->NewNode(simplified()->LoadField(
-                             AccessBuilder::ForFixedArraySlot(elements_kind)),
-                         js_array_maps, effect, control);
-  }
+  Node* native_context = effect = graph()->NewNode(
+      javascript()->LoadContext(0, Context::NATIVE_CONTEXT_INDEX, true),
+      context, context, effect);
+  Node* js_array_map = effect = graph()->NewNode(
+      javascript()->LoadContext(0, Context::ArrayMapIndex(elements_kind), true),
+      native_context, native_context, effect);
 
   // Setup elements and properties.
   Node* elements;
   if (capacity == 0) {
     elements = jsgraph()->EmptyFixedArrayConstant();
   } else {
     elements = effect =
         AllocateElements(effect, control, elements_kind, capacity, pretenure);
   }
   Node* properties = jsgraph()->EmptyFixedArrayConstant();
@@ skipping 1078 matching lines @@
 }
 
 
 CompilationDependencies* JSTypedLowering::dependencies() const {
   return dependencies_;
 }
 
 }  // namespace compiler
 }  // namespace internal
 }  // namespace v8