Rename ASSERT* to DCHECK*.

src/hydrogen-bce.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-bce.h"
 
 namespace v8 {
 namespace internal {
 
 
@@ skipping 95 matching lines @@
 
   bool OffsetIsCovered(int32_t offset) const {
     return offset >= LowerOffset() && offset <= UpperOffset();
   }
 
   bool HasSingleCheck() { return lower_check_ == upper_check_; }
 
   void UpdateUpperOffsets(HBoundsCheck* check, int32_t offset) {
     BoundsCheckBbData* data = FatherInDominatorTree();
     while (data != NULL && data->UpperCheck() == check) {
-      ASSERT(data->upper_offset_ < offset);
+      DCHECK(data->upper_offset_ < offset);
       data->upper_offset_ = offset;
       data = data->FatherInDominatorTree();
     }
   }
 
   void UpdateLowerOffsets(HBoundsCheck* check, int32_t offset) {
     BoundsCheckBbData* data = FatherInDominatorTree();
     while (data != NULL && data->LowerCheck() == check) {
-      ASSERT(data->lower_offset_ > offset);
+      DCHECK(data->lower_offset_ > offset);
       data->lower_offset_ = offset;
       data = data->FatherInDominatorTree();
     }
   }
 
   // The goal of this method is to modify either upper_offset_ or
   // lower_offset_ so that also new_offset is covered (the covered
   // range grows).
   //
   // The precondition is that new_check follows UpperCheck() and
   // LowerCheck() in the same basic block, and that new_offset is not
   // covered (otherwise we could simply remove new_check).
   //
   // If HasSingleCheck() is true then new_check is added as "second check"
   // (either upper or lower; note that HasSingleCheck() becomes false).
   // Otherwise one of the current checks is modified so that it also covers
   // new_offset, and new_check is removed.
   void CoverCheck(HBoundsCheck* new_check,
                   int32_t new_offset) {
-    ASSERT(new_check->index()->representation().IsSmiOrInteger32());
+    DCHECK(new_check->index()->representation().IsSmiOrInteger32());
     bool keep_new_check = false;
 
     if (new_offset > upper_offset_) {
       upper_offset_ = new_offset;
       if (HasSingleCheck()) {
         keep_new_check = true;
         upper_check_ = new_check;
       } else {
         TightenCheck(upper_check_, new_check, new_offset);
         UpdateUpperOffsets(upper_check_, upper_offset_);
@@ skipping 21 matching lines @@
           bounds_checks_eliminated()->Increment();
       new_check->DeleteAndReplaceWith(new_check->ActualValue());
     } else {
       HBoundsCheck* first_check = new_check == lower_check_ ? upper_check_
                                                             : lower_check_;
       if (FLAG_trace_bce) {
         base::OS::Print("Moving second check #%d after first check #%d\n",
                         new_check->id(), first_check->id());
       }
       // The length is guaranteed to be live at first_check.
-      ASSERT(new_check->length() == first_check->length());
+      DCHECK(new_check->length() == first_check->length());
       HInstruction* old_position = new_check->next();
       new_check->Unlink();
       new_check->InsertAfter(first_check);
       MoveIndexIfNecessary(new_check->index(), new_check, old_position);
     }
   }
 
   BoundsCheckBbData(BoundsCheckKey* key,
                     int32_t lower_offset,
                     int32_t upper_offset,
@@ skipping 73 matching lines @@
       if (must_move) {
         index->Unlink();
         index->InsertBefore(insert_before);
       }
     }
   }
 
   void TightenCheck(HBoundsCheck* original_check,
                     HBoundsCheck* tighter_check,
                     int32_t new_offset) {
-    ASSERT(original_check->length() == tighter_check->length());
+    DCHECK(original_check->length() == tighter_check->length());
     MoveIndexIfNecessary(tighter_check->index(), original_check, tighter_check);
     original_check->ReplaceAllUsesWith(original_check->index());
     original_check->SetOperandAt(0, tighter_check->index());
     if (FLAG_trace_bce) {
       base::OS::Print("Tightened check #%d with offset %d from #%d\n",
                       original_check->id(), new_offset, tighter_check->id());
     }
   }
 
   DISALLOW_COPY_AND_ASSIGN(BoundsCheckBbData);
@@ skipping 164 matching lines @@
     if (data->FatherInDominatorTree()) {
       table_.Insert(data->Key(), data->FatherInDominatorTree(), zone());
     } else {
       table_.Delete(data->Key());
     }
     data = data->NextInBasicBlock();
   }
 }
 
 } }  // namespace v8::internal