Rename ASSERT* to DCHECK*.

src/spaces.h

 // Copyright 2011 the V8 project authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #ifndef V8_SPACES_H_
 #define V8_SPACES_H_
 
 #include "src/allocation.h"
 #include "src/base/atomicops.h"
 #include "src/base/platform/mutex.h"
@@ skipping 56 matching lines @@
 // is to enable linear allocation without having to constantly update the byte
 // array every time the top field is updated and a new object is created.  The
 // special garbage section is not in the chain of garbage sections.
 //
 // Since the top and limit fields are in the space, not the page, only one page
 // has a special garbage section, and if the top and limit are equal then there
 // is no special garbage section.
 
 // Some assertion macros used in the debugging mode.
 
-#define ASSERT_PAGE_ALIGNED(address)                                           \
-  ASSERT((OffsetFrom(address) & Page::kPageAlignmentMask) == 0)
+#define DCHECK_PAGE_ALIGNED(address)                                           \
+  DCHECK((OffsetFrom(address) & Page::kPageAlignmentMask) == 0)
 
-#define ASSERT_OBJECT_ALIGNED(address)                                         \
-  ASSERT((OffsetFrom(address) & kObjectAlignmentMask) == 0)
+#define DCHECK_OBJECT_ALIGNED(address)                                         \
+  DCHECK((OffsetFrom(address) & kObjectAlignmentMask) == 0)
 
-#define ASSERT_OBJECT_SIZE(size)                                               \
-  ASSERT((0 < size) && (size <= Page::kMaxRegularHeapObjectSize))
+#define DCHECK_OBJECT_SIZE(size)                                               \
+  DCHECK((0 < size) && (size <= Page::kMaxRegularHeapObjectSize))
 
