[turbofan] delete old implementation of escape analysis

Bug: 
Change-Id: Ib9e0d0844ad5e7bc6cd038f736546cad77669321
Reviewed-on: https://chromium-review.googlesource.com/641530Reviewed-by: Jaroslav Sevcik <jarin@chromium.org>
Commit-Queue: Tobias Tebbi <tebbi@chromium.org>
Cr-Commit-Position: refs/heads/master@{#47699}

BUILD.gn

@@ -1419,10 +1419,6 @@ v8_source_set("v8_base") {
     "src/compiler/memory-optimizer.h",
     "src/compiler/move-optimizer.cc",
     "src/compiler/move-optimizer.h",
-    "src/compiler/new-escape-analysis-reducer.cc",
-    "src/compiler/new-escape-analysis-reducer.h",
-    "src/compiler/new-escape-analysis.cc",
-    "src/compiler/new-escape-analysis.h",
     "src/compiler/node-aux-data.h",
     "src/compiler/node-cache.cc",
     "src/compiler/node-cache.h",
@@ -2079,8 +2075,6 @@ v8_source_set("v8_base") {
     jumbo_excluded_sources = [
       # TODO(mostynb@opera.com): don't exclude these http://crbug.com/752428
       "src/profiler/heap-snapshot-generator.cc",  # Macro clash in mman-linux.h
-      "src/compiler/escape-analysis.cc",  # Symbol clashes with new-escape-analysis.cc
-      "src/compiler/escape-analysis-reducer.cc",  # Symbol clashes with new-escape-analysis-reducer.cc
     ]
   }
 

src/compiler/escape-analysis-reducer.h

-// Copyright 2015 the V8 project authors. All rights reserved.
+// Copyright 2017 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.
 
@@ -6,7 +6,6 @@
 #define V8_COMPILER_ESCAPE_ANALYSIS_REDUCER_H_
 
 #include "src/base/compiler-specific.h"
-#include "src/bit-vector.h"
 #include "src/compiler/escape-analysis.h"
 #include "src/compiler/graph-reducer.h"
 #include "src/globals.h"
@@ -15,55 +14,101 @@ namespace v8 {
 namespace internal {
 namespace compiler {
 
-// Forward declarations.
+class Deduplicator;
 class JSGraph;
 
+// Perform hash-consing when creating or mutating nodes. Used to avoid duplicate
+// nodes when creating ObjectState, StateValues and FrameState nodes
+class NodeHashCache {
+ public:
+  NodeHashCache(Graph* graph, Zone* zone)
+      : graph_(graph), cache_(zone), temp_nodes_(zone) {}
+
+  // Handle to a conceptually new mutable node. Tries to re-use existing nodes
+  // and to recycle memory if possible.
+  class Constructor {
+   public:
+    // Construct a new node as a clone of [from].
+    Constructor(NodeHashCache* cache, Node* from)
+        : node_cache_(cache), from_(from), tmp_(nullptr) {}
+    // Construct a new node from scratch.
+    Constructor(NodeHashCache* cache, const Operator* op, int input_count,
+                Node** inputs, Type* type);
+
+    // Modify the new node.
+    void ReplaceValueInput(Node* input, int i) {
+      if (!tmp_ && input == NodeProperties::GetValueInput(from_, i)) return;
+      Node* node = MutableNode();
+      NodeProperties::ReplaceValueInput(node, input, i);
+    }
+    void ReplaceInput(Node* input, int i) {
+      if (!tmp_ && input == from_->InputAt(i)) return;
+      Node* node = MutableNode();
+      node->ReplaceInput(i, input);
+    }
+
+    // Obtain the mutated node or a cached copy. Invalidates the [Constructor].
+    Node* Get();
+
+   private:
+    Node* MutableNode();
+
+    NodeHashCache* node_cache_;
+    // Original node, copied on write.
+    Node* from_;
+    // Temporary node used for mutations, can be recycled if cache is hit.
+    Node* tmp_;
+  };
+
+ private:
+  Node* Query(Node* node);
+  void Insert(Node* node) { cache_.insert(node); }
+
+  Graph* graph_;
+  struct NodeEquals {
+    bool operator()(Node* a, Node* b) const {
+      return NodeProperties::Equals(a, b);
+    }
+  };
+  struct NodeHashCode {
+    size_t operator()(Node* n) const { return NodeProperties::HashCode(n); }
+  };
+  ZoneUnorderedSet<Node*, NodeHashCode, NodeEquals> cache_;
+  // Unused nodes whose memory can be recycled.
+  ZoneVector<Node*> temp_nodes_;
+};
+
+// Modify the graph according to the information computed in the previous phase.
 class V8_EXPORT_PRIVATE EscapeAnalysisReducer final
     : public NON_EXPORTED_BASE(AdvancedReducer) {
  public:
   EscapeAnalysisReducer(Editor* editor, JSGraph* jsgraph,
-                        EscapeAnalysis* escape_analysis, Zone* zone);
+                        EscapeAnalysisResult analysis_result, Zone* zone);
 
+  Reduction Reduce(Node* node) override;
   const char* reducer_name() const override { return "EscapeAnalysisReducer"; }
-
-  Reduction Reduce(Node* node) final;
-
   void Finalize() override;
 
   // Verifies that all virtual allocation nodes have been dealt with. Run it
-  // after this reducer has been applied. Has no effect in release mode.
+  // after this reducer has been applied.
   void VerifyReplacement() const;
 
-  bool compilation_failed() const { return compilation_failed_; }
-
  private:
-  Reduction ReduceNode(Node* node);
-  Reduction ReduceLoad(Node* node);
-  Reduction ReduceStore(Node* node);
-  Reduction ReduceCheckMaps(Node* node);
-  Reduction ReduceAllocate(Node* node);
-  Reduction ReduceFinishRegion(Node* node);
-  Reduction ReduceReferenceEqual(Node* node);
-  Reduction ReduceObjectIsSmi(Node* node);
-  Reduction ReduceFrameStateUses(Node* node);
-  Node* ReduceDeoptState(Node* node, Node* effect, bool multiple_users);
-  Node* ReduceStateValueInput(Node* node, int node_index, Node* effect,
-                              bool node_multiused, bool already_cloned,
-                              bool multiple_users);
+  void ReduceFrameStateInputs(Node* node);
+  Node* ReduceDeoptState(Node* node, Node* effect, Deduplicator* deduplicator);
+  Node* ObjectIdNode(const VirtualObject* vobject);
+  Node* MaybeGuard(Node* original, Node* replacement);
 
   JSGraph* jsgraph() const { return jsgraph_; }
-  EscapeAnalysis* escape_analysis() const { return escape_analysis_; }
+  EscapeAnalysisResult analysis_result() const { return analysis_result_; }
   Zone* zone() const { return zone_; }
 
   JSGraph* const jsgraph_;
-  EscapeAnalysis* escape_analysis_;
+  EscapeAnalysisResult analysis_result_;
+  ZoneVector<Node*> object_id_cache_;
+  NodeHashCache node_cache_;
+  ZoneSet<Node*> arguments_elements_;
   Zone* const zone_;
-  // This bit vector marks nodes we already processed (allocs, loads, stores)
-  // and nodes that do not need a visit from ReduceDeoptState etc.
-  BitVector fully_reduced_;
-  bool exists_virtual_allocate_;
-  std::set<Node*> arguments_elements_;
-  bool compilation_failed_ = false;
 
   DISALLOW_COPY_AND_ASSIGN(EscapeAnalysisReducer);
 };

src/compiler/escape-analysis.h

-// Copyright 2015 the V8 project authors. All rights reserved.
+// Copyright 2017 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.
 
 #ifndef V8_COMPILER_ESCAPE_ANALYSIS_H_
 #define V8_COMPILER_ESCAPE_ANALYSIS_H_
 
-#include "src/compiler/graph.h"
+#include "src/base/functional.h"
+#include "src/compiler/graph-reducer.h"
+#include "src/compiler/js-graph.h"
+#include "src/compiler/persistent-map.h"
 #include "src/globals.h"
 
 namespace v8 {
 namespace internal {
 namespace compiler {
 
-// Forward declarations.
 class CommonOperatorBuilder;
-class EscapeStatusAnalysis;
-namespace impl {
-class MergeCache;
-class VirtualState;
-class VirtualObject;
-};  // namespace impl
-
-// EscapeObjectAnalysis simulates stores to determine values of loads if
-// an object is virtual and eliminated.
-class V8_EXPORT_PRIVATE EscapeAnalysis {
+class VariableTracker;
+class EscapeAnalysisTracker;
+
+// {EffectGraphReducer} reduces up to a fixed point. It distinguishes changes to
+// the effect output of a node from changes to the value output to reduce the
+// number of revisitations.
+class EffectGraphReducer {
+ public:
+  class Reduction {
    public:
-  EscapeAnalysis(Graph* graph, CommonOperatorBuilder* common, Zone* zone);
-  ~EscapeAnalysis();
-
-  bool Run();
-
-  Node* GetReplacement(Node* node);
-  Node* ResolveReplacement(Node* node);
-  bool IsVirtual(Node* node);
-  bool IsEscaped(Node* node);
-  bool CompareVirtualObjects(Node* left, Node* right);
-  Node* GetOrCreateObjectState(Node* effect, Node* node);
-  bool IsCyclicObjectState(Node* effect, Node* node);
-  bool ExistsVirtualAllocate();
-  bool SetReplacement(Node* node, Node* rep);
-  bool AllObjectsComplete();
+    bool value_changed() const { return value_changed_; }
+    void set_value_changed() { value_changed_ = true; }
+    bool effect_changed() const { return effect_changed_; }
+    void set_effect_changed() { effect_changed_ = true; }
+
+   private:
+    bool value_changed_ = false;
+    bool effect_changed_ = false;
+  };
+
+  EffectGraphReducer(Graph* graph,
+                     std::function<void(Node*, Reduction*)> reduce, Zone* zone);
+
+  void ReduceGraph() { ReduceFrom(graph_->end()); }
+
+  // Mark node for revisitation.
+  void Revisit(Node* node);
+
+  // Add a new root node to start reduction from. This is useful if the reducer
+  // adds nodes that are not yet reachable, but should already be considered
+  // part of the graph.
+  void AddRoot(Node* node) {
+    DCHECK(state_.Get(node) == State::kUnvisited);
+    state_.Set(node, State::kRevisit);
+    revisit_.push(node);
+  }
+
+  bool Complete() { return stack_.empty() && revisit_.empty(); }
+
+ private:
+  struct NodeState {
+    Node* node;
+    int input_index;
+  };
+  void ReduceFrom(Node* node);
+  enum class State : uint8_t { kUnvisited = 0, kRevisit, kOnStack, kVisited };
+  const uint8_t kNumStates = static_cast<uint8_t>(State::kVisited) + 1;
+  Graph* graph_;
+  NodeMarker<State> state_;
+  ZoneStack<Node*> revisit_;
+  ZoneStack<NodeState> stack_;
+  std::function<void(Node*, Reduction*)> reduce_;
+};
+
+// A variable is an abstract storage location, which is lowered to SSA values
+// and phi nodes by {VariableTracker}.
+class Variable {
+ public:
+  Variable() : id_(kInvalid) {}
+  bool operator==(Variable other) const { return id_ == other.id_; }
+  bool operator!=(Variable other) const { return id_ != other.id_; }
+  bool operator<(Variable other) const { return id_ < other.id_; }
+  static Variable Invalid() { return Variable(kInvalid); }
+  friend V8_INLINE size_t hash_value(Variable v) {
+    return base::hash_value(v.id_);
+  }
+  friend std::ostream& operator<<(std::ostream& os, Variable var) {
+    return os << var.id_;
+  }
+
+ private:
+  typedef int Id;
+  explicit Variable(Id id) : id_(id) {}
+  Id id_;
+  static const Id kInvalid = -1;
+
+  friend class VariableTracker;
+};
+
+// An object that can track the nodes in the graph whose current reduction
+// depends on the value of the object.
+class Dependable : public ZoneObject {
+ public:
+  explicit Dependable(Zone* zone) : dependants_(zone) {}
+  void AddDependency(Node* node) { dependants_.push_back(node); }
+  void RevisitDependants(EffectGraphReducer* reducer) {
+    for (Node* node : dependants_) {
+      reducer->Revisit(node);
+    }
+    dependants_.clear();
+  }
+
+ private:
+  ZoneVector<Node*> dependants_;
+};
+
+// A virtual object represents an allocation site and tracks the Variables
+// associated with its fields as well as its global escape status.
+class VirtualObject : public Dependable {
+ public:
+  typedef uint32_t Id;
+  typedef ZoneVector<Variable>::const_iterator const_iterator;
+  VirtualObject(VariableTracker* var_states, Id id, int size);
+  Maybe<Variable> FieldAt(int offset) const {
+    DCHECK(offset % kPointerSize == 0);
+    CHECK(!HasEscaped());
+    if (offset >= size()) {
+      // This can only happen in unreachable code.
+      return Nothing<Variable>();
+    }
+    return Just(fields_.at(offset / kPointerSize));
+  }
+  Id id() const { return id_; }
+  int size() const { return static_cast<int>(kPointerSize * fields_.size()); }
+  // Escaped might mean that the object escaped to untracked memory or that it
+  // is used in an operation that requires materialization.
+  void SetEscaped() { escaped_ = true; }
+  bool HasEscaped() const { return escaped_; }
+  const_iterator begin() const { return fields_.begin(); }
+  const_iterator end() const { return fields_.end(); }
+
+ private:
+  bool escaped_ = false;
+  Id id_;
+  ZoneVector<Variable> fields_;
+};
+
+class EscapeAnalysisResult {
+ public:
+  explicit EscapeAnalysisResult(EscapeAnalysisTracker* tracker)
+      : tracker_(tracker) {}
+
+  const VirtualObject* GetVirtualObject(Node* node);
+  Node* GetVirtualObjectField(const VirtualObject* vobject, int field,
+                              Node* effect);
+  Node* GetReplacementOf(Node* node);
+
+ private:
+  EscapeAnalysisTracker* tracker_;
+};
+
+class V8_EXPORT_PRIVATE EscapeAnalysis final
+    : public NON_EXPORTED_BASE(EffectGraphReducer) {
+ public:
+  EscapeAnalysis(JSGraph* jsgraph, Zone* zone);
+
+  EscapeAnalysisResult analysis_result() {
+    DCHECK(Complete());
+    return EscapeAnalysisResult(tracker_);
+  }
 
  private:
-  void RunObjectAnalysis();
-  bool Process(Node* node);
-  void ProcessLoadField(Node* node);
-  void ProcessStoreField(Node* node);
-  void ProcessLoadElement(Node* node);
-  void ProcessStoreElement(Node* node);
-  void ProcessCheckMaps(Node* node);
-  void ProcessAllocationUsers(Node* node);
-  void ProcessAllocation(Node* node);
-  void ProcessFinishRegion(Node* node);
-  void ProcessCall(Node* node);
-  void ProcessStart(Node* node);
-  bool ProcessEffectPhi(Node* node);
-
-  void ForwardVirtualState(Node* node);
-  impl::VirtualState* CopyForModificationAt(impl::VirtualState* state,
-                                            Node* node);
-  impl::VirtualObject* CopyForModificationAt(impl::VirtualObject* obj,
-                                             impl::VirtualState* state,
-                                             Node* node);
-
-  Node* replacement(Node* node);
-  bool UpdateReplacement(impl::VirtualState* state, Node* node, Node* rep);
-
-  impl::VirtualObject* GetVirtualObject(impl::VirtualState* state, Node* node);
-
-  void DebugPrint();
-  void DebugPrintState(impl::VirtualState* state);
-
-  Graph* graph() const;
-  Zone* zone() const { return zone_; }
-  CommonOperatorBuilder* common() const { return common_; }
-
-  Zone* const zone_;
-  Node* const slot_not_analyzed_;
-  CommonOperatorBuilder* const common_;
-  EscapeStatusAnalysis* status_analysis_;
-  ZoneVector<impl::VirtualState*> virtual_states_;
-  ZoneVector<Node*> replacements_;
-  ZoneSet<impl::VirtualObject*> cycle_detection_;
-  impl::MergeCache* cache_;
-
-  DISALLOW_COPY_AND_ASSIGN(EscapeAnalysis);
+  void Reduce(Node* node, Reduction* reduction);
+  JSGraph* jsgraph() { return jsgraph_; }
+  EscapeAnalysisTracker* tracker_;
+  JSGraph* jsgraph_;
 };
 
 }  // namespace compiler

src/compiler/new-escape-analysis-reducer.h

-// Copyright 2017 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.
-
-#ifndef V8_COMPILER_NEW_ESCAPE_ANALYSIS_REDUCER_H_
-#define V8_COMPILER_NEW_ESCAPE_ANALYSIS_REDUCER_H_
-
-#include "src/base/compiler-specific.h"
-#include "src/compiler/graph-reducer.h"
-#include "src/compiler/new-escape-analysis.h"
-#include "src/globals.h"
-
-namespace v8 {
-namespace internal {
-namespace compiler {
-
-class Deduplicator;
-class JSGraph;
-
-// Perform hash-consing when creating or mutating nodes. Used to avoid duplicate
-// nodes when creating ObjectState, StateValues and FrameState nodes
-class NodeHashCache {
- public:
-  NodeHashCache(Graph* graph, Zone* zone)
-      : graph_(graph), cache_(zone), temp_nodes_(zone) {}
-
-  // Handle to a conceptually new mutable node. Tries to re-use existing nodes
-  // and to recycle memory if possible.
-  class Constructor {
-   public:
-    // Construct a new node as a clone of [from].
-    Constructor(NodeHashCache* cache, Node* from)
-        : node_cache_(cache), from_(from), tmp_(nullptr) {}
-    // Construct a new node from scratch.
-    Constructor(NodeHashCache* cache, const Operator* op, int input_count,
-                Node** inputs, Type* type);
-
-    // Modify the new node.
-    void ReplaceValueInput(Node* input, int i) {
-      if (!tmp_ && input == NodeProperties::GetValueInput(from_, i)) return;
-      Node* node = MutableNode();
-      NodeProperties::ReplaceValueInput(node, input, i);
-    }
-    void ReplaceInput(Node* input, int i) {
-      if (!tmp_ && input == from_->InputAt(i)) return;
-      Node* node = MutableNode();
-      node->ReplaceInput(i, input);
-    }
-
-    // Obtain the mutated node or a cached copy. Invalidates the [Constructor].
-    Node* Get();
-
-   private:
-    Node* MutableNode();
-
-    NodeHashCache* node_cache_;
-    // Original node, copied on write.
-    Node* from_;
-    // Temporary node used for mutations, can be recycled if cache is hit.
-    Node* tmp_;
-  };
-
- private:
-  Node* Query(Node* node);
-  void Insert(Node* node) { cache_.insert(node); }
-
-  Graph* graph_;
-  struct NodeEquals {
-    bool operator()(Node* a, Node* b) const {
-      return NodeProperties::Equals(a, b);
-    }
-  };
-  struct NodeHashCode {
-    size_t operator()(Node* n) const { return NodeProperties::HashCode(n); }
-  };
-  ZoneUnorderedSet<Node*, NodeHashCode, NodeEquals> cache_;
-  // Unused nodes whose memory can be recycled.
-  ZoneVector<Node*> temp_nodes_;
-};
-
-// Modify the graph according to the information computed in the previous phase.
-class V8_EXPORT_PRIVATE NewEscapeAnalysisReducer final
-    : public NON_EXPORTED_BASE(AdvancedReducer) {
- public:
-  NewEscapeAnalysisReducer(Editor* editor, JSGraph* jsgraph,
-                           EscapeAnalysisResult analysis_result, Zone* zone);
-
-  Reduction Reduce(Node* node) override;
-  const char* reducer_name() const override {
-    return "NewEscapeAnalysisReducer";
-  }
-  void Finalize() override;
-
-  // Verifies that all virtual allocation nodes have been dealt with. Run it
-  // after this reducer has been applied.
-  void VerifyReplacement() const;
-
- private:
-  void ReduceFrameStateInputs(Node* node);
-  Node* ReduceDeoptState(Node* node, Node* effect, Deduplicator* deduplicator);
-  Node* ObjectIdNode(const VirtualObject* vobject);
-  Node* MaybeGuard(Node* original, Node* replacement);
-
-  JSGraph* jsgraph() const { return jsgraph_; }
-  EscapeAnalysisResult analysis_result() const { return analysis_result_; }
-  Zone* zone() const { return zone_; }
-
-  JSGraph* const jsgraph_;
-  EscapeAnalysisResult analysis_result_;
-  ZoneVector<Node*> object_id_cache_;
-  NodeHashCache node_cache_;
-  ZoneSet<Node*> arguments_elements_;
-  Zone* const zone_;
-
-  DISALLOW_COPY_AND_ASSIGN(NewEscapeAnalysisReducer);
-};
-
-}  // namespace compiler
-}  // namespace internal
-}  // namespace v8
-
-#endif  // V8_COMPILER_NEW_ESCAPE_ANALYSIS_REDUCER_H_

src/compiler/new-escape-analysis.h

-// Copyright 2017 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.
-
-#ifndef V8_COMPILER_NEW_ESCAPE_ANALYSIS_H_
-#define V8_COMPILER_NEW_ESCAPE_ANALYSIS_H_
-
-#include "src/base/functional.h"
-#include "src/compiler/graph-reducer.h"
-#include "src/compiler/js-graph.h"
-#include "src/compiler/persistent-map.h"
-#include "src/globals.h"
-
-namespace v8 {
-namespace internal {
-namespace compiler {
-
-class CommonOperatorBuilder;
-class VariableTracker;
-class EscapeAnalysisTracker;
-
-// {EffectGraphReducer} reduces up to a fixed point. It distinguishes changes to
-// the effect output of a node from changes to the value output to reduce the
-// number of revisitations.
-class EffectGraphReducer {
- public:
-  class Reduction {
-   public:
-    bool value_changed() const { return value_changed_; }
-    void set_value_changed() { value_changed_ = true; }
-    bool effect_changed() const { return effect_changed_; }
-    void set_effect_changed() { effect_changed_ = true; }
-
-   private:
-    bool value_changed_ = false;
-    bool effect_changed_ = false;
-  };
-
-  EffectGraphReducer(Graph* graph,
-                     std::function<void(Node*, Reduction*)> reduce, Zone* zone);
-
-  void ReduceGraph() { ReduceFrom(graph_->end()); }
-
-  // Mark node for revisitation.
-  void Revisit(Node* node);
-
-  // Add a new root node to start reduction from. This is useful if the reducer
-  // adds nodes that are not yet reachable, but should already be considered
-  // part of the graph.
-  void AddRoot(Node* node) {
-    DCHECK(state_.Get(node) == State::kUnvisited);
-    state_.Set(node, State::kRevisit);
-    revisit_.push(node);
-  }
-
-  bool Complete() { return stack_.empty() && revisit_.empty(); }
-
- private:
-  struct NodeState {
-    Node* node;
-    int input_index;
-  };
-  void ReduceFrom(Node* node);
-  enum class State : uint8_t { kUnvisited = 0, kRevisit, kOnStack, kVisited };
-  const uint8_t kNumStates = static_cast<uint8_t>(State::kVisited) + 1;
-  Graph* graph_;
-  NodeMarker<State> state_;
-  ZoneStack<Node*> revisit_;
-  ZoneStack<NodeState> stack_;
-  std::function<void(Node*, Reduction*)> reduce_;
-};
-
-// A variable is an abstract storage location, which is lowered to SSA values
-// and phi nodes by {VariableTracker}.
-class Variable {
- public:
-  Variable() : id_(kInvalid) {}
-  bool operator==(Variable other) const { return id_ == other.id_; }
-  bool operator!=(Variable other) const { return id_ != other.id_; }
-  bool operator<(Variable other) const { return id_ < other.id_; }
-  static Variable Invalid() { return Variable(kInvalid); }
-  friend V8_INLINE size_t hash_value(Variable v) {
-    return base::hash_value(v.id_);
-  }
-  friend std::ostream& operator<<(std::ostream& os, Variable var) {
-    return os << var.id_;
-  }
-
- private:
-  typedef int Id;
-  explicit Variable(Id id) : id_(id) {}
-  Id id_;
-  static const Id kInvalid = -1;
-
-  friend class VariableTracker;
-};
-
-// An object that can track the nodes in the graph whose current reduction
-// depends on the value of the object.
-class Dependable : public ZoneObject {
- public:
-  explicit Dependable(Zone* zone) : dependants_(zone) {}
-  void AddDependency(Node* node) { dependants_.push_back(node); }
-  void RevisitDependants(EffectGraphReducer* reducer) {
-    for (Node* node : dependants_) {
-      reducer->Revisit(node);
-    }
-    dependants_.clear();
-  }
-
- private:
-  ZoneVector<Node*> dependants_;
-};
-
-// A virtual object represents an allocation site and tracks the Variables
-// associated with its fields as well as its global escape status.
-class VirtualObject : public Dependable {
- public:
-  typedef uint32_t Id;
-  typedef ZoneVector<Variable>::const_iterator const_iterator;
-  VirtualObject(VariableTracker* var_states, Id id, int size);
-  Maybe<Variable> FieldAt(int offset) const {
-    DCHECK(offset % kPointerSize == 0);
-    CHECK(!HasEscaped());
-    if (offset >= size()) {
-      // This can only happen in unreachable code.
-      return Nothing<Variable>();
-    }
-    return Just(fields_.at(offset / kPointerSize));
-  }
-  Id id() const { return id_; }
-  int size() const { return static_cast<int>(kPointerSize * fields_.size()); }
-  // Escaped might mean that the object escaped to untracked memory or that it
-  // is used in an operation that requires materialization.
-  void SetEscaped() { escaped_ = true; }
-  bool HasEscaped() const { return escaped_; }
-  const_iterator begin() const { return fields_.begin(); }
-  const_iterator end() const { return fields_.end(); }
-
- private:
-  bool escaped_ = false;
-  Id id_;
-  ZoneVector<Variable> fields_;
-};
-
-class EscapeAnalysisResult {
- public:
-  explicit EscapeAnalysisResult(EscapeAnalysisTracker* tracker)
-      : tracker_(tracker) {}
-
-  const VirtualObject* GetVirtualObject(Node* node);
-  Node* GetVirtualObjectField(const VirtualObject* vobject, int field,
-                              Node* effect);
-  Node* GetReplacementOf(Node* node);
-
- private:
-  EscapeAnalysisTracker* tracker_;
-};
-
-class V8_EXPORT_PRIVATE NewEscapeAnalysis final
-    : public NON_EXPORTED_BASE(EffectGraphReducer) {
- public:
-  NewEscapeAnalysis(JSGraph* jsgraph, Zone* zone);
-
-  EscapeAnalysisResult analysis_result() {
-    DCHECK(Complete());
-    return EscapeAnalysisResult(tracker_);
-  }
-
- private:
-  void Reduce(Node* node, Reduction* reduction);
-  JSGraph* jsgraph() { return jsgraph_; }
-  EscapeAnalysisTracker* tracker_;
-  JSGraph* jsgraph_;
-};
-
-}  // namespace compiler
-}  // namespace internal
-}  // namespace v8
-
-#endif  // V8_COMPILER_NEW_ESCAPE_ANALYSIS_H_

src/compiler/pipeline.cc

@@ -49,8 +49,6 @@
 #include "src/compiler/machine-operator-reducer.h"
 #include "src/compiler/memory-optimizer.h"
 #include "src/compiler/move-optimizer.h"
-#include "src/compiler/new-escape-analysis-reducer.h"
-#include "src/compiler/new-escape-analysis.h"
 #include "src/compiler/osr.h"
 #include "src/compiler/pipeline-statistics.h"
 #include "src/compiler/redundancy-elimination.h"
@@ -1057,32 +1055,16 @@ struct EscapeAnalysisPhase {
   static const char* phase_name() { return "escape analysis"; }
 
   void Run(PipelineData* data, Zone* temp_zone) {
-    if (FLAG_turbo_new_escape) {
-      NewEscapeAnalysis escape_analysis(data->jsgraph(), temp_zone);
+    EscapeAnalysis escape_analysis(data->jsgraph(), temp_zone);
     escape_analysis.ReduceGraph();
     JSGraphReducer reducer(data->jsgraph(), temp_zone);
-      NewEscapeAnalysisReducer escape_reducer(&reducer, data->jsgraph(),
+    EscapeAnalysisReducer escape_reducer(&reducer, data->jsgraph(),
                                          escape_analysis.analysis_result(),
                                          temp_zone);
     AddReducer(data, &reducer, &escape_reducer);
     reducer.ReduceGraph();
     // TODO(tebbi): Turn this into a debug mode check once we have confidence.
     escape_reducer.VerifyReplacement();
-    } else {
-      EscapeAnalysis escape_analysis(data->graph(), data->jsgraph()->common(),
-                                     temp_zone);
-      if (!escape_analysis.Run()) return;
-      JSGraphReducer graph_reducer(data->jsgraph(), temp_zone);
-      EscapeAnalysisReducer escape_reducer(&graph_reducer, data->jsgraph(),
-                                           &escape_analysis, temp_zone);
-      AddReducer(data, &graph_reducer, &escape_reducer);
-      graph_reducer.ReduceGraph();
-      if (escape_reducer.compilation_failed()) {
-        data->set_compilation_failed();
-        return;
-      }
-      escape_reducer.VerifyReplacement();
-    }
   }
 };
 

src/flag-definitions.h

@@ -439,8 +439,6 @@ DEFINE_BOOL(turbo_loop_variable, true, "Turbofan loop variable optimization")
 DEFINE_BOOL(turbo_cf_optimization, true, "optimize control flow in TurboFan")
 DEFINE_BOOL(turbo_frame_elision, true, "elide frames in TurboFan")
 DEFINE_BOOL(turbo_escape, true, "enable escape analysis")
-DEFINE_BOOL(turbo_new_escape, true,
-            "enable new implementation of escape analysis")
 DEFINE_BOOL(turbo_instruction_scheduling, false,
             "enable instruction scheduling in TurboFan")
 DEFINE_BOOL(turbo_stress_instruction_scheduling, false,

src/v8.gyp

@@ -805,10 +805,6 @@
         'compiler/memory-optimizer.h',
         'compiler/move-optimizer.cc',
         'compiler/move-optimizer.h',
-        'compiler/new-escape-analysis.cc',
-        'compiler/new-escape-analysis.h',
-        'compiler/new-escape-analysis-reducer.cc',
-        'compiler/new-escape-analysis-reducer.h',
         'compiler/node-aux-data.h',
         'compiler/node-cache.cc',
         'compiler/node-cache.h',

test/unittests/BUILD.gn

@@ -56,7 +56,6 @@ v8_executable("unittests") {
     "compiler/dead-code-elimination-unittest.cc",
     "compiler/diamond-unittest.cc",
     "compiler/effect-control-linearizer-unittest.cc",
-    "compiler/escape-analysis-unittest.cc",
     "compiler/graph-reducer-unittest.cc",
     "compiler/graph-reducer-unittest.h",
     "compiler/graph-trimmer-unittest.cc",

test/unittests/unittests.gyp

@@ -49,7 +49,6 @@
       'compiler/dead-code-elimination-unittest.cc',
       'compiler/diamond-unittest.cc',
       'compiler/effect-control-linearizer-unittest.cc',
-      'compiler/escape-analysis-unittest.cc',
       'compiler/graph-reducer-unittest.cc',
       'compiler/graph-reducer-unittest.h',
       'compiler/graph-trimmer-unittest.cc',