Rename ASSERT* to DCHECK*.

src/heap.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/accessors.h"
 #include "src/api.h"
 #include "src/base/once.h"
 #include "src/base/utils/random-number-generator.h"
@@ skipping 127 matching lines @@
       chunks_queued_for_free_(NULL),
       gc_callbacks_depth_(0) {
   // Allow build-time customization of the max semispace size. Building
   // V8 with snapshots and a non-default max semispace size is much
   // easier if you can define it as part of the build environment.
 #if defined(V8_MAX_SEMISPACE_SIZE)
   max_semi_space_size_ = reserved_semispace_size_ = V8_MAX_SEMISPACE_SIZE;
 #endif
 
   // Ensure old_generation_size_ is a multiple of kPageSize.
-  ASSERT(MB >= Page::kPageSize);
+  DCHECK(MB >= Page::kPageSize);
 
   memset(roots_, 0, sizeof(roots_[0]) * kRootListLength);
   set_native_contexts_list(NULL);
   set_array_buffers_list(Smi::FromInt(0));
   set_allocation_sites_list(Smi::FromInt(0));
   set_encountered_weak_collections(Smi::FromInt(0));
   // Put a dummy entry in the remembered pages so we can find the list the
   // minidump even if there are no real unmapped pages.
   RememberUnmappedPage(NULL, false);
 
@@ skipping 270 matching lines @@
   // Reset GC statistics.
   promoted_objects_size_ = 0;
   semi_space_copied_object_size_ = 0;
   nodes_died_in_new_space_ = 0;
   nodes_copied_in_new_space_ = 0;
   nodes_promoted_ = 0;
 
   UpdateMaximumCommitted();
 
 #ifdef DEBUG
-  ASSERT(!AllowHeapAllocation::IsAllowed() && gc_state_ == NOT_IN_GC);
+  DCHECK(!AllowHeapAllocation::IsAllowed() && gc_state_ == NOT_IN_GC);
 
   if (FLAG_gc_verbose) Print();
 
   ReportStatisticsBeforeGC();
 #endif  // DEBUG
 
   store_buffer()->GCPrologue();
 
   if (isolate()->concurrent_osr_enabled()) {
     isolate()->optimizing_compiler_thread()->AgeBufferedOsrJobs();
@@ skipping 383 matching lines @@
       }
       collector = SCAVENGER;
       collector_reason = "incremental marking delaying mark-sweep";
     }
   }
 
   bool next_gc_likely_to_collect_more = false;
 
   {
     tracer()->Start(collector, gc_reason, collector_reason);
-    ASSERT(AllowHeapAllocation::IsAllowed());
+    DCHECK(AllowHeapAllocation::IsAllowed());
     DisallowHeapAllocation no_allocation_during_gc;
     GarbageCollectionPrologue();
 
     {
       HistogramTimerScope histogram_timer_scope(
           (collector == SCAVENGER) ? isolate_->counters()->gc_scavenger()
                                    : isolate_->counters()->gc_compactor());
       next_gc_likely_to_collect_more =
           PerformGarbageCollection(collector, gc_callback_flags);
     }
@@ skipping 25 matching lines @@
   return ++contexts_disposed_;
 }
 
 
 void Heap::MoveElements(FixedArray* array,
                         int dst_index,
                         int src_index,
                         int len) {
   if (len == 0) return;
 
-  ASSERT(array->map() != fixed_cow_array_map());
+  DCHECK(array->map() != fixed_cow_array_map());
   Object** dst_objects = array->data_start() + dst_index;
   MemMove(dst_objects, array->data_start() + src_index, len * kPointerSize);
   if (!InNewSpace(array)) {
     for (int i = 0; i < len; i++) {
       // TODO(hpayer): check store buffer for entries
       if (InNewSpace(dst_objects[i])) {
         RecordWrite(array->address(), array->OffsetOfElementAt(dst_index + i));
       }
     }
   }
@@ skipping 35 matching lines @@
   return result;
 }
 
 
 void Heap::ReserveSpace(int *sizes, Address *locations_out) {
   bool gc_performed = true;
   int counter = 0;
   static const int kThreshold = 20;
   while (gc_performed && counter++ < kThreshold) {
     gc_performed = false;
-    ASSERT(NEW_SPACE == FIRST_PAGED_SPACE - 1);
+    DCHECK(NEW_SPACE == FIRST_PAGED_SPACE - 1);
     for (int space = NEW_SPACE; space <= LAST_PAGED_SPACE; space++) {
       if (sizes[space] != 0) {
         AllocationResult allocation;
         if (space == NEW_SPACE) {
           allocation = new_space()->AllocateRaw(sizes[space]);
         } else {
           allocation = paged_space(space)->AllocateRaw(sizes[space]);
         }
         FreeListNode* node;
         if (!allocation.To(&node)) {
@@ skipping 149 matching lines @@
   } else {
     Scavenge();
   }
 
   UpdateSurvivalStatistics(start_new_space_size);
 
   isolate_->counters()->objs_since_last_young()->Set(0);
 
   // Callbacks that fire after this point might trigger nested GCs and
   // restart incremental marking, the assertion can't be moved down.
-  ASSERT(collector == SCAVENGER || incremental_marking()->IsStopped());
+  DCHECK(collector == SCAVENGER || incremental_marking()->IsStopped());
 
   gc_post_processing_depth_++;
   { AllowHeapAllocation allow_allocation;
     GCTracer::Scope scope(tracer(), GCTracer::Scope::EXTERNAL);
     freed_global_handles =
         isolate_->global_handles()->PostGarbageCollectionProcessing(collector);
   }
   gc_post_processing_depth_--;
 
   isolate_->eternal_handles()->PostGarbageCollectionProcessing(this);
@@ skipping 220 matching lines @@
                  (store_buffer_->Limit() - store_buffer_->Top()) >> 2) {
         // Did we find too many pointers in the previous page?  The heuristic is
         // that no page can take more then 1/5 the remaining slots in the store
         // buffer.
         current_page_->set_scan_on_scavenge(true);
         store_buffer_->SetTop(start_of_current_page_);
       } else {
         // In this case the page we scanned took a reasonable number of slots in
         // the store buffer.  It has now been rehabilitated and is no longer
         // marked scan_on_scavenge.
-        ASSERT(!current_page_->scan_on_scavenge());
+        DCHECK(!current_page_->scan_on_scavenge());
       }
     }
     start_of_current_page_ = store_buffer_->Top();
     current_page_ = page;
   } else if (event == kStoreBufferFullEvent) {
     // The current page overflowed the store buffer again.  Wipe out its entries
     // in the store buffer and mark it scan-on-scavenge again.  This may happen
     // several times while scanning.
     if (current_page_ == NULL) {
       // Store Buffer overflowed while scanning promoted objects.  These are not
       // in any particular page, though they are likely to be clustered by the
       // allocation routines.
       store_buffer_->EnsureSpace(StoreBuffer::kStoreBufferSize / 2);
     } else {
       // Store Buffer overflowed while scanning a particular old space page for
       // pointers to new space.
-      ASSERT(current_page_ == page);
-      ASSERT(page != NULL);
+      DCHECK(current_page_ == page);
+      DCHECK(page != NULL);
       current_page_->set_scan_on_scavenge(true);
-      ASSERT(start_of_current_page_ != store_buffer_->Top());
+      DCHECK(start_of_current_page_ != store_buffer_->Top());
       store_buffer_->SetTop(start_of_current_page_);
     }
   } else {
     UNREACHABLE();
   }
 }
 
 
 void PromotionQueue::Initialize() {
   // Assumes that a NewSpacePage exactly fits a number of promotion queue
   // entries (where each is a pair of intptr_t). This allows us to simplify
   // the test fpr when to switch pages.
-  ASSERT((Page::kPageSize - MemoryChunk::kBodyOffset) % (2 * kPointerSize)
+  DCHECK((Page::kPageSize - MemoryChunk::kBodyOffset) % (2 * kPointerSize)
          == 0);
   limit_ = reinterpret_cast<intptr_t*>(heap_->new_space()->ToSpaceStart());
   front_ = rear_ =
       reinterpret_cast<intptr_t*>(heap_->new_space()->ToSpaceEnd());
   emergency_stack_ = NULL;
   guard_ = false;
 }
 
 
 void PromotionQueue::RelocateQueueHead() {
-  ASSERT(emergency_stack_ == NULL);
+  DCHECK(emergency_stack_ == NULL);
 
   Page* p = Page::FromAllocationTop(reinterpret_cast<Address>(rear_));
   intptr_t* head_start = rear_;
   intptr_t* head_end =
       Min(front_, reinterpret_cast<intptr_t*>(p->area_end()));
 
   int entries_count =
       static_cast<int>(head_end - head_start) / kEntrySizeInWords;
 
   emergency_stack_ = new List<Entry>(2 * entries_count);
@@ skipping 146 matching lines @@
   UpdateNewSpaceReferencesInExternalStringTable(
       &UpdateNewSpaceReferenceInExternalStringTableEntry);
 
   promotion_queue_.Destroy();
 
   incremental_marking()->UpdateMarkingDequeAfterScavenge();
 
   ScavengeWeakObjectRetainer weak_object_retainer(this);
   ProcessWeakReferences(&weak_object_retainer);
 
-  ASSERT(new_space_front == new_space_.top());
+  DCHECK(new_space_front == new_space_.top());
 
   // Set age mark.
   new_space_.set_age_mark(new_space_.top());
 
   new_space_.LowerInlineAllocationLimit(
       new_space_.inline_allocation_limit_step());
 
   // Update how much has survived scavenge.
   IncrementYoungSurvivorsCounter(static_cast<int>(
       (PromotedSpaceSizeOfObjects() - survived_watermark) + new_space_.Size()));
@@ skipping 29 matching lines @@
   }
 #endif
 
   if (external_string_table_.new_space_strings_.is_empty()) return;
 
   Object** start = &external_string_table_.new_space_strings_[0];
   Object** end = start + external_string_table_.new_space_strings_.length();
   Object** last = start;
 
   for (Object** p = start; p < end; ++p) {
-    ASSERT(InFromSpace(*p));
+    DCHECK(InFromSpace(*p));
     String* target = updater_func(this, p);
 
     if (target == NULL) continue;
 
-    ASSERT(target->IsExternalString());
+    DCHECK(target->IsExternalString());
 
     if (InNewSpace(target)) {
       // String is still in new space.  Update the table entry.
       *last = target;
       ++last;
     } else {
       // String got promoted.  Move it to the old string list.
       external_string_table_.AddOldString(target);
     }
   }
 
-  ASSERT(last <= end);
+  DCHECK(last <= end);
   external_string_table_.ShrinkNewStrings(static_cast<int>(last - start));
 }
 
 
 void Heap::UpdateReferencesInExternalStringTable(
     ExternalStringTableUpdaterCallback updater_func) {
 
   // Update old space string references.
   if (external_string_table_.old_space_strings_.length() > 0) {
     Object** start = &external_string_table_.old_space_strings_[0];
@@ skipping 87 matching lines @@
 void Heap::VisitExternalResources(v8::ExternalResourceVisitor* visitor) {
   DisallowHeapAllocation no_allocation;
   // All external strings are listed in the external string table.
 
   class ExternalStringTableVisitorAdapter : public ObjectVisitor {
    public:
     explicit ExternalStringTableVisitorAdapter(
         v8::ExternalResourceVisitor* visitor) : visitor_(visitor) {}
     virtual void VisitPointers(Object** start, Object** end) {
       for (Object** p = start; p < end; p++) {
-        ASSERT((*p)->IsExternalString());
+        DCHECK((*p)->IsExternalString());
         visitor_->VisitExternalString(Utils::ToLocal(
             Handle<String>(String::cast(*p))));
       }
     }
    private:
     v8::ExternalResourceVisitor* visitor_;
   } external_string_table_visitor(visitor);
 
   external_string_table_.Iterate(&external_string_table_visitor);
 }
@@ skipping 35 matching lines @@
                                     &ScavengeStoreBufferCallback);
       while (!promotion_queue()->is_empty()) {
         HeapObject* target;
         int size;
         promotion_queue()->remove(&target, &size);
 
         // Promoted object might be already partially visited
         // during old space pointer iteration. Thus we search specificly
         // for pointers to from semispace instead of looking for pointers
         // to new space.
-        ASSERT(!target->IsMap());
+        DCHECK(!target->IsMap());
         IterateAndMarkPointersToFromSpace(target->address(),
                                           target->address() + size,
                                           &ScavengeObject);
       }
     }
 
     // Take another spin if there are now unswept objects in new space
     // (there are currently no more unswept promoted objects).
   } while (new_space_front != new_space_.top());
 
