Allow assertions to be enabled in Blink Release builds.

Source/platform/heap/Heap.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 425 matching lines @@
     m_size &= ~debugBitMask;
 }
 
 NO_SANITIZE_ADDRESS
 void HeapObjectHeader::setDebugMark()
 {
     checkHeader();
     m_size |= debugBitMask;
 }
 
-#ifndef NDEBUG
+#if ENABLE(ASSERT)
 NO_SANITIZE_ADDRESS
 void HeapObjectHeader::zapMagic()
 {
     m_magic = zappedMagic;
 }
 #endif
 
 HeapObjectHeader* HeapObjectHeader::fromPayload(const void* payload)
 {
     Address addr = reinterpret_cast<Address>(const_cast<void*>(payload));
     HeapObjectHeader* header =
         reinterpret_cast<HeapObjectHeader*>(addr - objectHeaderSize);
     return header;
 }
 
 void HeapObjectHeader::finalize(const GCInfo* gcInfo, Address object, size_t objectSize)
 {
     ASSERT(gcInfo);
     if (gcInfo->hasFinalizer()) {
         gcInfo->m_finalize(object);
     }
 
-#if !defined(NDEBUG) || defined(LEAK_SANITIZER) || defined(ADDRESS_SANITIZER)
+#if ENABLE(ASSERT) || defined(LEAK_SANITIZER) || defined(ADDRESS_SANITIZER)
     // In Debug builds, memory is zapped when it's freed, and the zapped memory is
     // zeroed out when the memory is reused. Memory is also zapped when using Leak
     // Sanitizer because the heap is used as a root region for LSan and therefore
     // pointers in unreachable memory could hide leaks.
     for (size_t i = 0; i < objectSize; i++)
         object[i] = finalizedZapValue;
 
     // Zap the primary vTable entry (secondary vTable entries are not zapped).
     *(reinterpret_cast<uintptr_t*>(object)) = zappedVTable;
 #endif
@@ skipping 344 matching lines @@
     // FIXME: Oilpan: Linking new pages into the front of the list is
     // crucial when performing allocations during finalization because
     // it ensures that those pages are not swept in the current GC
     // round. We should create a separate page list for that to
     // separate out the pages allocated during finalization clearly
     // from the pages currently being swept.
     page->link(&m_firstPage);
     addToFreeList(page->payload(), HeapPage<Header>::payloadSize());
 }
 
-#ifndef NDEBUG
+#if ENABLE(ASSERT)
 template<typename Header>
 void ThreadHeap<Header>::getScannedStats(HeapStats& scannedStats)
 {
     for (HeapPage<Header>* page = m_firstPage; page; page = page->next())
         page->getStats(scannedStats);
     for (LargeHeapObject<Header>* current = m_firstLargeHeapObject; current; current = current->next())
         current->getStats(scannedStats);
 }
 #endif
 
