[turbofan] Make inlining independent of typing.

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.h"
 #include "src/ast-numbering.h"
-#include "src/compiler/access-builder.h"
 #include "src/compiler/all-nodes.h"
 #include "src/compiler/ast-graph-builder.h"
 #include "src/compiler/common-operator.h"
-#include "src/compiler/graph-visualizer.h"
 #include "src/compiler/js-operator.h"
 #include "src/compiler/node-matchers.h"
 #include "src/compiler/node-properties.h"
 #include "src/compiler/operator-properties.h"
-#include "src/compiler/simplified-operator.h"
-#include "src/compiler/typer.h"
 #include "src/full-codegen.h"
 #include "src/parser.h"
 #include "src/rewriter.h"
 #include "src/scopes.h"
 
 namespace v8 {
 namespace internal {
 namespace compiler {
 
 
@@ skipping 66 matching lines @@
   size_t total_parameters() { return start_->op()->ValueOutputCount(); }
 
   // Counts only formal parameters.
   size_t formal_parameters() {
     DCHECK_GE(total_parameters(), 3u);
     return total_parameters() - 3;
   }
 
   // Inline this graph at {call}, use {jsgraph} and its zone to create
   // any new nodes.
-  Reduction InlineAtCall(JSGraph* jsgraph, Node* call);
+  Reduction InlineAtCall(JSGraph* jsgraph, Node* call, Node* context);
 
   // Ensure that only a single return reaches the end node.
   static void UnifyReturn(JSGraph* jsgraph);
 
  private:
   Node* start_;
   Node* end_;
 };
 
 
@@ skipping 92 matching lines @@
  private:
   Operator const sentinel_op_;
   Node* const sentinel_;
   NodeVector copies_;
   Graph* const source_graph_;
   Graph* const target_graph_;
   Zone* const temp_zone_;
 };
 
 
-Reduction Inlinee::InlineAtCall(JSGraph* jsgraph, Node* call) {
+Reduction Inlinee::InlineAtCall(JSGraph* jsgraph, Node* call, Node* context) {
   // The scheduler is smart enough to place our code; we just ensure {control}
-  // becomes the control input of the start of the inlinee.
+  // becomes the control input of the start of the inlinee, and {effect} becomes
+  // the effect input of the start of the inlinee.
   Node* control = NodeProperties::GetControlInput(call);
-
-  // The inlinee uses the context from the JSFunction object. This will
-  // also be the effect dependency for the inlinee as it produces an effect.
-  SimplifiedOperatorBuilder simplified(jsgraph->zone());
-  Node* context = jsgraph->graph()->NewNode(
-      simplified.LoadField(AccessBuilder::ForJSFunctionContext()),
-      NodeProperties::GetValueInput(call, 0),
-      NodeProperties::GetEffectInput(call), control);
+  Node* effect = NodeProperties::GetEffectInput(call);
 
   // Context is last argument.
   int inlinee_context_index = static_cast<int>(total_parameters()) - 1;
   // {inliner_inputs} counts JSFunction, Receiver, arguments, but not
   // context, effect, control.
   int inliner_inputs = call->op()->ValueInputCount();
   // Iterate over all uses of the start node.
   for (Edge edge : start_->use_edges()) {
     Node* use = edge.from();
     switch (use->opcode()) {
@@ skipping 11 matching lines @@
           // Call has fewer arguments than required, fill with undefined.
           NodeProperties::ReplaceWithValue(use, jsgraph->UndefinedConstant());
         } else {
           // We got too many arguments, discard for now.
           // TODO(sigurds): Fix to treat arguments array correctly.
         }
         break;
       }
       default:
         if (NodeProperties::IsEffectEdge(edge)) {
-          edge.UpdateTo(context);
+          edge.UpdateTo(effect);
         } else if (NodeProperties::IsControlEdge(edge)) {
           edge.UpdateTo(control);
         } else {
           UNREACHABLE();
         }
         break;
     }
   }
 
-  for (Edge edge : call->use_edges()) {
-    if (NodeProperties::IsControlEdge(edge)) {
-      // TODO(turbofan): Handle kIfException uses.
-      DCHECK_EQ(IrOpcode::kIfSuccess, edge.from()->opcode());
-      edge.from()->ReplaceUses(control_output());
-      edge.UpdateTo(nullptr);
-    } else if (NodeProperties::IsEffectEdge(edge)) {
-      edge.UpdateTo(effect_output());
-    } else {
-      edge.UpdateTo(value_output());
-    }
-  }
+  NodeProperties::ReplaceWithValue(call, value_output(), effect_output(),
+                                   control_output());
 
   return Reducer::Replace(value_output());
 }
 
 }  // namespace
 
 
 void JSInliner::AddClosureToFrameState(Node* frame_state,
                                        Handle<JSFunction> jsfunction) {
   FrameStateCallInfo call_info = OpParameter<FrameStateCallInfo>(frame_state);
@@ skipping 86 matching lines @@
 
     for (Node* node : visitor.copies()) {
       if (node && node->opcode() == IrOpcode::kFrameState) {
         DCHECK_EQ(1, OperatorProperties::GetFrameStateInputCount(node->op()));
         AddClosureToFrameState(node, function);
         NodeProperties::ReplaceFrameStateInput(node, 0, outer_frame_state);
       }
     }
   }
 
-  return inlinee.InlineAtCall(jsgraph_, node);
+  // The inlinee uses the context from the JSFunction object.
+  // TODO(turbofan): We might want to load the context from the JSFunction at
+  // runtime in case we only know the SharedFunctionInfo once we have dynamic
+  // type feedback in the compiler.
+  Node* context = jsgraph_->HeapConstant(handle(function->context()));
+
+  return inlinee.InlineAtCall(jsgraph_, node, context);
 }
 
 }  // namespace compiler
 }  // namespace internal
 }  // namespace v8