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 98 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 167 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 272 matching lines @@
 // 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 @@
     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 19 matching lines @@
     virtual void sweep() = 0;
 
     // Forcefully finalize all objects in this part of the Blink heap
     // (potentially with the exception of one object). This is used
     // during thread termination to make sure that all objects for the
     // dying thread are finalized.
     virtual void assertEmpty() = 0;
 
     virtual void clearFreeLists() = 0;
     virtual void clearMarks() = 0;
-#ifndef NDEBUG
+#if ENABLE(ASSERT)
     virtual void getScannedStats(HeapStats&) = 0;
 #endif
 
     virtual void makeConsistentForGC() = 0;
     virtual bool isConsistentForGC() = 0;
 
     // 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);
@@ skipping 16 matching lines @@
     virtual ~ThreadHeap();
 
     virtual BaseHeapPage* heapPageFromAddress(Address);
 #if ENABLE(GC_TRACING)
     virtual const GCInfo* findGCInfoOfLargeHeapObject(Address);
 #endif
     virtual void sweep();
     virtual void assertEmpty();
     virtual void clearFreeLists();
     virtual void clearMarks();
-#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 107 matching lines @@
     // and the object. Returns false when there is nothing more to do.
     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 collectAllGarbage();
     static void setForcePreciseGCForTesting();
 
@@ skipping 410 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 752 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