[turbofan] Lower monomorphic loads during graph building.

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

 // 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.
 
 #ifndef V8_COMPILER_JS_TYPE_HINT_LOWERING_H_
 #define V8_COMPILER_JS_TYPE_HINT_LOWERING_H_
 
 #include "src/base/flags.h"
 #include "src/compiler/graph-reducer.h"
 #include "src/deoptimize-reason.h"
 #include "src/handles.h"
 
 namespace v8 {
 namespace internal {
 
 // Forward declarations.
+class CompilationDependencies;
 class FeedbackNexus;
 class FeedbackSlot;
 
 namespace compiler {
 
 // Forward declarations.
 class JSGraph;
 class Node;
 class Operator;
 
@@ skipping 13 matching lines @@
 // effect and carry {Operator::Property} for the entire lowering). Use-sites
 // rely on this invariant, if it ever changes we need to switch the interface
 // away from using the {Reduction} class.
 class JSTypeHintLowering {
  public:
   // Flags that control the mode of operation.
   enum Flag { kNoFlags = 0u, kBailoutOnUninitialized = 1u << 1 };
   typedef base::Flags<Flag> Flags;
 
   JSTypeHintLowering(JSGraph* jsgraph, Handle<FeedbackVector> feedback_vector,
-                     Flags flags);
+                     Handle<Context> native_context,
+                     CompilationDependencies* dependencies, Flags flags);
 
   // Potential reduction of binary (arithmetic, logical, shift and relational
   // comparison) operations.
   Reduction ReduceBinaryOperation(const Operator* op, Node* left, Node* right,
                                   Node* effect, Node* control,
                                   FeedbackSlot slot) const;
 
   // Potential reduction to ToNumber operations
   Reduction ReduceToNumberOperation(Node* value, Node* effect, Node* control,
                                     FeedbackSlot slot) const;
 
   // Potential reduction to ToPrimitiveToString operations
   Reduction ReduceToPrimitiveToStringOperation(Node* value, Node* effect,
                                                Node* control,
                                                FeedbackSlot slot) const;
+  class LoweringResult {
+   public:
+    Node* value() const { return value_; }
+    Node* effect() const { return effect_; }
+    Node* control() const { return control_; }
+
+    bool Changed() const { return kind_ != LoweringResultKind::kNoChange; }
+    bool IsExit() const { return kind_ == LoweringResultKind::kExit; }
+    bool IsSideEffectFree() const {
+      return kind_ == LoweringResultKind::kSideEffectFree;
+    }
+
+    static LoweringResult SideEffectFree(Node* value, Node* effect,
+                                         Node* control) {
+      DCHECK_NOT_NULL(effect);
+      DCHECK_NOT_NULL(control);
+      return LoweringResult(LoweringResultKind::kSideEffectFree, value, effect,
+                            control);
+    }
+
+    static LoweringResult NoChange() {
+      return LoweringResult(LoweringResultKind::kNoChange, nullptr, nullptr,
+                            nullptr);
+    }
+
+    static LoweringResult Exit(Node* control) {
+      return LoweringResult(LoweringResultKind::kExit, nullptr, nullptr,
+                            control);
+    }
+
+   private:
+    enum class LoweringResultKind { kNoChange, kSideEffectFree, kExit };
+
+    LoweringResult(LoweringResultKind kind, Node* value, Node* effect,
+                   Node* control)
+        : kind_(kind), value_(value), effect_(effect), control_(control) {}
+
+    LoweringResultKind kind_;
+    Node* value_;
+    Node* effect_;
+    Node* control_;
+  };
 
   // Potential reduction of property access operations.
-  Reduction ReduceLoadNamedOperation(const Operator* op, Node* obj,
-                                     Node* effect, Node* control,
-                                     FeedbackSlot slot) const;
+  LoweringResult ReduceLoadNamedOperation(const Operator* op, Node* obj,
+                                          Node* effect, Node* control,
+                                          FeedbackSlot slot) const;
   Reduction ReduceLoadKeyedOperation(const Operator* op, Node* obj, Node* key,
                                      Node* effect, Node* control,
                                      FeedbackSlot slot) const;
   Reduction ReduceStoreNamedOperation(const Operator* op, Node* obj, Node* val,
                                       Node* effect, Node* control,
                                       FeedbackSlot slot) const;
   Reduction ReduceStoreKeyedOperation(const Operator* op, Node* obj, Node* key,
                                       Node* val, Node* effect, Node* control,
                                       FeedbackSlot slot) const;
 
  private:
   friend class JSSpeculativeBinopBuilder;
   Node* TryBuildSoftDeopt(FeedbackNexus& nexus, Node* effect, Node* control,
                           DeoptimizeReason reson) const;
 
   JSGraph* jsgraph() const { return jsgraph_; }
   Flags flags() const { return flags_; }
   const Handle<FeedbackVector>& feedback_vector() const {
     return feedback_vector_;
   }
+  Graph* graph() const;
+
+  Handle<Context> native_context() const { return native_context_; }
+  CompilationDependencies* dependencies() const { return dependencies_; }
 
   JSGraph* jsgraph_;
   Flags const flags_;
   Handle<FeedbackVector> feedback_vector_;
 
+  Handle<Context> native_context_;
+  CompilationDependencies* dependencies_;
+
   DISALLOW_COPY_AND_ASSIGN(JSTypeHintLowering);
 };
 
 }  // namespace compiler
 }  // namespace internal
 }  // namespace v8
 
 #endif  // V8_COMPILER_JS_TYPE_HINT_LOWERING_H_