[turbofan] Refactor escape analysis to only expose one class.

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"
 #include "src/compiler/graph-reducer.h"
 #include "src/compiler/js-operator.h"
 #include "src/compiler/node.h"
 #include "src/compiler/node-matchers.h"
 #include "src/compiler/node-properties.h"
 #include "src/compiler/simplified-operator.h"
 #include "src/objects-inl.h"
 #include "src/type-cache.h"
 
 namespace v8 {
 namespace internal {
 namespace compiler {
 
 
+// ------------------------------VirtualObject----------------------------------
+
+
 class VirtualObject : public ZoneObject {
  public:
   enum Status { kUntracked = 0, kTracked = 1 };
   VirtualObject(NodeId id, Zone* zone)
       : id_(id), status_(kUntracked), fields_(zone), replacement_(nullptr) {}
 
   VirtualObject(const VirtualObject& other)
       : id_(other.id_),
         status_(other.status_),
         fields_(other.fields_),
@@ skipping 40 matching lines @@
   void id(NodeId id) { id_ = id; }
 
  private:
   NodeId id_;
   Status status_;
   ZoneVector<Node*> fields_;
   Node* replacement_;
 };
 
 
+bool VirtualObject::UpdateFrom(const VirtualObject& other) {
+  bool changed = status_ != other.status_;
+  status_ = other.status_;
+  changed = replacement_ != other.replacement_ || changed;
+  replacement_ = other.replacement_;
+  if (fields_.size() != other.fields_.size()) {
+    fields_ = other.fields_;
+    return true;
+  }
+  for (size_t i = 0; i < fields_.size(); ++i) {
+    if (fields_[i] != other.fields_[i]) {
+      changed = true;
+      fields_[i] = other.fields_[i];
+    }
+  }
+  return changed;
+}
+
+
+// ------------------------------VirtualState-----------------------------------
+
+
 class VirtualState : public ZoneObject {
  public:
   VirtualState(Zone* zone, size_t size);
   VirtualState(const VirtualState& states);
 
   VirtualObject* GetVirtualObject(Node* node);
   VirtualObject* GetVirtualObject(size_t id);
   VirtualObject* GetOrCreateTrackedVirtualObject(NodeId id, Zone* zone);
   void SetVirtualObject(NodeId id, VirtualObject* state);
   void LastChangedAt(Node* node) { last_changed_ = node; }
   Node* GetLastChanged() { return last_changed_; }
   bool UpdateFrom(NodeId id, VirtualObject* state, Zone* zone);
   Node* ResolveReplacement(Node* node);
   bool UpdateReplacement(Node* node, Node* rep, Zone* zone);
   bool UpdateFrom(VirtualState* state, Zone* zone);
   bool MergeFrom(VirtualState* left, VirtualState* right, Zone* zone,
                  Graph* graph, CommonOperatorBuilder* common, Node* control);
 
   size_t size() { return info_.size(); }
 
  private:
   ZoneVector<VirtualObject*> info_;
   Node* last_changed_;
 };
 
 
-bool VirtualObject::UpdateFrom(const VirtualObject& other) {
-  bool changed = status_ != other.status_;
-  status_ = other.status_;
-  changed = replacement_ != other.replacement_ || changed;
-  replacement_ = other.replacement_;
-  if (fields_.size() != other.fields_.size()) {
-    fields_ = other.fields_;
-    return true;
-  }
-  for (size_t i = 0; i < fields_.size(); ++i) {
-    if (fields_[i] != other.fields_[i]) {
-      changed = true;
-      fields_[i] = other.fields_[i];
-    }
-  }
-  return changed;
-}
-
-
 VirtualState::VirtualState(Zone* zone, size_t size)
     : info_(zone), last_changed_(nullptr) {
   info_.resize(size);
 }
 
 
 VirtualState::VirtualState(const VirtualState& state)
     : info_(state.info_.get_allocator().zone()),
       last_changed_(state.last_changed_) {
   info_.resize(state.info_.size());
@@ skipping 151 matching lines @@
     }
     return true;
   }
   return false;
 }
 
 
 // ------------------------------EscapeStatusAnalysis---------------------------
 
 
-EscapeStatusAnalysis::EscapeStatusAnalysis(
-    EscapeObjectAnalysis* object_analysis, Graph* graph, Zone* zone)
+EscapeStatusAnalysis::EscapeStatusAnalysis(EscapeAnalysis* object_analysis,
+                                           Graph* graph, Zone* zone)
     : object_analysis_(object_analysis),
       graph_(graph),
       zone_(zone),
       info_(zone),
       queue_(zone) {}
 
 
 EscapeStatusAnalysis::~EscapeStatusAnalysis() {}
 
 
@@ skipping 193 matching lines @@
 void EscapeStatusAnalysis::DebugPrint() {
   for (NodeId id = 0; id < info_.size(); id++) {
     if (info_[id] != kUnknown) {
       PrintF("Node #%d is %s\n", id,
              info_[id] == kEscaped ? "escaping" : "virtual");
     }
   }
 }
 
 
-// -----------------------------EscapeObjectAnalysis---------------------------
+// -----------------------------EscapeAnalysis----------------------------------
 
 
-EscapeObjectAnalysis::EscapeObjectAnalysis(Graph* graph,
-                                           CommonOperatorBuilder* common,
-                                           Zone* zone)
-    : graph_(graph), common_(common), zone_(zone), virtual_states_(zone) {}
+EscapeAnalysis::EscapeAnalysis(Graph* graph, CommonOperatorBuilder* common,
+                               Zone* zone)
+    : graph_(graph),
+      common_(common),
+      zone_(zone),
+      virtual_states_(zone),
+      escape_status_(this, graph, zone) {}
 
 
-EscapeObjectAnalysis::~EscapeObjectAnalysis() {}
+EscapeAnalysis::~EscapeAnalysis() {}
 
 
-void EscapeObjectAnalysis::Run() {
+void EscapeAnalysis::Run() {
+  RunObjectAnalysis();
+  escape_status_.Run();
+}
+
+
+void EscapeAnalysis::RunObjectAnalysis() {
   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 14 matching lines @@
         }
       }
     }
   }
   if (FLAG_trace_turbo_escape) {
     DebugPrint();
   }
 }
 
 
