Rename ASSERT* to DCHECK*.

src/mark-compact.h

 // Copyright 2012 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.
 
 #ifndef V8_MARK_COMPACT_H_
 #define V8_MARK_COMPACT_H_
 
 #include "src/compiler-intrinsics.h"
 #include "src/spaces.h"
 
@@ skipping 152 matching lines @@
   bool overflowed() const { return overflowed_; }
 
   void ClearOverflowed() { overflowed_ = false; }
 
   void SetOverflowed() { overflowed_ = true; }
 
   // Push the (marked) object on the marking stack if there is room,
   // otherwise mark the object as overflowed and wait for a rescan of the
   // heap.
   INLINE(void PushBlack(HeapObject* object)) {
-    ASSERT(object->IsHeapObject());
+    DCHECK(object->IsHeapObject());
     if (IsFull()) {
       Marking::BlackToGrey(object);
       MemoryChunk::IncrementLiveBytesFromGC(object->address(), -object->Size());
       SetOverflowed();
     } else {
       array_[top_] = object;
       top_ = ((top_ + 1) & mask_);
     }
   }
 
   INLINE(void PushGrey(HeapObject* object)) {
-    ASSERT(object->IsHeapObject());
+    DCHECK(object->IsHeapObject());
     if (IsFull()) {
       SetOverflowed();
     } else {
       array_[top_] = object;
       top_ = ((top_ + 1) & mask_);
     }
   }
 
   INLINE(HeapObject* Pop()) {
-    ASSERT(!IsEmpty());
+    DCHECK(!IsEmpty());
     top_ = ((top_ - 1) & mask_);
     HeapObject* object = array_[top_];
-    ASSERT(object->IsHeapObject());
+    DCHECK(object->IsHeapObject());
     return object;
   }
 
   INLINE(void UnshiftGrey(HeapObject* object)) {
-    ASSERT(object->IsHeapObject());
+    DCHECK(object->IsHeapObject());
     if (IsFull()) {
       SetOverflowed();
     } else {
       bottom_ = ((bottom_ - 1) & mask_);
       array_[bottom_] = object;
     }
   }
 
   HeapObject** array() { return array_; }
   int bottom() { return bottom_; }
@@ skipping 44 matching lines @@
       : idx_(0), chain_length_(1), next_(next_buffer) {
     if (next_ != NULL) {
       chain_length_ = next_->chain_length_ + 1;
     }
   }
 
   ~SlotsBuffer() {
   }
 
   void Add(ObjectSlot slot) {
-    ASSERT(0 <= idx_ && idx_ < kNumberOfElements);
+    DCHECK(0 <= idx_ && idx_ < kNumberOfElements);
     slots_[idx_++] = slot;
   }
 
   enum SlotType {
     EMBEDDED_OBJECT_SLOT,
     RELOCATED_CODE_OBJECT,
     CODE_TARGET_SLOT,
     CODE_ENTRY_SLOT,
     DEBUG_TARGET_SLOT,
     JS_RETURN_SLOT,
@@ skipping 118 matching lines @@
         optimized_code_map_holder_head_(NULL) {}
 
   void AddCandidate(SharedFunctionInfo* shared_info) {
     if (GetNextCandidate(shared_info) == NULL) {
       SetNextCandidate(shared_info, shared_function_info_candidates_head_);
       shared_function_info_candidates_head_ = shared_info;
     }
   }
 
   void AddCandidate(JSFunction* function) {
-    ASSERT(function->code() == function->shared()->code());
+    DCHECK(function->code() == function->shared()->code());
     if (GetNextCandidate(function)->IsUndefined()) {
       SetNextCandidate(function, jsfunction_candidates_head_);
       jsfunction_candidates_head_ = function;
     }
   }
 
   void AddOptimizedCodeMap(SharedFunctionInfo* code_map_holder) {
     if (GetNextCodeMap(code_map_holder)->IsUndefined()) {
       SetNextCodeMap(code_map_holder, optimized_code_map_holder_head_);
       optimized_code_map_holder_head_ = code_map_holder;
@@ skipping 35 matching lines @@
     Object* next_candidate = candidate->next_function_link();
     return reinterpret_cast<JSFunction*>(next_candidate);
   }
 
   static void SetNextCandidate(JSFunction* candidate,
                                JSFunction* next_candidate) {
     candidate->set_next_function_link(next_candidate);
   }
 
   static void ClearNextCandidate(JSFunction* candidate, Object* undefined) {
-    ASSERT(undefined->IsUndefined());
+    DCHECK(undefined->IsUndefined());
     candidate->set_next_function_link(undefined, SKIP_WRITE_BARRIER);
   }
 
   static SharedFunctionInfo* GetNextCandidate(SharedFunctionInfo* candidate) {
     Object* next_candidate = candidate->code()->gc_metadata();
     return reinterpret_cast<SharedFunctionInfo*>(next_candidate);
   }
 
   static void SetNextCandidate(SharedFunctionInfo* candidate,
                                SharedFunctionInfo* next_candidate) {
@@ skipping 463 matching lines @@
         Bitmap::CellAlignIndex(
             chunk_->AddressToMarkbitIndex(cell_base_)));
     cells_ = chunk_->markbits()->cells();
   }
 
   inline bool Done() { return cell_index_ == last_cell_index_; }
 
   inline bool HasNext() { return cell_index_ < last_cell_index_ - 1; }
 
   inline MarkBit::CellType* CurrentCell() {
-    ASSERT(cell_index_ == Bitmap::IndexToCell(Bitmap::CellAlignIndex(
+    DCHECK(cell_index_ == Bitmap::IndexToCell(Bitmap::CellAlignIndex(
         chunk_->AddressToMarkbitIndex(cell_base_))));
     return &cells_[cell_index_];
   }
 
   inline Address CurrentCellBase() {
-    ASSERT(cell_index_ == Bitmap::IndexToCell(Bitmap::CellAlignIndex(
+    DCHECK(cell_index_ == Bitmap::IndexToCell(Bitmap::CellAlignIndex(
         chunk_->AddressToMarkbitIndex(cell_base_))));
     return cell_base_;
   }
 
   inline void Advance() {
     cell_index_++;
     cell_base_ += 32 * kPointerSize;
   }
 
  private:
@@ skipping 19 matching lines @@
  private:
   MarkCompactCollector* collector_;
 };
 
 
 const char* AllocationSpaceName(AllocationSpace space);
 
 } }  // namespace v8::internal
 
 #endif  // V8_MARK_COMPACT_H_