Rename ASSERT* to DCHECK*.

src/mark-compact.cc

 // 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.
 
 #include "src/v8.h"
 
 #include "src/base/atomicops.h"
 #include "src/code-stubs.h"
 #include "src/compilation-cache.h"
 #include "src/cpu-profiler.h"
@@ skipping 50 matching lines @@
   void VisitPointers(Object** start, Object** end) {
     for (Object** current = start; current < end; current++) {
       if ((*current)->IsHeapObject()) {
         HeapObject* object = HeapObject::cast(*current);
         CHECK(heap_->mark_compact_collector()->IsMarked(object));
       }
     }
   }
 
   void VisitEmbeddedPointer(RelocInfo* rinfo) {
-    ASSERT(rinfo->rmode() == RelocInfo::EMBEDDED_OBJECT);
+    DCHECK(rinfo->rmode() == RelocInfo::EMBEDDED_OBJECT);
     if (!rinfo->host()->IsWeakObject(rinfo->target_object())) {
       Object* p = rinfo->target_object();
       VisitPointer(&p);
     }
   }
 
   void VisitCell(RelocInfo* rinfo) {
     Code* code = rinfo->host();
-    ASSERT(rinfo->rmode() == RelocInfo::CELL);
+    DCHECK(rinfo->rmode() == RelocInfo::CELL);
     if (!code->IsWeakObject(rinfo->target_cell())) {
       ObjectVisitor::VisitCell(rinfo);
     }
   }
 
  private:
   Heap* heap_;
 };
 
 
