[turbofan] Lower monomorphic loads during graph building.

src/compiler/js-type-hint-lowering.cc

 // Copyright 2017 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/compiler/js-type-hint-lowering.h"
 
+#include "src/compiler/access-info.h"
 #include "src/compiler/js-graph.h"
 #include "src/compiler/operator-properties.h"
+#include "src/compiler/property-access-builder.h"
 #include "src/compiler/simplified-operator.h"
 #include "src/feedback-vector.h"
 #include "src/type-hints.h"
 
 namespace v8 {
 namespace internal {
 namespace compiler {
 
 namespace {
 
@@ skipping 170 matching lines @@
   const Operator* op_;
   Node* left_;
   Node* right_;
   Node* effect_;
   Node* control_;
   FeedbackSlot slot_;
 };
 
 JSTypeHintLowering::JSTypeHintLowering(JSGraph* jsgraph,
                                        Handle<FeedbackVector> feedback_vector,
+                                       Handle<Context> native_context,
+                                       CompilationDependencies* dependencies,
                                        Flags flags)
-    : jsgraph_(jsgraph), flags_(flags), feedback_vector_(feedback_vector) {}
+    : jsgraph_(jsgraph),
+      flags_(flags),
+      feedback_vector_(feedback_vector),
+      native_context_(native_context),
+      dependencies_(dependencies) {}
+
+Graph* JSTypeHintLowering::graph() const { return jsgraph_->graph(); }
 
 Reduction JSTypeHintLowering::ReduceBinaryOperation(const Operator* op,
                                                     Node* left, Node* right,
                                                     Node* effect, Node* control,
                                                     FeedbackSlot slot) const {
   switch (op->opcode()) {
     case IrOpcode::kJSStrictEqual:
       break;
     case IrOpcode::kJSEqual:
     case IrOpcode::kJSLessThan:
@@ skipping 56 matching lines @@
         jsgraph()->simplified()->CheckNonEmptyString(), input, effect, control);
     return Reduction(node);
   } else if (hint == BinaryOperationHint::kString) {
     Node* node = jsgraph()->graph()->NewNode(
         jsgraph()->simplified()->CheckString(), input, effect, control);
     return Reduction(node);
   }
   return Reduction();
 }
 
-Reduction JSTypeHintLowering::ReduceLoadNamedOperation(
-    const Operator* op, Node* obj, Node* effect, Node* control,
+JSTypeHintLowering::LoweringResult JSTypeHintLowering::ReduceLoadNamedOperation(
+    const Operator* op, Node* receiver, Node* effect, Node* control,
     FeedbackSlot slot) const {
   DCHECK_EQ(IrOpcode::kJSLoadNamed, op->opcode());
   DCHECK(!slot.IsInvalid());
   LoadICNexus nexus(feedback_vector(), slot);
   if (Node* node = TryBuildSoftDeopt(
           nexus, effect, control,
           DeoptimizeReason::kInsufficientTypeFeedbackForGenericNamedAccess)) {
-    return Reduction(node);
+    return LoweringResult::Exit(node);
   }
-  return Reduction();
+
+  // Try to extract maps from the feedback vector. Give up if the IC
+  // is megamorphic or unitialized.
+  MapHandles receiver_maps;
+  if (nexus.ExtractMaps(&receiver_maps) == 0) {
+    return LoweringResult::NoChange();
+  }
+
+  // Extract information about accesses from the maps.
+  NamedAccess const& p = NamedAccessOf(op);
+  AccessInfoFactory access_info_factory(dependencies(), native_context(),
+                                        graph()->zone());
+  // TODO(jarin) Use a temporary zone here.
+  ZoneVector<PropertyAccessInfo> access_infos(graph()->zone());
+  if (!access_info_factory.ComputePropertyAccessInfos(
+          receiver_maps, p.name(), AccessMode::kLoad, &access_infos)) {
+    return LoweringResult::NoChange();
+  }
+
+  // Bail out if not monomorphic.
+  if (access_infos.size() != 1) return LoweringResult::NoChange();
+
+  // We only lower data fields and data constants.
+  PropertyAccessInfo const& access_info = access_infos[0];
+  if (!access_info.IsDataField() && !access_info.IsDataConstant()) {
+    return LoweringResult::NoChange();
+  }
+
+  PropertyAccessBuilder access_builder(jsgraph(), dependencies());
+  if (!access_builder.TryBuildStringCheck(access_info.receiver_maps(),
+                                          &receiver, &effect, control) &&
+      !access_builder.TryBuildNumberCheck(access_info.receiver_maps(),
+                                          &receiver, &effect, control)) {
+    receiver = access_builder.BuildCheckHeapObject(receiver, &effect, control);
+    access_builder.BuildCheckMaps(receiver, &effect, control,
+                                  access_info.receiver_maps());
+  }
+
+  Handle<JSObject> holder;
+  if (access_info.holder().ToHandle(&holder)) {
+    access_builder.AssumePrototypesStable(native_context(),
+                                          access_info.receiver_maps(), holder);
+  }
+
+  Node* value = nullptr;
+  if (access_info.IsDataConstant()) {
+    value = jsgraph()->Constant(access_info.constant());
+  } else {
+    DCHECK(access_info.IsDataField());
+    value = access_builder.BuildLoadDataField(p.name(), access_info, receiver,
+                                              &effect, &control);
+  }
+  return LoweringResult::SideEffectFree(value, effect, control);
 }
 
 Reduction JSTypeHintLowering::ReduceLoadKeyedOperation(
     const Operator* op, Node* obj, Node* key, Node* effect, Node* control,
     FeedbackSlot slot) const {
   DCHECK_EQ(IrOpcode::kJSLoadProperty, op->opcode());
   DCHECK(!slot.IsInvalid());
   KeyedLoadICNexus nexus(feedback_vector(), slot);
   if (Node* node = TryBuildSoftDeopt(
           nexus, effect, control,
@@ skipping 42 matching lines @@
     Node* frame_state = NodeProperties::FindFrameStateBefore(deoptimize);
     deoptimize->ReplaceInput(0, frame_state);
     return deoptimize;
   }
   return nullptr;
 }
 
 }  // namespace compiler
 }  // namespace internal
 }  // namespace v8