Rename ASSERT* to DCHECK*.

src/incremental-marking.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/incremental-marking.h"
 
 #include "src/code-stubs.h"
 #include "src/compilation-cache.h"
@@ skipping 35 matching lines @@
       heap_->mark_compact_collector()->RecordSlot(
           HeapObject::RawField(obj, 0), slot, value);
     }
   }
 }
 
 
 void IncrementalMarking::RecordWriteFromCode(HeapObject* obj,
                                              Object** slot,
                                              Isolate* isolate) {
-  ASSERT(obj->IsHeapObject());
+  DCHECK(obj->IsHeapObject());
   IncrementalMarking* marking = isolate->heap()->incremental_marking();
 
   MemoryChunk* chunk = MemoryChunk::FromAddress(obj->address());
   int counter = chunk->write_barrier_counter();
   if (counter < (MemoryChunk::kWriteBarrierCounterGranularity / 2)) {
     marking->write_barriers_invoked_since_last_step_ +=
         MemoryChunk::kWriteBarrierCounterGranularity -
             chunk->write_barrier_counter();
     chunk->set_write_barrier_counter(
         MemoryChunk::kWriteBarrierCounterGranularity);
@@ skipping 20 matching lines @@
     RelocInfo rinfo(pc, RelocInfo::CODE_TARGET, 0, host);
     RecordWriteIntoCode(host, &rinfo, value);
   }
 }
 
 
 void IncrementalMarking::RecordWriteOfCodeEntrySlow(JSFunction* host,
                                                     Object** slot,
                                                     Code* value) {
   if (BaseRecordWrite(host, slot, value)) {
-    ASSERT(slot != NULL);
+    DCHECK(slot != NULL);
     heap_->mark_compact_collector()->
         RecordCodeEntrySlot(reinterpret_cast<Address>(slot), value);
   }
 }
 
 
 void IncrementalMarking::RecordWriteIntoCodeSlow(HeapObject* obj,
                                                  RelocInfo* rinfo,
                                                  Object* value) {
   MarkBit value_bit = Marking::MarkBitFrom(HeapObject::cast(value));
@@ skipping 27 matching lines @@
                                             -heap_obj->Size());
     }
     Marking::AnyToGrey(mark_bit);
   }
 }
 
 
 static inline void MarkBlackOrKeepGrey(HeapObject* heap_object,
                                        MarkBit mark_bit,
                                        int size) {
-  ASSERT(!Marking::IsImpossible(mark_bit));
+  DCHECK(!Marking::IsImpossible(mark_bit));
   if (mark_bit.Get()) return;
   mark_bit.Set();
   MemoryChunk::IncrementLiveBytesFromGC(heap_object->address(), size);
-  ASSERT(Marking::IsBlack(mark_bit));
+  DCHECK(Marking::IsBlack(mark_bit));
 }
 
 
 static inline void MarkBlackOrKeepBlack(HeapObject* heap_object,
                                         MarkBit mark_bit,
                                         int size) {
-  ASSERT(!Marking::IsImpossible(mark_bit));
+  DCHECK(!Marking::IsImpossible(mark_bit));
   if (Marking::IsBlack(mark_bit)) return;
   Marking::MarkBlack(mark_bit);
   MemoryChunk::IncrementLiveBytesFromGC(heap_object->address(), size);
-  ASSERT(Marking::IsBlack(mark_bit));
+  DCHECK(Marking::IsBlack(mark_bit));
 }
 
 
 class IncrementalMarkingMarkingVisitor
     : public StaticMarkingVisitor<IncrementalMarkingMarkingVisitor> {
  public:
   static void Initialize() {
     StaticMarkingVisitor<IncrementalMarkingMarkingVisitor>::Initialize();
     table_.Register(kVisitFixedArray, &VisitFixedArrayIncremental);
     table_.Register(kVisitNativeContext, &VisitNativeContextIncremental);
@@ skipping 277 matching lines @@
   return FLAG_incremental_marking &&
       FLAG_incremental_marking_steps &&
       heap_->gc_state() == Heap::NOT_IN_GC &&
       !heap_->isolate()->serializer_enabled() &&
       heap_->isolate()->IsInitialized() &&
       heap_->PromotedSpaceSizeOfObjects() > kActivationThreshold;
 }
 
 
 void IncrementalMarking::ActivateGeneratedStub(Code* stub) {
-  ASSERT(RecordWriteStub::GetMode(stub) ==
+  DCHECK(RecordWriteStub::GetMode(stub) ==
          RecordWriteStub::STORE_BUFFER_ONLY);
 
   if (!IsMarking()) {
     // Initially stub is generated in STORE_BUFFER_ONLY mode thus
     // we don't need to do anything if incremental marking is
     // not active.
   } else if (IsCompacting()) {
     RecordWriteStub::Patch(stub, RecordWriteStub::INCREMENTAL_COMPACTION);
   } else {
     RecordWriteStub::Patch(stub, RecordWriteStub::INCREMENTAL);
@@ skipping 46 matching lines @@
     CHECK(success);
     marking_deque_memory_committed_ = false;
   }
 }
 
 
 void IncrementalMarking::Start(CompactionFlag flag) {
   if (FLAG_trace_incremental_marking) {
     PrintF("[IncrementalMarking] Start\n");
   }
-  ASSERT(FLAG_incremental_marking);
-  ASSERT(FLAG_incremental_marking_steps);
-  ASSERT(state_ == STOPPED);
-  ASSERT(heap_->gc_state() == Heap::NOT_IN_GC);
-  ASSERT(!heap_->isolate()->serializer_enabled());
-  ASSERT(heap_->isolate()->IsInitialized());
+  DCHECK(FLAG_incremental_marking);
+  DCHECK(FLAG_incremental_marking_steps);
+  DCHECK(state_ == STOPPED);
+  DCHECK(heap_->gc_state() == Heap::NOT_IN_GC);
+  DCHECK(!heap_->isolate()->serializer_enabled());
+  DCHECK(heap_->isolate()->IsInitialized());
 
   ResetStepCounters();
 
   if (!heap_->mark_compact_collector()->sweeping_in_progress()) {
     StartMarking(flag);
   } else {
     if (FLAG_trace_incremental_marking) {
       PrintF("[IncrementalMarking] Start sweeping.\n");
     }
     state_ = SWEEPING;
@@ skipping 74 matching lines @@
   int current = marking_deque_.bottom();
   int mask = marking_deque_.mask();
   int limit = marking_deque_.top();
   HeapObject** array = marking_deque_.array();
   int new_top = current;
 
   Map* filler_map = heap_->one_pointer_filler_map();
 
   while (current != limit) {
     HeapObject* obj = array[current];
-    ASSERT(obj->IsHeapObject());
+    DCHECK(obj->IsHeapObject());
     current = ((current + 1) & mask);
     if (heap_->InNewSpace(obj)) {
       MapWord map_word = obj->map_word();
       if (map_word.IsForwardingAddress()) {
         HeapObject* dest = map_word.ToForwardingAddress();
         array[new_top] = dest;
         new_top = ((new_top + 1) & mask);
-        ASSERT(new_top != marking_deque_.bottom());
+        DCHECK(new_top != marking_deque_.bottom());
 #ifdef DEBUG
         MarkBit mark_bit = Marking::MarkBitFrom(obj);
-        ASSERT(Marking::IsGrey(mark_bit) ||
+        DCHECK(Marking::IsGrey(mark_bit) ||
                (obj->IsFiller() && Marking::IsWhite(mark_bit)));
 #endif
       }
     } else if (obj->map() != filler_map) {
       // Skip one word filler objects that appear on the
       // stack when we perform in place array shift.
       array[new_top] = obj;
       new_top = ((new_top + 1) & mask);
-      ASSERT(new_top != marking_deque_.bottom());
+      DCHECK(new_top != marking_deque_.bottom());
 #ifdef DEBUG
         MarkBit mark_bit = Marking::MarkBitFrom(obj);
         MemoryChunk* chunk = MemoryChunk::FromAddress(obj->address());
-        ASSERT(Marking::IsGrey(mark_bit) ||
+        DCHECK(Marking::IsGrey(mark_bit) ||
                (obj->IsFiller() && Marking::IsWhite(mark_bit)) ||
                (chunk->IsFlagSet(MemoryChunk::HAS_PROGRESS_BAR) &&
                 Marking::IsBlack(mark_bit)));
 #endif
     }
   }
   marking_deque_.set_top(new_top);
 }
 
 
 void IncrementalMarking::VisitObject(Map* map, HeapObject* obj, int size) {
   MarkBit map_mark_bit = Marking::MarkBitFrom(map);
   if (Marking::IsWhite(map_mark_bit)) {
     WhiteToGreyAndPush(map, map_mark_bit);
   }
 
   IncrementalMarkingMarkingVisitor::IterateBody(map, obj);
 
   MarkBit mark_bit = Marking::MarkBitFrom(obj);
-#if ENABLE_SLOW_ASSERTS
+#if ENABLE_SLOW_DCHECKS
   MemoryChunk* chunk = MemoryChunk::FromAddress(obj->address());
-  SLOW_ASSERT(Marking::IsGrey(mark_bit) ||
+  SLOW_DCHECK(Marking::IsGrey(mark_bit) ||
               (obj->IsFiller() && Marking::IsWhite(mark_bit)) ||
               (chunk->IsFlagSet(MemoryChunk::HAS_PROGRESS_BAR) &&
                Marking::IsBlack(mark_bit)));
 #endif
   MarkBlackOrKeepBlack(obj, mark_bit, size);
 }
 
 
 intptr_t IncrementalMarking::ProcessMarkingDeque(intptr_t bytes_to_process) {
   intptr_t bytes_processed = 0;
@@ skipping 114 matching lines @@
 void IncrementalMarking::Finalize() {
   Hurry();
   state_ = STOPPED;
   is_compacting_ = false;
   heap_->new_space()->LowerInlineAllocationLimit(0);
   IncrementalMarking::set_should_hurry(false);
   ResetStepCounters();
   PatchIncrementalMarkingRecordWriteStubs(heap_,
                                           RecordWriteStub::STORE_BUFFER_ONLY);
   DeactivateIncrementalWriteBarrier();
-  ASSERT(marking_deque_.IsEmpty());
+  DCHECK(marking_deque_.IsEmpty());
   heap_->isolate()->stack_guard()->ClearGC();
 }
 
 
 void IncrementalMarking::MarkingComplete(CompletionAction action) {
   state_ = COMPLETE;
   // We will set the stack guard to request a GC now.  This will mean the rest
   // of the GC gets performed as soon as possible (we can't do a GC here in a
   // record-write context).  If a few things get allocated between now and then
   // that shouldn't make us do a scavenge and keep being incremental, so we set
@@ skipping 161 matching lines @@
   bytes_scanned_ = 0;
   write_barriers_invoked_since_last_step_ = 0;
 }
 
 
 int64_t IncrementalMarking::SpaceLeftInOldSpace() {
   return heap_->MaxOldGenerationSize() - heap_->PromotedSpaceSizeOfObjects();
 }
 
 } }  // namespace v8::internal