[compiler] Delete unused variable.

src/compiler/loop-variable-optimizer.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/loop-variable-optimizer.h"
 
 #include "src/compiler/common-operator.h"
 #include "src/compiler/graph.h"
 #include "src/compiler/node-marker.h"
 #include "src/compiler/node-properties.h"
@@ skipping 131 matching lines @@
  private:
   VariableLimits() {}
   explicit VariableLimits(const VariableLimits* other)
       : head_(other->head_), limit_count_(other->limit_count_) {}
 
   const Constraint* head_ = nullptr;
   size_t limit_count_ = 0;
 };
 
 void InductionVariable::AddUpperBound(Node* bound,
-                                      InductionVariable::ConstraintKind kind,
-                                      Zone* graph_zone) {
+                                      InductionVariable::ConstraintKind kind) {
   if (FLAG_trace_turbo_loop) {
     OFStream os(stdout);
     os << "New upper bound for " << phi()->id() << " (loop "
        << NodeProperties::GetControlInput(phi())->id() << "): " << *bound
        << std::endl;
   }
   upper_bounds_.push_back(Bound(bound, kind));
 }
 
 void InductionVariable::AddLowerBound(Node* bound,
-                                      InductionVariable::ConstraintKind kind,
-                                      Zone* graph_zone) {
+                                      InductionVariable::ConstraintKind kind) {
   if (FLAG_trace_turbo_loop) {
     OFStream os(stdout);
     os << "New lower bound for " << phi()->id() << " (loop "
        << NodeProperties::GetControlInput(phi())->id() << "): " << *bound;
   }
   lower_bounds_.push_back(Bound(bound, kind));
 }
 
 void LoopVariableOptimizer::VisitBackedge(Node* from, Node* loop) {
   if (loop->op()->ControlInputCount() != 2) return;
 
   // Go through the constraints, and update the induction variables in
   // this loop if they are involved in the constraint.
   const VariableLimits* limits = limits_[from->id()];
   for (const Constraint* constraint = limits->head(); constraint != nullptr;
        constraint = constraint->next()) {
     if (constraint->left()->opcode() == IrOpcode::kPhi &&
         NodeProperties::GetControlInput(constraint->left()) == loop) {
       auto var = induction_vars_.find(constraint->left()->id());
       if (var != induction_vars_.end()) {
-        var->second->AddUpperBound(constraint->right(), constraint->kind(),
-                                   graph()->zone());
+        var->second->AddUpperBound(constraint->right(), constraint->kind());
       }
     }
     if (constraint->right()->opcode() == IrOpcode::kPhi &&
         NodeProperties::GetControlInput(constraint->right()) == loop) {
       auto var = induction_vars_.find(constraint->right()->id());
       if (var != induction_vars_.end()) {
-        var->second->AddUpperBound(constraint->left(), constraint->kind(),
-                                   graph()->zone());
+        var->second->AddUpperBound(constraint->left(), constraint->kind());
       }
     }
   }
 }
 
 void LoopVariableOptimizer::VisitNode(Node* node) {
   switch (node->opcode()) {
     case IrOpcode::kMerge:
       return VisitMerge(node);
     case IrOpcode::kLoop:
@@ skipping 189 matching lines @@
                                         backedge_value, backedge_control);
         induction_var->phi()->ReplaceInput(1, rename);
       }
     }
   }
 }
 
 }  // namespace compiler
 }  // namespace internal
 }  // namespace v8