Rename ASSERT* to DCHECK*.

src/hydrogen-range-analysis.cc

 // Copyright 2013 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/hydrogen-range-analysis.h"
 
 namespace v8 {
 namespace internal {
 
 
@@ skipping 46 matching lines @@
     for (HInstructionIterator it(block); !it.Done(); it.Advance()) {
       HValue* value = it.Current();
       InferRange(value);
 
       // Compute the bailout-on-minus-zero flag.
       if (value->IsChange()) {
         HChange* instr = HChange::cast(value);
         // Propagate flags for negative zero checks upwards from conversions
         // int32-to-tagged and int32-to-double.
         Representation from = instr->value()->representation();
-        ASSERT(from.Equals(instr->from()));
+        DCHECK(from.Equals(instr->from()));
         if (from.IsSmiOrInteger32()) {
-          ASSERT(instr->to().IsTagged() ||
+          DCHECK(instr->to().IsTagged() ||
                 instr->to().IsDouble() ||
                 instr->to().IsSmiOrInteger32());
           PropagateMinusZeroChecks(instr->value());
         }
       } else if (value->IsCompareMinusZeroAndBranch()) {
         HCompareMinusZeroAndBranch* instr =
             HCompareMinusZeroAndBranch::cast(value);
         if (instr->value()->representation().IsSmiOrInteger32()) {
           PropagateMinusZeroChecks(instr->value());
         }
@@ skipping 34 matching lines @@
       HInstruction* instr = it.Current();
       if (instr->HasRange()) instr->PoisonRange();
     }
   }
 #endif
 }
 
 
 void HRangeAnalysisPhase::InferControlFlowRange(HCompareNumericAndBranch* test,
                                                 HBasicBlock* dest) {
-  ASSERT((test->FirstSuccessor() == dest) == (test->SecondSuccessor() != dest));
+  DCHECK((test->FirstSuccessor() == dest) == (test->SecondSuccessor() != dest));
   if (test->representation().IsSmiOrInteger32()) {
     Token::Value op = test->token();
     if (test->SecondSuccessor() == dest) {
       op = Token::NegateCompareOp(op);
     }
     Token::Value inverted_op = Token::ReverseCompareOp(op);
     UpdateControlFlowRange(op, test->left(), test->right());
     UpdateControlFlowRange(inverted_op, test->right(), test->left());
   }
 }
@@ skipping 28 matching lines @@
     }
   }
 
   if (new_range != NULL && !new_range->IsMostGeneric()) {
     AddRange(value, new_range);
   }
 }
 
 
 void HRangeAnalysisPhase::InferRange(HValue* value) {
-  ASSERT(!value->HasRange());
+  DCHECK(!value->HasRange());
   if (!value->representation().IsNone()) {
     value->ComputeInitialRange(graph()->zone());
     Range* range = value->range();
     TraceRange("Initial inferred range of %d (%s) set to [%d,%d]\n",
                value->id(),
                value->Mnemonic(),
                range->lower(),
                range->upper());
   }
 }
 
 
 void HRangeAnalysisPhase::RollBackTo(int index) {
-  ASSERT(index <= changed_ranges_.length());
+  DCHECK(index <= changed_ranges_.length());
   for (int i = index; i < changed_ranges_.length(); ++i) {
     changed_ranges_[i]->RemoveLastAddedRange();
   }
   changed_ranges_.Rewind(index);
 }
 
 
 void HRangeAnalysisPhase::AddRange(HValue* value, Range* range) {
   Range* original_range = value->range();
   value->AddNewRange(range, graph()->zone());
   changed_ranges_.Add(value, zone());
   Range* new_range = value->range();
   TraceRange("Updated range of %d set to [%d,%d]\n",
              value->id(),
              new_range->lower(),
              new_range->upper());
   if (original_range != NULL) {
     TraceRange("Original range was [%d,%d]\n",
                original_range->lower(),
                original_range->upper());
   }
   TraceRange("New information was [%d,%d]\n",
              range->lower(),
              range->upper());
 }
 
 
 void HRangeAnalysisPhase::PropagateMinusZeroChecks(HValue* value) {
-  ASSERT(worklist_.is_empty());
-  ASSERT(in_worklist_.IsEmpty());
+  DCHECK(worklist_.is_empty());
+  DCHECK(in_worklist_.IsEmpty());
 
   AddToWorklist(value);
   while (!worklist_.is_empty()) {
     value = worklist_.RemoveLast();
 
     if (value->IsPhi()) {
       // For phis, we must propagate the check to all of its inputs.
       HPhi* phi = HPhi::cast(value);
       for (int i = 0; i < phi->OperandCount(); ++i) {
         AddToWorklist(phi->OperandAt(i));
@@ skipping 47 matching lines @@
         AddToWorklist(instr->left());
       }
     } else if (value->IsMathMinMax()) {
       HMathMinMax* instr = HMathMinMax::cast(value);
       AddToWorklist(instr->right());
       AddToWorklist(instr->left());
     }
   }
 
   in_worklist_.Clear();
-  ASSERT(in_worklist_.IsEmpty());
-  ASSERT(worklist_.is_empty());
+  DCHECK(in_worklist_.IsEmpty());
+  DCHECK(worklist_.is_empty());
 }
 
 
 } }  // namespace v8::internal