Replace ASSERT with DHCECK_op in platform/heap

third_party/WebKit/Source/platform/heap/HeapPage.cpp

 /*
  * Copyright (C) 2013 Google Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are
  * met:
  *
  *     * Redistributions of source code must retain the above copyright
  * notice, this list of conditions and the following disclaimer.
  *     * Redistributions in binary form must reproduce the above
@@ skipping 43 matching lines @@
 #ifdef ANNOTATE_CONTIGUOUS_CONTAINER
 // FIXME: have ContainerAnnotations.h define an ENABLE_-style name instead.
 #define ENABLE_ASAN_CONTAINER_ANNOTATIONS 1
 
 // When finalizing a non-inlined vector backing store/container, remove
 // its contiguous container annotation. Required as it will not be destructed
 // from its Vector.
 #define ASAN_RETIRE_CONTAINER_ANNOTATION(object, objectSize)          \
   do {                                                                \
     BasePage* page = PageFromObject(object);                          \
-    ASSERT(page);                                                     \
+    DCHECK(page);                                                     \
     bool is_container =                                               \
         ThreadState::IsVectorArenaIndex(page->Arena()->ArenaIndex()); \
     if (!is_container && page->IsLargeObjectPage())                   \
       is_container =                                                  \
           static_cast<LargeObjectPage*>(page)->IsVectorBackingPage(); \
     if (is_container)                                                 \
       ANNOTATE_DELETE_BUFFER(object, objectSize, 0);                  \
   } while (0)
 
 // A vector backing store represented by a large object is marked
 // so that when it is finalized, its ASan annotation will be
 // correctly retired.
 #define ASAN_MARK_LARGE_VECTOR_CONTAINER(arena, large_object)            \
   if (ThreadState::IsVectorArenaIndex(arena->ArenaIndex())) {            \
     BasePage* large_page = PageFromObject(large_object);                 \
-    ASSERT(large_page->IsLargeObjectPage());                             \
+    DCHECK(large_page->IsLargeObjectPage());                             \
     static_cast<LargeObjectPage*>(large_page)->SetIsVectorBackingPage(); \
   }
 #else
 #define ENABLE_ASAN_CONTAINER_ANNOTATIONS 0
 #define ASAN_RETIRE_CONTAINER_ANNOTATION(payload, payloadSize)
 #define ASAN_MARK_LARGE_VECTOR_CONTAINER(arena, largeObject)
 #endif
 
 namespace blink {
 
@@ skipping 14 matching lines @@
   ASAN_RETIRE_CONTAINER_ANNOTATION(object, object_size);
 }
 
 BaseArena::BaseArena(ThreadState* state, int index)
     : first_page_(nullptr),
       first_unswept_page_(nullptr),
       thread_state_(state),
       index_(index) {}
 
 BaseArena::~BaseArena() {
-  ASSERT(!first_page_);
-  ASSERT(!first_unswept_page_);
+  DCHECK(!first_page_);
+  DCHECK(!first_unswept_page_);
 }
 
 void BaseArena::RemoveAllPages() {
   ClearFreeLists();
 
-  ASSERT(!first_unswept_page_);
+  DCHECK(!first_unswept_page_);
   while (first_page_) {
     BasePage* page = first_page_;
     page->Unlink(&first_page_);
     page->RemoveFromHeap();
   }
 }
 
 void BaseArena::TakeSnapshot(const String& dump_base_name,
                              ThreadState::GCSnapshotInfo& info) {
   // |dumpBaseName| at this point is "blink_gc/thread_X/heaps/HeapName"
@@ skipping 31 matching lines @@
   for (BasePage* page = first_unswept_page_; page; page = page->Next()) {
     if (page->Contains(address))
       return page;
   }
   return nullptr;
 }
 #endif
 
 void BaseArena::MakeConsistentForGC() {
   ClearFreeLists();
-  ASSERT(IsConsistentForGC());
+#if DCHECK_IS_ON()
+  DCHECK(IsConsistentForGC());
+#endif
   for (BasePage* page = first_page_; page; page = page->Next()) {
     page->MarkAsUnswept();
     page->InvalidateObjectStartBitmap();
   }
 
   // We should not start a new GC until we finish sweeping in the current GC.
   CHECK(!first_unswept_page_);
 
   HeapCompact* heap_compactor = GetThreadState()->Heap().Compaction();
   if (!heap_compactor->IsCompactingArena(ArenaIndex()))
     return;
 
   BasePage* next_page = first_page_;
   while (next_page) {
     if (!next_page->IsLargeObjectPage())
       heap_compactor->AddCompactingPage(next_page);
     next_page = next_page->Next();
   }
 }
 
 void BaseArena::MakeConsistentForMutator() {
   ClearFreeLists();
-  ASSERT(IsConsistentForGC());
-  ASSERT(!first_page_);
+#if DCHECK_IS_ON()
+  DCHECK(IsConsistentForGC());
+#endif
+  DCHECK(!first_page_);
 
   // Drop marks from marked objects and rebuild free lists in preparation for
   // resuming the executions of mutators.
   BasePage* previous_page = nullptr;
   for (BasePage *page = first_unswept_page_; page;
        previous_page = page, page = page->Next()) {
     page->MakeConsistentForMutator();
     page->MarkAsSwept();
     page->InvalidateObjectStartBitmap();
   }
   if (previous_page) {
-    ASSERT(first_unswept_page_);
+    DCHECK(first_unswept_page_);
     previous_page->next_ = first_page_;
     first_page_ = first_unswept_page_;
     first_unswept_page_ = nullptr;
   }
-  ASSERT(!first_unswept_page_);
+  DCHECK(!first_unswept_page_);
 }
 
 size_t BaseArena::ObjectPayloadSizeForTesting() {
-  ASSERT(IsConsistentForGC());
-  ASSERT(!first_unswept_page_);
+#if DCHECK_IS_ON()
+  DCHECK(IsConsistentForGC());
+#endif
+  DCHECK(!first_unswept_page_);
 
   size_t object_payload_size = 0;
   for (BasePage* page = first_page_; page; page = page->Next())
     object_payload_size += page->ObjectPayloadSizeForTesting();
   return object_payload_size;
 }
 
 void BaseArena::PrepareForSweep() {
-  ASSERT(GetThreadState()->IsInGC());
-  ASSERT(!first_unswept_page_);
+  DCHECK(GetThreadState()->IsInGC());
+  DCHECK(!first_unswept_page_);
 
   // Move all pages to a list of unswept pages.
   first_unswept_page_ = first_page_;
   first_page_ = nullptr;
 }
 
 #if defined(ADDRESS_SANITIZER)
 void BaseArena::PoisonArena() {
   for (BasePage* page = first_unswept_page_; page; page = page->Next())
     page->PoisonUnmarkedObjects();
@@ skipping 42 matching lines @@
 }
 
 bool BaseArena::LazySweepWithDeadline(double deadline_seconds) {
   // It might be heavy to call
   // Platform::current()->monotonicallyIncreasingTimeSeconds() per page (i.e.,
   // 128 KB sweep or one LargeObject sweep), so we check the deadline per 10
   // pages.
   static const int kDeadlineCheckInterval = 10;
 
   CHECK(GetThreadState()->IsSweepingInProgress());
-  ASSERT(GetThreadState()->SweepForbidden());
-  ASSERT(!GetThreadState()->IsMainThread() ||
+  DCHECK(GetThreadState()->SweepForbidden());
+  DCHECK(!GetThreadState()->IsMainThread() ||
          ScriptForbiddenScope::IsScriptForbidden());
 
   NormalPageArena* normal_arena = nullptr;
   if (first_unswept_page_ && !first_unswept_page_->IsLargeObjectPage()) {
     // Mark this NormalPageArena as being lazily swept.
     NormalPage* normal_page =
         reinterpret_cast<NormalPage*>(first_unswept_page_);
     normal_arena = normal_page->ArenaForNormalPage();
     normal_arena->SetIsLazySweeping(true);
   }
@@ skipping 12 matching lines @@
     page_count++;
   }
   ThreadHeap::ReportMemoryUsageForTracing();
   if (normal_arena)
     normal_arena->SetIsLazySweeping(false);
   return true;
 }
 
 void BaseArena::CompleteSweep() {
   CHECK(GetThreadState()->IsSweepingInProgress());
-  ASSERT(GetThreadState()->SweepForbidden());
-  ASSERT(!GetThreadState()->IsMainThread() ||
+  DCHECK(GetThreadState()->SweepForbidden());
+  DCHECK(!GetThreadState()->IsMainThread() ||
          ScriptForbiddenScope::IsScriptForbidden());
 
   while (first_unswept_page_) {
     SweepUnsweptPage();
   }
   ThreadHeap::ReportMemoryUsageForTracing();
 }
 
 Address BaseArena::AllocateLargeObject(size_t allocation_size,
                                        size_t gc_info_index) {
@@ skipping 321 matching lines @@
   //
   // FIXME: This threshold is determined just to optimize blink_perf
   // benchmarks. Coalescing is very sensitive to the threashold and
   // we need further investigations on the coalescing scheme.
   if (promptly_freed_size_ < 1024 * 1024)
     return false;
 
   if (GetThreadState()->SweepForbidden())
     return false;
 
-  ASSERT(!HasCurrentAllocationArea());
+  DCHECK(!HasCurrentAllocationArea());
   TRACE_EVENT0("blink_gc", "BaseArena::coalesce");
 
   // Rebuild free lists.
   free_list_.Clear();
   size_t freed_size = 0;
   for (NormalPage* page = static_cast<NormalPage*>(first_page_); page;
        page = static_cast<NormalPage*>(page->Next())) {
     Address start_of_gap = page->Payload();
     for (Address header_address = start_of_gap;
          header_address < page->PayloadEnd();) {
       HeapObjectHeader* header =
           reinterpret_cast<HeapObjectHeader*>(header_address);
       size_t size = header->size();
-      ASSERT(size > 0);
-      ASSERT(size < BlinkPagePayloadSize());
+      DCHECK_GT(size, 0u);
+      DCHECK_LT(size, BlinkPagePayloadSize());
 
       if (header->IsPromptlyFreed()) {
-        ASSERT(size >= sizeof(HeapObjectHeader));
+        DCHECK_GE(size, sizeof(HeapObjectHeader));
         // Zero the memory in the free list header to maintain the
         // invariant that memory on the free list is zero filled.
         // The rest of the memory is already on the free list and is
         // therefore already zero filled.
         SET_MEMORY_INACCESSIBLE(header_address, sizeof(HeapObjectHeader));
         CHECK_MEMORY_INACCESSIBLE(header_address, size);
         freed_size += size;
         header_address += size;
         continue;
       }
@@ skipping 13 matching lines @@
         AddToFreeList(start_of_gap, header_address - start_of_gap);
 
       header_address += size;
       start_of_gap = header_address;
     }
 
     if (start_of_gap != page->PayloadEnd())
       AddToFreeList(start_of_gap, page->PayloadEnd() - start_of_gap);
   }
   GetThreadState()->DecreaseAllocatedObjectSize(freed_size);
-  ASSERT(promptly_freed_size_ == freed_size);
+  DCHECK_EQ(promptly_freed_size_, freed_size);
   promptly_freed_size_ = 0;
   return true;
 }
 
 void NormalPageArena::PromptlyFreeObject(HeapObjectHeader* header) {
-  ASSERT(!GetThreadState()->SweepForbidden());
+  DCHECK(!GetThreadState()->SweepForbidden());
   Address address = reinterpret_cast<Address>(header);
   Address payload = header->Payload();
   size_t size = header->size();
   size_t payload_size = header->PayloadSize();
-  ASSERT(size > 0);
-  ASSERT(PageFromObject(address) == FindPageFromAddress(address));
-
+  DCHECK_GT(size, 0u);
+#if DCHECK_IS_ON()
+  DCHECK_EQ(PageFromObject(address), FindPageFromAddress(address));
+#endif
   {
     ThreadState::SweepForbiddenScope forbidden_scope(GetThreadState());
     header->Finalize(payload, payload_size);
     if (address + size == current_allocation_point_) {
       current_allocation_point_ = address;
       SetRemainingAllocationSize(remaining_allocation_size_ + size);
       SET_MEMORY_INACCESSIBLE(address, size);
       return;
     }
     SET_MEMORY_INACCESSIBLE(payload, payload_size);
     header->MarkPromptlyFreed();
   }
 
   promptly_freed_size_ += size;
 }
 
 bool NormalPageArena::ExpandObject(HeapObjectHeader* header, size_t new_size) {
   // It's possible that Vector requests a smaller expanded size because
   // Vector::shrinkCapacity can set a capacity smaller than the actual payload
   // size.
   if (header->PayloadSize() >= new_size)
     return true;
   size_t allocation_size = ThreadHeap::AllocationSizeFromSize(new_size);
-  ASSERT(allocation_size > header->size());
+  DCHECK_GT(allocation_size, header->size());
   size_t expand_size = allocation_size - header->size();
   if (IsObjectAllocatedAtAllocationPoint(header) &&
       expand_size <= remaining_allocation_size_) {
     current_allocation_point_ += expand_size;
-    ASSERT(remaining_allocation_size_ >= expand_size);
+    DCHECK_GE(remaining_allocation_size_, expand_size);
     SetRemainingAllocationSize(remaining_allocation_size_ - expand_size);
     // Unpoison the memory used for the object (payload).
     SET_MEMORY_ACCESSIBLE(header->PayloadEnd(), expand_size);
     header->SetSize(allocation_size);
-    ASSERT(FindPageFromAddress(header->PayloadEnd() - 1));
+#if DCHECK_IS_ON()
+    DCHECK(FindPageFromAddress(header->PayloadEnd() - 1));
+#endif
     return true;
   }
   return false;
 }
 
 bool NormalPageArena::ShrinkObject(HeapObjectHeader* header, size_t new_size) {
-  ASSERT(header->PayloadSize() > new_size);
+  DCHECK_GT(header->PayloadSize(), new_size);
   size_t allocation_size = ThreadHeap::AllocationSizeFromSize(new_size);
-  ASSERT(header->size() > allocation_size);
+  DCHECK_GT(header->size(), allocation_size);
   size_t shrink_size = header->size() - allocation_size;
   if (IsObjectAllocatedAtAllocationPoint(header)) {
     current_allocation_point_ -= shrink_size;
     SetRemainingAllocationSize(remaining_allocation_size_ + shrink_size);
     SET_MEMORY_INACCESSIBLE(current_allocation_point_, shrink_size);
     header->SetSize(allocation_size);
     return true;
   }
-  ASSERT(shrink_size >= sizeof(HeapObjectHeader));
-  ASSERT(header->GcInfoIndex() > 0);
+  DCHECK_GE(shrink_size, sizeof(HeapObjectHeader));
+  DCHECK_GT(header->GcInfoIndex(), 0u);
   Address shrink_address = header->PayloadEnd() - shrink_size;
   HeapObjectHeader* freed_header = new (NotNull, shrink_address)
       HeapObjectHeader(shrink_size, header->GcInfoIndex());
   freed_header->MarkPromptlyFreed();
-  ASSERT(PageFromObject(reinterpret_cast<Address>(header)) ==
-         FindPageFromAddress(reinterpret_cast<Address>(header)));
+#if DCHECK_IS_ON()
+  DCHECK_EQ(PageFromObject(reinterpret_cast<Address>(header)),
+            FindPageFromAddress(reinterpret_cast<Address>(header)));
+#endif
   promptly_freed_size_ += shrink_size;
   header->SetSize(allocation_size);
   SET_MEMORY_INACCESSIBLE(shrink_address + sizeof(HeapObjectHeader),
                           shrink_size - sizeof(HeapObjectHeader));
   return false;
 }
 
 Address NormalPageArena::LazySweepPages(size_t allocation_size,
                                         size_t gc_info_index) {
-  ASSERT(!HasCurrentAllocationArea());
+  DCHECK(!HasCurrentAllocationArea());
   AutoReset<bool> is_lazy_sweeping(&is_lazy_sweeping_, true);
   Address result = nullptr;
   while (first_unswept_page_) {
     BasePage* page = first_unswept_page_;
     if (page->IsEmpty()) {
       page->Unlink(&first_unswept_page_);
       page->RemoveFromHeap();
     } else {
       // Sweep a page and move the page from m_firstUnsweptPages to
       // m_firstPages.
@@ skipping 28 matching lines @@
         remaining_allocation_size_ - last_remaining_allocation_size_);
   last_remaining_allocation_size_ = remaining_allocation_size_;
 }
 
 void NormalPageArena::UpdateRemainingAllocationSize() {
   if (last_remaining_allocation_size_ > RemainingAllocationSize()) {
     GetThreadState()->IncreaseAllocatedObjectSize(
         last_remaining_allocation_size_ - RemainingAllocationSize());
     last_remaining_allocation_size_ = RemainingAllocationSize();
   }
-  ASSERT(last_remaining_allocation_size_ == RemainingAllocationSize());
+  DCHECK_EQ(last_remaining_allocation_size_, RemainingAllocationSize());
 }
 
 void NormalPageArena::SetAllocationPoint(Address point, size_t size) {
 #if DCHECK_IS_ON()
   if (point) {
-    ASSERT(size);
+    DCHECK(size);
     BasePage* page = PageFromObject(point);
-    ASSERT(!page->IsLargeObjectPage());
-    ASSERT(size <= static_cast<NormalPage*>(page)->PayloadSize());
+    DCHECK(!page->IsLargeObjectPage());
+    DCHECK_LE(size, static_cast<NormalPage*>(page)->PayloadSize());
   }
 #endif
   if (HasCurrentAllocationArea()) {
     AddToFreeList(CurrentAllocationPoint(), RemainingAllocationSize());
   }
   UpdateRemainingAllocationSize();
   current_allocation_point_ = point;
   last_remaining_allocation_size_ = remaining_allocation_size_ = size;
 }
 
 Address NormalPageArena::OutOfLineAllocate(size_t allocation_size,
                                            size_t gc_info_index) {
-  ASSERT(allocation_size > RemainingAllocationSize());
-  ASSERT(allocation_size >= kAllocationGranularity);
+  DCHECK_GT(allocation_size, RemainingAllocationSize());
+  DCHECK_GE(allocation_size, kAllocationGranularity);
 
   // 1. If this allocation is big enough, allocate a large object.
   if (allocation_size >= kLargeObjectSizeThreshold)
     return AllocateLargeObject(allocation_size, gc_info_index);
 
   // 2. Try to allocate from a free list.
   UpdateRemainingAllocationSize();
   Address result = AllocateFromFreeList(allocation_size, gc_info_index);
   if (result)
     return result;
@@ skipping 45 matching lines @@
     if (allocation_size > bucket_size) {
       // Final bucket candidate; check initial entry if it is able
       // to service this allocation. Do not perform a linear scan,
       // as it is considered too costly.
       if (!entry || entry->size() < allocation_size)
         break;
     }
     if (entry) {
       entry->Unlink(&free_list_.free_lists_[index]);
       SetAllocationPoint(entry->GetAddress(), entry->size());
-      ASSERT(HasCurrentAllocationArea());
-      ASSERT(RemainingAllocationSize() >= allocation_size);
+      DCHECK(HasCurrentAllocationArea());
+      DCHECK_GE(RemainingAllocationSize(), allocation_size);
       free_list_.biggest_free_list_index_ = index;
       return AllocateObject(allocation_size, gc_info_index);
     }
   }
   free_list_.biggest_free_list_index_ = index;
   return nullptr;
 }
 
 LargeObjectArena::LargeObjectArena(ThreadState* state, int index)
     : BaseArena(state, index) {}
 
 Address LargeObjectArena::AllocateLargeObjectPage(size_t allocation_size,
                                                   size_t gc_info_index) {
   // Caller already added space for object header and rounded up to allocation
   // alignment
-  ASSERT(!(allocation_size & kAllocationMask));
+  DCHECK(!(allocation_size & kAllocationMask));
 
   // 1. Try to sweep large objects more than allocationSize bytes
   // before allocating a new large object.
   Address result = LazySweep(allocation_size, gc_info_index);
   if (result)
     return result;
 
   // 2. If we have failed in sweeping allocationSize bytes,
   // we complete sweeping before allocating this large object.
   GetThreadState()->CompleteSweep();
@@ skipping 16 matching lines @@
 
   GetThreadState()->ShouldFlushHeapDoesNotContainCache();
   PageMemory* page_memory = PageMemory::Allocate(
       large_object_size, GetThreadState()->Heap().GetRegionTree());
   Address large_object_address = page_memory->WritableStart();
   Address header_address =
       large_object_address + LargeObjectPage::PageHeaderSize();
 #if DCHECK_IS_ON()
   // Verify that the allocated PageMemory is expectedly zeroed.
   for (size_t i = 0; i < large_object_size; ++i)
-    ASSERT(!large_object_address[i]);
+    DCHECK(!large_object_address[i]);
 #endif
-  ASSERT(gc_info_index > 0);
+  DCHECK_GT(gc_info_index, 0u);
   HeapObjectHeader* header = new (NotNull, header_address)
       HeapObjectHeader(kLargeObjectSizeInHeader, gc_info_index);
   Address result = header_address + sizeof(*header);
-  ASSERT(!(reinterpret_cast<uintptr_t>(result) & kAllocationMask));
+  DCHECK(!(reinterpret_cast<uintptr_t>(result) & kAllocationMask));
   LargeObjectPage* large_object = new (large_object_address)
       LargeObjectPage(page_memory, this, allocation_size);
 
   // Poison the object header and allocationGranularity bytes after the object
   ASAN_POISON_MEMORY_REGION(header, sizeof(*header));
   ASAN_POISON_MEMORY_REGION(large_object->GetAddress() + large_object->size(),
                             kAllocationGranularity);
 
   large_object->Link(&first_page_);
 
@@ skipping 29 matching lines @@
     BasePage* page = first_unswept_page_;
     if (page->IsEmpty()) {
       swept_size += static_cast<LargeObjectPage*>(page)->PayloadSize() +
                     sizeof(HeapObjectHeader);
       page->Unlink(&first_unswept_page_);
       page->RemoveFromHeap();
       // For LargeObjectPage, stop lazy sweeping once we have swept
       // more than allocationSize bytes.
       if (swept_size >= allocation_size) {
         result = DoAllocateLargeObjectPage(allocation_size, gc_info_index);
-        ASSERT(result);
+        DCHECK(result);
         break;
       }
     } else {
       // Sweep a page and move the page from m_firstUnsweptPages to
       // m_firstPages.
       page->Sweep();
       page->Unlink(&first_unswept_page_);
       page->Link(&first_page_);
       page->MarkAsSwept();
     }
   }
   return result;
 }
 
 FreeList::FreeList() : biggest_free_list_index_(0) {}
 
 void FreeList::AddToFreeList(Address address, size_t size) {
-  ASSERT(size < BlinkPagePayloadSize());
+  DCHECK_LT(size, BlinkPagePayloadSize());
   // The free list entries are only pointer aligned (but when we allocate
   // from them we are 8 byte aligned due to the header size).
-  ASSERT(!((reinterpret_cast<uintptr_t>(address) + sizeof(HeapObjectHeader)) &
+  DCHECK(!((reinterpret_cast<uintptr_t>(address) + sizeof(HeapObjectHeader)) &
            kAllocationMask));
-  ASSERT(!(size & kAllocationMask));
+  DCHECK(!(size & kAllocationMask));
   ASAN_UNPOISON_MEMORY_REGION(address, size);
   FreeListEntry* entry;
   if (size < sizeof(*entry)) {
     // Create a dummy header with only a size and freelist bit set.
-    ASSERT(size >= sizeof(HeapObjectHeader));
+    DCHECK_GE(size, sizeof(HeapObjectHeader));
     // Free list encode the size to mark the lost memory as freelist memory.
     new (NotNull, address)
         HeapObjectHeader(size, kGcInfoIndexForFreeListHeader);
 
     ASAN_POISON_MEMORY_REGION(address, size);
     // This memory gets lost. Sweeping can reclaim it.
     return;
   }
   entry = new (NotNull, address) FreeListEntry(size);
 
@@ skipping 64 matching lines @@
   for (size_t i = 0; i < size; i++) {
     // See the comment in addToFreeList().
     if (address[i] != kReuseAllowedZapValue)
       address[i] = kReuseForbiddenZapValue;
   }
 }
 
 void NEVER_INLINE FreeList::CheckFreedMemoryIsZapped(Address address,
                                                      size_t size) {
   for (size_t i = 0; i < size; i++) {
-    ASSERT(address[i] == kReuseAllowedZapValue ||
+    DCHECK(address[i] == kReuseAllowedZapValue ||
            address[i] == kReuseForbiddenZapValue);
   }
 }
 #endif
 
 size_t FreeList::FreeListSize() const {
   size_t free_size = 0;
   for (unsigned i = 0; i < kBlinkPageSizeLog2; ++i) {
     FreeListEntry* entry = free_lists_[i];
     while (entry) {
@@ skipping 23 matching lines @@
   return free_size;
 }
 
 void FreeList::Clear() {
   biggest_free_list_index_ = 0;
   for (size_t i = 0; i < kBlinkPageSizeLog2; ++i)
     free_lists_[i] = nullptr;
 }
 
 int FreeList::BucketIndexForSize(size_t size) {
-  ASSERT(size > 0);
+  DCHECK_GT(size, 0u);
   int index = -1;
   while (size) {
     size >>= 1;
     index++;
   }
   return index;
 }
 
 bool FreeList::TakeSnapshot(const String& dump_base_name) {
   bool did_dump_bucket_stats = false;
@@ skipping 13 matching lines @@
             ->CreateMemoryAllocatorDumpForCurrentGC(dump_name);
     bucket_dump->AddScalar("free_count", "objects", entry_count);
     bucket_dump->AddScalar("free_size", "bytes", free_size);
     did_dump_bucket_stats = true;
   }
   return did_dump_bucket_stats;
 }
 
 BasePage::BasePage(PageMemory* storage, BaseArena* arena)
     : storage_(storage), arena_(arena), next_(nullptr), swept_(true) {
-  ASSERT(IsPageHeaderAddress(reinterpret_cast<Address>(this)));
+#if DCHECK_IS_ON()
+  DCHECK(IsPageHeaderAddress(reinterpret_cast<Address>(this)));
+#endif
 }
 
 NormalPage::NormalPage(PageMemory* storage, BaseArena* arena)
     : BasePage(storage, arena), object_start_bit_map_computed_(false) {
-  ASSERT(IsPageHeaderAddress(reinterpret_cast<Address>(this)));
+#if DCHECK_IS_ON()
+  DCHECK(IsPageHeaderAddress(reinterpret_cast<Address>(this)));
+#endif
 }
 
 size_t NormalPage::ObjectPayloadSizeForTesting() {
   size_t object_payload_size = 0;
   Address header_address = Payload();
   MarkAsSwept();
-  ASSERT(header_address != PayloadEnd());
+  DCHECK_NE(header_address, PayloadEnd());
   do {
     HeapObjectHeader* header =
         reinterpret_cast<HeapObjectHeader*>(header_address);
     if (!header->IsFree()) {
       object_payload_size += header->PayloadSize();
     }
-    ASSERT(header->size() < BlinkPagePayloadSize());
+    DCHECK_LT(header->size(), BlinkPagePayloadSize());
     header_address += header->size();
-    ASSERT(header_address <= PayloadEnd());
+    DCHECK_LE(header_address, PayloadEnd());
   } while (header_address < PayloadEnd());
   return object_payload_size;
 }
 
 bool NormalPage::IsEmpty() {
   HeapObjectHeader* header = reinterpret_cast<HeapObjectHeader*>(Payload());
   return header->IsFree() && header->size() == PayloadSize();
 }
 
 void NormalPage::RemoveFromHeap() {
@@ skipping 13 matching lines @@
 #endif
 
 void NormalPage::Sweep() {
   size_t marked_object_size = 0;
   Address start_of_gap = Payload();
   NormalPageArena* page_arena = ArenaForNormalPage();
   for (Address header_address = start_of_gap; header_address < PayloadEnd();) {
     HeapObjectHeader* header =
         reinterpret_cast<HeapObjectHeader*>(header_address);
     size_t size = header->size();
-    ASSERT(size > 0);
-    ASSERT(size < BlinkPagePayloadSize());
+    DCHECK_GT(size, 0u);
+    DCHECK_LT(size, BlinkPagePayloadSize());
 
     if (header->IsPromptlyFreed())
       page_arena->DecreasePromptlyFreedSize(size);
     if (header->IsFree()) {
       // Zero the memory in the free list header to maintain the
       // invariant that memory on the free list is zero filled.
       // The rest of the memory is already on the free list and is
       // therefore already zero filled.
       SET_MEMORY_INACCESSIBLE(header_address, size < sizeof(FreeListEntry)
                                                   ? size
@@ skipping 53 matching lines @@
   NormalPageArena* page_arena = ArenaForNormalPage();
 #if defined(ADDRESS_SANITIZER)
   bool is_vector_arena =
       ThreadState::IsVectorArenaIndex(page_arena->ArenaIndex());
 #endif
   HeapCompact* compact = page_arena->GetThreadState()->Heap().Compaction();
   for (Address header_address = Payload(); header_address < PayloadEnd();) {
     HeapObjectHeader* header =
         reinterpret_cast<HeapObjectHeader*>(header_address);
     size_t size = header->size();
-    DCHECK(size > 0 && size < BlinkPagePayloadSize());
+    DCHECK_GT(size, 0u);
+    DCHECK_LT(size, BlinkPagePayloadSize());
 
     if (header->IsPromptlyFreed())
       page_arena->DecreasePromptlyFreedSize(size);
     if (header->IsFree()) {
       // Unpoison the freelist entry so that we
       // can compact into it as wanted.
       ASAN_UNPOISON_MEMORY_REGION(header_address, size);
       header_address += size;
       continue;
     }
@@ skipping 79 matching lines @@
 #endif
 }
 
 void NormalPage::MakeConsistentForMutator() {
   Address start_of_gap = Payload();
   NormalPageArena* normal_arena = ArenaForNormalPage();
   for (Address header_address = Payload(); header_address < PayloadEnd();) {
     HeapObjectHeader* header =
         reinterpret_cast<HeapObjectHeader*>(header_address);
     size_t size = header->size();
-    ASSERT(size < BlinkPagePayloadSize());
+    DCHECK_LT(size, BlinkPagePayloadSize());
     if (header->IsPromptlyFreed())
       ArenaForNormalPage()->DecreasePromptlyFreedSize(size);
     if (header->IsFree()) {
       // Zero the memory in the free list header to maintain the
       // invariant that memory on the free list is zero filled.
       // The rest of the memory is already on the free list and is
       // therefore already zero filled.
       SET_MEMORY_INACCESSIBLE(header_address, size < sizeof(FreeListEntry)
                                                   ? size
                                                   : sizeof(FreeListEntry));
       CHECK_MEMORY_INACCESSIBLE(header_address, size);
       header_address += size;
       continue;
     }
     if (start_of_gap != header_address)
       normal_arena->AddToFreeList(start_of_gap, header_address - start_of_gap);
     if (header->IsMarked())
       header->Unmark();
     header_address += size;
     start_of_gap = header_address;
-    ASSERT(header_address <= PayloadEnd());
+    DCHECK_LE(header_address, PayloadEnd());
   }
   if (start_of_gap != PayloadEnd())
     normal_arena->AddToFreeList(start_of_gap, PayloadEnd() - start_of_gap);
 }
 
 #if defined(ADDRESS_SANITIZER)
 void NormalPage::PoisonUnmarkedObjects() {
   for (Address header_address = Payload(); header_address < PayloadEnd();) {
     HeapObjectHeader* header =
         reinterpret_cast<HeapObjectHeader*>(header_address);
-    ASSERT(header->size() < BlinkPagePayloadSize());
+    DCHECK_LT(header->size(), BlinkPagePayloadSize());
     // Check if a free list entry first since we cannot call
     // isMarked on a free list entry.
     if (header->IsFree()) {
       header_address += header->size();
       continue;
     }
     if (!header->IsMarked())
       ASAN_POISON_MEMORY_REGION(header->Payload(), header->PayloadSize());
     header_address += header->size();
   }
 }
 #endif
 
 void NormalPage::PopulateObjectStartBitMap() {
   memset(&object_start_bit_map_, 0, kObjectStartBitMapSize);
   Address start = Payload();
   for (Address header_address = start; header_address < PayloadEnd();) {
     HeapObjectHeader* header =
         reinterpret_cast<HeapObjectHeader*>(header_address);
     size_t object_offset = header_address - start;
-    ASSERT(!(object_offset & kAllocationMask));
+    DCHECK(!(object_offset & kAllocationMask));
     size_t object_start_number = object_offset / kAllocationGranularity;
     size_t map_index = object_start_number / 8;
-    ASSERT(map_index < kObjectStartBitMapSize);
+    DCHECK_LT(map_index, kObjectStartBitMapSize);
     object_start_bit_map_[map_index] |= (1 << (object_start_number & 7));
     header_address += header->size();
-    ASSERT(header_address <= PayloadEnd());
+    DCHECK_LE(header_address, PayloadEnd());
   }
   object_start_bit_map_computed_ = true;
 }
 
 static int NumberOfLeadingZeroes(uint8_t byte) {
   if (!byte)
     return 8;
   int result = 0;
   if (byte <= 0x0F) {
     result += 4;
     byte = byte << 4;
   }
   if (byte <= 0x3F) {
     result += 2;
     byte = byte << 2;
   }
   if (byte <= 0x7F)
     result++;
   return result;
 }
 
 HeapObjectHeader* NormalPage::FindHeaderFromAddress(Address address) {
   if (address < Payload())
     return nullptr;
   if (!object_start_bit_map_computed_)
     PopulateObjectStartBitMap();
   size_t object_offset = address - Payload();
   size_t object_start_number = object_offset / kAllocationGranularity;
   size_t map_index = object_start_number / 8;
-  ASSERT(map_index < kObjectStartBitMapSize);
+  DCHECK_LT(map_index, kObjectStartBitMapSize);
   size_t bit = object_start_number & 7;
   uint8_t byte = object_start_bit_map_[map_index] & ((1 << (bit + 1)) - 1);
   while (!byte) {
-    ASSERT(map_index > 0);
+    DCHECK_GT(map_index, 0u);
     byte = object_start_bit_map_[--map_index];
   }
   int leading_zeroes = NumberOfLeadingZeroes(byte);
   object_start_number = (map_index * 8) + 7 - leading_zeroes;
   object_offset = object_start_number * kAllocationGranularity;
   Address object_address = object_offset + Payload();
   HeapObjectHeader* header =
       reinterpret_cast<HeapObjectHeader*>(object_address);
   if (header->IsFree())
     return nullptr;
@@ skipping 20 matching lines @@
     //
     // class A : public GarbageCollected<A> { virtual void f() = 0; };
     // class B : public A {
     //   B() : A(foo()) { };
     // };
     //
     // If foo() allocates something and triggers a GC, the vtable of A
     // has not yet been initialized. In this case, we should mark the A
     // object without tracing any member of the A object.
     visitor->MarkHeaderNoTracing(header);
-    ASSERT(IsUninitializedMemory(header->Payload(), header->PayloadSize()));
+#if DCHECK_IS_ON()
+    DCHECK(IsUninitializedMemory(header->Payload(), header->PayloadSize()));
+#endif
   } else {
     visitor->MarkHeader(header, gc_info->trace_);
   }
 }
 
 void NormalPage::CheckAndMarkPointer(Visitor* visitor, Address address) {
 #if DCHECK_IS_ON()
   DCHECK(Contains(address));
 #endif
   HeapObjectHeader* header = FindHeaderFromAddress(address);
@@ skipping 55 matching lines @@
   page_dump->AddScalar("dead_size", "bytes", dead_size);
   page_dump->AddScalar("free_size", "bytes", free_size);
   heap_info.free_size += free_size;
   heap_info.free_count += free_count;
 }
 
 #if DCHECK_IS_ON()
 bool NormalPage::Contains(Address addr) {
   Address blink_page_start = RoundToBlinkPageStart(GetAddress());
   // Page is at aligned address plus guard page size.
-  ASSERT(blink_page_start == GetAddress() - kBlinkGuardPageSize);
+  DCHECK_EQ(blink_page_start, GetAddress() - kBlinkGuardPageSize);
   return blink_page_start <= addr && addr < blink_page_start + kBlinkPageSize;
 }
 #endif
 
 LargeObjectPage::LargeObjectPage(PageMemory* storage,
                                  BaseArena* arena,
                                  size_t payload_size)
     : BasePage(storage, arena),
       payload_size_(payload_size)
 #if ENABLE(ASAN_CONTAINER_ANNOTATIONS)
@@ skipping 103 matching lines @@
 
 size_t HeapDoesNotContainCache::GetHash(Address address) {
   size_t value = (reinterpret_cast<size_t>(address) >> kBlinkPageSizeLog2);
   value ^= value >> kNumberOfEntriesLog2;
   value ^= value >> (kNumberOfEntriesLog2 * 2);
   value &= kNumberOfEntries - 1;
   return value & ~1;  // Returns only even number.
 }
 
 bool HeapDoesNotContainCache::Lookup(Address address) {
-  ASSERT(ThreadState::Current()->IsInGC());
+  DCHECK(ThreadState::Current()->IsInGC());
 
   size_t index = GetHash(address);
-  ASSERT(!(index & 1));
+  DCHECK(!(index & 1));
   Address cache_page = RoundToBlinkPageStart(address);
   if (entries_[index] == cache_page)
     return entries_[index];
   if (entries_[index + 1] == cache_page)
     return entries_[index + 1];
   return false;
 }
 
 void HeapDoesNotContainCache::AddEntry(Address address) {
-  ASSERT(ThreadState::Current()->IsInGC());
+  DCHECK(ThreadState::Current()->IsInGC());
 
   has_entries_ = true;
   size_t index = GetHash(address);
-  ASSERT(!(index & 1));
+  DCHECK(!(index & 1));
   Address cache_page = RoundToBlinkPageStart(address);
   entries_[index + 1] = entries_[index];
   entries_[index] = cache_page;
 }
 
 }  // namespace blink