[turbofan] Deopt support for escape analysis

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 "src/base/flags.h"
 #include "src/bootstrapper.h"
 #include "src/compilation-dependencies.h"
 #include "src/compiler/common-operator.h"
@@ skipping 414 matching lines @@
   }
 }
 
 
 // -----------------------------EscapeObjectAnalysis---------------------------
 
 
 EscapeObjectAnalysis::EscapeObjectAnalysis(Graph* graph,
                                            CommonOperatorBuilder* common,
                                            Zone* zone)
-    : graph_(graph), common_(common), zone_(zone), virtual_states_(zone) {}
+    : graph_(graph),
+      common_(common),
+      zone_(zone),
+      virtual_states_(zone),
+      effects_(zone) {}
 
 
 EscapeObjectAnalysis::~EscapeObjectAnalysis() {}
 
 
 void EscapeObjectAnalysis::Run() {
+  effects_.resize(graph()->NodeCount());
   virtual_states_.resize(graph()->NodeCount());
   ZoneVector<Node*> queue(zone());
   queue.push_back(graph()->start());
   while (!queue.empty()) {
     Node* node = queue.back();
     queue.pop_back();
     if (Process(node)) {
       for (Edge edge : node->use_edges()) {
         if (NodeProperties::IsEffectEdge(edge)) {
           Node* use = edge.from();
@@ skipping 26 matching lines @@
   if (node->op()->EffectOutputCount() == 0) return false;
   for (Edge edge : node->use_edges()) {
     if (NodeProperties::IsEffectEdge(edge)) {
       return false;
     }
   }
   return true;
 }
 
 
+void EscapeObjectAnalysis::RecordEffectForFrameStateUses(Node* node,
+                                                         Node* effect) {
+  DCHECK(effect->op()->EffectInputCount() > 0);
+  ZoneVector<Node*> queue(zone());
+  queue.push_back(node);

[Jarin, 2015/12/02 12:24:34]

Nit: why is it called a queue when it is a stack? (Here and above.)

[sigurds, 2015/12/02 16:35:12]

Done.

+  while (!queue.empty()) {
+    Node* cur = queue.back();
+    queue.pop_back();
+    for (Edge edge : cur->input_edges()) {
+      Node* input = edge.to();
+      if (input->opcode() == IrOpcode::kFrameState ||
+          input->opcode() == IrOpcode::kStateValues) {
+        if (effects_[input->id()] != effect) {
+          effects_[input->id()] = effect;
+          if (FLAG_trace_turbo_escape) {
+            PrintF("Recorded effect #%d (%s) for frame state %d\n",
+                   effect->id(), effect->op()->mnemonic(), input->id());
+          }
+        }
+        // climb up the chain.
+        queue.push_back(input);
+      }
+    }
+  }
+}
+
+
 bool EscapeObjectAnalysis::Process(Node* node) {
   switch (node->opcode()) {
     case IrOpcode::kAllocate:
       ProcessAllocation(node);
       break;
     case IrOpcode::kBeginRegion:
       ForwardVirtualState(node);
       break;
     case IrOpcode::kFinishRegion:
       ProcessFinishRegion(node);
       break;
     case IrOpcode::kStoreField:
       ProcessStoreField(node);
       break;
     case IrOpcode::kLoadField:
       ProcessLoadField(node);
       break;
     case IrOpcode::kStart:
       ProcessStart(node);
       break;
     case IrOpcode::kEffectPhi:
       return ProcessEffectPhi(node);
       break;
     default:
       if (node->op()->EffectInputCount() > 0) {
         ForwardVirtualState(node);
+        RecordEffectForFrameStateUses(node, node);
       }
       break;
   }
   return true;
 }
 
 
 bool EscapeObjectAnalysis::IsEffectBranchPoint(Node* node) {
   int count = 0;
   for (Edge edge : node->use_edges()) {
@@ skipping 147 matching lines @@
 
 Node* EscapeObjectAnalysis::GetReplacement(Node* at, NodeId id) {
   VirtualState* states = virtual_states_[at->id()];
   if (VirtualObject* obj = states->GetVirtualObject(id)) {
     return obj->GetReplacement();
   }
   return nullptr;
 }
 
 
+VirtualObject* EscapeObjectAnalysis::GetVirtualObject(Node* at, NodeId id) {
+  if (VirtualState* states = virtual_states_[at->id()]) {
+    return states->GetVirtualObject(id);
+  }
+  return nullptr;
+}
+
+
+Node* EscapeObjectAnalysis::GetEffect(Node* node) {
+  return effects_[node->id()];
+}
+
+
 int EscapeObjectAnalysis::OffsetFromAccess(Node* node) {
   DCHECK(OpParameter<FieldAccess>(node).offset % kPointerSize == 0);
   return OpParameter<FieldAccess>(node).offset / kPointerSize;
 }
 
 
 void EscapeObjectAnalysis::ProcessLoadField(Node* node) {
   DCHECK_EQ(node->opcode(), IrOpcode::kLoadField);
   ForwardVirtualState(node);
   Node* from = NodeProperties::GetValueInput(node, 0);
@@ skipping 101 matching lines @@
           PrintF("  Object #%zu links to object #%d\n", id, obj->id());
         }
       }
     }
   }
 }
 
 }  // namespace compiler
 }  // namespace internal
 }  // namespace v8