[turbofan] Speculative optimize number operations with no feedback.

src/compiler/redundancy-elimination.cc

 // Copyright 2016 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/redundancy-elimination.h"
 
 #include "src/compiler/node-properties.h"
 
 namespace v8 {
 namespace internal {
@@ skipping 16 matching lines @@
     case IrOpcode::kCheckedFloat64ToInt32:
     case IrOpcode::kCheckedInt32Add:
     case IrOpcode::kCheckedInt32Sub:
     case IrOpcode::kCheckedInt32Div:
     case IrOpcode::kCheckedInt32Mod:
     case IrOpcode::kCheckedInt32Mul:
     case IrOpcode::kCheckedTaggedToFloat64:
     case IrOpcode::kCheckedTaggedToInt32:
     case IrOpcode::kCheckedUint32ToInt32:
       return ReduceCheckNode(node);
+    case IrOpcode::kSpeculativeNumberAdd:
+    case IrOpcode::kSpeculativeNumberSubtract:
+    case IrOpcode::kSpeculativeNumberMultiply:
+    case IrOpcode::kSpeculativeNumberModulus:
+    case IrOpcode::kSpeculativeNumberDivide:
+    case IrOpcode::kSpeculativeNumberShiftLeft:
+    case IrOpcode::kSpeculativeNumberEqual:
+    case IrOpcode::kSpeculativeNumberLessThan:
+    case IrOpcode::kSpeculativeNumberLessThanOrEqual:
+      return ReduceSpeculativeNode(node);
     case IrOpcode::kEffectPhi:
       return ReduceEffectPhi(node);
     case IrOpcode::kDead:
       break;
     case IrOpcode::kStart:
       return ReduceStart(node);
     default:
       return ReduceOtherNode(node);
   }
   return NoChange();
@@ skipping 65 matching lines @@
 namespace {
 
 bool IsCompatibleCheck(Node const* a, Node const* b) {
   if (a->op() != b->op()) return false;
   for (int i = a->op()->ValueInputCount(); --i >= 0;) {
     if (a->InputAt(i) != b->InputAt(i)) return false;
   }
   return true;
 }
 
+bool IsCompatibleSpeculative(Node const* a, Node const* b) {
+  if (a->opcode() != b->opcode()) return false;
+  DCHECK_EQ(a->InputCount(), b->InputCount());
+  for (int i = a->op()->ValueInputCount(); --i >= 0;) {
+    if (a->InputAt(i) != b->InputAt(i)) return false;
+  }
+  return true;
+}
+
 }  // namespace
 
-Node* RedundancyElimination::EffectPathChecks::LookupCheck(Node* node) const {
+template <typename Predicate>

[Jarin, 2016/07/26 09:39:21]

Do we really need to have templates for this? How about passing a flag to the
compatibility check?

+Node* RedundancyElimination::EffectPathChecks::LookupCheck(
+    Node* node, Predicate predicate) const {
   for (Check const* check = head_; check != nullptr; check = check->next) {
-    if (IsCompatibleCheck(check->node, node)) {
+    if (predicate(check->node, node)) {
       DCHECK(!check->node->IsDead());
       return check->node;
     }
   }
   return nullptr;
 }
 
 RedundancyElimination::EffectPathChecks const*
 RedundancyElimination::PathChecksForEffectNodes::Get(Node* node) const {
   size_t const id = node->id();
   if (id < info_for_node_.size()) return info_for_node_[id];
   return nullptr;
 }
 
 void RedundancyElimination::PathChecksForEffectNodes::Set(
     Node* node, EffectPathChecks const* checks) {
   size_t const id = node->id();
   if (id >= info_for_node_.size()) info_for_node_.resize(id + 1, nullptr);
   info_for_node_[id] = checks;
 }
 
 Reduction RedundancyElimination::ReduceCheckNode(Node* node) {
   Node* const effect = NodeProperties::GetEffectInput(node);
   EffectPathChecks const* checks = node_checks_.Get(effect);
   // If we do not know anything about the predecessor, do not propagate just yet
   // because we will have to recompute anyway once we compute the predecessor.
   if (checks == nullptr) return NoChange();
   // See if we have another check that dominates us.
-  if (Node* check = checks->LookupCheck(node)) {
+  if (Node* check = checks->LookupCheck(node, IsCompatibleCheck)) {
     ReplaceWithValue(node, check);
     return Replace(check);
   }
   // Learn from this check.
   return UpdateChecks(node, checks->AddCheck(zone(), node));
 }
 
+Reduction RedundancyElimination::ReduceSpeculativeNode(Node* node) {
+  Node* const effect = NodeProperties::GetEffectInput(node);
+  EffectPathChecks const* checks = node_checks_.Get(effect);
+  // If we do not know anything about the predecessor, do not propagate just yet
+  // because we will have to recompute anyway once we compute the predecessor.
+  if (checks == nullptr) return NoChange();
+  // See if we have another speculative {node} that dominates us.
+  if (Node* check = checks->LookupCheck(node, IsCompatibleSpeculative)) {
+    ReplaceWithValue(node, check);
+    return Replace(check);
+  }
+  // Learn from this speculative {node}.
+  return UpdateChecks(node, checks->AddCheck(zone(), node));
+}
+
 Reduction RedundancyElimination::ReduceEffectPhi(Node* node) {
   Node* const control = NodeProperties::GetControlInput(node);
   if (control->opcode() == IrOpcode::kLoop) {
     // Here we rely on having only reducible loops:
     // The loop entry edge always dominates the header, so we can just use
     // the information from the loop entry edge.
     return TakeChecksFromFirstEffect(node);
   }
   DCHECK_EQ(IrOpcode::kMerge, control->opcode());
 
@@ skipping 55 matching lines @@
       node_checks_.Set(node, checks);
       return Changed(node);
     }
   }
   return NoChange();
 }
 
 }  // namespace compiler
 }  // namespace internal
 }  // namespace v8