@@ skipping 215 matching lines @@
 {
     clearObjectStartBitMap();
     heap()->stats().increaseAllocatedSpace(blinkPageSize);
     Address startOfGap = payload();
     for (Address headerAddress = startOfGap; headerAddress < end(); ) {
         BasicObjectHeader* basicHeader = reinterpret_cast<BasicObjectHeader*>(headerAddress);
         ASSERT(basicHeader->size() < blinkPagePayloadSize());
 
         if (basicHeader->isFree()) {
             size_t size = basicHeader->size();
-#if defined(NDEBUG) && !defined(LEAK_SANITIZER) && !defined(ADDRESS_SANITIZER)
+#if !ENABLE(ASSERT) && !defined(LEAK_SANITIZER) && !defined(ADDRESS_SANITIZER)
             // 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.
             if (size < sizeof(FreeListEntry))
                 memset(headerAddress, 0, size);
             else
                 memset(headerAddress, 0, sizeof(FreeListEntry));
 #endif
             headerAddress += size;
             continue;
         }
         // At this point we know this is a valid object of type Header
         Header* header = static_cast<Header*>(basicHeader);
 
         if (!header->isMarked()) {
             // For ASan we unpoison the specific object when calling the finalizer and
             // poison it again when done to allow the object's own finalizer to operate
             // on the object, but not have other finalizers be allowed to access it.
             ASAN_UNPOISON_MEMORY_REGION(header->payload(), header->payloadSize());
             finalize(header);
             size_t size = header->size();
-#if defined(NDEBUG) && !defined(LEAK_SANITIZER) && !defined(ADDRESS_SANITIZER)
+#if !ENABLE(ASSERT) && !defined(LEAK_SANITIZER) && !defined(ADDRESS_SANITIZER)
             // This memory will be added to the freelist. Maintain the invariant
             // that memory on the freelist is zero filled.
             memset(headerAddress, 0, size);
 #endif
             ASAN_POISON_MEMORY_REGION(header->payload(), header->payloadSize());
             headerAddress += size;
             continue;
         }
 
         if (startOfGap != headerAddress)
@@ skipping 259 matching lines @@
     CallbackStack* next;
     for (CallbackStack* current = *first; current; current = next) {
         next = current->m_next;
         delete current;
     }
     *first = 0;
 }
 
 CallbackStack::~CallbackStack()
 {
-#ifndef NDEBUG
+#if ENABLE(ASSERT)
     clearUnused();
 #endif
 }
 
 void CallbackStack::clearUnused()
 {
     for (size_t i = 0; i < bufferSize; i++)
         m_buffer[i] = Item(0, 0);
 }
 
 bool CallbackStack::isEmpty()
 {
     return m_current == &(m_buffer[0]) && !m_next;
 }
 
 bool CallbackStack::popAndInvokeCallback(CallbackStack** first, Visitor* visitor)
 {
     if (m_current == &(m_buffer[0])) {
         if (!m_next) {
-#ifndef NDEBUG
+#if ENABLE(ASSERT)
             clearUnused();
 #endif
             return false;
         }
         CallbackStack* nextStack = m_next;
         *first = nextStack;
         delete this;
         return nextStack->popAndInvokeCallback(first, visitor);
     }
     Item* item = --m_current;
@@ skipping 32 matching lines @@
         m_next->invokeOldestCallbacks(visitor);
 
     // This loop can tolerate entries being added by the callbacks after
     // iteration starts.
     for (unsigned i = 0; m_buffer + i < m_current; i++) {
         Item& item = m_buffer[i];
         item.callback()(visitor, item.object());
     }
 }
 
-#ifndef NDEBUG
+#if ENABLE(ASSERT)
 bool CallbackStack::hasCallbackForObject(const void* object)
 {
     for (unsigned i = 0; m_buffer + i < m_current; i++) {
         Item* item = &m_buffer[i];
         if (item->object() == object) {
             return true;
         }
     }
     if (m_next)
         return m_next->hasCallbackForObject(object);
@@ skipping 86 matching lines @@
     virtual void registerWeakMembers(const void* closure, const void* containingObject, WeakPointerCallback callback) OVERRIDE
     {
         Heap::pushWeakObjectPointerCallback(const_cast<void*>(closure), const_cast<void*>(containingObject), callback);
     }
 
     virtual void registerWeakTable(const void* closure, EphemeronCallback iterationCallback, EphemeronCallback iterationDoneCallback)
     {
         Heap::registerWeakTable(const_cast<void*>(closure), iterationCallback, iterationDoneCallback);
     }
 
-#ifndef NDEBUG
+#if ENABLE(ASSERT)
     virtual bool weakTableRegistered(const void* closure)
     {
         return Heap::weakTableRegistered(closure);
     }
 #endif
 
     virtual bool isMarked(const void* objectPointer) OVERRIDE
     {
         return FinalizedHeapObjectHeader::fromPayload(objectPointer)->isMarked();
     }
@@ skipping 162 matching lines @@
         if (page)
             return page;
     }
     return 0;
 }
 
 Address Heap::checkAndMarkPointer(Visitor* visitor, Address address)
 {
     ASSERT(ThreadState::isAnyThreadInGC());
 
-#ifdef NDEBUG
+#if !ENABLE(ASSERT)
     if (s_heapDoesNotContainCache->lookup(address))
         return 0;
 #endif
 
     ThreadState::AttachedThreadStateSet& threads = ThreadState::attachedThreads();
     for (ThreadState::AttachedThreadStateSet::iterator it = threads.begin(), end = threads.end(); it != end; ++it) {
         if ((*it)->checkAndMarkPointer(visitor, address)) {
             // Pointer was in a page of that thread. If it actually pointed
             // into an object then that object was found and marked.
             ASSERT(!s_heapDoesNotContainCache->lookup(address));
             s_lastGCWasConservative = true;
             return address;
         }
     }
 
-#ifdef NDEBUG
+#if !ENABLE(ASSERT)
     s_heapDoesNotContainCache->addEntry(address, true);
 #else
     if (!s_heapDoesNotContainCache->lookup(address))
         s_heapDoesNotContainCache->addEntry(address, true);
 #endif
     return 0;
 }
 
 #if ENABLE(GC_TRACING)
 const GCInfo* Heap::findGCInfo(Address address)
@@ skipping 79 matching lines @@
 {
     CallbackStack::Item* slot = s_ephemeronStack->allocateEntry(&s_ephemeronStack);
     *slot = CallbackStack::Item(table, iterationCallback);
 
     // We use the callback stack of weak cell pointers for the ephemeronIterationDone callbacks.
     // These callbacks are called right after marking and before any thread commences execution
     // so it suits our needs for telling the ephemerons that the iteration is done.
     pushWeakCellPointerCallback(static_cast<void**>(table), iterationDoneCallback);
 }
 
-#ifndef NDEBUG
+#if ENABLE(ASSERT)
 bool Heap::weakTableRegistered(const void* table)
 {
     ASSERT(s_ephemeronStack);
     return s_ephemeronStack->hasCallbackForObject(table);
 }
 #endif
 
 void Heap::prepareForGC()
 {
     ASSERT(ThreadState::isAnyThreadInGC());
@@ skipping 139 matching lines @@
 template class ThreadHeap<HeapObjectHeader>;
 
 Visitor* Heap::s_markingVisitor;
 CallbackStack* Heap::s_markingStack;
 CallbackStack* Heap::s_weakCallbackStack;
 CallbackStack* Heap::s_ephemeronStack;
 HeapDoesNotContainCache* Heap::s_heapDoesNotContainCache;
 bool Heap::s_shutdownCalled = false;
 bool Heap::s_lastGCWasConservative = false;
 }