-bool EscapeObjectAnalysis::IsDanglingEffectNode(Node* node) {
+bool EscapeAnalysis::IsDanglingEffectNode(Node* node) {
   if (node->op()->EffectInputCount() == 0) return false;
   if (node->op()->EffectOutputCount() == 0) return false;
   for (Edge edge : node->use_edges()) {
     if (NodeProperties::IsEffectEdge(edge)) {
       return false;
     }
   }
   return true;
 }
 
 
-bool EscapeObjectAnalysis::Process(Node* node) {
+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);
       break;
@@ skipping 12 matching lines @@
     default:
       if (node->op()->EffectInputCount() > 0) {
         ForwardVirtualState(node);
       }
       break;
   }
   return true;
 }
 
 
-bool EscapeObjectAnalysis::IsEffectBranchPoint(Node* node) {
+bool EscapeAnalysis::IsEffectBranchPoint(Node* node) {
   int count = 0;
   for (Edge edge : node->use_edges()) {
     Node* use = edge.from();
     if (NodeProperties::IsEffectEdge(edge) &&
         use->opcode() != IrOpcode::kLoadField) {
       if (++count > 1) {
         return true;
       }
     }
   }
   return false;
 }
 
 
-void EscapeObjectAnalysis::ForwardVirtualState(Node* node) {
+void EscapeAnalysis::ForwardVirtualState(Node* node) {
   DCHECK_EQ(node->op()->EffectInputCount(), 1);
   if (node->opcode() != IrOpcode::kLoadField && IsDanglingEffectNode(node)) {
     PrintF("Dangeling effect node: #%d (%s)\n", node->id(),
            node->op()->mnemonic());
     DCHECK(false);
   }
   Node* effect = NodeProperties::GetEffectInput(node);
   // Break the cycle for effect phis.
   if (effect->opcode() == IrOpcode::kEffectPhi) {
     if (virtual_states_[effect->id()] == nullptr) {
@@ skipping 15 matching lines @@
     virtual_states_[node->id()] = virtual_states_[effect->id()];
     if (FLAG_trace_turbo_escape) {
       PrintF("Forwarding object state %p from #%d (%s) to #%d (%s)\n",
              static_cast<void*>(virtual_states_[effect->id()]), effect->id(),
              effect->op()->mnemonic(), node->id(), node->op()->mnemonic());
     }
   }
 }
 
 
-void EscapeObjectAnalysis::ProcessStart(Node* node) {
+void EscapeAnalysis::ProcessStart(Node* node) {
   DCHECK_EQ(node->opcode(), IrOpcode::kStart);
   virtual_states_[node->id()] =
       new (zone()) VirtualState(zone(), graph()->NodeCount());
 }
 
 
-bool EscapeObjectAnalysis::ProcessEffectPhi(Node* node) {
+bool EscapeAnalysis::ProcessEffectPhi(Node* node) {
   DCHECK_EQ(node->opcode(), IrOpcode::kEffectPhi);
   // For now only support binary phis.
   DCHECK_EQ(node->op()->EffectInputCount(), 2);
   Node* left = NodeProperties::GetEffectInput(node, 0);
   Node* right = NodeProperties::GetEffectInput(node, 1);
   bool changed = false;
 
   VirtualState* mergeState = virtual_states_[node->id()];
   if (!mergeState) {
     mergeState = new (zone()) VirtualState(zone(), graph()->NodeCount());
@@ skipping 32 matching lines @@
   if (FLAG_trace_turbo_escape) {
     PrintF("Merge %s the node.\n", changed ? "changed" : "did not change");
   }
   if (changed) {
     mergeState->LastChangedAt(node);
   }
   return changed;
 }
 
 
-void EscapeObjectAnalysis::ProcessAllocation(Node* node) {
+void EscapeAnalysis::ProcessAllocation(Node* node) {
   DCHECK_EQ(node->opcode(), IrOpcode::kAllocate);
   ForwardVirtualState(node);
 
   // Check if we have already processed this node.
   if (virtual_states_[node->id()]->GetVirtualObject(node)) return;
 
   NumberMatcher size(node->InputAt(0));
   if (size.HasValue()) {
     virtual_states_[node->id()]->SetVirtualObject(
         node->id(), new (zone()) VirtualObject(node->id(), zone(),
                                                size.Value() / kPointerSize));
   } else {
     virtual_states_[node->id()]->SetVirtualObject(
         node->id(), new (zone()) VirtualObject(node->id(), zone()));
   }
   virtual_states_[node->id()]->LastChangedAt(node);
 }
 
 
-void EscapeObjectAnalysis::ProcessFinishRegion(Node* node) {
+void EscapeAnalysis::ProcessFinishRegion(Node* node) {
   DCHECK_EQ(node->opcode(), IrOpcode::kFinishRegion);
   ForwardVirtualState(node);
   Node* allocation = NodeProperties::GetValueInput(node, 0);
   if (allocation->opcode() == IrOpcode::kAllocate) {
     VirtualState* states = virtual_states_[node->id()];
     DCHECK_NOT_NULL(states->GetVirtualObject(allocation));
     if (!states->GetVirtualObject(node->id())) {
       states->SetVirtualObject(node->id(),
                                states->GetVirtualObject(allocation));
       if (FLAG_trace_turbo_escape) {
         PrintF("Linked finish region node #%d to node #%d\n", node->id(),
                allocation->id());
       }
       states->LastChangedAt(node);
     }
   }
 }
 
 
-Node* EscapeObjectAnalysis::GetReplacement(Node* at, NodeId id) {
+Node* EscapeAnalysis::GetReplacement(Node* at, NodeId id) {
   VirtualState* states = virtual_states_[at->id()];
   if (VirtualObject* obj = states->GetVirtualObject(id)) {
     return obj->GetReplacement();
   }
   return nullptr;
 }
 
 
-int EscapeObjectAnalysis::OffsetFromAccess(Node* node) {
+bool EscapeAnalysis::IsVirtual(Node* node) {
+  return escape_status_.IsVirtual(node);
+}
+
+
+bool EscapeAnalysis::IsEscaped(Node* node) {
+  return escape_status_.IsEscaped(node);
+}
+
+
+int EscapeAnalysis::OffsetFromAccess(Node* node) {
   DCHECK(OpParameter<FieldAccess>(node).offset % kPointerSize == 0);
   return OpParameter<FieldAccess>(node).offset / kPointerSize;
 }
 
 
-void EscapeObjectAnalysis::ProcessLoadField(Node* node) {
+void EscapeAnalysis::ProcessLoadField(Node* node) {
   DCHECK_EQ(node->opcode(), IrOpcode::kLoadField);
   ForwardVirtualState(node);
   Node* from = NodeProperties::GetValueInput(node, 0);
   int offset = OffsetFromAccess(node);
   VirtualState* states = virtual_states_[node->id()];
   if (VirtualObject* state = states->GetVirtualObject(from)) {
     if (!state->IsTracked()) return;
     Node* value = state->GetField(offset);
     if (value) {
       // Record that the load has this alias.
@@ skipping 41 matching lines @@
         }
       } else if (FLAG_trace_turbo_escape) {
         PrintF(" has incomplete virtual object info: %p %p\n",
                static_cast<void*>(l), static_cast<void*>(r));
       }
     }
   }
 }
 
 
-void EscapeObjectAnalysis::ProcessStoreField(Node* node) {
+void EscapeAnalysis::ProcessStoreField(Node* node) {
   DCHECK_EQ(node->opcode(), IrOpcode::kStoreField);
   ForwardVirtualState(node);
   Node* to = NodeProperties::GetValueInput(node, 0);
   Node* val = NodeProperties::GetValueInput(node, 1);
   int offset = OffsetFromAccess(node);
   VirtualState* states = virtual_states_[node->id()];
   if (VirtualObject* obj = states->GetVirtualObject(to)) {
     if (!obj->IsTracked()) return;
     if (obj->SetField(offset, states->ResolveReplacement(val))) {
       states->LastChangedAt(node);
     }
   }
 }
 
 
-void EscapeObjectAnalysis::DebugPrint() {
+void EscapeAnalysis::DebugPrint() {
   ZoneVector<VirtualState*> object_states(zone());
   for (NodeId id = 0; id < virtual_states_.size(); id++) {
     if (VirtualState* states = virtual_states_[id]) {
       if (std::find(object_states.begin(), object_states.end(), states) ==
           object_states.end()) {
         object_states.push_back(states);
       }
     }
   }
   for (size_t n = 0; n < object_states.size(); n++) {
@@ skipping 16 matching lines @@
           PrintF("  Object #%zu links to object #%d\n", id, obj->id());
         }
       }
     }
   }
 }
 
 }  // namespace compiler
 }  // namespace internal
 }  // namespace v8