[turbofan] Remove eager frame state from call nodes.

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-numbering.h"
 #include "src/ast/ast.h"
 #include "src/ast/scopes.h"
 #include "src/compiler.h"
@@ skipping 37 matching lines @@
   Node* receiver() {
     DCHECK_EQ(IrOpcode::kJSCallFunction, call_->opcode());
     return call_->InputAt(1);
   }
 
   Node* new_target() {
     DCHECK_EQ(IrOpcode::kJSCallConstruct, call_->opcode());
     return call_->InputAt(formal_arguments() + 1);
   }
 
-  Node* frame_state_before() {
-    return NodeProperties::GetFrameStateInput(call_, 1);
-  }
-
-  Node* frame_state_after() {
-    // Both, {JSCallFunction} and {JSCallConstruct}, have frame state after.
+  Node* frame_state() {
+    // Both, {JSCallFunction} and {JSCallConstruct}, have frame state.
     return NodeProperties::GetFrameStateInput(call_, 0);
   }
 
   int formal_arguments() {
     // Both, {JSCallFunction} and {JSCallConstruct}, have two extra inputs:
     //  - JSCallConstruct: Includes target function and new target.
     //  - JSCallFunction: Includes target function and receiver.
     return call_->op()->ValueInputCount() - 2;
   }
 
@@ skipping 253 matching lines @@
       info_->context()->native_context()) {
     TRACE("Not inlining %s into %s because of different native contexts\n",
           shared_info->DebugName()->ToCString().get(),
           info_->shared_info()->DebugName()->ToCString().get());
     return NoChange();
   }
 
   // TODO(turbofan): TranslatedState::GetAdaptedArguments() currently relies on
   // not inlining recursive functions. We might want to relax that at some
   // point.
-  for (Node* frame_state = call.frame_state_after();
+  for (Node* frame_state = call.frame_state();
        frame_state->opcode() == IrOpcode::kFrameState;
        frame_state = frame_state->InputAt(kFrameStateOuterStateInput)) {
     FrameStateInfo const& frame_info = OpParameter<FrameStateInfo>(frame_state);
     Handle<SharedFunctionInfo> frame_shared_info;
     if (frame_info.shared_info().ToHandle(&frame_shared_info) &&
         *frame_shared_info == *shared_info) {
       TRACE("Not inlining %s into %s because call is recursive\n",
             shared_info->DebugName()->ToCString().get(),
             info_->shared_info()->DebugName()->ToCString().get());
       return NoChange();
@@ skipping 64 matching lines @@
     Graph::SubgraphScope scope(graph());
     AstGraphBuilder graph_builder(&zone, &info, jsgraph(), loop_assignment,
                                   type_hint_analysis);
     graph_builder.CreateGraph(false);
 
     // Extract the inlinee start/end nodes.
     start = graph()->start();
     end = graph()->end();
   }
 
-  Node* frame_state = call.frame_state_after();
+  Node* frame_state = call.frame_state();
   Node* new_target = jsgraph_->UndefinedConstant();
 
   // Inline {JSCallConstruct} requires some additional magic.
   if (node->opcode() == IrOpcode::kJSCallConstruct) {
     // Insert nodes around the call that model the behavior required for a
     // constructor dispatch (allocate implicit receiver and check return value).
     // This models the behavior usually accomplished by our {JSConstructStub}.
     // Note that the context has to be the callers context (input to call node).
     Node* receiver = jsgraph_->UndefinedConstant();  // Implicit receiver.
     if (NeedsImplicitReceiver(shared_info)) {
+      Node* frame_state_before = NodeProperties::FindFrameStateBefore(node);
       Node* effect = NodeProperties::GetEffectInput(node);
       Node* context = NodeProperties::GetContextInput(node);
       Node* create = jsgraph_->graph()->NewNode(
           jsgraph_->javascript()->Create(), call.target(), call.new_target(),
-          context, call.frame_state_before(), effect);
+          context, frame_state_before, effect);
       NodeProperties::ReplaceEffectInput(node, create);
       // Insert a check of the return value to determine whether the return
       // value
       // or the implicit receiver should be selected as a result of the call.
       Node* check = jsgraph_->graph()->NewNode(
           jsgraph_->javascript()->CallRuntime(Runtime::kInlineIsJSReceiver, 1),
           node, context, node, start);
       Node* select = jsgraph_->graph()->NewNode(
           jsgraph_->common()->Select(MachineRepresentation::kTagged), check,
           node, create);
@@ skipping 26 matching lines @@
 
   // Insert a JSConvertReceiver node for sloppy callees. Note that the context
   // passed into this node has to be the callees context (loaded above). Note
   // that the frame state passed to the JSConvertReceiver must be the frame
   // state _before_ the call; it is not necessary to fiddle with the receiver
   // in that frame state tho, as the conversion of the receiver can be repeated
   // any number of times, it's not observable.
   if (node->opcode() == IrOpcode::kJSCallFunction &&
       is_sloppy(parse_info.language_mode()) && !shared_info->native()) {
     const CallFunctionParameters& p = CallFunctionParametersOf(node->op());
+    Node* frame_state_before = NodeProperties::FindFrameStateBefore(node);
     Node* effect = NodeProperties::GetEffectInput(node);
     Node* convert = jsgraph_->graph()->NewNode(
         jsgraph_->javascript()->ConvertReceiver(p.convert_mode()),
-        call.receiver(), context, call.frame_state_before(), effect, start);
+        call.receiver(), context, frame_state_before, effect, start);
     NodeProperties::ReplaceValueInput(node, convert, 1);
     NodeProperties::ReplaceEffectInput(node, convert);
   }
 
   // If we are inlining a JS call at tail position then we have to pop current
   // frame state and its potential arguments adaptor frame state in order to
   // make the call stack be consistent with non-inlining case.
   // After that we add a tail caller frame state which lets deoptimizer handle
   // the case when the outermost function inlines a tail call (it should remove
   // potential arguments adaptor frame that belongs to outermost function when
@@ skipping 18 matching lines @@
   }
 
   return InlineCall(node, new_target, context, frame_state, start, end);
 }
 
 Graph* JSInliner::graph() const { return jsgraph()->graph(); }
 
 }  // namespace compiler
 }  // namespace internal
 }  // namespace v8