@@ skipping 136 matching lines @@
   // Helper function used by CopyObject to copy a source object to an
   // allocated target object and update the forwarding pointer in the source
   // object.  Returns the target object.
   INLINE(static void MigrateObject(Heap* heap,
                                    HeapObject* source,
                                    HeapObject* target,
                                    int size)) {
     // If we migrate into to-space, then the to-space top pointer should be
     // right after the target object. Incorporate double alignment
     // over-allocation.
-    ASSERT(!heap->InToSpace(target) ||
+    DCHECK(!heap->InToSpace(target) ||
         target->address() + size == heap->new_space()->top() ||
         target->address() + size + kPointerSize == heap->new_space()->top());
 
     // Make sure that we do not overwrite the promotion queue which is at
     // the end of to-space.
-    ASSERT(!heap->InToSpace(target) ||
+    DCHECK(!heap->InToSpace(target) ||
         heap->promotion_queue()->IsBelowPromotionQueue(
             heap->new_space()->top()));
 
     // Copy the content of source to target.
     heap->CopyBlock(target->address(), source->address(), size);
 
     // Set the forwarding address.
     source->set_map_word(MapWord::FromForwardingAddress(target));
 
     if (logging_and_profiling_mode == LOGGING_AND_PROFILING_ENABLED) {
@@ skipping 11 matching lines @@
 
   template<int alignment>
   static inline bool SemiSpaceCopyObject(Map* map,
                                          HeapObject** slot,
                                          HeapObject* object,
                                          int object_size) {
     Heap* heap = map->GetHeap();
 
     int allocation_size = object_size;
     if (alignment != kObjectAlignment) {
-      ASSERT(alignment == kDoubleAlignment);
+      DCHECK(alignment == kDoubleAlignment);
       allocation_size += kPointerSize;
     }
 
-    ASSERT(heap->AllowedToBeMigrated(object, NEW_SPACE));
+    DCHECK(heap->AllowedToBeMigrated(object, NEW_SPACE));
     AllocationResult allocation =
         heap->new_space()->AllocateRaw(allocation_size);
 
     HeapObject* target = NULL;  // Initialization to please compiler.
     if (allocation.To(&target)) {
       if (alignment != kObjectAlignment) {
         target = EnsureDoubleAligned(heap, target, allocation_size);
       }
 
       // Order is important here: Set the promotion limit before migrating
@@ skipping 16 matching lines @@
 
   template<ObjectContents object_contents, int alignment>
   static inline bool PromoteObject(Map* map,
                                    HeapObject** slot,
                                    HeapObject* object,
                                    int object_size) {
     Heap* heap = map->GetHeap();
 
     int allocation_size = object_size;
     if (alignment != kObjectAlignment) {
-      ASSERT(alignment == kDoubleAlignment);
+      DCHECK(alignment == kDoubleAlignment);
       allocation_size += kPointerSize;
     }
 
     AllocationResult allocation;
     if (object_contents == DATA_OBJECT) {
-      ASSERT(heap->AllowedToBeMigrated(object, OLD_DATA_SPACE));
+      DCHECK(heap->AllowedToBeMigrated(object, OLD_DATA_SPACE));
       allocation = heap->old_data_space()->AllocateRaw(allocation_size);
     } else {
-      ASSERT(heap->AllowedToBeMigrated(object, OLD_POINTER_SPACE));
+      DCHECK(heap->AllowedToBeMigrated(object, OLD_POINTER_SPACE));
       allocation = heap->old_pointer_space()->AllocateRaw(allocation_size);
     }
 
     HeapObject* target = NULL;  // Initialization to please compiler.
     if (allocation.To(&target)) {
       if (alignment != kObjectAlignment) {
         target = EnsureDoubleAligned(heap, target, allocation_size);
       }
 
       // Order is important: slot might be inside of the target if target
@@ skipping 15 matching lines @@
     }
     return false;
   }
 
 
   template<ObjectContents object_contents, int alignment>
   static inline void EvacuateObject(Map* map,
                                     HeapObject** slot,
                                     HeapObject* object,
                                     int object_size) {
-    SLOW_ASSERT(object_size <= Page::kMaxRegularHeapObjectSize);
-    SLOW_ASSERT(object->Size() == object_size);
+    SLOW_DCHECK(object_size <= Page::kMaxRegularHeapObjectSize);
+    SLOW_DCHECK(object->Size() == object_size);
     Heap* heap = map->GetHeap();
 
     if (!heap->ShouldBePromoted(object->address(), object_size)) {
       // A semi-space copy may fail due to fragmentation. In that case, we
       // try to promote the object.
       if (SemiSpaceCopyObject<alignment>(map, slot, object, object_size)) {
         return;
       }
     }
 
@@ skipping 93 matching lines @@
     int object_size = SeqTwoByteString::cast(object)->
         SeqTwoByteStringSize(map->instance_type());
     EvacuateObject<DATA_OBJECT, kObjectAlignment>(
         map, slot, object, object_size);
   }
 
 
   static inline void EvacuateShortcutCandidate(Map* map,
                                                HeapObject** slot,
                                                HeapObject* object) {
-    ASSERT(IsShortcutCandidate(map->instance_type()));
+    DCHECK(IsShortcutCandidate(map->instance_type()));
 
     Heap* heap = map->GetHeap();
 
     if (marks_handling == IGNORE_MARKS &&
         ConsString::cast(object)->unchecked_second() ==
         heap->empty_string()) {
       HeapObject* first =
           HeapObject::cast(ConsString::cast(object)->unchecked_first());
 
       *slot = first;
@@ skipping 99 matching lines @@
       scavenging_visitors_table_.Register(
           StaticVisitorBase::kVisitShortcutCandidate,
           scavenging_visitors_table_.GetVisitorById(
               StaticVisitorBase::kVisitConsString));
     }
   }
 }
 
 
 void Heap::ScavengeObjectSlow(HeapObject** p, HeapObject* object) {
-  SLOW_ASSERT(object->GetIsolate()->heap()->InFromSpace(object));
+  SLOW_DCHECK(object->GetIsolate()->heap()->InFromSpace(object));
   MapWord first_word = object->map_word();
-  SLOW_ASSERT(!first_word.IsForwardingAddress());
+  SLOW_DCHECK(!first_word.IsForwardingAddress());
   Map* map = first_word.ToMap();
   map->GetHeap()->DoScavengeObject(map, p, object);
 }
 
 
 AllocationResult Heap::AllocatePartialMap(InstanceType instance_type,
                                           int instance_size) {
   Object* result;
   AllocationResult allocation = AllocateRaw(Map::kSize, MAP_SPACE, MAP_SPACE);
   if (!allocation.To(&result)) return allocation;
@@ skipping 52 matching lines @@
 
 AllocationResult Heap::AllocateFillerObject(int size,
                                             bool double_align,
                                             AllocationSpace space) {
   HeapObject* obj;
   { AllocationResult allocation = AllocateRaw(size, space, space);
     if (!allocation.To(&obj)) return allocation;
   }
 #ifdef DEBUG
   MemoryChunk* chunk = MemoryChunk::FromAddress(obj->address());
-  ASSERT(chunk->owner()->identity() == space);
+  DCHECK(chunk->owner()->identity() == space);
 #endif
   CreateFillerObjectAt(obj->address(), size);
   return obj;
 }
 
 
 const Heap::StringTypeTable Heap::string_type_table[] = {
 #define STRING_TYPE_ELEMENT(type, size, name, camel_name)                      \
   {type, size, k##camel_name##MapRootIndex},
   STRING_TYPE_LIST(STRING_TYPE_ELEMENT)
@@ skipping 53 matching lines @@
     if (!allocation.To(&obj)) return false;
   }
   set_null_value(Oddball::cast(obj));
   Oddball::cast(obj)->set_kind(Oddball::kNull);
 
   { AllocationResult allocation = Allocate(undefined_map(), OLD_POINTER_SPACE);
     if (!allocation.To(&obj)) return false;
   }
   set_undefined_value(Oddball::cast(obj));
   Oddball::cast(obj)->set_kind(Oddball::kUndefined);
-  ASSERT(!InNewSpace(undefined_value()));
+  DCHECK(!InNewSpace(undefined_value()));
 
   // Set preliminary exception sentinel value before actually initializing it.
   set_exception(null_value());
 
   // Allocate the empty descriptor array.
   { AllocationResult allocation = AllocateEmptyFixedArray();
     if (!allocation.To(&obj)) return false;
   }
   set_empty_descriptor_array(DescriptorArray::cast(obj));
 
@@ skipping 51 matching lines @@
 #define ALLOCATE_MAP(instance_type, size, field_name)                          \
     { Map* map;                                                                \
       if (!AllocateMap((instance_type), size).To(&map)) return false;          \
       set_##field_name##_map(map);                                             \
     }
 
 #define ALLOCATE_VARSIZE_MAP(instance_type, field_name)                        \
     ALLOCATE_MAP(instance_type, kVariableSizeSentinel, field_name)
 
     ALLOCATE_VARSIZE_MAP(FIXED_ARRAY_TYPE, fixed_cow_array)
-    ASSERT(fixed_array_map() != fixed_cow_array_map());
+    DCHECK(fixed_array_map() != fixed_cow_array_map());
 
     ALLOCATE_VARSIZE_MAP(FIXED_ARRAY_TYPE, scope_info)
     ALLOCATE_MAP(HEAP_NUMBER_TYPE, HeapNumber::kSize, heap_number)
     ALLOCATE_MAP(
         MUTABLE_HEAP_NUMBER_TYPE, HeapNumber::kSize, mutable_heap_number)
     ALLOCATE_MAP(SYMBOL_TYPE, Symbol::kSize, symbol)
     ALLOCATE_MAP(FOREIGN_TYPE, Foreign::kSize, foreign)
 
     ALLOCATE_MAP(ODDBALL_TYPE, Oddball::kSize, the_hole);
     ALLOCATE_MAP(ODDBALL_TYPE, Oddball::kSize, boolean);
@@ skipping 103 matching lines @@
 #define ALLOCATE_EMPTY_FIXED_TYPED_ARRAY(Type, type, TYPE, ctype, size)        \
     { FixedTypedArrayBase* obj;                                                \
       if (!AllocateEmptyFixedTypedArray(kExternal##Type##Array).To(&obj))      \
           return false;                                                        \
       set_empty_fixed_##type##_array(obj);                                     \
     }
 
     TYPED_ARRAYS(ALLOCATE_EMPTY_FIXED_TYPED_ARRAY)
 #undef ALLOCATE_EMPTY_FIXED_TYPED_ARRAY
   }
-  ASSERT(!InNewSpace(empty_fixed_array()));
+  DCHECK(!InNewSpace(empty_fixed_array()));
   return true;
 }
 
 
 AllocationResult Heap::AllocateHeapNumber(double value,
                                           MutableMode mode,
                                           PretenureFlag pretenure) {
   // Statically ensure that it is safe to allocate heap numbers in paged
   // spaces.
   int size = HeapNumber::kSize;
@@ skipping 108 matching lines @@
   Heap::CreateJSConstructEntryStub();
 }
 
 
 void Heap::CreateInitialObjects() {
   HandleScope scope(isolate());
   Factory* factory = isolate()->factory();
 
   // The -0 value must be set before NewNumber works.
   set_minus_zero_value(*factory->NewHeapNumber(-0.0, IMMUTABLE, TENURED));
-  ASSERT(std::signbit(minus_zero_value()->Number()) != 0);
+  DCHECK(std::signbit(minus_zero_value()->Number()) != 0);
 
   set_nan_value(
       *factory->NewHeapNumber(base::OS::nan_value(), IMMUTABLE, TENURED));
   set_infinity_value(*factory->NewHeapNumber(V8_INFINITY, IMMUTABLE, TENURED));
 
   // The hole has not been created yet, but we want to put something
   // predictable in the gaps in the string table, so lets make that Smi zero.
   set_the_hole_value(reinterpret_cast<Oddball*>(Smi::FromInt(0)));
 
   // Allocate initial string table.
@@ skipping 198 matching lines @@
 }
 
 
 Object* RegExpResultsCache::Lookup(Heap* heap,
                                    String* key_string,
                                    Object* key_pattern,
                                    ResultsCacheType type) {
   FixedArray* cache;
   if (!key_string->IsInternalizedString()) return Smi::FromInt(0);
   if (type == STRING_SPLIT_SUBSTRINGS) {
-    ASSERT(key_pattern->IsString());
+    DCHECK(key_pattern->IsString());
     if (!key_pattern->IsInternalizedString()) return Smi::FromInt(0);
     cache = heap->string_split_cache();
   } else {
-    ASSERT(type == REGEXP_MULTIPLE_INDICES);
-    ASSERT(key_pattern->IsFixedArray());
+    DCHECK(type == REGEXP_MULTIPLE_INDICES);
+    DCHECK(key_pattern->IsFixedArray());
     cache = heap->regexp_multiple_cache();
   }
 
   uint32_t hash = key_string->Hash();
   uint32_t index = ((hash & (kRegExpResultsCacheSize - 1)) &
       ~(kArrayEntriesPerCacheEntry - 1));
   if (cache->get(index + kStringOffset) == key_string &&
       cache->get(index + kPatternOffset) == key_pattern) {
     return cache->get(index + kArrayOffset);
   }
   index =
       ((index + kArrayEntriesPerCacheEntry) & (kRegExpResultsCacheSize - 1));
   if (cache->get(index + kStringOffset) == key_string &&
       cache->get(index + kPatternOffset) == key_pattern) {
     return cache->get(index + kArrayOffset);
   }
   return Smi::FromInt(0);
 }
 
 
 void RegExpResultsCache::Enter(Isolate* isolate,
                                Handle<String> key_string,
                                Handle<Object> key_pattern,
                                Handle<FixedArray> value_array,
                                ResultsCacheType type) {
   Factory* factory = isolate->factory();
   Handle<FixedArray> cache;
   if (!key_string->IsInternalizedString()) return;
   if (type == STRING_SPLIT_SUBSTRINGS) {
-    ASSERT(key_pattern->IsString());
+    DCHECK(key_pattern->IsString());
     if (!key_pattern->IsInternalizedString()) return;
     cache = factory->string_split_cache();
   } else {
-    ASSERT(type == REGEXP_MULTIPLE_INDICES);
-    ASSERT(key_pattern->IsFixedArray());
+    DCHECK(type == REGEXP_MULTIPLE_INDICES);
+    DCHECK(key_pattern->IsFixedArray());
     cache = factory->regexp_multiple_cache();
   }
 
   uint32_t hash = key_string->Hash();
   uint32_t index = ((hash & (kRegExpResultsCacheSize - 1)) &
       ~(kArrayEntriesPerCacheEntry - 1));
   if (cache->get(index + kStringOffset) == Smi::FromInt(0)) {
     cache->set(index + kStringOffset, *key_string);
     cache->set(index + kPatternOffset, *key_pattern);
     cache->set(index + kArrayOffset, *value_array);
@@ skipping 58 matching lines @@
 
 void Heap::FlushAllocationSitesScratchpad() {
   for (int i = 0; i < allocation_sites_scratchpad_length_; i++) {
     allocation_sites_scratchpad()->set_undefined(i);
   }
   allocation_sites_scratchpad_length_ = 0;
 }
 
 
 void Heap::InitializeAllocationSitesScratchpad() {
-  ASSERT(allocation_sites_scratchpad()->length() ==
+  DCHECK(allocation_sites_scratchpad()->length() ==
          kAllocationSiteScratchpadSize);
   for (int i = 0; i < kAllocationSiteScratchpadSize; i++) {
     allocation_sites_scratchpad()->set_undefined(i);
   }
 }
 
 
 void Heap::AddAllocationSiteToScratchpad(AllocationSite* site,
                                          ScratchpadSlotMode mode) {
   if (allocation_sites_scratchpad_length_ < kAllocationSiteScratchpadSize) {
@@ skipping 246 matching lines @@
 
   object->set_map(MapForFixedTypedArray(array_type));
   FixedTypedArrayBase* elements = FixedTypedArrayBase::cast(object);
   elements->set_length(length);
   memset(elements->DataPtr(), 0, elements->DataSize());
   return elements;
 }
 
 
 AllocationResult Heap::AllocateCode(int object_size, bool immovable) {
-  ASSERT(IsAligned(static_cast<intptr_t>(object_size), kCodeAlignment));
+  DCHECK(IsAligned(static_cast<intptr_t>(object_size), kCodeAlignment));
   AllocationResult allocation =
       AllocateRaw(object_size, CODE_SPACE, CODE_SPACE);
 
   HeapObject* result;
   if (!allocation.To(&result)) return allocation;
 
   if (immovable) {
     Address address = result->address();
     // Code objects which should stay at a fixed address are allocated either
     // in the first page of code space (objects on the first page of each space
     // are never moved) or in large object space.
     if (!code_space_->FirstPage()->Contains(address) &&
         MemoryChunk::FromAddress(address)->owner()->identity() != LO_SPACE) {
       // Discard the first code allocation, which was on a page where it could
       // be moved.
       CreateFillerObjectAt(result->address(), object_size);
       allocation = lo_space_->AllocateRaw(object_size, EXECUTABLE);
       if (!allocation.To(&result)) return allocation;
       OnAllocationEvent(result, object_size);
     }
   }
 
   result->set_map_no_write_barrier(code_map());
   Code* code = Code::cast(result);
-  ASSERT(isolate_->code_range() == NULL ||
+  DCHECK(isolate_->code_range() == NULL ||
          !isolate_->code_range()->valid() ||
          isolate_->code_range()->contains(code->address()));
   code->set_gc_metadata(Smi::FromInt(0));
   code->set_ic_age(global_ic_age_);
   return code;
 }
 
 
 AllocationResult Heap::CopyCode(Code* code) {
   AllocationResult allocation;
@@ skipping 17 matching lines @@
   // Copy code object.
   Address old_addr = code->address();
   Address new_addr = result->address();
   CopyBlock(new_addr, old_addr, obj_size);
   Code* new_code = Code::cast(result);
 
   // Update the constant pool.
   new_code->set_constant_pool(new_constant_pool);
 
   // Relocate the copy.
-  ASSERT(isolate_->code_range() == NULL ||
+  DCHECK(isolate_->code_range() == NULL ||
          !isolate_->code_range()->valid() ||
          isolate_->code_range()->contains(code->address()));
   new_code->Relocate(new_addr - old_addr);
   return new_code;
 }
 
 
 AllocationResult Heap::CopyCode(Code* code, Vector<byte> reloc_info) {
   // Allocate ByteArray and ConstantPoolArray before the Code object, so that we
   // do not risk leaving uninitialized Code object (and breaking the heap).
@@ skipping 39 matching lines @@
 
   // Update constant pool.
   new_code->set_constant_pool(new_constant_pool);
 
   // Copy patched rinfo.
   CopyBytes(new_code->relocation_start(),
             reloc_info.start(),
             static_cast<size_t>(reloc_info.length()));
 
   // Relocate the copy.
-  ASSERT(isolate_->code_range() == NULL ||
+  DCHECK(isolate_->code_range() == NULL ||
          !isolate_->code_range()->valid() ||
          isolate_->code_range()->contains(code->address()));
   new_code->Relocate(new_addr - old_addr);
 
 #ifdef VERIFY_HEAP
   if (FLAG_verify_heap) code->ObjectVerify();
 #endif
   return new_code;
 }
 
 
 void Heap::InitializeAllocationMemento(AllocationMemento* memento,
                                        AllocationSite* allocation_site) {
   memento->set_map_no_write_barrier(allocation_memento_map());
-  ASSERT(allocation_site->map() == allocation_site_map());
+  DCHECK(allocation_site->map() == allocation_site_map());
   memento->set_allocation_site(allocation_site, SKIP_WRITE_BARRIER);
   if (FLAG_allocation_site_pretenuring) {
     allocation_site->IncrementMementoCreateCount();
   }
 }
 
 
 AllocationResult Heap::Allocate(Map* map, AllocationSpace space,
                             AllocationSite* allocation_site) {
-  ASSERT(gc_state_ == NOT_IN_GC);
-  ASSERT(map->instance_type() != MAP_TYPE);
+  DCHECK(gc_state_ == NOT_IN_GC);
+  DCHECK(map->instance_type() != MAP_TYPE);
   // If allocation failures are disallowed, we may allocate in a different
   // space when new space is full and the object is not a large object.
   AllocationSpace retry_space =
       (space != NEW_SPACE) ? space : TargetSpaceId(map->instance_type());
   int size = map->instance_size();
   if (allocation_site != NULL) {
     size += AllocationMemento::kSize;
   }
   HeapObject* result;
   AllocationResult allocation = AllocateRaw(size, space, retry_space);
@@ skipping 25 matching lines @@
   // We cannot always fill with one_pointer_filler_map because objects
   // created from API functions expect their internal fields to be initialized
   // with undefined_value.
   // Pre-allocated fields need to be initialized with undefined_value as well
   // so that object accesses before the constructor completes (e.g. in the
   // debugger) will not cause a crash.
   if (map->constructor()->IsJSFunction() &&
       JSFunction::cast(map->constructor())->
           IsInobjectSlackTrackingInProgress()) {
     // We might want to shrink the object later.
-    ASSERT(obj->GetInternalFieldCount() == 0);
+    DCHECK(obj->GetInternalFieldCount() == 0);
     filler = Heap::one_pointer_filler_map();
   } else {
     filler = Heap::undefined_value();
   }
   obj->InitializeBody(map, Heap::undefined_value(), filler);
 }
 
 
 AllocationResult Heap::AllocateJSObjectFromMap(
     Map* map,
     PretenureFlag pretenure,
     bool allocate_properties,
     AllocationSite* allocation_site) {
   // JSFunctions should be allocated using AllocateFunction to be
   // properly initialized.
-  ASSERT(map->instance_type() != JS_FUNCTION_TYPE);
+  DCHECK(map->instance_type() != JS_FUNCTION_TYPE);
 
   // Both types of global objects should be allocated using
   // AllocateGlobalObject to be properly initialized.
-  ASSERT(map->instance_type() != JS_GLOBAL_OBJECT_TYPE);
-  ASSERT(map->instance_type() != JS_BUILTINS_OBJECT_TYPE);
+  DCHECK(map->instance_type() != JS_GLOBAL_OBJECT_TYPE);
+  DCHECK(map->instance_type() != JS_BUILTINS_OBJECT_TYPE);
 
   // Allocate the backing storage for the properties.
   FixedArray* properties;
   if (allocate_properties) {
     int prop_size = map->InitialPropertiesLength();
-    ASSERT(prop_size >= 0);
+    DCHECK(prop_size >= 0);
     { AllocationResult allocation = AllocateFixedArray(prop_size, pretenure);
       if (!allocation.To(&properties)) return allocation;
     }
   } else {
     properties = empty_fixed_array();
   }
 
   // Allocate the JSObject.
   int size = map->instance_size();
   AllocationSpace space = SelectSpace(size, OLD_POINTER_SPACE, pretenure);
   JSObject* js_obj;
   AllocationResult allocation = Allocate(map, space, allocation_site);
   if (!allocation.To(&js_obj)) return allocation;
 
   // Initialize the JSObject.
   InitializeJSObjectFromMap(js_obj, properties, map);
-  ASSERT(js_obj->HasFastElements() ||
+  DCHECK(js_obj->HasFastElements() ||
          js_obj->HasExternalArrayElements() ||
          js_obj->HasFixedTypedArrayElements());
   return js_obj;
 }
 
 
 AllocationResult Heap::AllocateJSObject(JSFunction* constructor,
                                         PretenureFlag pretenure,
                                         AllocationSite* allocation_site) {
-  ASSERT(constructor->has_initial_map());
+  DCHECK(constructor->has_initial_map());
 
   // Allocate the object based on the constructors initial map.
   AllocationResult allocation = AllocateJSObjectFromMap(
       constructor->initial_map(), pretenure, true, allocation_site);
 #ifdef DEBUG
   // Make sure result is NOT a global object if valid.
   HeapObject* obj;
-  ASSERT(!allocation.To(&obj) || !obj->IsGlobalObject());
+  DCHECK(!allocation.To(&obj) || !obj->IsGlobalObject());
 #endif
   return allocation;
 }
 
 
 AllocationResult Heap::CopyJSObject(JSObject* source, AllocationSite* site) {
   // Never used to copy functions.  If functions need to be copied we
   // have to be careful to clear the literals array.
-  SLOW_ASSERT(!source->IsJSFunction());
+  SLOW_DCHECK(!source->IsJSFunction());
 
   // Make the clone.
   Map* map = source->map();
   int object_size = map->instance_size();
   HeapObject* clone;
 
-  ASSERT(site == NULL || AllocationSite::CanTrack(map->instance_type()));
+  DCHECK(site == NULL || AllocationSite::CanTrack(map->instance_type()));
 
   WriteBarrierMode wb_mode = UPDATE_WRITE_BARRIER;
 
   // If we're forced to always allocate, we use the general allocation
   // functions which may leave us with an object in old space.
   if (always_allocate()) {
     { AllocationResult allocation =
           AllocateRaw(object_size, NEW_SPACE, OLD_POINTER_SPACE);
       if (!allocation.To(&clone)) return allocation;
     }
     Address clone_address = clone->address();
     CopyBlock(clone_address,
               source->address(),
               object_size);
     // Update write barrier for all fields that lie beyond the header.
     RecordWrites(clone_address,
                  JSObject::kHeaderSize,
                  (object_size - JSObject::kHeaderSize) / kPointerSize);
   } else {
     wb_mode = SKIP_WRITE_BARRIER;
 
     { int adjusted_object_size = site != NULL
           ? object_size + AllocationMemento::kSize
           : object_size;
     AllocationResult allocation =
           AllocateRaw(adjusted_object_size, NEW_SPACE, NEW_SPACE);
       if (!allocation.To(&clone)) return allocation;
     }
-    SLOW_ASSERT(InNewSpace(clone));
+    SLOW_DCHECK(InNewSpace(clone));
     // Since we know the clone is allocated in new space, we can copy
     // the contents without worrying about updating the write barrier.
     CopyBlock(clone->address(),
               source->address(),
               object_size);
 
     if (site != NULL) {
       AllocationMemento* alloc_memento = reinterpret_cast<AllocationMemento*>(
           reinterpret_cast<Address>(clone) + object_size);
       InitializeAllocationMemento(alloc_memento, site);
     }
   }
 
-  SLOW_ASSERT(
+  SLOW_DCHECK(
       JSObject::cast(clone)->GetElementsKind() == source->GetElementsKind());
   FixedArrayBase* elements = FixedArrayBase::cast(source->elements());
   FixedArray* properties = FixedArray::cast(source->properties());
   // Update elements if necessary.
   if (elements->length() > 0) {
     FixedArrayBase* elem;
     { AllocationResult allocation;
       if (elements->map() == fixed_cow_array_map()) {
         allocation = FixedArray::cast(elements);
       } else if (source->HasFastDoubleElements()) {
@@ skipping 15 matching lines @@
   }
   // Return the new clone.
   return clone;
 }
 
 
 static inline void WriteOneByteData(Vector<const char> vector,
                                     uint8_t* chars,
                                     int len) {
   // Only works for ascii.
-  ASSERT(vector.length() == len);
+  DCHECK(vector.length() == len);
   MemCopy(chars, vector.start(), len);
 }
 
 static inline void WriteTwoByteData(Vector<const char> vector,
                                     uint16_t* chars,
                                     int len) {
   const uint8_t* stream = reinterpret_cast<const uint8_t*>(vector.start());
   unsigned stream_length = vector.length();
   while (stream_length != 0) {
     unsigned consumed = 0;
     uint32_t c = unibrow::Utf8::ValueOf(stream, stream_length, &consumed);
-    ASSERT(c != unibrow::Utf8::kBadChar);
-    ASSERT(consumed <= stream_length);
+    DCHECK(c != unibrow::Utf8::kBadChar);
+    DCHECK(consumed <= stream_length);
     stream_length -= consumed;
     stream += consumed;
     if (c > unibrow::Utf16::kMaxNonSurrogateCharCode) {
       len -= 2;
       if (len < 0) break;
       *chars++ = unibrow::Utf16::LeadSurrogate(c);
       *chars++ = unibrow::Utf16::TrailSurrogate(c);
     } else {
       len -= 1;
       if (len < 0) break;
       *chars++ = c;
     }
   }
-  ASSERT(stream_length == 0);
-  ASSERT(len == 0);
+  DCHECK(stream_length == 0);
+  DCHECK(len == 0);
 }
 
 
 static inline void WriteOneByteData(String* s, uint8_t* chars, int len) {
-  ASSERT(s->length() == len);
+  DCHECK(s->length() == len);
   String::WriteToFlat(s, chars, 0, len);
 }
 
 
 static inline void WriteTwoByteData(String* s, uint16_t* chars, int len) {
-  ASSERT(s->length() == len);
+  DCHECK(s->length() == len);
   String::WriteToFlat(s, chars, 0, len);
 }
 
 
 template<bool is_one_byte, typename T>
 AllocationResult Heap::AllocateInternalizedStringImpl(
     T t, int chars, uint32_t hash_field) {
-  ASSERT(chars >= 0);
+  DCHECK(chars >= 0);
   // Compute map and object size.
   int size;
   Map* map;
 
-  ASSERT_LE(0, chars);
-  ASSERT_GE(String::kMaxLength, chars);
+  DCHECK_LE(0, chars);
+  DCHECK_GE(String::kMaxLength, chars);
   if (is_one_byte) {
     map = ascii_internalized_string_map();
     size = SeqOneByteString::SizeFor(chars);
   } else {
     map = internalized_string_map();
     size = SeqTwoByteString::SizeFor(chars);
   }
   AllocationSpace space = SelectSpace(size, OLD_DATA_SPACE, TENURED);
 
   // Allocate string.
   HeapObject* result;
   { AllocationResult allocation = AllocateRaw(size, space, OLD_DATA_SPACE);
     if (!allocation.To(&result)) return allocation;
   }
 
   result->set_map_no_write_barrier(map);
   // Set length and hash fields of the allocated string.
   String* answer = String::cast(result);
   answer->set_length(chars);
   answer->set_hash_field(hash_field);
 
-  ASSERT_EQ(size, answer->Size());
+  DCHECK_EQ(size, answer->Size());
 
   if (is_one_byte) {
     WriteOneByteData(t, SeqOneByteString::cast(answer)->GetChars(), chars);
   } else {
     WriteTwoByteData(t, SeqTwoByteString::cast(answer)->GetChars(), chars);
   }
   return answer;
 }
 
 
 // Need explicit instantiations.
 template
 AllocationResult Heap::AllocateInternalizedStringImpl<true>(
     String*, int, uint32_t);
 template
 AllocationResult Heap::AllocateInternalizedStringImpl<false>(
     String*, int, uint32_t);
 template
 AllocationResult Heap::AllocateInternalizedStringImpl<false>(
     Vector<const char>, int, uint32_t);
 
 
 AllocationResult Heap::AllocateRawOneByteString(int length,
                                                 PretenureFlag pretenure) {
-  ASSERT_LE(0, length);
-  ASSERT_GE(String::kMaxLength, length);
+  DCHECK_LE(0, length);
+  DCHECK_GE(String::kMaxLength, length);
   int size = SeqOneByteString::SizeFor(length);
-  ASSERT(size <= SeqOneByteString::kMaxSize);
+  DCHECK(size <= SeqOneByteString::kMaxSize);
   AllocationSpace space = SelectSpace(size, OLD_DATA_SPACE, pretenure);
 
   HeapObject* result;
   { AllocationResult allocation = AllocateRaw(size, space, OLD_DATA_SPACE);
     if (!allocation.To(&result)) return allocation;
   }
 
   // Partially initialize the object.
   result->set_map_no_write_barrier(ascii_string_map());
   String::cast(result)->set_length(length);
   String::cast(result)->set_hash_field(String::kEmptyHashField);
-  ASSERT_EQ(size, HeapObject::cast(result)->Size());
+  DCHECK_EQ(size, HeapObject::cast(result)->Size());
 
   return result;
 }
 
 
 AllocationResult Heap::AllocateRawTwoByteString(int length,
                                                 PretenureFlag pretenure) {
-  ASSERT_LE(0, length);
-  ASSERT_GE(String::kMaxLength, length);
+  DCHECK_LE(0, length);
+  DCHECK_GE(String::kMaxLength, length);
   int size = SeqTwoByteString::SizeFor(length);
-  ASSERT(size <= SeqTwoByteString::kMaxSize);
+  DCHECK(size <= SeqTwoByteString::kMaxSize);
   AllocationSpace space = SelectSpace(size, OLD_DATA_SPACE, pretenure);
 
   HeapObject* result;
   { AllocationResult allocation = AllocateRaw(size, space, OLD_DATA_SPACE);
     if (!allocation.To(&result)) return allocation;
   }
 
   // Partially initialize the object.
   result->set_map_no_write_barrier(string_map());
   String::cast(result)->set_length(length);
   String::cast(result)->set_hash_field(String::kEmptyHashField);
-  ASSERT_EQ(size, HeapObject::cast(result)->Size());
+  DCHECK_EQ(size, HeapObject::cast(result)->Size());
   return result;
 }
 
 
 AllocationResult Heap::AllocateEmptyFixedArray() {
   int size = FixedArray::SizeFor(0);
   HeapObject* result;
   { AllocationResult allocation =
         AllocateRaw(size, OLD_DATA_SPACE, OLD_DATA_SPACE);
     if (!allocation.To(&result)) return allocation;
@@ skipping 119 matching lines @@
   int size = FixedArray::SizeFor(length);
   AllocationSpace space = SelectSpace(size, OLD_POINTER_SPACE, pretenure);
 
   return AllocateRaw(size, space, OLD_POINTER_SPACE);
 }
 
 
 AllocationResult Heap::AllocateFixedArrayWithFiller(int length,
                                                     PretenureFlag pretenure,
                                                     Object* filler) {
-  ASSERT(length >= 0);
-  ASSERT(empty_fixed_array()->IsFixedArray());
+  DCHECK(length >= 0);
+  DCHECK(empty_fixed_array()->IsFixedArray());
   if (length == 0) return empty_fixed_array();
 
-  ASSERT(!InNewSpace(filler));
+  DCHECK(!InNewSpace(filler));
   HeapObject* result;
   { AllocationResult allocation = AllocateRawFixedArray(length, pretenure);
     if (!allocation.To(&result)) return allocation;
   }
 
   result->set_map_no_write_barrier(fixed_array_map());
   FixedArray* array = FixedArray::cast(result);
   array->set_length(length);
   MemsetPointer(array->data_start(), filler, length);
   return array;
@@ skipping 134 matching lines @@
     hash = isolate()->random_number_generator()->NextInt() & Name::kHashBitMask;
     attempts++;
   } while (hash == 0 && attempts < 30);
   if (hash == 0) hash = 1;  // never return 0
 
   Symbol::cast(result)->set_hash_field(
       Name::kIsNotArrayIndexMask | (hash << Name::kHashShift));
   Symbol::cast(result)->set_name(undefined_value());
   Symbol::cast(result)->set_flags(Smi::FromInt(0));
 
-  ASSERT(!Symbol::cast(result)->is_private());
+  DCHECK(!Symbol::cast(result)->is_private());
   return result;
 }
 
 
 AllocationResult Heap::AllocateStruct(InstanceType type) {
   Map* map;
   switch (type) {
 #define MAKE_CASE(NAME, Name, name) \
     case NAME##_TYPE: map = name##_map(); break;
 STRUCT_LIST(MAKE_CASE)
@@ skipping 16 matching lines @@
 bool Heap::IsHeapIterable() {
   // TODO(hpayer): This function is not correct. Allocation folding in old
   // space breaks the iterability.
   return (old_pointer_space()->swept_precisely() &&
           old_data_space()->swept_precisely() &&
           new_space_top_after_last_gc_ == new_space()->top());
 }
 
 
 void Heap::MakeHeapIterable() {
-  ASSERT(AllowHeapAllocation::IsAllowed());
+  DCHECK(AllowHeapAllocation::IsAllowed());
   if (!IsHeapIterable()) {
     CollectAllGarbage(kMakeHeapIterableMask, "Heap::MakeHeapIterable");
   }
   if (mark_compact_collector()->sweeping_in_progress()) {
     mark_compact_collector()->EnsureSweepingCompleted();
   }
-  ASSERT(IsHeapIterable());
+  DCHECK(IsHeapIterable());
 }
 
 
 void Heap::AdvanceIdleIncrementalMarking(intptr_t step_size) {
   incremental_marking()->Step(step_size,
                               IncrementalMarking::NO_GC_VIA_STACK_GUARD);
 
   if (incremental_marking()->IsComplete()) {
     bool uncommit = false;
     if (gc_count_at_last_idle_gc_ == gc_count_) {
@@ skipping 292 matching lines @@
     // If the store buffer becomes overfull we mark pages as being exempt from
     // the store buffer.  These pages are scanned to find pointers that point
     // to the new space.  In that case we may hit newly promoted objects and
     // fix the pointers before the promotion queue gets to them.  Thus the 'if'.
     if (object->IsHeapObject()) {
       if (Heap::InFromSpace(object)) {
         callback(reinterpret_cast<HeapObject**>(slot),
                  HeapObject::cast(object));
         Object* new_object = *slot;
         if (InNewSpace(new_object)) {
-          SLOW_ASSERT(Heap::InToSpace(new_object));
-          SLOW_ASSERT(new_object->IsHeapObject());
+          SLOW_DCHECK(Heap::InToSpace(new_object));
+          SLOW_DCHECK(new_object->IsHeapObject());
           store_buffer_.EnterDirectlyIntoStoreBuffer(
               reinterpret_cast<Address>(slot));
         }
-        SLOW_ASSERT(!MarkCompactCollector::IsOnEvacuationCandidate(new_object));
+        SLOW_DCHECK(!MarkCompactCollector::IsOnEvacuationCandidate(new_object));
       } else if (record_slots &&
                  MarkCompactCollector::IsOnEvacuationCandidate(object)) {
         mark_compact_collector()->RecordSlot(slot, slot, object);
       }
     }
     slot_address += kPointerSize;
   }
 }
 
 
@@ skipping 25 matching lines @@
   Map* free_space_map = heap->free_space_map();
   for ( ; current < limit; current++) {
     Object* o = *current;
     Address current_address = reinterpret_cast<Address>(current);
     // Skip free space.
     if (o == free_space_map) {
       Address current_address = reinterpret_cast<Address>(current);
       FreeSpace* free_space =
           FreeSpace::cast(HeapObject::FromAddress(current_address));
       int skip = free_space->Size();
-      ASSERT(current_address + skip <= reinterpret_cast<Address>(limit));
-      ASSERT(skip > 0);
+      DCHECK(current_address + skip <= reinterpret_cast<Address>(limit));
+      DCHECK(skip > 0);
       current_address += skip - kPointerSize;
       current = reinterpret_cast<Object**>(current_address);
       continue;
     }
     // Skip the current linear allocation space between top and limit which is
     // unmarked with the free space map, but can contain junk.
     if (current_address == special_garbage_start &&
         special_garbage_end != special_garbage_start) {
       current_address = special_garbage_end - kPointerSize;
       current = reinterpret_cast<Object**>(current_address);
       continue;
     }
     if (!(*filter)(current)) continue;
-    ASSERT(current_address < special_garbage_start ||
+    DCHECK(current_address < special_garbage_start ||
            current_address >= special_garbage_end);
-    ASSERT(reinterpret_cast<uintptr_t>(o) != kFreeListZapValue);
+    DCHECK(reinterpret_cast<uintptr_t>(o) != kFreeListZapValue);
     // We have to check that the pointer does not point into new space
     // without trying to cast it to a heap object since the hash field of
     // a string can contain values like 1 and 3 which are tagged null
     // pointers.
     if (!heap->InNewSpace(o)) continue;
     while (**store_buffer_position < current &&
            *store_buffer_position < store_buffer_top) {
       (*store_buffer_position)++;
     }
     if (**store_buffer_position != current ||
@@ skipping 275 matching lines @@
 
   initial_semispace_size_ = Min(initial_semispace_size_, max_semi_space_size_);
 
   // The old generation is paged and needs at least one page for each space.
   int paged_space_count = LAST_PAGED_SPACE - FIRST_PAGED_SPACE + 1;
   max_old_generation_size_ =
       Max(static_cast<intptr_t>(paged_space_count * Page::kPageSize),
           max_old_generation_size_);
 
   // We rely on being able to allocate new arrays in paged spaces.
-  ASSERT(Page::kMaxRegularHeapObjectSize >=
+  DCHECK(Page::kMaxRegularHeapObjectSize >=
          (JSArray::kSize +
           FixedArray::SizeFor(JSObject::kInitialMaxFastElementArray) +
           AllocationMemento::kSize));
 
   code_range_size_ = code_range_size * MB;
 
   configured_ = true;
   return true;
 }
 
@@ skipping 27 matching lines @@
       isolate()->memory_allocator()->Size() +
       isolate()->memory_allocator()->Available();
   *stats->os_error = base::OS::GetLastError();
       isolate()->memory_allocator()->Available();
   if (take_snapshot) {
     HeapIterator iterator(this);
     for (HeapObject* obj = iterator.next();
          obj != NULL;
          obj = iterator.next()) {
       InstanceType type = obj->map()->instance_type();
-      ASSERT(0 <= type && type <= LAST_TYPE);
+      DCHECK(0 <= type && type <= LAST_TYPE);
       stats->objects_per_type[type]++;
       stats->size_per_type[type] += obj->Size();
     }
   }
 }
 
 
 intptr_t Heap::PromotedSpaceSizeOfObjects() {
   return old_pointer_space_->SizeOfObjects()
       + old_data_space_->SizeOfObjects()
@@ skipping 164 matching lines @@
   if (!property_cell_space_->SetUp()) return false;
 
   // The large object code space may contain code or data.  We set the memory
   // to be non-executable here for safety, but this means we need to enable it
   // explicitly when allocating large code objects.
   lo_space_ = new LargeObjectSpace(this, max_old_generation_size_, LO_SPACE);
   if (lo_space_ == NULL) return false;
   if (!lo_space_->SetUp()) return false;
 
   // Set up the seed that is used to randomize the string hash function.
-  ASSERT(hash_seed() == 0);
+  DCHECK(hash_seed() == 0);
   if (FLAG_randomize_hashes) {
     if (FLAG_hash_seed == 0) {
       int rnd = isolate()->random_number_generator()->NextInt();
       set_hash_seed(Smi::FromInt(rnd & Name::kHashBitMask));
     } else {
       set_hash_seed(Smi::FromInt(FLAG_hash_seed));
     }
   }
 
   LOG(isolate_, IntPtrTEvent("heap-capacity", Capacity()));
@@ skipping 18 matching lines @@
 
   set_native_contexts_list(undefined_value());
   set_array_buffers_list(undefined_value());
   set_allocation_sites_list(undefined_value());
   weak_object_to_code_table_ = undefined_value();
   return true;
 }
 
 
 void Heap::SetStackLimits() {
-  ASSERT(isolate_ != NULL);
-  ASSERT(isolate_ == isolate());
+  DCHECK(isolate_ != NULL);
+  DCHECK(isolate_ == isolate());
   // On 64 bit machines, pointers are generally out of range of Smis.  We write
   // something that looks like an out of range Smi to the GC.
 
   // Set up the special root array entries containing the stack limits.
   // These are actually addresses, but the tag makes the GC ignore it.
   roots_[kStackLimitRootIndex] =
       reinterpret_cast<Object*>(
           (isolate_->stack_guard()->jslimit() & ~kSmiTagMask) | kSmiTag);
   roots_[kRealStackLimitRootIndex] =
       reinterpret_cast<Object*>(
@@ skipping 108 matching lines @@
   store_buffer()->TearDown();
   incremental_marking()->TearDown();
 
   isolate_->memory_allocator()->TearDown();
 }
 
 
 void Heap::AddGCPrologueCallback(v8::Isolate::GCPrologueCallback callback,
                                  GCType gc_type,
                                  bool pass_isolate) {
-  ASSERT(callback != NULL);
+  DCHECK(callback != NULL);
   GCPrologueCallbackPair pair(callback, gc_type, pass_isolate);
-  ASSERT(!gc_prologue_callbacks_.Contains(pair));
+  DCHECK(!gc_prologue_callbacks_.Contains(pair));
   return gc_prologue_callbacks_.Add(pair);
 }
 
 
 void Heap::RemoveGCPrologueCallback(v8::Isolate::GCPrologueCallback callback) {
-  ASSERT(callback != NULL);
+  DCHECK(callback != NULL);
   for (int i = 0; i < gc_prologue_callbacks_.length(); ++i) {
     if (gc_prologue_callbacks_[i].callback == callback) {
       gc_prologue_callbacks_.Remove(i);
       return;
     }
   }
   UNREACHABLE();
 }
 
 
 void Heap::AddGCEpilogueCallback(v8::Isolate::GCEpilogueCallback callback,
                                  GCType gc_type,
                                  bool pass_isolate) {
-  ASSERT(callback != NULL);
+  DCHECK(callback != NULL);
   GCEpilogueCallbackPair pair(callback, gc_type, pass_isolate);
-  ASSERT(!gc_epilogue_callbacks_.Contains(pair));
+  DCHECK(!gc_epilogue_callbacks_.Contains(pair));
   return gc_epilogue_callbacks_.Add(pair);
 }
 
 
 void Heap::RemoveGCEpilogueCallback(v8::Isolate::GCEpilogueCallback callback) {
-  ASSERT(callback != NULL);
+  DCHECK(callback != NULL);
   for (int i = 0; i < gc_epilogue_callbacks_.length(); ++i) {
     if (gc_epilogue_callbacks_[i].callback == callback) {
       gc_epilogue_callbacks_.Remove(i);
       return;
     }
   }
   UNREACHABLE();
 }
 
 
 // TODO(ishell): Find a better place for this.
 void Heap::AddWeakObjectToCodeDependency(Handle<Object> obj,
                                          Handle<DependentCode> dep) {
-  ASSERT(!InNewSpace(*obj));
-  ASSERT(!InNewSpace(*dep));
+  DCHECK(!InNewSpace(*obj));
+  DCHECK(!InNewSpace(*dep));
   // This handle scope keeps the table handle local to this function, which
   // allows us to safely skip write barriers in table update operations.
   HandleScope scope(isolate());
   Handle<WeakHashTable> table(WeakHashTable::cast(weak_object_to_code_table_),
                               isolate());
   table = WeakHashTable::Put(table, obj, dep);
 
   if (ShouldZapGarbage() && weak_object_to_code_table_ != *table) {
     WeakHashTable::cast(weak_object_to_code_table_)->Zap(the_hole_value());
   }
   set_weak_object_to_code_table(*table);
-  ASSERT_EQ(*dep, table->Lookup(obj));
+  DCHECK_EQ(*dep, table->Lookup(obj));
 }
 
 
 DependentCode* Heap::LookupWeakObjectToCodeDependency(Handle<Object> obj) {
   Object* dep = WeakHashTable::cast(weak_object_to_code_table_)->Lookup(obj);
   if (dep->IsDependentCode()) return DependentCode::cast(dep);
   return DependentCode::cast(empty_fixed_array());
 }
 
 
@@ skipping 129 matching lines @@
     }
   }
 
   // Return iterator for the new current space.
   return CreateIterator();
 }
 
 
 // Create an iterator for the space to iterate.
 ObjectIterator* SpaceIterator::CreateIterator() {
-  ASSERT(iterator_ == NULL);
+  DCHECK(iterator_ == NULL);
 
   switch (current_space_) {
     case NEW_SPACE:
       iterator_ = new SemiSpaceIterator(heap_->new_space(), size_func_);
       break;
     case OLD_POINTER_SPACE:
       iterator_ =
           new HeapObjectIterator(heap_->old_pointer_space(), size_func_);
       break;
     case OLD_DATA_SPACE:
@@ skipping 11 matching lines @@
     case PROPERTY_CELL_SPACE:
       iterator_ = new HeapObjectIterator(heap_->property_cell_space(),
                                          size_func_);
       break;
     case LO_SPACE:
       iterator_ = new LargeObjectIterator(heap_->lo_space(), size_func_);
       break;
   }
 
   // Return the newly allocated iterator;
-  ASSERT(iterator_ != NULL);
+  DCHECK(iterator_ != NULL);
   return iterator_;
 }
 
 
 class HeapObjectsFilter {
  public:
   virtual ~HeapObjectsFilter() {}
   virtual bool SkipObject(HeapObject* object) = 0;
 };
 
@@ skipping 90 matching lines @@
   }
   object_iterator_ = space_iterator_->next();
 }
 
 
 void HeapIterator::Shutdown() {
 #ifdef DEBUG
   // Assert that in filtering mode we have iterated through all
   // objects. Otherwise, heap will be left in an inconsistent state.
   if (filtering_ != kNoFiltering) {
-    ASSERT(object_iterator_ == NULL);
+    DCHECK(object_iterator_ == NULL);
   }
 #endif
   // Make sure the last iterator is deallocated.
   delete space_iterator_;
   space_iterator_ = NULL;
   object_iterator_ = NULL;
   delete filter_;
   filter_ = NULL;
 }
 
@@ skipping 84 matching lines @@
 }
 
 
 void PathTracer::Reset() {
   found_target_ = false;
   object_stack_.Clear();
 }
 
 
 void PathTracer::TracePathFrom(Object** root) {
-  ASSERT((search_target_ == kAnyGlobalObject) ||
+  DCHECK((search_target_ == kAnyGlobalObject) ||
          search_target_->IsHeapObject());
   found_target_in_trace_ = false;
   Reset();
 
   MarkVisitor mark_visitor(this);
   MarkRecursively(root, &mark_visitor);
 
   UnmarkVisitor unmark_visitor(this);
   UnmarkRecursively(root, &unmark_visitor);
 
@@ skipping 74 matching lines @@
 }
 
 
 void PathTracer::ProcessResults() {
   if (found_target_) {
     OFStream os(stdout);
     os << "=====================================\n"
        << "====        Path to object       ====\n"
        << "=====================================\n\n";
 
-    ASSERT(!object_stack_.is_empty());
+    DCHECK(!object_stack_.is_empty());
     for (int i = 0; i < object_stack_.length(); i++) {
       if (i > 0) os << "\n     |\n     |\n     V\n\n";
       object_stack_[i]->Print(os);
     }
     os << "=====================================\n";
   }
 }
 
 
 // Triggers a depth-first traversal of reachable objects from one
@@ skipping 69 matching lines @@
   DisallowHeapAllocation no_gc;
   if (!name->IsUniqueName()) {
     if (!StringTable::InternalizeStringIfExists(name->GetIsolate(),
                                                 Handle<String>::cast(name)).
         ToHandle(&name)) {
       return;
     }
   }
   // This cache is cleared only between mark compact passes, so we expect the
   // cache to only contain old space names.
-  ASSERT(!map->GetIsolate()->heap()->InNewSpace(*name));
+  DCHECK(!map->GetIsolate()->heap()->InNewSpace(*name));
 
   int index = (Hash(map, name) & kHashMask);
   // After a GC there will be free slots, so we use them in order (this may
   // help to get the most frequently used one in position 0).
   for (int i = 0; i< kEntriesPerBucket; i++) {
     Key& key = keys_[index];
     Object* free_entry_indicator = NULL;
     if (key.map == free_entry_indicator) {
       key.map = *map;
       key.name = *name;
@@ skipping 27 matching lines @@
   for (int index = 0; index < kLength; index++) keys_[index].source = NULL;
 }
 
 
 void ExternalStringTable::CleanUp() {
   int last = 0;
   for (int i = 0; i < new_space_strings_.length(); ++i) {
     if (new_space_strings_[i] == heap_->the_hole_value()) {
       continue;
     }
-    ASSERT(new_space_strings_[i]->IsExternalString());
+    DCHECK(new_space_strings_[i]->IsExternalString());
     if (heap_->InNewSpace(new_space_strings_[i])) {
       new_space_strings_[last++] = new_space_strings_[i];
     } else {
       old_space_strings_.Add(new_space_strings_[i]);
     }
   }
   new_space_strings_.Rewind(last);
   new_space_strings_.Trim();
 
   last = 0;
   for (int i = 0; i < old_space_strings_.length(); ++i) {
     if (old_space_strings_[i] == heap_->the_hole_value()) {
       continue;
     }
-    ASSERT(old_space_strings_[i]->IsExternalString());
-    ASSERT(!heap_->InNewSpace(old_space_strings_[i]));
+    DCHECK(old_space_strings_[i]->IsExternalString());
+    DCHECK(!heap_->InNewSpace(old_space_strings_[i]));
     old_space_strings_[last++] = old_space_strings_[i];
   }
   old_space_strings_.Rewind(last);
   old_space_strings_.Trim();
 #ifdef VERIFY_HEAP
   if (FLAG_verify_heap) {
     Verify();
   }
 #endif
 }
@@ skipping 146 matching lines @@
       static_cast<int>(object_sizes_last_time_[index]));
   CODE_AGE_LIST_COMPLETE(ADJUST_LAST_TIME_OBJECT_COUNT)
 #undef ADJUST_LAST_TIME_OBJECT_COUNT
 
   MemCopy(object_counts_last_time_, object_counts_, sizeof(object_counts_));
   MemCopy(object_sizes_last_time_, object_sizes_, sizeof(object_sizes_));
   ClearObjectStats();
 }
 
 } }  // namespace v8::internal