Stabilize escape analysis (without deopt)

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 {
@@ skipping 16 matching lines @@
       return ReduceLoad(node);
     case IrOpcode::kStoreField:
     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::kObjectIsSmi:
+      return ReduceObjectIsSmi(node);
     case IrOpcode::kStateValues:
     case IrOpcode::kFrameState:
       return ReplaceWithDeoptDummy(node);
     default:
       break;
   }
   return NoChange();
 }
 
 
@@ skipping 92 matching lines @@
     // Left-hand side is not a virtual object.
     ReplaceWithValue(node, jsgraph()->FalseConstant());
     if (FLAG_trace_turbo_escape) {
       PrintF("Replaced ref eq #%d with false\n", node->id());
     }
   }
   return NoChange();
 }
 
 
+Reduction EscapeAnalysisReducer::ReduceObjectIsSmi(Node* node) {
+  DCHECK_EQ(node->opcode(), IrOpcode::kObjectIsSmi);
+  Node* input = NodeProperties::GetValueInput(node, 0);
+  if (escape_analysis()->IsAllocation(input)) {

[Michael Starzinger, 2015/12/14 10:41:49]

IIUC, for the escape analysis it would suffice to only do this reduction if
"IsVirtual(input)". So we could limit the reducer to that case and leave the
general optimization (i.e. ObjectIsSmi(Allocate) nodes) to another reducer. Then
we would not need the additional "IsAllocation" function either I think.

[sigurds, 2015/12/14 11:58:09]

Done.

+    ReplaceWithValue(node, jsgraph()->FalseConstant());
+    if (FLAG_trace_turbo_escape) {
+      PrintF("Replaced ObjectIsSmi #%d with false\n", node->id());
+    }
+    return Replace(node);
+  }
+  return NoChange();
+}
+
+
 // TODO(sigurds): This is a temporary solution until escape analysis
 // supports deoptimization.
 Reduction EscapeAnalysisReducer::ReplaceWithDeoptDummy(Node* node) {
   DCHECK(node->opcode() == IrOpcode::kStateValues ||
          node->opcode() == IrOpcode::kFrameState);
   Reduction r = NoChange();
   for (int i = 0; i < node->op()->ValueInputCount(); ++i) {
     Node* input = NodeProperties::GetValueInput(node, i);
     if (input->opcode() == IrOpcode::kFinishRegion ||
         input->opcode() == IrOpcode::kAllocate ||
         input->opcode() == IrOpcode::kPhi) {
       if (escape_analysis()->IsVirtual(input)) {
         NodeProperties::ReplaceValueInput(node, jsgraph()->UndefinedConstant(),
                                           i);
         if (FLAG_trace_turbo_escape) {
           PrintF("Replaced state value (#%d) input with dummy\n", node->id());
         }
         r = Changed(node);
       }
     }
   }
   return r;
 }
 
 
 }  // namespace compiler
 }  // namespace internal
 }  // namespace v8