[turbofan] Lower monomorphic loads during graph building.

src/compiler/js-inlining.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/compiler/js-inlining.h"
 
 #include "src/ast/ast.h"
 #include "src/compilation-info.h"
 #include "src/compiler.h"
 #include "src/compiler/all-nodes.h"
@@ skipping 356 matching lines @@
     Handle<JSFunction> function = Handle<JSFunction>::cast(match.Value());
 
     // Disallow cross native-context inlining for now. This means that all parts
     // of the resulting code will operate on the same global object. This also
     // prevents cross context leaks, where we could inline functions from a
     // different context and hold on to that context (and closure) from the code
     // object.
     // TODO(turbofan): We might want to revisit this restriction later when we
     // have a need for this, and we know how to model different native contexts
     // in the same graph in a compositional way.
-    if (function->context()->native_context() !=
-        info_->context()->native_context()) {
+    if (function->context()->native_context() != *native_context()) {
       return false;
     }
 
     shared_info_out = handle(function->shared());
     return true;
   }
 
   // This reducer can also handle calls where the target is statically known to
   // be the result of a closure instantiation operation, as follows:
   //  - JSCall(JSCreateClosure[shared](context), receiver, args...)
@@ skipping 58 matching lines @@
 
   // Must succeed.
   UNREACHABLE();
 }
 
 Reduction JSInliner::Reduce(Node* node) {
   if (!IrOpcode::IsInlineeOpcode(node->opcode())) return NoChange();
   return ReduceJSCall(node);
 }
 
+Handle<Context> JSInliner::native_context() const {
+  return handle(info_->context()->native_context());
+}
+
 Reduction JSInliner::ReduceJSCall(Node* node) {
   DCHECK(IrOpcode::IsInlineeOpcode(node->opcode()));
   Handle<SharedFunctionInfo> shared_info;
   JSCallAccessor call(node);
 
   // Determine the call target.
   if (!DetermineCallTarget(node, shared_info)) return NoChange();
 
   // Inlining is only supported in the bytecode pipeline.
   if (!info_->is_optimizing_from_bytecode()) {
@@ skipping 107 matching lines @@
   Node* end;
   {
     // Run the BytecodeGraphBuilder to create the subgraph.
     Graph::SubgraphScope scope(graph());
     JSTypeHintLowering::Flags flags = JSTypeHintLowering::kNoFlags;
     if (info_->is_bailout_on_uninitialized()) {
       flags |= JSTypeHintLowering::kBailoutOnUninitialized;
     }
     BytecodeGraphBuilder graph_builder(
         parse_info.zone(), shared_info, feedback_vector, BailoutId::None(),
-        jsgraph(), call.frequency(), source_positions_, inlining_id, flags);
+        jsgraph(), call.frequency(), source_positions_, native_context(),
+        info_->dependencies(), inlining_id, flags);
     graph_builder.CreateGraph(false);
 
     // Extract the inlinee start/end nodes.
     start = graph()->start();
     end = graph()->end();
   }
 
   // If we are inlining into a surrounding exception handler, we collect all
   // potentially throwing nodes within the inlinee that are not handled locally
   // by the inlinee itself. They are later wired into the surrounding handler.
@@ skipping 195 matching lines @@
 
 CommonOperatorBuilder* JSInliner::common() const { return jsgraph()->common(); }
 
 SimplifiedOperatorBuilder* JSInliner::simplified() const {
   return jsgraph()->simplified();
 }
 
 }  // namespace compiler
 }  // namespace internal
 }  // namespace v8