[turbofan] Use bounds checks to eliminate subsequent inc/dec overflow checks.

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 18 matching lines @@
     case IrOpcode::kCheckedInt32Add:
     case IrOpcode::kCheckedInt32Sub:
     case IrOpcode::kCheckedInt32Div:
     case IrOpcode::kCheckedInt32Mod:
     case IrOpcode::kCheckedInt32Mul:
     case IrOpcode::kCheckedTaggedToFloat64:
     case IrOpcode::kCheckedTaggedSignedToInt32:
     case IrOpcode::kCheckedTaggedToInt32:
     case IrOpcode::kCheckedUint32ToInt32:
       return ReduceCheckNode(node);
+    case IrOpcode::kSpeculativeNumberAdd:
+    case IrOpcode::kSpeculativeNumberSubtract:
+      // For increments and decrements by a constant, try to learn from the last
+      // bounds check.
+      return TryReuseBoundsCheckForFirstInput(node);
     case IrOpcode::kEffectPhi:
       return ReduceEffectPhi(node);
     case IrOpcode::kDead:
       break;
     case IrOpcode::kStart:
       return ReduceStart(node);
     default:
       return ReduceOtherNode(node);
   }
   return NoChange();
@@ skipping 77 matching lines @@
 Node* RedundancyElimination::EffectPathChecks::LookupCheck(Node* node) const {
   for (Check const* check = head_; check != nullptr; check = check->next) {
     if (IsCompatibleCheck(check->node, node)) {
       DCHECK(!check->node->IsDead());
       return check->node;
     }
   }
   return nullptr;
 }
 
+Node* RedundancyElimination::EffectPathChecks::LookupBoundsCheckFor(
+    Node* node) const {
+  for (Check const* check = head_; check != nullptr; check = check->next) {
+    if (check->node->opcode() == IrOpcode::kCheckBounds &&
+        check->node->InputAt(0) == node) {
+      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)) {
     ReplaceWithValue(node, check);
     return Replace(check);
   }
+
   // Learn from this check.
   return UpdateChecks(node, checks->AddCheck(zone(), node));
 }
 
+Reduction RedundancyElimination::TryReuseBoundsCheckForFirstInput(Node* node) {
+  DCHECK(node->opcode() == IrOpcode::kSpeculativeNumberAdd ||
+         node->opcode() == IrOpcode::kSpeculativeNumberSubtract);
+
+  DCHECK_EQ(1, node->op()->EffectInputCount());
+  DCHECK_EQ(1, node->op()->EffectOutputCount());
+
+  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();
+
+  Node* left = node->InputAt(0);
+  Node* right = node->InputAt(1);
+  // Only use bounds checks for increments/decrements by a constant.
+  if (right->opcode() == IrOpcode::kNumberConstant) {
+    if (Node* bounds_check = checks->LookupBoundsCheckFor(left)) {
+      // Only use the bounds checked type if it is better.
+      if (NodeProperties::GetType(bounds_check)
+              ->Is(NodeProperties::GetType(left))) {
+        node->ReplaceInput(0, bounds_check);
+      }
+    }
+  }
+
+  return UpdateChecks(node, checks);
+}
+
 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