-#define ASSERT_PAGE_OFFSET(offset)                                             \
-  ASSERT((Page::kObjectStartOffset <= offset)                                  \
+#define DCHECK_PAGE_OFFSET(offset)                                             \
+  DCHECK((Page::kObjectStartOffset <= offset)                                  \
       && (offset <= Page::kPageSize))
 
-#define ASSERT_MAP_PAGE_INDEX(index)                                           \
-  ASSERT((0 <= index) && (index <= MapSpace::kMaxMapPageIndex))
+#define DCHECK_MAP_PAGE_INDEX(index)                                           \
+  DCHECK((0 <= index) && (index <= MapSpace::kMaxMapPageIndex))
 
 
 class PagedSpace;
 class MemoryAllocator;
 class AllocationInfo;
 class Space;
 class FreeList;
 class MemoryChunk;
 
 class MarkBit {
@@ skipping 213 matching lines @@
     if ((reinterpret_cast<intptr_t>(owner_) & kPageHeaderTagMask) ==
         kPageHeaderTag) {
       return reinterpret_cast<Space*>(reinterpret_cast<intptr_t>(owner_) -
                                       kPageHeaderTag);
     } else {
       return NULL;
     }
   }
 
   void set_owner(Space* space) {
-    ASSERT((reinterpret_cast<intptr_t>(space) & kPageHeaderTagMask) == 0);
+    DCHECK((reinterpret_cast<intptr_t>(space) & kPageHeaderTagMask) == 0);
     owner_ = reinterpret_cast<Address>(space) + kPageHeaderTag;
-    ASSERT((reinterpret_cast<intptr_t>(owner_) & kPageHeaderTagMask) ==
+    DCHECK((reinterpret_cast<intptr_t>(owner_) & kPageHeaderTagMask) ==
            kPageHeaderTag);
   }
 
   base::VirtualMemory* reserved_memory() {
     return &reservation_;
   }
 
   void InitializeReservedMemory() {
     reservation_.Reset();
   }
 
   void set_reserved_memory(base::VirtualMemory* reservation) {
-    ASSERT_NOT_NULL(reservation);
+    DCHECK_NOT_NULL(reservation);
     reservation_.TakeControl(reservation);
   }
 
   bool scan_on_scavenge() { return IsFlagSet(SCAN_ON_SCAVENGE); }
   void initialize_scan_on_scavenge(bool scan) {
     if (scan) {
       SetFlag(SCAN_ON_SCAVENGE);
     } else {
       ClearFlag(SCAN_ON_SCAVENGE);
     }
@@ skipping 139 matching lines @@
     live_byte_count_ = 0;
   }
   void IncrementLiveBytes(int by) {
     if (FLAG_gc_verbose) {
       printf("UpdateLiveBytes:%p:%x%c=%x->%x\n",
              static_cast<void*>(this), live_byte_count_,
              ((by < 0) ? '-' : '+'), ((by < 0) ? -by : by),
              live_byte_count_ + by);
     }
     live_byte_count_ += by;
-    ASSERT_LE(static_cast<unsigned>(live_byte_count_), size_);
+    DCHECK_LE(static_cast<unsigned>(live_byte_count_), size_);
   }
   int LiveBytes() {
-    ASSERT(static_cast<unsigned>(live_byte_count_) <= size_);
+    DCHECK(static_cast<unsigned>(live_byte_count_) <= size_);
     return live_byte_count_;
   }
 
   int write_barrier_counter() {
     return static_cast<int>(write_barrier_counter_);
   }
 
   void set_write_barrier_counter(int counter) {
     write_barrier_counter_ = counter;
   }
 
   int progress_bar() {
-    ASSERT(IsFlagSet(HAS_PROGRESS_BAR));
+    DCHECK(IsFlagSet(HAS_PROGRESS_BAR));
     return progress_bar_;
   }
 
   void set_progress_bar(int progress_bar) {
-    ASSERT(IsFlagSet(HAS_PROGRESS_BAR));
+    DCHECK(IsFlagSet(HAS_PROGRESS_BAR));
     progress_bar_ = progress_bar;
   }
 
   void ResetProgressBar() {
     if (IsFlagSet(MemoryChunk::HAS_PROGRESS_BAR)) {
       set_progress_bar(0);
       ClearFlag(MemoryChunk::HAS_PROGRESS_BAR);
     }
   }
 
   bool IsLeftOfProgressBar(Object** slot) {
     Address slot_address = reinterpret_cast<Address>(slot);
-    ASSERT(slot_address > this->address());
+    DCHECK(slot_address > this->address());
     return (slot_address - (this->address() + kObjectStartOffset)) <
            progress_bar();
   }
 
   static void IncrementLiveBytesFromGC(Address address, int by) {
     MemoryChunk::FromAddress(address)->IncrementLiveBytes(by);
   }
 
   static void IncrementLiveBytesFromMutator(Address address, int by);
 
@@ skipping 107 matching lines @@
 
   inline SlotsBuffer* slots_buffer() {
     return slots_buffer_;
   }
 
   inline SlotsBuffer** slots_buffer_address() {
     return &slots_buffer_;
   }
 
   void MarkEvacuationCandidate() {
-    ASSERT(slots_buffer_ == NULL);
+    DCHECK(slots_buffer_ == NULL);
     SetFlag(EVACUATION_CANDIDATE);
   }
 
   void ClearEvacuationCandidate() {
-    ASSERT(slots_buffer_ == NULL);
+    DCHECK(slots_buffer_ == NULL);
     ClearFlag(EVACUATION_CANDIDATE);
   }
 
   Address area_start() { return area_start_; }
   Address area_end() { return area_end_; }
   int area_size() {
     return static_cast<int>(area_end() - area_start());
   }
   bool CommitArea(size_t requested);
 
@@ skipping 101 matching lines @@
   }
 
   // Returns the offset of a given address to this page.
   INLINE(int Offset(Address a)) {
     int offset = static_cast<int>(a - address());
     return offset;
   }
 
   // Returns the address for a given offset to the this page.
   Address OffsetToAddress(int offset) {
-    ASSERT_PAGE_OFFSET(offset);
+    DCHECK_PAGE_OFFSET(offset);
     return address() + offset;
   }
 
   // ---------------------------------------------------------------------
 
   // Page size in bytes.  This must be a multiple of the OS page size.
   static const int kPageSize = 1 << kPageSizeBits;
 
   // Maximum object size that fits in a page. Objects larger than that size
   // are allocated in large object space and are never moved in memory. This
@@ skipping 129 matching lines @@
   // Can only be called once, at heap initialization time.
   // Returns false on failure.
   bool SetUp(size_t requested_size);
 
   // Frees the range of virtual memory, and frees the data structures used to
   // manage it.
   void TearDown();
 
   bool valid() { return code_range_ != NULL; }
   Address start() {
-    ASSERT(valid());
+    DCHECK(valid());
     return static_cast<Address>(code_range_->address());
   }
   bool contains(Address address) {
     if (!valid()) return false;
     Address start = static_cast<Address>(code_range_->address());
     return start <= address && address < start + code_range_->size();
   }
 
   // Allocates a chunk of memory from the large-object portion of
   // the code range.  On platforms with no separate code range, should
   // not be called.
   MUST_USE_RESULT Address AllocateRawMemory(const size_t requested_size,
                                             const size_t commit_size,
                                             size_t* allocated);
   bool CommitRawMemory(Address start, size_t length);
   bool UncommitRawMemory(Address start, size_t length);
   void FreeRawMemory(Address buf, size_t length);
 
  private:
   Isolate* isolate_;
 
   // The reserved range of virtual memory that all code objects are put in.
   base::VirtualMemory* code_range_;
   // Plain old data class, just a struct plus a constructor.
   class FreeBlock {
    public:
     FreeBlock(Address start_arg, size_t size_arg)
         : start(start_arg), size(size_arg) {
-      ASSERT(IsAddressAligned(start, MemoryChunk::kAlignment));
-      ASSERT(size >= static_cast<size_t>(Page::kPageSize));
+      DCHECK(IsAddressAligned(start, MemoryChunk::kAlignment));
+      DCHECK(size >= static_cast<size_t>(Page::kPageSize));
     }
     FreeBlock(void* start_arg, size_t size_arg)
         : start(static_cast<Address>(start_arg)), size(size_arg) {
-      ASSERT(IsAddressAligned(start, MemoryChunk::kAlignment));
-      ASSERT(size >= static_cast<size_t>(Page::kPageSize));
+      DCHECK(IsAddressAligned(start, MemoryChunk::kAlignment));
+      DCHECK(size >= static_cast<size_t>(Page::kPageSize));
     }
 
     Address start;
     size_t size;
   };
 
   // Freed blocks of memory are added to the free list.  When the allocation
   // list is exhausted, the free list is sorted and merged to make the new
   // allocation list.
   List<FreeBlock> free_list_;
@@ skipping 341 matching lines @@
 // Page::next_page() call.
 
 // An abstraction of allocation and relocation pointers in a page-structured
 // space.
 class AllocationInfo {
  public:
   AllocationInfo() : top_(NULL), limit_(NULL) {
   }
 
   INLINE(void set_top(Address top)) {
-    SLOW_ASSERT(top == NULL ||
+    SLOW_DCHECK(top == NULL ||
         (reinterpret_cast<intptr_t>(top) & HeapObjectTagMask()) == 0);
     top_ = top;
   }
 
   INLINE(Address top()) const {
-    SLOW_ASSERT(top_ == NULL ||
+    SLOW_DCHECK(top_ == NULL ||
         (reinterpret_cast<intptr_t>(top_) & HeapObjectTagMask()) == 0);
     return top_;
   }
 
   Address* top_address() {
     return &top_;
   }
 
   INLINE(void set_limit(Address limit)) {
-    SLOW_ASSERT(limit == NULL ||
+    SLOW_DCHECK(limit == NULL ||
         (reinterpret_cast<intptr_t>(limit) & HeapObjectTagMask()) == 0);
     limit_ = limit;
   }
 
   INLINE(Address limit()) const {
-    SLOW_ASSERT(limit_ == NULL ||
+    SLOW_DCHECK(limit_ == NULL ||
         (reinterpret_cast<intptr_t>(limit_) & HeapObjectTagMask()) == 0);
     return limit_;
   }
 
   Address* limit_address() {
     return &limit_;
   }
 
 #ifdef DEBUG
   bool VerifyPagedAllocation() {
@@ skipping 56 matching lines @@
 
   // Grow the space by adding available bytes.  They are initially marked as
   // being in use (part of the size), but will normally be immediately freed,
   // putting them on the free list and removing them from size_.
   void ExpandSpace(int size_in_bytes) {
     capacity_ += size_in_bytes;
     size_ += size_in_bytes;
     if (capacity_ > max_capacity_) {
       max_capacity_ = capacity_;
     }
-    ASSERT(size_ >= 0);
+    DCHECK(size_ >= 0);
   }
 
   // Shrink the space by removing available bytes.  Since shrinking is done
   // during sweeping, bytes have been marked as being in use (part of the size)
   // and are hereby freed.
   void ShrinkSpace(int size_in_bytes) {
     capacity_ -= size_in_bytes;
     size_ -= size_in_bytes;
-    ASSERT(size_ >= 0);
+    DCHECK(size_ >= 0);
   }
 
   // Allocate from available bytes (available -> size).
   void AllocateBytes(intptr_t size_in_bytes) {
     size_ += size_in_bytes;
-    ASSERT(size_ >= 0);
+    DCHECK(size_ >= 0);
   }
 
   // Free allocated bytes, making them available (size -> available).
   void DeallocateBytes(intptr_t size_in_bytes) {
     size_ -= size_in_bytes;
-    ASSERT(size_ >= 0);
+    DCHECK(size_ >= 0);
   }
 
   // Waste free bytes (available -> waste).
   void WasteBytes(int size_in_bytes) {
-    ASSERT(size_in_bytes >= 0);
+    DCHECK(size_in_bytes >= 0);
     waste_ += size_in_bytes;
   }
 
  private:
   intptr_t capacity_;
   intptr_t max_capacity_;
   intptr_t size_;
   intptr_t waste_;
 };
 
@@ skipping 237 matching lines @@
     *obj = T::cast(object_);
     return true;
   }
 
   Object* ToObjectChecked() {
     CHECK(!IsRetry());
     return object_;
   }
 
   AllocationSpace RetrySpace() {
-    ASSERT(IsRetry());
+    DCHECK(IsRetry());
     return retry_space_;
   }
 
  private:
   explicit AllocationResult(AllocationSpace space) : object_(NULL),
                                                      retry_space_(space) { }
 
   Object* object_;
   AllocationSpace retry_space_;
 };
@@ skipping 131 matching lines @@
     accounting_stats_.WasteBytes(wasted);
     return size_in_bytes - wasted;
   }
 
   void ResetFreeList() {
     free_list_.Reset();
   }
 
   // Set space allocation info.
   void SetTopAndLimit(Address top, Address limit) {
-    ASSERT(top == limit ||
+    DCHECK(top == limit ||
            Page::FromAddress(top) == Page::FromAddress(limit - 1));
     MemoryChunk::UpdateHighWaterMark(allocation_info_.top());
     allocation_info_.set_top(top);
     allocation_info_.set_limit(limit);
   }
 
   // Empty space allocation info, returning unused area to free list.
   void EmptyAllocationInfo() {
     // Mark the old linear allocation area with a free space map so it can be
     // skipped when scanning the heap.
@@ skipping 45 matching lines @@
     return !p->IsEvacuationCandidate() &&
            !p->IsFlagSet(Page::RESCAN_ON_EVACUATION) &&
            !p->WasSweptPrecisely();
   }
 
   void IncrementUnsweptFreeBytes(intptr_t by) {
     unswept_free_bytes_ += by;
   }
 
   void IncreaseUnsweptFreeBytes(Page* p) {
-    ASSERT(ShouldBeSweptBySweeperThreads(p));
+    DCHECK(ShouldBeSweptBySweeperThreads(p));
     unswept_free_bytes_ += (p->area_size() - p->LiveBytes());
   }
 
   void DecrementUnsweptFreeBytes(intptr_t by) {
     unswept_free_bytes_ -= by;
   }
 
   void DecreaseUnsweptFreeBytes(Page* p) {
-    ASSERT(ShouldBeSweptBySweeperThreads(p));
+    DCHECK(ShouldBeSweptBySweeperThreads(p));
     unswept_free_bytes_ -= (p->area_size() - p->LiveBytes());
   }
 
   void ResetUnsweptFreeBytes() {
     unswept_free_bytes_ = 0;
   }
 
   // This function tries to steal size_in_bytes memory from the sweeper threads
   // free-lists. If it does not succeed stealing enough memory, it will wait
   // for the sweeper threads to finish sweeping.
@@ skipping 258 matching lines @@
   // the maximum capacity.
   bool GrowTo(int new_capacity);
 
   // Shrinks the semispace to the new capacity.  The new capacity
   // requested must be more than the amount of used memory in the
   // semispace and less than the current capacity.
   bool ShrinkTo(int new_capacity);
 
   // Returns the start address of the first page of the space.
   Address space_start() {
-    ASSERT(anchor_.next_page() != &anchor_);
+    DCHECK(anchor_.next_page() != &anchor_);
     return anchor_.next_page()->area_start();
   }
 
   // Returns the start address of the current page of the space.
   Address page_low() {
     return current_page_->area_start();
   }
 
   // Returns one past the end address of the space.
   Address space_end() {
@@ skipping 139 matching lines @@
   // of allocation.
   SemiSpaceIterator(NewSpace* space, Address start);
   // Iterate from one address to another in the same semi-space.
   SemiSpaceIterator(Address from, Address to);
 
   HeapObject* Next() {
     if (current_ == limit_) return NULL;
     if (NewSpacePage::IsAtEnd(current_)) {
       NewSpacePage* page = NewSpacePage::FromLimit(current_);
       page = page->next_page();
-      ASSERT(!page->is_anchor());
+      DCHECK(!page->is_anchor());
       current_ = page->area_start();
       if (current_ == limit_) return NULL;
     }
 
     HeapObject* object = HeapObject::FromAddress(current_);
     int size = (size_func_ == NULL) ? object->Size() : size_func_(object);
 
     current_ += size;
     return object;
   }
@@ skipping 99 matching lines @@
         static_cast<int>(top() - to_space_.page_low());
   }
 
   // The same, but returning an int.  We have to have the one that returns
   // intptr_t because it is inherited, but if we know we are dealing with the
   // new space, which can't get as big as the other spaces then this is useful:
   int SizeAsInt() { return static_cast<int>(Size()); }
 
   // Return the current capacity of a semispace.
   intptr_t EffectiveCapacity() {
-    SLOW_ASSERT(to_space_.Capacity() == from_space_.Capacity());
+    SLOW_DCHECK(to_space_.Capacity() == from_space_.Capacity());
     return (to_space_.Capacity() / Page::kPageSize) * NewSpacePage::kAreaSize;
   }
 
   // Return the current capacity of a semispace.
   intptr_t Capacity() {
-    ASSERT(to_space_.Capacity() == from_space_.Capacity());
+    DCHECK(to_space_.Capacity() == from_space_.Capacity());
     return to_space_.Capacity();
   }
 
   // Return the total amount of memory committed for new space.
   intptr_t CommittedMemory() {
     if (from_space_.is_committed()) return 2 * Capacity();
     return Capacity();
   }
 
   // Return the total amount of memory committed for new space.
   intptr_t MaximumCommittedMemory() {
     return to_space_.MaximumCommittedMemory() +
         from_space_.MaximumCommittedMemory();
   }
 
   // Approximate amount of physical memory committed for this space.
   size_t CommittedPhysicalMemory();
 
   // Return the available bytes without growing.
   intptr_t Available() {
     return Capacity() - Size();
   }
 
   // Return the maximum capacity of a semispace.
   int MaximumCapacity() {
-    ASSERT(to_space_.MaximumCapacity() == from_space_.MaximumCapacity());
+    DCHECK(to_space_.MaximumCapacity() == from_space_.MaximumCapacity());
     return to_space_.MaximumCapacity();
   }
 
   bool IsAtMaximumCapacity() {
     return Capacity() == MaximumCapacity();
   }
 
   // Returns the initial capacity of a semispace.
   int InitialCapacity() {
-    ASSERT(to_space_.InitialCapacity() == from_space_.InitialCapacity());
+    DCHECK(to_space_.InitialCapacity() == from_space_.InitialCapacity());
     return to_space_.InitialCapacity();
   }
 
   // Return the address of the allocation pointer in the active semispace.
   Address top() {
-    ASSERT(to_space_.current_page()->ContainsLimit(allocation_info_.top()));
+    DCHECK(to_space_.current_page()->ContainsLimit(allocation_info_.top()));
     return allocation_info_.top();
   }
 
   void set_top(Address top) {
-    ASSERT(to_space_.current_page()->ContainsLimit(top));
+    DCHECK(to_space_.current_page()->ContainsLimit(top));
     allocation_info_.set_top(top);
   }
 
   // Return the address of the allocation pointer limit in the active semispace.
   Address limit() {
-    ASSERT(to_space_.current_page()->ContainsLimit(allocation_info_.limit()));
+    DCHECK(to_space_.current_page()->ContainsLimit(allocation_info_.limit()));
     return allocation_info_.limit();
   }
 
   // Return the address of the first object in the active semispace.
   Address bottom() { return to_space_.space_start(); }
 
   // Get the age mark of the inactive semispace.
   Address age_mark() { return from_space_.age_mark(); }
   // Set the age mark in the active semispace.
   void set_age_mark(Address mark) { to_space_.set_age_mark(mark); }
 
   // The start address of the space and a bit mask. Anding an address in the
   // new space with the mask will result in the start address.
   Address start() { return start_; }
   uintptr_t mask() { return address_mask_; }
 
   INLINE(uint32_t AddressToMarkbitIndex(Address addr)) {
-    ASSERT(Contains(addr));
-    ASSERT(IsAligned(OffsetFrom(addr), kPointerSize) ||
+    DCHECK(Contains(addr));
+    DCHECK(IsAligned(OffsetFrom(addr), kPointerSize) ||
            IsAligned(OffsetFrom(addr) - 1, kPointerSize));
     return static_cast<uint32_t>(addr - start_) >> kPointerSizeLog2;
   }
 
   INLINE(Address MarkbitIndexToAddress(uint32_t index)) {
     return reinterpret_cast<Address>(index << kPointerSizeLog2);
   }
 
   // The allocation top and limit address.
   Address* allocation_top_address() {
@@ skipping 145 matching lines @@
       : PagedSpace(heap, max_capacity, id, executable) {
   }
 
  public:
   TRACK_MEMORY("OldSpace")
 };
 
 
 // For contiguous spaces, top should be in the space (or at the end) and limit
 // should be the end of the space.
-#define ASSERT_SEMISPACE_ALLOCATION_INFO(info, space) \
-  SLOW_ASSERT((space).page_low() <= (info).top() \
+#define DCHECK_SEMISPACE_ALLOCATION_INFO(info, space) \
+  SLOW_DCHECK((space).page_low() <= (info).top() \
               && (info).top() <= (space).page_high() \
               && (info).limit() <= (space).page_high())
 
 
 // -----------------------------------------------------------------------------
 // Old space for all map objects
 
 class MapSpace : public PagedSpace {
  public:
   // Creates a map space object with a maximum capacity.
@@ skipping 278 matching lines @@
   }
   // Must be small, since an iteration is used for lookup.
   static const int kMaxComments = 64;
 };
 #endif
 
 
 } }  // namespace v8::internal
 
 #endif  // V8_SPACES_H_