Replace ASSERTs in platform/heap/ with DCHECKs

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

 /*
  * 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 85 matching lines @@
 #if defined(MEMORY_SANITIZER)
 // TODO(kojii): We actually need __msan_poison/unpoison here, but it'll be
 // added later.
 #define SET_MEMORY_INACCESSIBLE(address, size) \
   FreeList::zapFreedMemory(address, size);
 #define SET_MEMORY_ACCESSIBLE(address, size) memset((address), 0, (size))
 #define CHECK_MEMORY_INACCESSIBLE(address, size)     \
   ASAN_UNPOISON_MEMORY_REGION(address, size);        \
   FreeList::checkFreedMemoryIsZapped(address, size); \
   ASAN_POISON_MEMORY_REGION(address, size)
-#elif ENABLE(ASSERT) || defined(LEAK_SANITIZER) || defined(ADDRESS_SANITIZER)
+#elif DCHECK_IS_ON() || defined(LEAK_SANITIZER) || defined(ADDRESS_SANITIZER)
 #define SET_MEMORY_INACCESSIBLE(address, size) \
   FreeList::zapFreedMemory(address, size);     \
   ASAN_POISON_MEMORY_REGION(address, size)
 #define SET_MEMORY_ACCESSIBLE(address, size)  \
   ASAN_UNPOISON_MEMORY_REGION(address, size); \
   memset((address), 0, (size))
 #define CHECK_MEMORY_INACCESSIBLE(address, size)     \
   ASAN_UNPOISON_MEMORY_REGION(address, size);        \
   FreeList::checkFreedMemoryIsZapped(address, size); \
   ASAN_POISON_MEMORY_REGION(address, size)
 #else
 #define SET_MEMORY_INACCESSIBLE(address, size) memset((address), 0, (size))
 #define SET_MEMORY_ACCESSIBLE(address, size) \
   do {                                       \
   } while (false)
 #define CHECK_MEMORY_INACCESSIBLE(address, size) \
   do {                                           \
   } while (false)
 #endif
 
-#if !ENABLE(ASSERT) && CPU(64BIT)
+#if !DCHECK_IS_ON() && CPU(64BIT)
 #define USE_4BYTE_HEADER_PADDING 1
 #else
 #define USE_4BYTE_HEADER_PADDING 0
 #endif
 
 class NormalPageArena;
 class PageMemory;
 
 // HeapObjectHeader is 4 byte (32 bit) that has the following layout:
 //
@@ skipping 38 matching lines @@
     nonLargeObjectPageSizeMax >= blinkPageSize,
     "max size supported by HeapObjectHeader must at least be blinkPageSize");
 
 class PLATFORM_EXPORT HeapObjectHeader {
   DISALLOW_NEW_EXCEPT_PLACEMENT_NEW();
 
  public:
   // If gcInfoIndex is 0, this header is interpreted as a free list header.
   NO_SANITIZE_ADDRESS
   HeapObjectHeader(size_t size, size_t gcInfoIndex) {
-#if ENABLE(ASSERT)
+#if DCHECK_IS_ON()
     m_magic = magic;
 #endif
     // sizeof(HeapObjectHeader) must be equal to or smaller than
     // allocationGranurarity, because HeapObjectHeader is used as a header
     // for an freed entry.  Given that the smallest entry size is
     // allocationGranurarity, HeapObjectHeader must fit into the size.
     static_assert(
         sizeof(HeapObjectHeader) <= allocationGranularity,
         "size of HeapObjectHeader must be smaller than allocationGranularity");
 #if CPU(64BIT)
     static_assert(sizeof(HeapObjectHeader) == 8,
                   "size of HeapObjectHeader must be 8 byte aligned");
 #endif
 
-    ASSERT(gcInfoIndex < GCInfoTable::maxIndex);
-    ASSERT(size < nonLargeObjectPageSizeMax);
-    ASSERT(!(size & allocationMask));
+    DCHECK_LT(gcInfoIndex, gcInfoMaxIndex);
+    DCHECK_LT(size, nonLargeObjectPageSizeMax);
+    DCHECK(!(size & allocationMask));
     m_encoded = static_cast<uint32_t>(
         (gcInfoIndex << headerGCInfoIndexShift) | size |
         (gcInfoIndex == gcInfoIndexForFreeListHeader ? headerFreedBitMask : 0));
   }
 
   NO_SANITIZE_ADDRESS
   bool isFree() const { return m_encoded & headerFreedBitMask; }
   NO_SANITIZE_ADDRESS
   bool isPromptlyFreed() const {
     return (m_encoded & headerPromptlyFreedBitMask) ==
            headerPromptlyFreedBitMask;
   }
   NO_SANITIZE_ADDRESS
   void markPromptlyFreed() { m_encoded |= headerPromptlyFreedBitMask; }
   size_t size() const;
 
   NO_SANITIZE_ADDRESS
   size_t gcInfoIndex() const {
     return (m_encoded & headerGCInfoIndexMask) >> headerGCInfoIndexShift;
   }
   NO_SANITIZE_ADDRESS
   void setSize(size_t size) {
-    ASSERT(size < nonLargeObjectPageSizeMax);
+    DCHECK_LT(size, nonLargeObjectPageSizeMax);
     m_encoded = static_cast<uint32_t>(size) | (m_encoded & ~headerSizeMask);
   }
   bool isWrapperHeaderMarked() const;
   void markWrapperHeader();
   void unmarkWrapperHeader();
   bool isMarked() const;
   void mark();
   void unmark();
   void markDead();
   bool isDead() const;
 
   Address payload();
   size_t payloadSize();
   Address payloadEnd();
 
-#if ENABLE(ASSERT)
+#if DCHECK_IS_ON()
   bool checkHeader() const;
   // Zap magic number with a new magic number that means there was once an
   // object allocated here, but it was freed because nobody marked it during
   // GC.
   void zapMagic();
 #endif
 
   void finalize(Address, size_t);
   static HeapObjectHeader* fromPayload(const void*);
 
   static const uint16_t magic = 0xfff1;
   static const uint16_t zappedMagic = 0x4321;
 
  private:
   uint32_t m_encoded;
-#if ENABLE(ASSERT)
+#if DCHECK_IS_ON()
   uint16_t m_magic;
 #endif
 
 // In 64 bit architectures, we intentionally add 4 byte padding immediately
 // after the HeapObjectHeader. This is because:
 //
 // | HeapObjectHeader (4 byte)   |  <- 8 byte aligned
 // | padding (4 byte)            |
 // | object payload (8 * n byte) |  <- 8 byte aligned
 //
 // is better than:
 //
 // | HeapObjectHeader (4 byte)   |  <- 4 byte aligned
 // | object payload (8 * n byte) |  <- 8 byte aligned
 // | padding (4 byte)            |  <- 4 byte aligned
 //
 // since the former layout aligns both header and payload to 8 byte.
 #if USE_4BYTE_HEADER_PADDING
  public:
   uint32_t m_padding;
 #endif
 };
 
 class FreeListEntry final : public HeapObjectHeader {
  public:
   NO_SANITIZE_ADDRESS
   explicit FreeListEntry(size_t size)
       : HeapObjectHeader(size, gcInfoIndexForFreeListHeader), m_next(nullptr) {
-#if ENABLE(ASSERT)
-    ASSERT(size >= sizeof(HeapObjectHeader));
+#if DCHECK_IS_ON()
+    DCHECK_GE(size, sizeof(HeapObjectHeader));
     zapMagic();
 #endif
   }
 
   Address getAddress() { return reinterpret_cast<Address>(this); }
 
   NO_SANITIZE_ADDRESS
   void unlink(FreeListEntry** prevNext) {
     *prevNext = m_next;
     m_next = nullptr;
   }
 
   NO_SANITIZE_ADDRESS
   void link(FreeListEntry** prevNext) {
     m_next = *prevNext;
     *prevNext = this;
   }
 
   NO_SANITIZE_ADDRESS
   FreeListEntry* next() const { return m_next; }
 
   NO_SANITIZE_ADDRESS
   void append(FreeListEntry* next) {
-    ASSERT(!m_next);
+    DCHECK(!m_next);
     m_next = next;
   }
 
  private:
   FreeListEntry* m_next;
 };
 
 // Blink heap pages are set up with a guard page before and after the payload.
 inline size_t blinkPagePayloadSize() {
   return blinkPageSize - 2 * blinkGuardPageSize;
@@ skipping 16 matching lines @@
 // Masks an address down to the enclosing blink page base address.
 inline Address blinkPageAddress(Address address) {
   return reinterpret_cast<Address>(reinterpret_cast<uintptr_t>(address) &
                                    blinkPageBaseMask);
 }
 
 inline bool vTableInitialized(void* objectPointer) {
   return !!(*reinterpret_cast<Address*>(objectPointer));
 }
 
-#if ENABLE(ASSERT)
+#if DCHECK_IS_ON()
 // Sanity check for a page header address: the address of the page
 // header should be OS page size away from being Blink page size
 // aligned.
 inline bool isPageHeaderAddress(Address address) {
   return !((reinterpret_cast<uintptr_t>(address) & blinkPageOffsetMask) -
            blinkGuardPageSize);
 }
 #endif
 
 // BasePage is a base class for NormalPage and LargeObjectPage.
@@ skipping 54 matching lines @@
     STACK_ALLOCATED();
 
    public:
     size_t freeCount = 0;
     size_t freeSize = 0;
   };
 
   virtual void takeSnapshot(base::trace_event::MemoryAllocatorDump*,
                             ThreadState::GCSnapshotInfo&,
                             HeapSnapshotInfo&) = 0;
-#if ENABLE(ASSERT)
+#if DCHECK_IS_ON()
   virtual bool contains(Address) = 0;
 #endif
   virtual size_t size() = 0;
   virtual bool isLargeObjectPage() { return false; }
 
   Address getAddress() { return reinterpret_cast<Address>(this); }
   PageMemory* storage() const { return m_storage; }
   BaseArena* arena() const { return m_arena; }
   bool orphaned() { return !m_arena; }
   bool terminating() { return m_terminating; }
   void setTerminating() { m_terminating = true; }
 
   // Returns true if this page has been swept by the ongoing lazy sweep.
   bool hasBeenSwept() const { return m_swept; }
 
   void markAsSwept() {
-    ASSERT(!m_swept);
+    DCHECK(!m_swept);
     m_swept = true;
   }
 
   void markAsUnswept() {
-    ASSERT(m_swept);
+    DCHECK(m_swept);
     m_swept = false;
   }
 
  private:
   PageMemory* m_storage;
   BaseArena* m_arena;
   BasePage* m_next;
   // Whether the page is part of a terminating thread or not.
   bool m_terminating;
 
@@ skipping 30 matching lines @@
   }
 #if defined(ADDRESS_SANITIZER)
   void poisonUnmarkedObjects() override;
 #endif
   void checkAndMarkPointer(Visitor*, Address) override;
   void markOrphaned() override;
 
   void takeSnapshot(base::trace_event::MemoryAllocatorDump*,
                     ThreadState::GCSnapshotInfo&,
                     HeapSnapshotInfo&) override;
-#if ENABLE(ASSERT)
+#if DCHECK_IS_ON()
   // Returns true for the whole blinkPageSize page that the page is on, even
   // for the header, and the unmapped guard page at the start. That ensures
   // the result can be used to populate the negative page cache.
   bool contains(Address) override;
 #endif
   size_t size() override { return blinkPageSize; }
   static size_t pageHeaderSize() {
     // Compute the amount of padding we have to add to a header to make
     // the size of the header plus the padding a multiple of 8 bytes.
     size_t paddingSize = (sizeof(NormalPage) + allocationGranularity -
@@ skipping 57 matching lines @@
   void invalidateObjectStartBitmap() override {}
 #if defined(ADDRESS_SANITIZER)
   void poisonUnmarkedObjects() override;
 #endif
   void checkAndMarkPointer(Visitor*, Address) override;
   void markOrphaned() override;
 
   void takeSnapshot(base::trace_event::MemoryAllocatorDump*,
                     ThreadState::GCSnapshotInfo&,
                     HeapSnapshotInfo&) override;
-#if ENABLE(ASSERT)
+#if DCHECK_IS_ON()
   // Returns true for any address that is on one of the pages that this
   // large object uses. That ensures that we can use a negative result to
   // populate the negative page cache.
   bool contains(Address) override;
 #endif
   virtual size_t size() {
     return pageHeaderSize() + sizeof(HeapObjectHeader) + m_payloadSize;
   }
   static size_t pageHeaderSize() {
     // Compute the amount of padding we have to add to a header to make
@@ skipping 80 matching lines @@
   void addToFreeList(Address, size_t);
   void clear();
 
   // Returns a bucket number for inserting a FreeListEntry of a given size.
   // All FreeListEntries in the given bucket, n, have size >= 2^n.
   static int bucketIndexForSize(size_t);
 
   // Returns true if the freelist snapshot is captured.
   bool takeSnapshot(const String& dumpBaseName);
 
-#if ENABLE(ASSERT) || defined(LEAK_SANITIZER) || defined(ADDRESS_SANITIZER) || \
+#if DCHECK_IS_ON() || defined(LEAK_SANITIZER) || defined(ADDRESS_SANITIZER) || \
     defined(MEMORY_SANITIZER)
   static void zapFreedMemory(Address, size_t);
   static void checkFreedMemoryIsZapped(Address, size_t);
 #endif
 
  private:
   int m_biggestFreeListIndex;
 
   // All FreeListEntries in the nth list have size >= 2^n.
   FreeListEntry* m_freeLists[blinkPageSizeLog2];
@@ skipping 13 matching lines @@
 // LargeObjectPages.
 class PLATFORM_EXPORT BaseArena {
   USING_FAST_MALLOC(BaseArena);
 
  public:
   BaseArena(ThreadState*, int);
   virtual ~BaseArena();
   void cleanupPages();
 
   void takeSnapshot(const String& dumpBaseName, ThreadState::GCSnapshotInfo&);
-#if ENABLE(ASSERT)
+#if DCHECK_IS_ON()
   BasePage* findPageFromAddress(Address);
 #endif
   virtual void takeFreelistSnapshot(const String& dumpBaseName) {}
   virtual void clearFreeLists() {}
   void makeConsistentForGC();
   void makeConsistentForMutator();
-#if ENABLE(ASSERT)
+#if DCHECK_IS_ON()
   virtual bool isConsistentForGC() = 0;
 #endif
   size_t objectPayloadSizeForTesting();
   void prepareHeapForTermination();
   void prepareForSweep();
 #if defined(ADDRESS_SANITIZER)
   void poisonArena();
 #endif
   Address lazySweep(size_t, size_t gcInfoIndex);
   void sweepUnsweptPage();
@@ skipping 20 matching lines @@
 
   // Index into the page pools.  This is used to ensure that the pages of the
   // same type go into the correct page pool and thus avoid type confusion.
   int m_index;
 };
 
 class PLATFORM_EXPORT NormalPageArena final : public BaseArena {
  public:
   NormalPageArena(ThreadState*, int);
   void addToFreeList(Address address, size_t size) {
-    ASSERT(findPageFromAddress(address));
-    ASSERT(findPageFromAddress(address + size - 1));
+    DCHECK(findPageFromAddress(address));
+    DCHECK(findPageFromAddress(address + size - 1));
     m_freeList.addToFreeList(address, size);
   }
   void clearFreeLists() override;
-#if ENABLE(ASSERT)
+#if DCHECK_IS_ON()
   bool isConsistentForGC() override;
   bool pagesToBeSweptContains(Address);
 #endif
   void takeFreelistSnapshot(const String& dumpBaseName) override;
 
   Address allocateObject(size_t allocationSize, size_t gcInfoIndex);
 
   void freePage(NormalPage*);
 
   bool coalesce();
@@ skipping 41 matching lines @@
   size_t m_promptlyFreedSize;
 
   bool m_isLazySweeping;
 };
 
 class LargeObjectArena final : public BaseArena {
  public:
   LargeObjectArena(ThreadState*, int);
   Address allocateLargeObjectPage(size_t, size_t gcInfoIndex);
   void freeLargeObjectPage(LargeObjectPage*);
-#if ENABLE(ASSERT)
+#if DCHECK_IS_ON()
   bool isConsistentForGC() override { return true; }
 #endif
  private:
   Address doAllocateLargeObjectPage(size_t, size_t gcInfoIndex);
   Address lazySweepPages(size_t, size_t gcInfoIndex) override;
 };
 
 // Mask an address down to the enclosing oilpan heap base page.  All oilpan heap
 // pages are aligned at blinkPageBase plus the size of a guard size.
 // FIXME: Remove PLATFORM_EXPORT once we get a proper public interface to our
 // typed arenas.  This is only exported to enable tests in HeapTest.cpp.
 PLATFORM_EXPORT inline BasePage* pageFromObject(const void* object) {
   Address address = reinterpret_cast<Address>(const_cast<void*>(object));
   BasePage* page = reinterpret_cast<BasePage*>(blinkPageAddress(address) +
                                                blinkGuardPageSize);
-  ASSERT(page->contains(address));
+  DCHECK(page->contains(address));
   return page;
 }
 
 NO_SANITIZE_ADDRESS inline size_t HeapObjectHeader::size() const {
   size_t result = m_encoded & headerSizeMask;
   // Large objects should not refer to header->size().
   // The actual size of a large object is stored in
   // LargeObjectPage::m_payloadSize.
-  ASSERT(result != largeObjectSizeInHeader);
-  ASSERT(!pageFromObject(this)->isLargeObjectPage());
+  DCHECK_NE(result, largeObjectSizeInHeader);
+  DCHECK(!pageFromObject(this)->isLargeObjectPage());
   return result;
 }
 
-#if ENABLE(ASSERT)
+#if DCHECK_IS_ON()
 NO_SANITIZE_ADDRESS inline bool HeapObjectHeader::checkHeader() const {
   return !pageFromObject(this)->orphaned() && m_magic == magic;
 }
 #endif
 
 inline Address HeapObjectHeader::payload() {
   return reinterpret_cast<Address>(this) + sizeof(HeapObjectHeader);
 }
 
 inline Address HeapObjectHeader::payloadEnd() {
   return reinterpret_cast<Address>(this) + size();
 }
 
 NO_SANITIZE_ADDRESS inline size_t HeapObjectHeader::payloadSize() {
   size_t size = m_encoded & headerSizeMask;
   if (UNLIKELY(size == largeObjectSizeInHeader)) {
-    ASSERT(pageFromObject(this)->isLargeObjectPage());
+    DCHECK(pageFromObject(this)->isLargeObjectPage());
     return static_cast<LargeObjectPage*>(pageFromObject(this))->payloadSize();
   }
-  ASSERT(!pageFromObject(this)->isLargeObjectPage());
+  DCHECK(!pageFromObject(this)->isLargeObjectPage());
   return size - sizeof(HeapObjectHeader);
 }
 
 inline HeapObjectHeader* HeapObjectHeader::fromPayload(const void* payload) {
   Address addr = reinterpret_cast<Address>(const_cast<void*>(payload));
   HeapObjectHeader* header =
       reinterpret_cast<HeapObjectHeader*>(addr - sizeof(HeapObjectHeader));
-  ASSERT(header->checkHeader());
+  DCHECK(header->checkHeader());
   return header;
 }
 
 NO_SANITIZE_ADDRESS inline bool HeapObjectHeader::isWrapperHeaderMarked()
     const {
-  ASSERT(checkHeader());
+  DCHECK(checkHeader());
   return m_encoded & headerWrapperMarkBitMask;
 }
 
 NO_SANITIZE_ADDRESS inline void HeapObjectHeader::markWrapperHeader() {
-  ASSERT(checkHeader());
-  ASSERT(!isWrapperHeaderMarked());
+  DCHECK(checkHeader());
+  DCHECK(!isWrapperHeaderMarked());
   m_encoded |= headerWrapperMarkBitMask;
 }
 
 NO_SANITIZE_ADDRESS inline void HeapObjectHeader::unmarkWrapperHeader() {
-  ASSERT(checkHeader());
-  ASSERT(isWrapperHeaderMarked());
+  DCHECK(checkHeader());
+  DCHECK(isWrapperHeaderMarked());
   m_encoded &= ~headerWrapperMarkBitMask;
 }
 
 NO_SANITIZE_ADDRESS inline bool HeapObjectHeader::isMarked() const {
-  ASSERT(checkHeader());
+  DCHECK(checkHeader());
   return m_encoded & headerMarkBitMask;
 }
 
 NO_SANITIZE_ADDRESS inline void HeapObjectHeader::mark() {
-  ASSERT(checkHeader());
-  ASSERT(!isMarked());
+  DCHECK(checkHeader());
+  DCHECK(!isMarked());
   m_encoded = m_encoded | headerMarkBitMask;
 }
 
 NO_SANITIZE_ADDRESS inline void HeapObjectHeader::unmark() {
-  ASSERT(checkHeader());
-  ASSERT(isMarked());
+  DCHECK(checkHeader());
+  DCHECK(isMarked());
   m_encoded &= ~headerMarkBitMask;
 }
 
 NO_SANITIZE_ADDRESS inline bool HeapObjectHeader::isDead() const {
-  ASSERT(checkHeader());
+  DCHECK(checkHeader());
   return m_encoded & headerDeadBitMask;
 }
 
 NO_SANITIZE_ADDRESS inline void HeapObjectHeader::markDead() {
-  ASSERT(checkHeader());
-  ASSERT(!isMarked());
+  DCHECK(checkHeader());
+  DCHECK(!isMarked());
   m_encoded |= headerDeadBitMask;
 }
 
 inline Address NormalPageArena::allocateObject(size_t allocationSize,
                                                size_t gcInfoIndex) {
   if (LIKELY(allocationSize <= m_remainingAllocationSize)) {
     Address headerAddress = m_currentAllocationPoint;
     m_currentAllocationPoint += allocationSize;
     m_remainingAllocationSize -= allocationSize;
-    ASSERT(gcInfoIndex > 0);
+    DCHECK_GT(gcInfoIndex, 0UL);
     new (NotNull, headerAddress) HeapObjectHeader(allocationSize, gcInfoIndex);
     Address result = headerAddress + sizeof(HeapObjectHeader);
-    ASSERT(!(reinterpret_cast<uintptr_t>(result) & allocationMask));
+    DCHECK(!(reinterpret_cast<uintptr_t>(result) & allocationMask));
 
     SET_MEMORY_ACCESSIBLE(result, allocationSize - sizeof(HeapObjectHeader));
-    ASSERT(findPageFromAddress(headerAddress + allocationSize - 1));
+    DCHECK(findPageFromAddress(headerAddress + allocationSize - 1));
     return result;
   }
   return outOfLineAllocate(allocationSize, gcInfoIndex);
 }
 
 inline NormalPageArena* NormalPage::arenaForNormalPage() const {
   return static_cast<NormalPageArena*>(arena());
 }
 
 }  // namespace blink
 
 #endif  // HeapPage_h