Improve escape analysis

src/compiler/escape-analysis-reducer.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-reducer.h"
 
 #include "src/compiler/js-graph.h"
 #include "src/compiler/js-operator.h"
 
 namespace v8 {
 namespace internal {
 namespace compiler {
 
 EscapeAnalysisReducer::EscapeAnalysisReducer(Editor* editor, JSGraph* jsgraph,
                                              EscapeAnalysis* escape_analysis,
                                              Zone* zone)
     : AdvancedReducer(editor),
       jsgraph_(jsgraph),
       escape_analysis_(escape_analysis),
       zone_(zone) {}
 
 
 Reduction EscapeAnalysisReducer::Reduce(Node* node) {
   switch (node->opcode()) {
     case IrOpcode::kLoadField:
-      return ReduceLoadField(node);
+    case IrOpcode::kLoadElement:
+      return ReduceLoad(node);
     case IrOpcode::kStoreField:
-      return ReduceStoreField(node);
+    case IrOpcode::kStoreElement:
+      return ReduceStore(node);
     case IrOpcode::kAllocate:
       return ReduceAllocate(node);
     case IrOpcode::kFinishRegion:
       return ReduceFinishRegion(node);
     case IrOpcode::kReferenceEqual:
       return ReduceReferenceEqual(node);
     case IrOpcode::kStateValues:
     case IrOpcode::kFrameState:
       return ReplaceWithDeoptDummy(node);
     default:
       break;
   }
   return NoChange();
 }
 
 
-Reduction EscapeAnalysisReducer::ReduceLoadField(Node* node) {
-  DCHECK_EQ(node->opcode(), IrOpcode::kLoadField);
+Reduction EscapeAnalysisReducer::ReduceLoad(Node* node) {
+  DCHECK(node->opcode() == IrOpcode::kLoadField ||
+         node->opcode() == IrOpcode::kLoadElement);
   if (Node* rep = escape_analysis()->GetReplacement(node, node->id())) {
     if (FLAG_trace_turbo_escape) {
-      PrintF("Replaced #%d with #%d\n", node->id(), rep->id());
+      PrintF("Replaced #%d (%s) with #%d (%s)\n", node->id(),
+             node->op()->mnemonic(), rep->id(), rep->op()->mnemonic());
     }
     ReplaceWithValue(node, rep);
     return Changed(rep);
   }
   return NoChange();
 }
 
 
-Reduction EscapeAnalysisReducer::ReduceStoreField(Node* node) {
-  DCHECK_EQ(node->opcode(), IrOpcode::kStoreField);
+Reduction EscapeAnalysisReducer::ReduceStore(Node* node) {
+  DCHECK(node->opcode() == IrOpcode::kStoreField ||
+         node->opcode() == IrOpcode::kStoreElement);
   if (escape_analysis()->IsVirtual(NodeProperties::GetValueInput(node, 0))) {
     if (FLAG_trace_turbo_escape) {
-      PrintF("Removed store field #%d from effect chain\n", node->id());
+      PrintF("Removed #%d (%s) from effect chain\n", node->id(),
+             node->op()->mnemonic());
     }
     RelaxEffectsAndControls(node);
     return Changed(node);
   }
   return NoChange();
 }
 
 
 Reduction EscapeAnalysisReducer::ReduceAllocate(Node* node) {
   DCHECK_EQ(node->opcode(), IrOpcode::kAllocate);
@@ skipping 10 matching lines @@
 
 Reduction EscapeAnalysisReducer::ReduceFinishRegion(Node* node) {
   DCHECK_EQ(node->opcode(), IrOpcode::kFinishRegion);
   Node* effect = NodeProperties::GetEffectInput(node, 0);
   if (effect->opcode() == IrOpcode::kBeginRegion) {
     RelaxEffectsAndControls(effect);
     RelaxEffectsAndControls(node);
     if (FLAG_trace_turbo_escape) {
       PrintF("Removed region #%d / #%d from effect chain,", effect->id(),
              node->id());
-      PrintF("%d user(s) of #%d remain(s):", node->UseCount(), node->id());
+      PrintF(" %d user(s) of #%d remain(s):", node->UseCount(), node->id());
       for (Edge edge : node->use_edges()) {
         PrintF(" #%d", edge.from()->id());
       }
       PrintF("\n");
     }
     return Changed(node);
   }
   return NoChange();
 }
 
@@ skipping 57 matching lines @@
       }
     }
   }
   return r;
 }
 
 
 }  // namespace compiler
 }  // namespace internal
 }  // namespace v8