@@ skipping 259 matching lines @@
   PrintF("[%s]: %d pages, %d (%.1f%%) free\n",
          AllocationSpaceName(space->identity()),
          number_of_pages,
          static_cast<int>(free),
          static_cast<double>(free) * 100 / reserved);
 }
 
 
 bool MarkCompactCollector::StartCompaction(CompactionMode mode) {
   if (!compacting_) {
-    ASSERT(evacuation_candidates_.length() == 0);
+    DCHECK(evacuation_candidates_.length() == 0);
 
 #ifdef ENABLE_GDB_JIT_INTERFACE
     // If GDBJIT interface is active disable compaction.
     if (FLAG_gdbjit) return false;
 #endif
 
     CollectEvacuationCandidates(heap()->old_pointer_space());
     CollectEvacuationCandidates(heap()->old_data_space());
 
     if (FLAG_compact_code_space &&
@@ skipping 17 matching lines @@
     compacting_ = evacuation_candidates_.length() > 0;
   }
 
   return compacting_;
 }
 
 
 void MarkCompactCollector::CollectGarbage() {
   // Make sure that Prepare() has been called. The individual steps below will
   // update the state as they proceed.
-  ASSERT(state_ == PREPARE_GC);
+  DCHECK(state_ == PREPARE_GC);
 
   MarkLiveObjects();
-  ASSERT(heap_->incremental_marking()->IsStopped());
+  DCHECK(heap_->incremental_marking()->IsStopped());
 
   if (FLAG_collect_maps) ClearNonLiveReferences();
 
   ClearWeakCollections();
 
 #ifdef VERIFY_HEAP
   if (FLAG_verify_heap) {
     VerifyMarking(heap_);
   }
 #endif
@@ skipping 13 matching lines @@
   if (FLAG_collect_maps && FLAG_omit_map_checks_for_leaf_maps) {
     VerifyOmittedMapChecks();
   }
 #endif
 
   Finish();
 
   if (marking_parity_ == EVEN_MARKING_PARITY) {
     marking_parity_ = ODD_MARKING_PARITY;
   } else {
-    ASSERT(marking_parity_ == ODD_MARKING_PARITY);
+    DCHECK(marking_parity_ == ODD_MARKING_PARITY);
     marking_parity_ = EVEN_MARKING_PARITY;
   }
 }
 
 
 #ifdef VERIFY_HEAP
 void MarkCompactCollector::VerifyMarkbitsAreClean(PagedSpace* space) {
   PageIterator it(space);
 
   while (it.has_next()) {
@@ skipping 111 matching lines @@
   }
 
   Heap* heap_;
   PagedSpace* space_;
 
   DISALLOW_COPY_AND_ASSIGN(SweeperTask);
 };
 
 
 void MarkCompactCollector::StartSweeperThreads() {
-  ASSERT(free_list_old_pointer_space_.get()->IsEmpty());
-  ASSERT(free_list_old_data_space_.get()->IsEmpty());
+  DCHECK(free_list_old_pointer_space_.get()->IsEmpty());
+  DCHECK(free_list_old_data_space_.get()->IsEmpty());
   sweeping_in_progress_ = true;
   for (int i = 0; i < isolate()->num_sweeper_threads(); i++) {
     isolate()->sweeper_threads()[i]->StartSweeping();
   }
   if (FLAG_job_based_sweeping) {
     V8::GetCurrentPlatform()->CallOnBackgroundThread(
         new SweeperTask(heap(), heap()->old_data_space()),
         v8::Platform::kShortRunningTask);
     V8::GetCurrentPlatform()->CallOnBackgroundThread(
         new SweeperTask(heap(), heap()->old_pointer_space()),
         v8::Platform::kShortRunningTask);
   }
 }
 
 
 void MarkCompactCollector::EnsureSweepingCompleted() {
-  ASSERT(sweeping_in_progress_ == true);
+  DCHECK(sweeping_in_progress_ == true);
 
   // If sweeping is not completed, we try to complete it here. If we do not
   // have sweeper threads we have to complete since we do not have a good
   // indicator for a swept space in that case.
   if (!AreSweeperThreadsActivated() || !IsSweepingCompleted()) {
     SweepInParallel(heap()->paged_space(OLD_DATA_SPACE), 0);
     SweepInParallel(heap()->paged_space(OLD_POINTER_SPACE), 0);
   }
 
   for (int i = 0; i < isolate()->num_sweeper_threads(); i++) {
@@ skipping 57 matching lines @@
 }
 
 
 bool MarkCompactCollector::AreSweeperThreadsActivated() {
   return isolate()->sweeper_threads() != NULL || FLAG_job_based_sweeping;
 }
 
 
 void Marking::TransferMark(Address old_start, Address new_start) {
   // This is only used when resizing an object.
-  ASSERT(MemoryChunk::FromAddress(old_start) ==
+  DCHECK(MemoryChunk::FromAddress(old_start) ==
          MemoryChunk::FromAddress(new_start));
 
   if (!heap_->incremental_marking()->IsMarking()) return;
 
   // If the mark doesn't move, we don't check the color of the object.
   // It doesn't matter whether the object is black, since it hasn't changed
   // size, so the adjustment to the live data count will be zero anyway.
   if (old_start == new_start) return;
 
   MarkBit new_mark_bit = MarkBitFrom(new_start);
   MarkBit old_mark_bit = MarkBitFrom(old_start);
 
 #ifdef DEBUG
   ObjectColor old_color = Color(old_mark_bit);
 #endif
 
   if (Marking::IsBlack(old_mark_bit)) {
     old_mark_bit.Clear();
-    ASSERT(IsWhite(old_mark_bit));
+    DCHECK(IsWhite(old_mark_bit));
     Marking::MarkBlack(new_mark_bit);
     return;
   } else if (Marking::IsGrey(old_mark_bit)) {
     old_mark_bit.Clear();
     old_mark_bit.Next().Clear();
-    ASSERT(IsWhite(old_mark_bit));
+    DCHECK(IsWhite(old_mark_bit));
     heap_->incremental_marking()->WhiteToGreyAndPush(
         HeapObject::FromAddress(new_start), new_mark_bit);
     heap_->incremental_marking()->RestartIfNotMarking();
   }
 
 #ifdef DEBUG
   ObjectColor new_color = Color(new_mark_bit);
-  ASSERT(new_color == old_color);
+  DCHECK(new_color == old_color);
 #endif
 }
 
 
 const char* AllocationSpaceName(AllocationSpace space) {
   switch (space) {
     case NEW_SPACE: return "NEW_SPACE";
     case OLD_POINTER_SPACE: return "OLD_POINTER_SPACE";
     case OLD_DATA_SPACE: return "OLD_DATA_SPACE";
     case CODE_SPACE: return "CODE_SPACE";
@@ skipping 64 matching lines @@
     return 1;
   }
 
   if (ratio <= ratio_threshold) return 0;  // Not fragmented.
 
   return static_cast<int>(ratio - ratio_threshold);
 }
 
 
 void MarkCompactCollector::CollectEvacuationCandidates(PagedSpace* space) {
-  ASSERT(space->identity() == OLD_POINTER_SPACE ||
+  DCHECK(space->identity() == OLD_POINTER_SPACE ||
          space->identity() == OLD_DATA_SPACE ||
          space->identity() == CODE_SPACE);
 
   static const int kMaxMaxEvacuationCandidates = 1000;
   int number_of_pages = space->CountTotalPages();
   int max_evacuation_candidates =
       static_cast<int>(std::sqrt(number_of_pages / 2.0) + 1);
 
   if (FLAG_stress_compaction || FLAG_always_compact) {
     max_evacuation_candidates = kMaxMaxEvacuationCandidates;
@@ skipping 146 matching lines @@
     for (int i = 0; i < npages; i++) {
       Page* p = evacuation_candidates_[i];
       slots_buffer_allocator_.DeallocateChain(p->slots_buffer_address());
       p->ClearEvacuationCandidate();
       p->ClearFlag(MemoryChunk::RESCAN_ON_EVACUATION);
     }
     compacting_ = false;
     evacuation_candidates_.Rewind(0);
     invalidated_code_.Rewind(0);
   }
-  ASSERT_EQ(0, evacuation_candidates_.length());
+  DCHECK_EQ(0, evacuation_candidates_.length());
 }
 
 
 void MarkCompactCollector::Prepare() {
   was_marked_incrementally_ = heap()->incremental_marking()->IsMarking();
 
 #ifdef DEBUG
-  ASSERT(state_ == IDLE);
+  DCHECK(state_ == IDLE);
   state_ = PREPARE_GC;
 #endif
 
-  ASSERT(!FLAG_never_compact || !FLAG_always_compact);
+  DCHECK(!FLAG_never_compact || !FLAG_always_compact);
 
   if (sweeping_in_progress()) {
     // Instead of waiting we could also abort the sweeper threads here.
     EnsureSweepingCompleted();
   }
 
   // Clear marking bits if incremental marking is aborted.
   if (was_marked_incrementally_ && abort_incremental_marking_) {
     heap()->incremental_marking()->Abort();
     ClearMarkbits();
@@ skipping 17 matching lines @@
 #ifdef VERIFY_HEAP
   if (!was_marked_incrementally_ && FLAG_verify_heap) {
     VerifyMarkbitsAreClean();
   }
 #endif
 }
 
 
 void MarkCompactCollector::Finish() {
 #ifdef DEBUG
-  ASSERT(state_ == SWEEP_SPACES || state_ == RELOCATE_OBJECTS);
+  DCHECK(state_ == SWEEP_SPACES || state_ == RELOCATE_OBJECTS);
   state_ = IDLE;
 #endif
   // The stub cache is not traversed during GC; clear the cache to
   // force lazy re-initialization of it. This must be done after the
   // GC, because it relies on the new address of certain old space
   // objects (empty string, illegal builtin).
   isolate()->stub_cache()->Clear();
 
   if (have_code_to_deoptimize_) {
     // Some code objects were marked for deoptimization during the GC.
@@ skipping 130 matching lines @@
           Code::cast(code_map->get(i + SharedFunctionInfo::kCachedCodeOffset));
       if (!Marking::MarkBitFrom(code).Get()) continue;
 
       // Move every slot in the entry.
       for (int j = 0; j < SharedFunctionInfo::kEntryLength; j++) {
         int dst_index = new_length++;
         Object** slot = code_map->RawFieldOfElementAt(dst_index);
         Object* object = code_map->get(i + j);
         code_map->set(dst_index, object);
         if (j == SharedFunctionInfo::kOsrAstIdOffset) {
-          ASSERT(object->IsSmi());
+          DCHECK(object->IsSmi());
         } else {
-          ASSERT(Marking::IsBlack(
+          DCHECK(Marking::IsBlack(
               Marking::MarkBitFrom(HeapObject::cast(*slot))));
           isolate_->heap()->mark_compact_collector()->
               RecordSlot(slot, slot, *slot);
         }
       }
     }
 
     // Trim the optimized code map if entries have been removed.
     if (new_length < old_length) {
       holder->TrimOptimizedCodeMap(old_length - new_length);
@@ skipping 33 matching lines @@
         break;
       }
 
       candidate = next_candidate;
     }
   }
 }
 
 
 void CodeFlusher::EvictCandidate(JSFunction* function) {
-  ASSERT(!function->next_function_link()->IsUndefined());
+  DCHECK(!function->next_function_link()->IsUndefined());
   Object* undefined = isolate_->heap()->undefined_value();
 
   // Make sure previous flushing decisions are revisited.
   isolate_->heap()->incremental_marking()->RecordWrites(function);
   isolate_->heap()->incremental_marking()->RecordWrites(function->shared());
 
   if (FLAG_trace_code_flushing) {
     PrintF("[code-flushing abandons closure: ");
     function->shared()->ShortPrint();
     PrintF("]\n");
@@ skipping 16 matching lines @@
         break;
       }
 
       candidate = next_candidate;
     }
   }
 }
 
 
 void CodeFlusher::EvictOptimizedCodeMap(SharedFunctionInfo* code_map_holder) {
-  ASSERT(!FixedArray::cast(code_map_holder->optimized_code_map())->
+  DCHECK(!FixedArray::cast(code_map_holder->optimized_code_map())->
          get(SharedFunctionInfo::kNextMapIndex)->IsUndefined());
 
   // Make sure previous flushing decisions are revisited.
   isolate_->heap()->incremental_marking()->RecordWrites(code_map_holder);
 
   if (FLAG_trace_code_flushing) {
     PrintF("[code-flushing abandons code-map: ");
     code_map_holder->ShortPrint();
     PrintF("]\n");
   }
@@ skipping 22 matching lines @@
 
 
 void CodeFlusher::EvictJSFunctionCandidates() {
   JSFunction* candidate = jsfunction_candidates_head_;
   JSFunction* next_candidate;
   while (candidate != NULL) {
     next_candidate = GetNextCandidate(candidate);
     EvictCandidate(candidate);
     candidate = next_candidate;
   }
-  ASSERT(jsfunction_candidates_head_ == NULL);
+  DCHECK(jsfunction_candidates_head_ == NULL);
 }
 
 
 void CodeFlusher::EvictSharedFunctionInfoCandidates() {
   SharedFunctionInfo* candidate = shared_function_info_candidates_head_;
   SharedFunctionInfo* next_candidate;
   while (candidate != NULL) {
     next_candidate = GetNextCandidate(candidate);
     EvictCandidate(candidate);
     candidate = next_candidate;
   }
-  ASSERT(shared_function_info_candidates_head_ == NULL);
+  DCHECK(shared_function_info_candidates_head_ == NULL);
 }
 
 
 void CodeFlusher::EvictOptimizedCodeMaps() {
   SharedFunctionInfo* holder = optimized_code_map_holder_head_;
   SharedFunctionInfo* next_holder;
   while (holder != NULL) {
     next_holder = GetNextCodeMap(holder);
     EvictOptimizedCodeMap(holder);
     holder = next_holder;
   }
-  ASSERT(optimized_code_map_holder_head_ == NULL);
+  DCHECK(optimized_code_map_holder_head_ == NULL);
 }
 
 
 void CodeFlusher::IteratePointersToFromSpace(ObjectVisitor* v) {
   Heap* heap = isolate_->heap();
 
   JSFunction** slot = &jsfunction_candidates_head_;
   JSFunction* candidate = jsfunction_candidates_head_;
   while (candidate != NULL) {
     if (heap->InFromSpace(candidate)) {
@@ skipping 111 matching lines @@
     collector->RecordSlot(anchor_slot, p, object);
     MarkBit mark = Marking::MarkBitFrom(object);
     collector->MarkObject(object, mark);
   }
 
 
   // Visit an unmarked object.
   INLINE(static void VisitUnmarkedObject(MarkCompactCollector* collector,
                                          HeapObject* obj)) {
 #ifdef DEBUG
-    ASSERT(collector->heap()->Contains(obj));
-    ASSERT(!collector->heap()->mark_compact_collector()->IsMarked(obj));
+    DCHECK(collector->heap()->Contains(obj));
+    DCHECK(!collector->heap()->mark_compact_collector()->IsMarked(obj));
 #endif
     Map* map = obj->map();
     Heap* heap = obj->GetHeap();
     MarkBit mark = Marking::MarkBitFrom(obj);
     heap->mark_compact_collector()->SetMark(obj, mark);
     // Mark the map pointer and the body.
     MarkBit map_mark = Marking::MarkBitFrom(map);
     heap->mark_compact_collector()->MarkObject(map, map_mark);
     IterateBody(map, obj);
   }
@@ skipping 145 matching lines @@
 }
 
 
 template<>
 class MarkCompactMarkingVisitor::ObjectStatsTracker<
     MarkCompactMarkingVisitor::kVisitMap> {
  public:
   static inline void Visit(Map* map, HeapObject* obj) {
     Heap* heap = map->GetHeap();
     Map* map_obj = Map::cast(obj);
-    ASSERT(map->instance_type() == MAP_TYPE);
+    DCHECK(map->instance_type() == MAP_TYPE);
     DescriptorArray* array = map_obj->instance_descriptors();
     if (map_obj->owns_descriptors() &&
         array != heap->empty_descriptor_array()) {
       int fixed_array_size = array->Size();
       heap->RecordFixedArraySubTypeStats(DESCRIPTOR_ARRAY_SUB_TYPE,
                                          fixed_array_size);
     }
     if (map_obj->HasTransitionArray()) {
       int fixed_array_size = map_obj->transitions()->Size();
       heap->RecordFixedArraySubTypeStats(TRANSITION_ARRAY_SUB_TYPE,
@@ skipping 14 matching lines @@
 };
 
 
 template<>
 class MarkCompactMarkingVisitor::ObjectStatsTracker<
     MarkCompactMarkingVisitor::kVisitCode> {
  public:
   static inline void Visit(Map* map, HeapObject* obj) {
     Heap* heap = map->GetHeap();
     int object_size = obj->Size();
-    ASSERT(map->instance_type() == CODE_TYPE);
+    DCHECK(map->instance_type() == CODE_TYPE);
     Code* code_obj = Code::cast(obj);
     heap->RecordCodeSubTypeStats(code_obj->kind(), code_obj->GetRawAge(),
                                  object_size);
     ObjectStatsVisitBase(kVisitCode, map, obj);
   }
 };
 
 
 template<>
 class MarkCompactMarkingVisitor::ObjectStatsTracker<
@@ skipping 117 matching lines @@
   // If code flushing is disabled, there is no need to prepare for it.
   if (!is_code_flushing_enabled()) return;
 
   // Ensure that empty descriptor array is marked. Method MarkDescriptorArray
   // relies on it being marked before any other descriptor array.
   HeapObject* descriptor_array = heap()->empty_descriptor_array();
   MarkBit descriptor_array_mark = Marking::MarkBitFrom(descriptor_array);
   MarkObject(descriptor_array, descriptor_array_mark);
 
   // Make sure we are not referencing the code from the stack.
-  ASSERT(this == heap()->mark_compact_collector());
+  DCHECK(this == heap()->mark_compact_collector());
   PrepareThreadForCodeFlushing(heap()->isolate(),
                                heap()->isolate()->thread_local_top());
 
   // Iterate the archived stacks in all threads to check if
   // the code is referenced.
   CodeMarkingVisitor code_marking_visitor(this);
   heap()->isolate()->thread_manager()->IterateArchivedThreads(
       &code_marking_visitor);
 
   SharedFunctionInfoMarkingVisitor visitor(this);
@@ skipping 56 matching lines @@
   explicit StringTableCleaner(Heap* heap)
     : heap_(heap), pointers_removed_(0) { }
 
   virtual void VisitPointers(Object** start, Object** end) {
     // Visit all HeapObject pointers in [start, end).
     for (Object** p = start; p < end; p++) {
       Object* o = *p;
       if (o->IsHeapObject() &&
           !Marking::MarkBitFrom(HeapObject::cast(o)).Get()) {
         if (finalize_external_strings) {
-          ASSERT(o->IsExternalString());
+          DCHECK(o->IsExternalString());
           heap_->FinalizeExternalString(String::cast(*p));
         } else {
           pointers_removed_++;
         }
         // Set the entry to the_hole_value (as deleted).
         *p = heap_->the_hole_value();
       }
     }
   }
 
   int PointersRemoved() {
-    ASSERT(!finalize_external_strings);
+    DCHECK(!finalize_external_strings);
     return pointers_removed_;
   }
 
  private:
   Heap* heap_;
   int pointers_removed_;
 };
 
 
 typedef StringTableCleaner<false> InternalizedStringTableCleaner;
@@ skipping 24 matching lines @@
 
 // Fill the marking stack with overflowed objects returned by the given
 // iterator.  Stop when the marking stack is filled or the end of the space
 // is reached, whichever comes first.
 template<class T>
 static void DiscoverGreyObjectsWithIterator(Heap* heap,
                                             MarkingDeque* marking_deque,
                                             T* it) {
   // The caller should ensure that the marking stack is initially not full,
   // so that we don't waste effort pointlessly scanning for objects.
-  ASSERT(!marking_deque->IsFull());
+  DCHECK(!marking_deque->IsFull());
 
   Map* filler_map = heap->one_pointer_filler_map();
   for (HeapObject* object = it->Next();
        object != NULL;
        object = it->Next()) {
     MarkBit markbit = Marking::MarkBitFrom(object);
     if ((object->map() != filler_map) && Marking::IsGrey(markbit)) {
       Marking::GreyToBlack(markbit);
       MemoryChunk::IncrementLiveBytesFromGC(object->address(), object->Size());
       marking_deque->PushBlack(object);
       if (marking_deque->IsFull()) return;
     }
   }
 }
 
 
 static inline int MarkWordToObjectStarts(uint32_t mark_bits, int* starts);
 
 
 static void DiscoverGreyObjectsOnPage(MarkingDeque* marking_deque,
                                       MemoryChunk* p) {
-  ASSERT(!marking_deque->IsFull());
-  ASSERT(strcmp(Marking::kWhiteBitPattern, "00") == 0);
-  ASSERT(strcmp(Marking::kBlackBitPattern, "10") == 0);
-  ASSERT(strcmp(Marking::kGreyBitPattern, "11") == 0);
-  ASSERT(strcmp(Marking::kImpossibleBitPattern, "01") == 0);
+  DCHECK(!marking_deque->IsFull());
+  DCHECK(strcmp(Marking::kWhiteBitPattern, "00") == 0);
+  DCHECK(strcmp(Marking::kBlackBitPattern, "10") == 0);
+  DCHECK(strcmp(Marking::kGreyBitPattern, "11") == 0);
+  DCHECK(strcmp(Marking::kImpossibleBitPattern, "01") == 0);
 
   for (MarkBitCellIterator it(p); !it.Done(); it.Advance()) {
     Address cell_base = it.CurrentCellBase();
     MarkBit::CellType* cell = it.CurrentCell();
 
     const MarkBit::CellType current_cell = *cell;
     if (current_cell == 0) continue;
 
     MarkBit::CellType grey_objects;
     if (it.HasNext()) {
       const MarkBit::CellType next_cell = *(cell+1);
       grey_objects = current_cell &
           ((current_cell >> 1) | (next_cell << (Bitmap::kBitsPerCell - 1)));
     } else {
       grey_objects = current_cell & (current_cell >> 1);
     }
 
     int offset = 0;
     while (grey_objects != 0) {
       int trailing_zeros = CompilerIntrinsics::CountTrailingZeros(grey_objects);
       grey_objects >>= trailing_zeros;
       offset += trailing_zeros;
       MarkBit markbit(cell, 1 << offset, false);
-      ASSERT(Marking::IsGrey(markbit));
+      DCHECK(Marking::IsGrey(markbit));
       Marking::GreyToBlack(markbit);
       Address addr = cell_base + offset * kPointerSize;
       HeapObject* object = HeapObject::FromAddress(addr);
       MemoryChunk::IncrementLiveBytesFromGC(object->address(), object->Size());
       marking_deque->PushBlack(object);
       if (marking_deque->IsFull()) return;
       offset += 2;
       grey_objects >>= 2;
     }
 
     grey_objects >>= (Bitmap::kBitsPerCell - 1);
   }
 }
 
 
 int MarkCompactCollector::DiscoverAndEvacuateBlackObjectsOnPage(
     NewSpace* new_space,
     NewSpacePage* p) {
-  ASSERT(strcmp(Marking::kWhiteBitPattern, "00") == 0);
-  ASSERT(strcmp(Marking::kBlackBitPattern, "10") == 0);
-  ASSERT(strcmp(Marking::kGreyBitPattern, "11") == 0);
-  ASSERT(strcmp(Marking::kImpossibleBitPattern, "01") == 0);
+  DCHECK(strcmp(Marking::kWhiteBitPattern, "00") == 0);
+  DCHECK(strcmp(Marking::kBlackBitPattern, "10") == 0);
+  DCHECK(strcmp(Marking::kGreyBitPattern, "11") == 0);
+  DCHECK(strcmp(Marking::kImpossibleBitPattern, "01") == 0);
 
   MarkBit::CellType* cells = p->markbits()->cells();
   int survivors_size = 0;
 
   for (MarkBitCellIterator it(p); !it.Done(); it.Advance()) {
     Address cell_base = it.CurrentCellBase();
     MarkBit::CellType* cell = it.CurrentCell();
 
     MarkBit::CellType current_cell = *cell;
     if (current_cell == 0) continue;
@@ skipping 22 matching lines @@
 
       AllocationResult allocation = new_space->AllocateRaw(size);
       if (allocation.IsRetry()) {
         if (!new_space->AddFreshPage()) {
           // Shouldn't happen. We are sweeping linearly, and to-space
           // has the same number of pages as from-space, so there is
           // always room.
           UNREACHABLE();
         }
         allocation = new_space->AllocateRaw(size);
-        ASSERT(!allocation.IsRetry());
+        DCHECK(!allocation.IsRetry());
       }
       Object* target = allocation.ToObjectChecked();
 
       MigrateObject(HeapObject::cast(target),
                     object,
                     size,
                     NEW_SPACE);
       heap()->IncrementSemiSpaceCopiedObjectSize(size);
     }
     *cells = 0;
@@ skipping 36 matching lines @@
   if (!o->IsHeapObject()) return false;
   HeapObject* heap_object = HeapObject::cast(o);
   MarkBit mark = Marking::MarkBitFrom(heap_object);
   return !mark.Get();
 }
 
 
 bool MarkCompactCollector::IsUnmarkedHeapObjectWithHeap(Heap* heap,
                                                         Object** p) {
   Object* o = *p;
-  ASSERT(o->IsHeapObject());
+  DCHECK(o->IsHeapObject());
   HeapObject* heap_object = HeapObject::cast(o);
   MarkBit mark = Marking::MarkBitFrom(heap_object);
   return !mark.Get();
 }
 
 
 void MarkCompactCollector::MarkStringTable(RootMarkingVisitor* visitor) {
   StringTable* string_table = heap()->string_table();
   // Mark the string table itself.
   MarkBit string_table_mark = Marking::MarkBitFrom(string_table);
@@ skipping 31 matching lines @@
 }
 
 
 void MarkCompactCollector::MarkImplicitRefGroups() {
   List<ImplicitRefGroup*>* ref_groups =
       isolate()->global_handles()->implicit_ref_groups();
 
   int last = 0;
   for (int i = 0; i < ref_groups->length(); i++) {
     ImplicitRefGroup* entry = ref_groups->at(i);
-    ASSERT(entry != NULL);
+    DCHECK(entry != NULL);
 
     if (!IsMarked(*entry->parent)) {
       (*ref_groups)[last++] = entry;
       continue;
     }
 
     Object*** children = entry->children;
     // A parent object is marked, so mark all child heap objects.
     for (size_t j = 0; j < entry->length; ++j) {
       if ((*children[j])->IsHeapObject()) {
@@ skipping 21 matching lines @@
 }
 
 
 // Mark all objects reachable from the objects on the marking stack.
 // Before: the marking stack contains zero or more heap object pointers.
 // After: the marking stack is empty, and all objects reachable from the
 // marking stack have been marked, or are overflowed in the heap.
 void MarkCompactCollector::EmptyMarkingDeque() {
   while (!marking_deque_.IsEmpty()) {
     HeapObject* object = marking_deque_.Pop();
-    ASSERT(object->IsHeapObject());
-    ASSERT(heap()->Contains(object));
-    ASSERT(Marking::IsBlack(Marking::MarkBitFrom(object)));
+    DCHECK(object->IsHeapObject());
+    DCHECK(heap()->Contains(object));
+    DCHECK(Marking::IsBlack(Marking::MarkBitFrom(object)));
 
     Map* map = object->map();
     MarkBit map_mark = Marking::MarkBitFrom(map);
     MarkObject(map, map_mark);
 
     MarkCompactMarkingVisitor::IterateBody(map, object);
   }
 }
 
 
 // Sweep the heap for overflowed objects, clear their overflow bits, and
 // push them on the marking stack.  Stop early if the marking stack fills
 // before sweeping completes.  If sweeping completes, there are no remaining
 // overflowed objects in the heap so the overflow flag on the markings stack
 // is cleared.
 void MarkCompactCollector::RefillMarkingDeque() {
-  ASSERT(marking_deque_.overflowed());
+  DCHECK(marking_deque_.overflowed());
 
   DiscoverGreyObjectsInNewSpace(heap(), &marking_deque_);
   if (marking_deque_.IsFull()) return;
 
   DiscoverGreyObjectsInSpace(heap(),
                              &marking_deque_,
                              heap()->old_pointer_space());
   if (marking_deque_.IsFull()) return;
 
   DiscoverGreyObjectsInSpace(heap(),
@@ skipping 41 matching lines @@
     RefillMarkingDeque();
     EmptyMarkingDeque();
   }
 }
 
 
 // Mark all objects reachable (transitively) from objects on the marking
 // stack including references only considered in the atomic marking pause.
 void MarkCompactCollector::ProcessEphemeralMarking(ObjectVisitor* visitor) {
   bool work_to_do = true;
-  ASSERT(marking_deque_.IsEmpty());
+  DCHECK(marking_deque_.IsEmpty());
   while (work_to_do) {
     isolate()->global_handles()->IterateObjectGroups(
         visitor, &IsUnmarkedHeapObjectWithHeap);
     MarkImplicitRefGroups();
     ProcessWeakCollections();
     work_to_do = !marking_deque_.IsEmpty();
     ProcessMarkingDeque();
   }
 }
 
@@ skipping 39 matching lines @@
     incremental_marking->Finalize();
     incremental_marking_overflowed =
         incremental_marking->marking_deque()->overflowed();
     incremental_marking->marking_deque()->ClearOverflowed();
   } else {
     // Abort any pending incremental activities e.g. incremental sweeping.
     incremental_marking->Abort();
   }
 
 #ifdef DEBUG
-  ASSERT(state_ == PREPARE_GC);
+  DCHECK(state_ == PREPARE_GC);
   state_ = MARK_LIVE_OBJECTS;
 #endif
   // The to space contains live objects, a page in from space is used as a
   // marking stack.
   Address marking_deque_start = heap()->new_space()->FromSpacePageLow();
   Address marking_deque_end = heap()->new_space()->FromSpacePageHigh();
   if (FLAG_force_marking_deque_overflows) {
     marking_deque_end = marking_deque_start + 64 * kPointerSize;
   }
   marking_deque_.Initialize(marking_deque_start,
                             marking_deque_end);
-  ASSERT(!marking_deque_.overflowed());
+  DCHECK(!marking_deque_.overflowed());
 
   if (incremental_marking_overflowed) {
     // There are overflowed objects left in the heap after incremental marking.
     marking_deque_.SetOverflowed();
   }
 
   PrepareForCodeFlushing();
 
   if (was_marked_incrementally_) {
     // There is no write barrier on cells so we have to scan them now at the end
     // of the incremental marking.
     {
       HeapObjectIterator cell_iterator(heap()->cell_space());
       HeapObject* cell;
       while ((cell = cell_iterator.Next()) != NULL) {
-        ASSERT(cell->IsCell());
+        DCHECK(cell->IsCell());
         if (IsMarked(cell)) {
           int offset = Cell::kValueOffset;
           MarkCompactMarkingVisitor::VisitPointer(
               heap(),
               reinterpret_cast<Object**>(cell->address() + offset));
         }
       }
     }
     {
       HeapObjectIterator js_global_property_cell_iterator(
           heap()->property_cell_space());
       HeapObject* cell;
       while ((cell = js_global_property_cell_iterator.Next()) != NULL) {
-        ASSERT(cell->IsPropertyCell());
+        DCHECK(cell->IsPropertyCell());
         if (IsMarked(cell)) {
           MarkCompactMarkingVisitor::VisitPropertyCell(cell->map(), cell);
         }
       }
     }
   }
 
   RootMarkingVisitor root_visitor(heap());
   MarkRoots(&root_visitor);
 
@@ skipping 94 matching lines @@
              i += MapCache::kEntrySize) {
           Object* raw_key = map_cache->get(i);
           if (raw_key == heap()->undefined_value() ||
               raw_key == heap()->the_hole_value()) continue;
           STATIC_ASSERT(MapCache::kEntrySize == 2);
           Object* raw_map = map_cache->get(i + 1);
           if (raw_map->IsHeapObject() && IsMarked(raw_map)) {
             ++used_elements;
           } else {
             // Delete useless entries with unmarked maps.
-            ASSERT(raw_map->IsMap());
+            DCHECK(raw_map->IsMap());
             map_cache->set_the_hole(i);
             map_cache->set_the_hole(i + 1);
           }
         }
         if (used_elements == 0) {
           context->set(Context::MAP_CACHE_INDEX, heap()->undefined_value());
         } else {
           // Note: we don't actually shrink the cache here to avoid
           // extra complexity during GC. We rely on subsequent cache
           // usages (EnsureCapacity) to do this.
@@ skipping 100 matching lines @@
 
   int new_number_of_transitions = 0;
   const int header = Map::kProtoTransitionHeaderSize;
   const int proto_offset = header + Map::kProtoTransitionPrototypeOffset;
   const int map_offset = header + Map::kProtoTransitionMapOffset;
   const int step = Map::kProtoTransitionElementsPerEntry;
   for (int i = 0; i < number_of_transitions; i++) {
     Object* prototype = prototype_transitions->get(proto_offset + i * step);
     Object* cached_map = prototype_transitions->get(map_offset + i * step);
     if (IsMarked(prototype) && IsMarked(cached_map)) {
-      ASSERT(!prototype->IsUndefined());
+      DCHECK(!prototype->IsUndefined());
       int proto_index = proto_offset + new_number_of_transitions * step;
       int map_index = map_offset + new_number_of_transitions * step;
       if (new_number_of_transitions != i) {
         prototype_transitions->set(
             proto_index,
             prototype,
             UPDATE_WRITE_BARRIER);
         prototype_transitions->set(
             map_index,
             cached_map,
@@ skipping 33 matching lines @@
   }
 }
 
 
 void MarkCompactCollector::ClearDependentICList(Object* head) {
   Object* current = head;
   Object* undefined = heap()->undefined_value();
   while (current != undefined) {
     Code* code = Code::cast(current);
     if (IsMarked(code)) {
-      ASSERT(code->is_weak_stub());
+      DCHECK(code->is_weak_stub());
       IC::InvalidateMaps(code);
     }
     current = code->next_code_link();
     code->set_next_code_link(undefined);
   }
 }
 
 
 void MarkCompactCollector::ClearDependentCode(
     DependentCode* entries) {
   DisallowHeapAllocation no_allocation;
   DependentCode::GroupStartIndexes starts(entries);
   int number_of_entries = starts.number_of_entries();
   if (number_of_entries == 0) return;
   int g = DependentCode::kWeakICGroup;
   if (starts.at(g) != starts.at(g + 1)) {
     int i = starts.at(g);
-    ASSERT(i + 1 == starts.at(g + 1));
+    DCHECK(i + 1 == starts.at(g + 1));
     Object* head = entries->object_at(i);
     ClearDependentICList(head);
   }
   g = DependentCode::kWeakCodeGroup;
   for (int i = starts.at(g); i < starts.at(g + 1); i++) {
     // If the entry is compilation info then the map must be alive,
     // and ClearDependentCode shouldn't be called.
-    ASSERT(entries->is_code_at(i));
+    DCHECK(entries->is_code_at(i));
     Code* code = entries->code_at(i);
     if (IsMarked(code) && !code->marked_for_deoptimization()) {
       code->set_marked_for_deoptimization(true);
       code->InvalidateEmbeddedObjects();
       have_code_to_deoptimize_ = true;
     }
   }
   for (int i = 0; i < number_of_entries; i++) {
     entries->clear_at(i);
   }
 }
 
 
 int MarkCompactCollector::ClearNonLiveDependentCodeInGroup(
     DependentCode* entries, int group, int start, int end, int new_start) {
   int survived = 0;
   if (group == DependentCode::kWeakICGroup) {
     // Dependent weak IC stubs form a linked list and only the head is stored
     // in the dependent code array.
     if (start != end) {
-      ASSERT(start + 1 == end);
+      DCHECK(start + 1 == end);
       Object* old_head = entries->object_at(start);
       MarkCompactWeakObjectRetainer retainer;
       Object* head = VisitWeakList<Code>(heap(), old_head, &retainer);
       entries->set_object_at(new_start, head);
       Object** slot = entries->slot_at(new_start);
       RecordSlot(slot, slot, head);
       // We do not compact this group even if the head is undefined,
       // more dependent ICs are likely to be added later.
       survived = 1;
     }
   } else {
     for (int i = start; i < end; i++) {
       Object* obj = entries->object_at(i);
-      ASSERT(obj->IsCode() || IsMarked(obj));
+      DCHECK(obj->IsCode() || IsMarked(obj));
       if (IsMarked(obj) &&
           (!obj->IsCode() || !WillBeDeoptimized(Code::cast(obj)))) {
         if (new_start + survived != i) {
           entries->set_object_at(new_start + survived, obj);
         }
         Object** slot = entries->slot_at(new_start + survived);
         RecordSlot(slot, slot, obj);
         survived++;
       }
     }
@@ skipping 22 matching lines @@
 }
 
 
 void MarkCompactCollector::ProcessWeakCollections() {
   GCTracer::Scope gc_scope(heap()->tracer(),
                            GCTracer::Scope::MC_WEAKCOLLECTION_PROCESS);
   Object* weak_collection_obj = heap()->encountered_weak_collections();
   while (weak_collection_obj != Smi::FromInt(0)) {
     JSWeakCollection* weak_collection =
         reinterpret_cast<JSWeakCollection*>(weak_collection_obj);
-    ASSERT(MarkCompactCollector::IsMarked(weak_collection));
+    DCHECK(MarkCompactCollector::IsMarked(weak_collection));
     if (weak_collection->table()->IsHashTable()) {
       ObjectHashTable* table = ObjectHashTable::cast(weak_collection->table());
       Object** anchor = reinterpret_cast<Object**>(table->address());
       for (int i = 0; i < table->Capacity(); i++) {
         if (MarkCompactCollector::IsMarked(HeapObject::cast(table->KeyAt(i)))) {
           Object** key_slot =
               table->RawFieldOfElementAt(ObjectHashTable::EntryToIndex(i));
           RecordSlot(anchor, key_slot, *key_slot);
           Object** value_slot =
               table->RawFieldOfElementAt(ObjectHashTable::EntryToValueIndex(i));
           MarkCompactMarkingVisitor::MarkObjectByPointer(
               this, anchor, value_slot);
         }
       }
     }
     weak_collection_obj = weak_collection->next();
   }
 }
 
 
 void MarkCompactCollector::ClearWeakCollections() {
   GCTracer::Scope gc_scope(heap()->tracer(),
                            GCTracer::Scope::MC_WEAKCOLLECTION_CLEAR);
   Object* weak_collection_obj = heap()->encountered_weak_collections();
   while (weak_collection_obj != Smi::FromInt(0)) {
     JSWeakCollection* weak_collection =
         reinterpret_cast<JSWeakCollection*>(weak_collection_obj);
-    ASSERT(MarkCompactCollector::IsMarked(weak_collection));
+    DCHECK(MarkCompactCollector::IsMarked(weak_collection));
     if (weak_collection->table()->IsHashTable()) {
       ObjectHashTable* table = ObjectHashTable::cast(weak_collection->table());
       for (int i = 0; i < table->Capacity(); i++) {
         HeapObject* key = HeapObject::cast(table->KeyAt(i));
         if (!MarkCompactCollector::IsMarked(key)) {
           table->RemoveEntry(i);
         }
       }
     }
     weak_collection_obj = weak_collection->next();
@@ skipping 29 matching lines @@
 // to new space.  We should clear them to avoid encountering them during next
 // pointer iteration.  This is an issue if the store buffer overflows and we
 // have to scan the entire old space, including dead objects, looking for
 // pointers to new space.
 void MarkCompactCollector::MigrateObject(HeapObject* dst,
                                          HeapObject* src,
                                          int size,
                                          AllocationSpace dest) {
   Address dst_addr = dst->address();
   Address src_addr = src->address();
-  ASSERT(heap()->AllowedToBeMigrated(src, dest));
-  ASSERT(dest != LO_SPACE && size <= Page::kMaxRegularHeapObjectSize);
+  DCHECK(heap()->AllowedToBeMigrated(src, dest));
+  DCHECK(dest != LO_SPACE && size <= Page::kMaxRegularHeapObjectSize);
   if (dest == OLD_POINTER_SPACE) {
     Address src_slot = src_addr;
     Address dst_slot = dst_addr;
-    ASSERT(IsAligned(size, kPointerSize));
+    DCHECK(IsAligned(size, kPointerSize));
 
     for (int remaining = size / kPointerSize; remaining > 0; remaining--) {
       Object* value = Memory::Object_at(src_slot);
 
       Memory::Object_at(dst_slot) = value;
 
       // We special case ConstantPoolArrays below since they could contain
       // integers value entries which look like tagged pointers.
       // TODO(mstarzinger): restructure this code to avoid this special-casing.
       if (!src->IsConstantPoolArray()) {
@@ skipping 42 matching lines @@
   } else if (dest == CODE_SPACE) {
     PROFILE(isolate(), CodeMoveEvent(src_addr, dst_addr));
     heap()->MoveBlock(dst_addr, src_addr, size);
     SlotsBuffer::AddTo(&slots_buffer_allocator_,
                        &migration_slots_buffer_,
                        SlotsBuffer::RELOCATED_CODE_OBJECT,
                        dst_addr,
                        SlotsBuffer::IGNORE_OVERFLOW);
     Code::cast(dst)->Relocate(dst_addr - src_addr);
   } else {
-    ASSERT(dest == OLD_DATA_SPACE || dest == NEW_SPACE);
+    DCHECK(dest == OLD_DATA_SPACE || dest == NEW_SPACE);
     heap()->MoveBlock(dst_addr, src_addr, size);
   }
   heap()->OnMoveEvent(dst, src, size);
   Memory::Address_at(src_addr) = dst_addr;
 }
 
 
 // Visitor for updating pointers from live objects in old spaces to new space.
 // It does not expect to encounter pointers to dead objects.
 class PointersUpdatingVisitor: public ObjectVisitor {
  public:
   explicit PointersUpdatingVisitor(Heap* heap) : heap_(heap) { }
 
   void VisitPointer(Object** p) {
     UpdatePointer(p);
   }
 
   void VisitPointers(Object** start, Object** end) {
     for (Object** p = start; p < end; p++) UpdatePointer(p);
   }
 
   void VisitEmbeddedPointer(RelocInfo* rinfo) {
-    ASSERT(rinfo->rmode() == RelocInfo::EMBEDDED_OBJECT);
+    DCHECK(rinfo->rmode() == RelocInfo::EMBEDDED_OBJECT);
     Object* target = rinfo->target_object();
     Object* old_target = target;
     VisitPointer(&target);
     // Avoid unnecessary changes that might unnecessary flush the instruction
     // cache.
     if (target != old_target) {
       rinfo->set_target_object(target);
     }
   }
 
   void VisitCodeTarget(RelocInfo* rinfo) {
-    ASSERT(RelocInfo::IsCodeTarget(rinfo->rmode()));
+    DCHECK(RelocInfo::IsCodeTarget(rinfo->rmode()));
     Object* target = Code::GetCodeFromTargetAddress(rinfo->target_address());
     Object* old_target = target;
     VisitPointer(&target);
     if (target != old_target) {
       rinfo->set_target_address(Code::cast(target)->instruction_start());
     }
   }
 
   void VisitCodeAgeSequence(RelocInfo* rinfo) {
-    ASSERT(RelocInfo::IsCodeAgeSequence(rinfo->rmode()));
+    DCHECK(RelocInfo::IsCodeAgeSequence(rinfo->rmode()));
     Object* stub = rinfo->code_age_stub();
-    ASSERT(stub != NULL);
+    DCHECK(stub != NULL);
     VisitPointer(&stub);
     if (stub != rinfo->code_age_stub()) {
       rinfo->set_code_age_stub(Code::cast(stub));
     }
   }
 
   void VisitDebugTarget(RelocInfo* rinfo) {
-    ASSERT((RelocInfo::IsJSReturn(rinfo->rmode()) &&
+    DCHECK((RelocInfo::IsJSReturn(rinfo->rmode()) &&
             rinfo->IsPatchedReturnSequence()) ||
            (RelocInfo::IsDebugBreakSlot(rinfo->rmode()) &&
             rinfo->IsPatchedDebugBreakSlotSequence()));
     Object* target = Code::GetCodeFromTargetAddress(rinfo->call_address());
     VisitPointer(&target);
     rinfo->set_call_address(Code::cast(target)->instruction_start());
   }
 
   static inline void UpdateSlot(Heap* heap, Object** slot) {
     Object* obj = *slot;
 
     if (!obj->IsHeapObject()) return;
 
     HeapObject* heap_obj = HeapObject::cast(obj);
 
     MapWord map_word = heap_obj->map_word();
     if (map_word.IsForwardingAddress()) {
-      ASSERT(heap->InFromSpace(heap_obj) ||
+      DCHECK(heap->InFromSpace(heap_obj) ||
              MarkCompactCollector::IsOnEvacuationCandidate(heap_obj));
       HeapObject* target = map_word.ToForwardingAddress();
       *slot = target;
-      ASSERT(!heap->InFromSpace(target) &&
+      DCHECK(!heap->InFromSpace(target) &&
              !MarkCompactCollector::IsOnEvacuationCandidate(target));
     }
   }
 
  private:
   inline void UpdatePointer(Object** p) {
     UpdateSlot(heap_, p);
   }
 
   Heap* heap_;
@@ skipping 35 matching lines @@
   if (map_word.IsForwardingAddress()) {
     return String::cast(map_word.ToForwardingAddress());
   }
 
   return String::cast(*p);
 }
 
 
 bool MarkCompactCollector::TryPromoteObject(HeapObject* object,
                                             int object_size) {
-  ASSERT(object_size <= Page::kMaxRegularHeapObjectSize);
+  DCHECK(object_size <= Page::kMaxRegularHeapObjectSize);
 
   OldSpace* target_space = heap()->TargetSpace(object);
 
-  ASSERT(target_space == heap()->old_pointer_space() ||
+  DCHECK(target_space == heap()->old_pointer_space() ||
          target_space == heap()->old_data_space());
   HeapObject* target;
   AllocationResult allocation = target_space->AllocateRaw(object_size);
   if (allocation.To(&target)) {
     MigrateObject(target,
                   object,
                   object_size,
                   target_space->identity());
     heap()->IncrementPromotedObjectsSize(object_size);
     return true;
@@ skipping 33 matching lines @@
   }
 
   heap_->IncrementYoungSurvivorsCounter(survivors_size);
   new_space->set_age_mark(new_space->top());
 }
 
 
 void MarkCompactCollector::EvacuateLiveObjectsFromPage(Page* p) {
   AlwaysAllocateScope always_allocate(isolate());
   PagedSpace* space = static_cast<PagedSpace*>(p->owner());
-  ASSERT(p->IsEvacuationCandidate() && !p->WasSwept());
+  DCHECK(p->IsEvacuationCandidate() && !p->WasSwept());
   p->MarkSweptPrecisely();
 
   int offsets[16];
 
   for (MarkBitCellIterator it(p); !it.Done(); it.Advance()) {
     Address cell_base = it.CurrentCellBase();
     MarkBit::CellType* cell = it.CurrentCell();
 
     if (*cell == 0) continue;
 
     int live_objects = MarkWordToObjectStarts(*cell, offsets);
     for (int i = 0; i < live_objects; i++) {
       Address object_addr = cell_base + offsets[i] * kPointerSize;
       HeapObject* object = HeapObject::FromAddress(object_addr);
-      ASSERT(Marking::IsBlack(Marking::MarkBitFrom(object)));
+      DCHECK(Marking::IsBlack(Marking::MarkBitFrom(object)));
 
       int size = object->Size();
 
       HeapObject* target_object;
       AllocationResult allocation = space->AllocateRaw(size);
       if (!allocation.To(&target_object)) {
         // If allocation failed, use emergency memory and re-try allocation.
         CHECK(space->HasEmergencyMemory());
         space->UseEmergencyMemory();
         allocation = space->AllocateRaw(size);
       }
       if (!allocation.To(&target_object)) {
         // OS refused to give us memory.
         V8::FatalProcessOutOfMemory("Evacuation");
         return;
       }
 
       MigrateObject(target_object, object, size, space->identity());
-      ASSERT(object->map_word().IsForwardingAddress());
+      DCHECK(object->map_word().IsForwardingAddress());
     }
 
     // Clear marking bits for current cell.
     *cell = 0;
   }
   p->ResetLiveBytes();
 }
 
 
 void MarkCompactCollector::EvacuatePages() {
   int npages = evacuation_candidates_.length();
   for (int i = 0; i < npages; i++) {
     Page* p = evacuation_candidates_[i];
-    ASSERT(p->IsEvacuationCandidate() ||
+    DCHECK(p->IsEvacuationCandidate() ||
            p->IsFlagSet(Page::RESCAN_ON_EVACUATION));
-    ASSERT(static_cast<int>(p->parallel_sweeping()) ==
+    DCHECK(static_cast<int>(p->parallel_sweeping()) ==
            MemoryChunk::SWEEPING_DONE);
     PagedSpace* space = static_cast<PagedSpace*>(p->owner());
     // Allocate emergency memory for the case when compaction fails due to out
     // of memory.
     if (!space->HasEmergencyMemory()) {
       space->CreateEmergencyMemory();
     }
     if (p->IsEvacuationCandidate()) {
       // During compaction we might have to request a new page. Check that we
       // have an emergency page and the space still has room for that.
@@ skipping 98 matching lines @@
   ZAP_FREE_SPACE
 };
 
 
 template<MarkCompactCollector::SweepingParallelism mode>
 static intptr_t Free(PagedSpace* space,
                      FreeList* free_list,
                      Address start,
                      int size) {
   if (mode == MarkCompactCollector::SWEEP_ON_MAIN_THREAD) {
-    ASSERT(free_list == NULL);
+    DCHECK(free_list == NULL);
     return space->Free(start, size);
   } else {
     // TODO(hpayer): account for wasted bytes in concurrent sweeping too.
     return size - free_list->Free(start, size);
   }
 }
 
 
 // Sweep a space precisely.  After this has been done the space can
 // be iterated precisely, hitting only the live objects.  Code space
 // is always swept precisely because we want to be able to iterate
 // over it.  Map space is swept precisely, because it is not compacted.
 // Slots in live objects pointing into evacuation candidates are updated
 // if requested.
 // Returns the size of the biggest continuous freed memory chunk in bytes.
 template<SweepingMode sweeping_mode,
          MarkCompactCollector::SweepingParallelism parallelism,
          SkipListRebuildingMode skip_list_mode,
          FreeSpaceTreatmentMode free_space_mode>
 static int SweepPrecisely(PagedSpace* space,
                            FreeList* free_list,
                            Page* p,
                            ObjectVisitor* v) {
-  ASSERT(!p->IsEvacuationCandidate() && !p->WasSwept());
-  ASSERT_EQ(skip_list_mode == REBUILD_SKIP_LIST,
+  DCHECK(!p->IsEvacuationCandidate() && !p->WasSwept());
+  DCHECK_EQ(skip_list_mode == REBUILD_SKIP_LIST,
             space->identity() == CODE_SPACE);
-  ASSERT((p->skip_list() == NULL) || (skip_list_mode == REBUILD_SKIP_LIST));
-  ASSERT(parallelism == MarkCompactCollector::SWEEP_ON_MAIN_THREAD ||
+  DCHECK((p->skip_list() == NULL) || (skip_list_mode == REBUILD_SKIP_LIST));
+  DCHECK(parallelism == MarkCompactCollector::SWEEP_ON_MAIN_THREAD ||
          sweeping_mode == SWEEP_ONLY);
 
   Address free_start = p->area_start();
-  ASSERT(reinterpret_cast<intptr_t>(free_start) % (32 * kPointerSize) == 0);
+  DCHECK(reinterpret_cast<intptr_t>(free_start) % (32 * kPointerSize) == 0);
   int offsets[16];
 
   SkipList* skip_list = p->skip_list();
   int curr_region = -1;
   if ((skip_list_mode == REBUILD_SKIP_LIST) && skip_list) {
     skip_list->Clear();
   }
 
   intptr_t freed_bytes = 0;
   intptr_t max_freed_bytes = 0;
@@ skipping 12 matching lines @@
         }
         freed_bytes = Free<parallelism>(space, free_list, free_start, size);
         max_freed_bytes = Max(freed_bytes, max_freed_bytes);
 #ifdef ENABLE_GDB_JIT_INTERFACE
         if (FLAG_gdbjit && space->identity() == CODE_SPACE) {
           GDBJITInterface::RemoveCodeRange(free_start, free_end);
         }
 #endif
       }
       HeapObject* live_object = HeapObject::FromAddress(free_end);
-      ASSERT(Marking::IsBlack(Marking::MarkBitFrom(live_object)));
+      DCHECK(Marking::IsBlack(Marking::MarkBitFrom(live_object)));
       Map* map = live_object->map();
       int size = live_object->SizeFromMap(map);
       if (sweeping_mode == SWEEP_AND_VISIT_LIVE_OBJECTS) {
         live_object->IterateBody(map->instance_type(), size, v);
       }
       if ((skip_list_mode == REBUILD_SKIP_LIST) && skip_list != NULL) {
         int new_region_start =
             SkipList::RegionNumber(free_end);
         int new_region_end =
             SkipList::RegionNumber(free_end + size - kPointerSize);
@@ skipping 95 matching lines @@
   MarkBit mark_bit =
       p->markbits()->MarkBitFromIndex(Page::FastAddressToMarkbitIndex(addr));
 
   return mark_bit.Get();
 }
 
 
 void MarkCompactCollector::InvalidateCode(Code* code) {
   if (heap_->incremental_marking()->IsCompacting() &&
       !ShouldSkipEvacuationSlotRecording(code)) {
-    ASSERT(compacting_);
+    DCHECK(compacting_);
 
     // If the object is white than no slots were recorded on it yet.
     MarkBit mark_bit = Marking::MarkBitFrom(code);
     if (Marking::IsWhite(mark_bit)) return;
 
     invalidated_code_.Add(code);
   }
 }
 
 
@@ skipping 113 matching lines @@
         }
       }
     }
   }
 
   int npages = evacuation_candidates_.length();
   { GCTracer::Scope gc_scope(
       heap()->tracer(), GCTracer::Scope::MC_UPDATE_POINTERS_BETWEEN_EVACUATED);
     for (int i = 0; i < npages; i++) {
       Page* p = evacuation_candidates_[i];
-      ASSERT(p->IsEvacuationCandidate() ||
+      DCHECK(p->IsEvacuationCandidate() ||
              p->IsFlagSet(Page::RESCAN_ON_EVACUATION));
 
       if (p->IsEvacuationCandidate()) {
         SlotsBuffer::UpdateSlotsRecordedIn(heap_,
                                            p->slots_buffer(),
                                            code_slots_filtering_required);
         if (FLAG_trace_fragmentation) {
           PrintF("  page %p slots buffer: %d\n",
                  reinterpret_cast<void*>(p),
                  SlotsBuffer::SizeOfChain(p->slots_buffer()));
@@ skipping 85 matching lines @@
   EvacuationWeakObjectRetainer evacuation_object_retainer;
   heap()->ProcessWeakReferences(&evacuation_object_retainer);
 
   // Visit invalidated code (we ignored all slots on it) and clear mark-bits
   // under it.
   ProcessInvalidatedCode(&updating_visitor);
 
   heap_->isolate()->inner_pointer_to_code_cache()->Flush();
 
   slots_buffer_allocator_.DeallocateChain(&migration_slots_buffer_);
-  ASSERT(migration_slots_buffer_ == NULL);
+  DCHECK(migration_slots_buffer_ == NULL);
 }
 
 
 void MarkCompactCollector::MoveEvacuationCandidatesToEndOfPagesList() {
   int npages = evacuation_candidates_.length();
   for (int i = 0; i < npages; i++) {
     Page* p = evacuation_candidates_[i];
     if (!p->IsEvacuationCandidate()) continue;
     p->Unlink();
     PagedSpace* space = static_cast<PagedSpace*>(p->owner());
@@ skipping 213 matching lines @@
 #undef X
 
 
 // Takes a word of mark bits.  Returns the number of objects that start in the
 // range.  Puts the offsets of the words in the supplied array.
 static inline int MarkWordToObjectStarts(uint32_t mark_bits, int* starts) {
   int objects = 0;
   int offset = 0;
 
   // No consecutive 1 bits.
-  ASSERT((mark_bits & 0x180) != 0x180);
-  ASSERT((mark_bits & 0x18000) != 0x18000);
-  ASSERT((mark_bits & 0x1800000) != 0x1800000);
+  DCHECK((mark_bits & 0x180) != 0x180);
+  DCHECK((mark_bits & 0x18000) != 0x18000);
+  DCHECK((mark_bits & 0x1800000) != 0x1800000);
 
   while (mark_bits != 0) {
     int byte = (mark_bits & 0xff);
     mark_bits >>= 8;
     if (byte != 0) {
-      ASSERT(byte < kStartTableLines);  // No consecutive 1 bits.
+      DCHECK(byte < kStartTableLines);  // No consecutive 1 bits.
       char* table = kStartTable + byte * kStartTableEntriesPerLine;
       int objects_in_these_8_words = table[0];
-      ASSERT(objects_in_these_8_words != kStartTableInvalidLine);
-      ASSERT(objects_in_these_8_words < kStartTableEntriesPerLine);
+      DCHECK(objects_in_these_8_words != kStartTableInvalidLine);
+      DCHECK(objects_in_these_8_words < kStartTableEntriesPerLine);
       for (int i = 0; i < objects_in_these_8_words; i++) {
         starts[objects++] = offset + table[1 + i];
       }
     }
     offset += 8;
   }
   return objects;
 }
 
 
 static inline Address DigestFreeStart(Address approximate_free_start,
                                       uint32_t free_start_cell) {
-  ASSERT(free_start_cell != 0);
+  DCHECK(free_start_cell != 0);
 
   // No consecutive 1 bits.
-  ASSERT((free_start_cell & (free_start_cell << 1)) == 0);
+  DCHECK((free_start_cell & (free_start_cell << 1)) == 0);
 
   int offsets[16];
   uint32_t cell = free_start_cell;
   int offset_of_last_live;
   if ((cell & 0x80000000u) != 0) {
     // This case would overflow below.
     offset_of_last_live = 31;
   } else {
     // Remove all but one bit, the most significant.  This is an optimization
     // that may or may not be worthwhile.
     cell |= cell >> 16;
     cell |= cell >> 8;
     cell |= cell >> 4;
     cell |= cell >> 2;
     cell |= cell >> 1;
     cell = (cell + 1) >> 1;
     int live_objects = MarkWordToObjectStarts(cell, offsets);
-    ASSERT(live_objects == 1);
+    DCHECK(live_objects == 1);
     offset_of_last_live = offsets[live_objects - 1];
   }
   Address last_live_start =
       approximate_free_start + offset_of_last_live * kPointerSize;
   HeapObject* last_live = HeapObject::FromAddress(last_live_start);
   Address free_start = last_live_start + last_live->Size();
   return free_start;
 }
 
 
 static inline Address StartOfLiveObject(Address block_address, uint32_t cell) {
-  ASSERT(cell != 0);
+  DCHECK(cell != 0);
 
   // No consecutive 1 bits.
-  ASSERT((cell & (cell << 1)) == 0);
+  DCHECK((cell & (cell << 1)) == 0);
 
   int offsets[16];
   if (cell == 0x80000000u) {  // Avoid overflow below.
     return block_address + 31 * kPointerSize;
   }
   uint32_t first_set_bit = ((cell ^ (cell - 1)) + 1) >> 1;
-  ASSERT((first_set_bit & cell) == first_set_bit);
+  DCHECK((first_set_bit & cell) == first_set_bit);
   int live_objects = MarkWordToObjectStarts(first_set_bit, offsets);
-  ASSERT(live_objects == 1);
+  DCHECK(live_objects == 1);
   USE(live_objects);
   return block_address + offsets[0] * kPointerSize;
 }
 
 
 // Force instantiation of templatized SweepConservatively method for
 // SWEEP_ON_MAIN_THREAD mode.
 template int MarkCompactCollector::
     SweepConservatively<MarkCompactCollector::SWEEP_ON_MAIN_THREAD>(
         PagedSpace*, FreeList*, Page*);
@@ skipping 10 matching lines @@
 // spaces have been put on the free list and the smaller ones have been
 // ignored and left untouched.  A free space is always either ignored or put
 // on the free list, never split up into two parts.  This is important
 // because it means that any FreeSpace maps left actually describe a region of
 // memory that can be ignored when scanning.  Dead objects other than free
 // spaces will not contain the free space map.
 template<MarkCompactCollector::SweepingParallelism mode>
 int MarkCompactCollector::SweepConservatively(PagedSpace* space,
                                               FreeList* free_list,
                                               Page* p) {
-  ASSERT(!p->IsEvacuationCandidate() && !p->WasSwept());
-  ASSERT((mode == MarkCompactCollector::SWEEP_IN_PARALLEL &&
+  DCHECK(!p->IsEvacuationCandidate() && !p->WasSwept());
+  DCHECK((mode == MarkCompactCollector::SWEEP_IN_PARALLEL &&
          free_list != NULL) ||
          (mode == MarkCompactCollector::SWEEP_ON_MAIN_THREAD &&
          free_list == NULL));
 
   intptr_t freed_bytes = 0;
   intptr_t max_freed_bytes = 0;
   size_t size = 0;
 
   // Skip over all the dead objects at the start of the page and mark them free.
   Address cell_base = 0;
   MarkBit::CellType* cell = NULL;
   MarkBitCellIterator it(p);
   for (; !it.Done(); it.Advance()) {
     cell_base = it.CurrentCellBase();
     cell = it.CurrentCell();
     if (*cell != 0) break;
   }
 
   if (it.Done()) {
     size = p->area_end() - p->area_start();
     freed_bytes = Free<mode>(space, free_list, p->area_start(),
                              static_cast<int>(size));
     max_freed_bytes = Max(freed_bytes, max_freed_bytes);
-    ASSERT_EQ(0, p->LiveBytes());
+    DCHECK_EQ(0, p->LiveBytes());
     if (mode == MarkCompactCollector::SWEEP_IN_PARALLEL) {
       // When concurrent sweeping is active, the page will be marked after
       // sweeping by the main thread.
       p->set_parallel_sweeping(MemoryChunk::SWEEPING_FINALIZE);
     } else {
       p->MarkSweptConservatively();
     }
     return FreeList::GuaranteedAllocatable(static_cast<int>(max_freed_bytes));
   }
 
@@ skipping 63 matching lines @@
 
 
 int MarkCompactCollector::SweepInParallel(PagedSpace* space,
                                           int required_freed_bytes) {
   int max_freed = 0;
   int max_freed_overall = 0;
   PageIterator it(space);
   while (it.has_next()) {
     Page* p = it.next();
     max_freed = SweepInParallel(p, space);
-    ASSERT(max_freed >= 0);
+    DCHECK(max_freed >= 0);
     if (required_freed_bytes > 0 && max_freed >= required_freed_bytes) {
       return max_freed;
     }
     max_freed_overall = Max(max_freed, max_freed_overall);
     if (p == space->end_of_unswept_pages()) break;
   }
   return max_freed_overall;
 }
 
 
@@ skipping 29 matching lines @@
   space->set_end_of_unswept_pages(space->FirstPage());
 
   PageIterator it(space);
 
   int pages_swept = 0;
   bool unused_page_present = false;
   bool parallel_sweeping_active = false;
 
   while (it.has_next()) {
     Page* p = it.next();
-    ASSERT(p->parallel_sweeping() == MemoryChunk::SWEEPING_DONE);
+    DCHECK(p->parallel_sweeping() == MemoryChunk::SWEEPING_DONE);
 
     // Clear sweeping flags indicating that marking bits are still intact.
     p->ClearSweptPrecisely();
     p->ClearSweptConservatively();
 
     if (p->IsFlagSet(Page::RESCAN_ON_EVACUATION) ||
         p->IsEvacuationCandidate()) {
       // Will be processed in EvacuateNewSpaceAndCandidates.
-      ASSERT(evacuation_candidates_.length() > 0);
+      DCHECK(evacuation_candidates_.length() > 0);
       continue;
     }
 
     // One unused page is kept, all further are released before sweeping them.
     if (p->LiveBytes() == 0) {
       if (unused_page_present) {
         if (FLAG_gc_verbose) {
           PrintF("Sweeping 0x%" V8PRIxPTR " released page.\n",
                  reinterpret_cast<intptr_t>(p));
         }
@@ skipping 191 matching lines @@
   while (it.has_next()) {
     Page* p = it.next();
     if (p->parallel_sweeping() == MemoryChunk::SWEEPING_FINALIZE) {
       p->set_parallel_sweeping(MemoryChunk::SWEEPING_DONE);
       if (space->swept_precisely()) {
         p->MarkSweptPrecisely();
       } else {
         p->MarkSweptConservatively();
       }
     }
-    ASSERT(p->parallel_sweeping() == MemoryChunk::SWEEPING_DONE);
+    DCHECK(p->parallel_sweeping() == MemoryChunk::SWEEPING_DONE);
   }
 }
 
 
 void MarkCompactCollector::ParallelSweepSpacesComplete() {
   ParallelSweepSpaceComplete(heap()->old_pointer_space());
   ParallelSweepSpaceComplete(heap()->old_data_space());
 }
 
 
@@ skipping 53 matching lines @@
                         AdditionMode mode) {
   SlotsBuffer* buffer = *buffer_address;
   if (buffer == NULL || !buffer->HasSpaceForTypedSlot()) {
     if (mode == FAIL_ON_OVERFLOW && ChainLengthThresholdReached(buffer)) {
       allocator->DeallocateChain(buffer_address);
       return false;
     }
     buffer = allocator->AllocateBuffer(buffer);
     *buffer_address = buffer;
   }
-  ASSERT(buffer->HasSpaceForTypedSlot());
+  DCHECK(buffer->HasSpaceForTypedSlot());
   buffer->Add(reinterpret_cast<ObjectSlot>(type));
   buffer->Add(reinterpret_cast<ObjectSlot>(addr));
   return true;
 }
 
 
 static inline SlotsBuffer::SlotType SlotTypeForRMode(RelocInfo::Mode rmode) {
   if (RelocInfo::IsCodeTarget(rmode)) {
     return SlotsBuffer::CODE_TARGET_SLOT;
   } else if (RelocInfo::IsEmbeddedObject(rmode)) {
@@ skipping 52 matching lines @@
                             SlotsBuffer::CODE_ENTRY_SLOT,
                             slot,
                             SlotsBuffer::FAIL_ON_OVERFLOW)) {
       EvictEvacuationCandidate(target_page);
     }
   }
 }
 
 
 void MarkCompactCollector::RecordCodeTargetPatch(Address pc, Code* target) {
-  ASSERT(heap()->gc_state() == Heap::MARK_COMPACT);
+  DCHECK(heap()->gc_state() == Heap::MARK_COMPACT);
   if (is_compacting()) {
     Code* host = isolate()->inner_pointer_to_code_cache()->
         GcSafeFindCodeForInnerPointer(pc);
     MarkBit mark_bit = Marking::MarkBitFrom(host);
     if (Marking::IsBlack(mark_bit)) {
       RelocInfo rinfo(pc, RelocInfo::CODE_TARGET, 0, host);
       RecordRelocSlot(&rinfo, target);
     }
   }
 }
 
 
 static inline SlotsBuffer::SlotType DecodeSlotType(
     SlotsBuffer::ObjectSlot slot) {
   return static_cast<SlotsBuffer::SlotType>(reinterpret_cast<intptr_t>(slot));
 }
 
 
 void SlotsBuffer::UpdateSlots(Heap* heap) {
   PointersUpdatingVisitor v(heap);
 
   for (int slot_idx = 0; slot_idx < idx_; ++slot_idx) {
     ObjectSlot slot = slots_[slot_idx];
     if (!IsTypedSlot(slot)) {
       PointersUpdatingVisitor::UpdateSlot(heap, slot);
     } else {
       ++slot_idx;
-      ASSERT(slot_idx < idx_);
+      DCHECK(slot_idx < idx_);
       UpdateSlot(heap->isolate(),
                  &v,
                  DecodeSlotType(slot),
                  reinterpret_cast<Address>(slots_[slot_idx]));
     }
   }
 }
 
 
 void SlotsBuffer::UpdateSlotsWithFilter(Heap* heap) {
   PointersUpdatingVisitor v(heap);
 
   for (int slot_idx = 0; slot_idx < idx_; ++slot_idx) {
     ObjectSlot slot = slots_[slot_idx];
     if (!IsTypedSlot(slot)) {
       if (!IsOnInvalidatedCodeObject(reinterpret_cast<Address>(slot))) {
         PointersUpdatingVisitor::UpdateSlot(heap, slot);
       }
     } else {
       ++slot_idx;
-      ASSERT(slot_idx < idx_);
+      DCHECK(slot_idx < idx_);
       Address pc = reinterpret_cast<Address>(slots_[slot_idx]);
       if (!IsOnInvalidatedCodeObject(pc)) {
         UpdateSlot(heap->isolate(),
                    &v,
                    DecodeSlotType(slot),
                    reinterpret_cast<Address>(slots_[slot_idx]));
       }
     }
   }
 }
@@ skipping 14 matching lines @@
   while (buffer != NULL) {
     SlotsBuffer* next_buffer = buffer->next();
     DeallocateBuffer(buffer);
     buffer = next_buffer;
   }
   *buffer_address = NULL;
 }
 
 
 } }  // namespace v8::internal