Allow assertions to be enabled in Blink Release builds.

Source/platform/heap/Heap.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 113 matching lines @@
 {
     return (allocationGranularity - (sizeof(Header) % allocationGranularity)) % allocationGranularity;
 }
 
 // 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);
 }
 
-#ifndef NDEBUG
+#if ENABLE(ASSERT)
 
 // 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) - osPageSize());
 }
 #endif
 
@@ skipping 131 matching lines @@
 //
 // Object memory layout:
 // [ LargeObjectHeader | ] [ FinalizedObjectHeader | ] HeapObjectHeader | payload
 // The [ ] notation denotes that the LargeObjectHeader and the FinalizedObjectHeader
 // are independently optional.
 class PLATFORM_EXPORT HeapObjectHeader : public BasicObjectHeader {
 public:
     NO_SANITIZE_ADDRESS
     explicit HeapObjectHeader(size_t encodedSize)
         : BasicObjectHeader(encodedSize)
-#ifndef NDEBUG
+#if ENABLE(ASSERT)
         , m_magic(magic)
 #endif
     { }
 
     NO_SANITIZE_ADDRESS
     HeapObjectHeader(size_t encodedSize, const GCInfo*)
         : BasicObjectHeader(encodedSize)
-#ifndef NDEBUG
+#if ENABLE(ASSERT)
         , m_magic(magic)
 #endif
     { }
 
     inline void checkHeader() const;
     inline bool isMarked() const;
 
     inline void mark();
     inline void unmark();
 
@@ skipping 15 matching lines @@
     static void finalize(const GCInfo*, Address, size_t);
     static HeapObjectHeader* fromPayload(const void*);
 
     static const intptr_t magic = 0xc0de247;
     static const intptr_t zappedMagic = 0xC0DEdead;
     // The zap value for vtables should be < 4K to ensure it cannot be
     // used for dispatch.
     static const intptr_t zappedVTable = 0xd0d;
 
 private:
-#ifndef NDEBUG
+#if ENABLE(ASSERT)
     intptr_t m_magic;
 #endif
 };
 
 const size_t objectHeaderSize = sizeof(HeapObjectHeader);
 
 // Each object on the GeneralHeap needs to carry a pointer to its
 // own GCInfo structure for tracing and potential finalization.
 class PLATFORM_EXPORT FinalizedHeapObjectHeader : public HeapObjectHeader {
 public:
@@ skipping 29 matching lines @@
 
 const size_t finalizedHeaderSize = sizeof(FinalizedHeapObjectHeader);
 
 class FreeListEntry : public HeapObjectHeader {
 public:
     NO_SANITIZE_ADDRESS
     explicit FreeListEntry(size_t size)
         : HeapObjectHeader(freeListEncodedSize(size))
         , m_next(0)
     {
-#if !defined(NDEBUG) && !defined(ADDRESS_SANITIZER)
+#if ENABLE(ASSERT) && !defined(ADDRESS_SANITIZER)
         // Zap free area with asterisks, aka 0x2a2a2a2a.
         // For ASan don't zap since we keep accounting in the freelist entry.
         for (size_t i = sizeof(*this); i < size; i++)
             reinterpret_cast<Address>(this)[i] = freelistZapValue;
         ASSERT(size >= objectHeaderSize);
         zapMagic();
 #endif
     }
 
     Address address() { return reinterpret_cast<Address>(this); }
@@ skipping 316 matching lines @@
 
 private:
     Mutex m_mutex[NumberOfHeaps];
 };
 
 class OrphanedPagePool : public PagePool<BaseHeapPage> {
 public:
     ~OrphanedPagePool();
     void addOrphanedPage(int, BaseHeapPage*);
     void decommitOrphanedPages();
-#ifndef NDEBUG
+#if ENABLE(ASSERT)
     bool contains(void*);
 #endif
 private:
     void clearMemory(PageMemory*);
 };
 
 // The CallbackStack contains all the visitor callbacks used to trace and mark
 // objects. A specific CallbackStack instance contains at most bufferSize elements.
 // If more space is needed a new CallbackStack instance is created and chained
 // together with the former instance. I.e. a logical CallbackStack can be made of
 // multiple chained CallbackStack object instances.
 // There are two logical callback stacks. One containing all the marking callbacks and
 // one containing the weak pointer callbacks.
 class CallbackStack {
 public:
     CallbackStack(CallbackStack** first)
         : m_limit(&(m_buffer[bufferSize]))
         , m_current(&(m_buffer[0]))
         , m_next(*first)
     {
-#ifndef NDEBUG
+#if ENABLE(ASSERT)
         clearUnused();
 #endif
         *first = this;
     }
 
     ~CallbackStack();
     void clearUnused();
 
     bool isEmpty();
 
@@ skipping 25 matching lines @@
     template<CallbackInvocationMode Mode> bool popAndInvokeCallback(CallbackStack** first, Visitor*);
     static void invokeCallbacks(CallbackStack** first, Visitor*);
 
     Item* allocateEntry(CallbackStack** first)
     {
         if (m_current < m_limit)
             return m_current++;
         return (new CallbackStack(first))->allocateEntry(first);
     }
 
-#ifndef NDEBUG
+#if ENABLE(ASSERT)
     bool hasCallbackForObject(const void*);
 #endif
 
 private:
     void invokeOldestCallbacks(Visitor*);
 
     static const size_t bufferSize = 8000;
     Item m_buffer[bufferSize];
     Item* m_limit;
     Item* m_current;
@@ skipping 14 matching lines @@
 #if ENABLE(GC_TRACING)
     virtual const GCInfo* findGCInfoOfLargeHeapObject(Address) = 0;
 #endif
 
     // Sweep this part of the Blink heap. This finalizes dead objects
     // and builds freelists for all the unused memory.
     virtual void sweep() = 0;
 
     virtual void clearFreeLists() = 0;
     virtual void clearLiveAndMarkDead() = 0;
-#ifndef NDEBUG
+#if ENABLE(ASSERT)
     virtual void getScannedStats(HeapStats&) = 0;
 #endif
 
     virtual void makeConsistentForGC() = 0;
     virtual bool isConsistentForGC() = 0;
 
     virtual void prepareHeapForTermination() = 0;
 
     // Returns a bucket number for inserting a FreeListEntry of a
     // given size. All FreeListEntries in the given bucket, n, have
@@ skipping 18 matching lines @@
     virtual ~ThreadHeap();
     virtual void cleanupPages();
 
     virtual BaseHeapPage* heapPageFromAddress(Address);
 #if ENABLE(GC_TRACING)
     virtual const GCInfo* findGCInfoOfLargeHeapObject(Address);
 #endif
     virtual void sweep();
     virtual void clearFreeLists();
     virtual void clearLiveAndMarkDead();
-#ifndef NDEBUG
+#if ENABLE(ASSERT)
     virtual void getScannedStats(HeapStats&);
 #endif
 
     virtual void makeConsistentForGC();
     virtual bool isConsistentForGC();
 
     ThreadState* threadState() { return m_threadState; }
     HeapStats& stats() { return m_threadState->stats(); }
     void flushHeapContainsCache()
     {
@@ skipping 50 matching lines @@
 
 class PLATFORM_EXPORT Heap {
 public:
     static void init();
     static void shutdown();
     static void doShutdown();
 
     static BaseHeapPage* contains(Address);
     static BaseHeapPage* contains(void* pointer) { return contains(reinterpret_cast<Address>(pointer)); }
     static BaseHeapPage* contains(const void* pointer) { return contains(const_cast<void*>(pointer)); }
-#ifndef NDEBUG
+#if ENABLE(ASSERT)
     static bool containedInHeapOrOrphanedPage(void*);
 #endif
 
     // Push a trace callback on the marking stack.
     static void pushTraceCallback(void* containerObject, TraceCallback);
 
     // Add a weak pointer callback to the weak callback work list. General
     // object pointer callbacks are added to a thread local weak callback work
     // list and the callback is called on the thread that owns the object, with
     // the closure pointer as an argument. Most of the time, the closure and
@@ skipping 12 matching lines @@
     // and the object. Returns false when there is nothing more to do.
     template<CallbackInvocationMode Mode> static bool popAndInvokeTraceCallback(Visitor*);
 
     // Remove an item from the weak callback work list and call the callback
     // with the visitor and the closure pointer. Returns false when there is
     // nothing more to do.
     static bool popAndInvokeWeakPointerCallback(Visitor*);
 
     // Register an ephemeron table for fixed-point iteration.
     static void registerWeakTable(void* containerObject, EphemeronCallback, EphemeronCallback);
-#ifndef NDEBUG
+#if ENABLE(ASSERT)
     static bool weakTableRegistered(const void*);
 #endif
 
     template<typename T> static Address allocate(size_t);
     template<typename T> static Address reallocate(void* previous, size_t);
 
     static void collectGarbage(ThreadState::StackState);
     static void collectGarbageForTerminatingThread(ThreadState*);
     static void collectAllGarbage();
     template<CallbackInvocationMode Mode> static void traceRootsAndPerformGlobalWeakProcessing();
@@ skipping 347 matching lines @@
 #define GC_PLUGIN_IGNORE(bug)                           \
     __attribute__((annotate("blink_gc_plugin_ignore")))
 #else
 #define STACK_ALLOCATED() DISALLOW_ALLOCATION()
 #define GC_PLUGIN_IGNORE(bug)
 #endif
 
 NO_SANITIZE_ADDRESS
 void HeapObjectHeader::checkHeader() const
 {
-#ifndef NDEBUG
+#if ENABLE(ASSERT)
     BaseHeapPage* page = pageHeaderFromObject(this);
     ASSERT(page->orphaned() || m_magic == magic);
 #endif
 }
 
 Address HeapObjectHeader::payload()
 {
     return reinterpret_cast<Address>(this) + objectHeaderSize;
 }
 
@@ skipping 52 matching lines @@
     Address headerAddress = m_currentAllocationPoint;
     m_currentAllocationPoint += allocationSize;
     m_remainingAllocationSize -= allocationSize;
     Header* header = new (NotNull, headerAddress) Header(allocationSize, gcInfo);
     size_t payloadSize = allocationSize - sizeof(Header);
     stats().increaseObjectSpace(payloadSize);
     Address result = headerAddress + sizeof(*header);
     ASSERT(!(reinterpret_cast<uintptr_t>(result) & allocationMask));
     // Unpoison the memory used for the object (payload).
     ASAN_UNPOISON_MEMORY_REGION(result, payloadSize);
-#if !defined(NDEBUG) || defined(LEAK_SANITIZER) || defined(ADDRESS_SANITIZER)
+#if ENABLE(ASSERT) || defined(LEAK_SANITIZER) || defined(ADDRESS_SANITIZER)
     memset(result, 0, payloadSize);
 #endif
     ASSERT(heapPageFromAddress(headerAddress + allocationSize - 1));
     return result;
 }
 
 // FIXME: Allocate objects that do not need finalization separately
 // and use separate sweeping to not have to check for finalizers.
 template<typename T>
 Address Heap::allocate(size_t size)
@@ skipping 103 matching lines @@
     static void registerWeakMembers(Visitor* visitor, const void* closure, const void* object, WeakPointerCallback callback)
     {
         visitor->registerWeakMembers(closure, object, callback);
     }
 
     static void registerWeakTable(Visitor* visitor, const void* closure, EphemeronCallback iterationCallback, EphemeronCallback iterationDoneCallback)
     {
         visitor->registerWeakTable(closure, iterationCallback, iterationDoneCallback);
     }
 
-#ifndef NDEBUG
+#if ENABLE(ASSERT)
     static bool weakTableRegistered(Visitor* visitor, const void* closure)
     {
         return visitor->weakTableRegistered(closure);
     }
 #endif
 
     template<typename T>
     struct ResultType {
         typedef T* Type;
     };
@@ skipping 753 matching lines @@
         COMPILE_ASSERT(!WTF::IsWeak<T>::value, WeDontSupportWeaknessInHeapVectorsOrDeques);
         if (WTF::ShouldBeTraced<Traits>::value)
             WTF::TraceInCollectionTrait<WTF::NoWeakHandlingInCollections, WTF::WeakPointersActWeak, HeapVectorBacking<T, Traits>, void>::trace(visitor, self);
     }
     static void mark(Visitor* visitor, const Backing* backing)
     {
         visitor->mark(backing, &trace);
     }
     static void checkGCInfo(Visitor* visitor, const Backing* backing)
     {
-#ifndef NDEBUG
+#if ENABLE(ASSERT)
         visitor->checkGCInfo(const_cast<Backing*>(backing), GCInfoTrait<Backing>::get());
 #endif
     }
 };
 
 // The trace trait for the heap hashtable backing is used when we find a
 // direct pointer to the backing from the conservative stack scanner. This
 // normally indicates that there is an ongoing iteration over the table, and so
 // we disable weak processing of table entries. When the backing is found
 // through the owning hash table we mark differently, in order to do weak
 // processing.
 template<typename Table>
 struct TraceTrait<HeapHashTableBacking<Table> > {
     typedef HeapHashTableBacking<Table> Backing;
     typedef typename Table::ValueTraits Traits;
     static void trace(Visitor* visitor, void* self)
     {
         if (WTF::ShouldBeTraced<Traits>::value || Traits::weakHandlingFlag == WTF::WeakHandlingInCollections)
             WTF::TraceInCollectionTrait<WTF::NoWeakHandlingInCollections, WTF::WeakPointersActStrong, Backing, void>::trace(visitor, self);
     }
     static void mark(Visitor* visitor, const Backing* backing)
     {
         if (WTF::ShouldBeTraced<Traits>::value || Traits::weakHandlingFlag == WTF::WeakHandlingInCollections)
             visitor->mark(backing, &trace);
         else
             visitor->markNoTracing(backing); // If we know the trace function will do nothing there is no need to call it.
     }
     static void checkGCInfo(Visitor* visitor, const Backing* backing)
     {
-#ifndef NDEBUG
+#if ENABLE(ASSERT)
         visitor->checkGCInfo(const_cast<Backing*>(backing), GCInfoTrait<Backing>::get());
 #endif
     }
 };
 
 template<typename Table>
 void HeapHashTableBacking<Table>::finalize(void* pointer)
 {
     typedef typename Table::ValueType Value;
     ASSERT(Table::ValueTraits::needsDestruction);
@@ skipping 33 matching lines @@
 };
 
 template<typename T>
 struct IfWeakMember<WeakMember<T> > {
     static bool isDead(Visitor* visitor, const WeakMember<T>& t) { return !visitor->isAlive(t.get()); }
 };
 
 }
 
 #endif // Heap_h