Merged: [turbofan] No longer ignore FrameState input to Call

src/compiler/escape-analysis.cc

 // Copyright 2015 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/escape-analysis.h"
 
 #include <limits>
 
 #include "src/base/flags.h"
 #include "src/bootstrapper.h"
 #include "src/compilation-dependencies.h"
 #include "src/compiler/common-operator.h"
 #include "src/compiler/graph-reducer.h"
 #include "src/compiler/js-operator.h"
+#include "src/compiler/linkage.h"
 #include "src/compiler/node-matchers.h"
 #include "src/compiler/node-properties.h"
 #include "src/compiler/node.h"
 #include "src/compiler/operator-properties.h"
 #include "src/compiler/simplified-operator.h"
 #include "src/compiler/type-cache.h"
 #include "src/objects-inl.h"
 
 namespace v8 {
 namespace internal {
@@ skipping 1034 matching lines @@
       if (++count > 1) {
         status_[node->id()] |= kBranchPointComputed | kBranchPoint;
         return true;
       }
     }
   }
   status_[node->id()] |= kBranchPointComputed;
   return false;
 }
 
+namespace {
+
+bool HasFrameStateInput(const Operator* op) {
+  if (op->opcode() == IrOpcode::kCall || op->opcode() == IrOpcode::kTailCall) {
+    const CallDescriptor* d = CallDescriptorOf(op);
+    return d->NeedsFrameState();
+  } else {
+    return OperatorProperties::HasFrameStateInput(op);
+  }
+}
+
+}  // namespace
+
 bool EscapeAnalysis::Process(Node* node) {
   switch (node->opcode()) {
     case IrOpcode::kAllocate:
       ProcessAllocation(node);
       break;
     case IrOpcode::kBeginRegion:
       ForwardVirtualState(node);
       break;
     case IrOpcode::kFinishRegion:
       ProcessFinishRegion(node);
@@ skipping 16 matching lines @@
     case IrOpcode::kEffectPhi:
       return ProcessEffectPhi(node);
       break;
     default:
       if (node->op()->EffectInputCount() > 0) {
         ForwardVirtualState(node);
       }
       ProcessAllocationUsers(node);
       break;
   }
-  if (OperatorProperties::HasFrameStateInput(node->op())) {
+  if (HasFrameStateInput(node->op())) {
     virtual_states_[node->id()]->SetCopyRequired();
   }
   return true;
 }
 
 void EscapeAnalysis::ProcessAllocationUsers(Node* node) {
   for (Edge edge : node->input_edges()) {
     Node* input = edge.to();
     Node* use = edge.from();
     if (edge.index() >= use->op()->ValueInputCount() +
@@ skipping 597 matching lines @@
     }
   }
   return false;
 }
 
 Graph* EscapeAnalysis::graph() const { return status_analysis_->graph(); }
 
 }  // namespace compiler
 }  // namespace internal
 }  // namespace v8