Allow assertions to be enabled in Blink Release builds.

Source/wtf/PartitionAlloc.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 91 matching lines @@
 #include "wtf/CPU.h"
 #include "wtf/PageAllocator.h"
 #include "wtf/SpinLock.h"
 
 #include <limits.h>
 
 #if defined(MEMORY_TOOL_REPLACES_ALLOCATOR)
 #include <stdlib.h>
 #endif
 
-#ifndef NDEBUG
+#if ENABLE(ASSERT)
 #include <string.h>
 #endif
 
 namespace WTF {
 
 // Maximum size of a partition's mappings. 2046MB. Note that the total amount of
 // bytes allocatable at the API will be smaller. This is because things like
 // guard pages, metadata, page headers and wasted space come out of the total.
 // The 2GB is not necessarily contiguous in virtual address space.
 static const size_t kMaxPartitionSize = 2046u * 1024u * 1024u;
@@ skipping 60 matching lines @@
 static const size_t kGenericSmallestBucket = 1 << (kGenericMinBucketedOrder - 1);
 static const size_t kGenericMaxBucketSpacing = 1 << ((kGenericMaxBucketedOrder - 1) - kGenericNumBucketsPerOrderBits);
 static const size_t kGenericMaxBucketed = (1 << (kGenericMaxBucketedOrder - 1)) + ((kGenericNumBucketsPerOrder - 1) * kGenericMaxBucketSpacing);
 static const size_t kGenericMinDirectMappedDownsize = kGenericMaxBucketed + 1; // Limit when downsizing a direct mapping using realloc().
 static const size_t kGenericMaxDirectMapped = INT_MAX - kSystemPageSize;
 static const size_t kBitsPerSizet = sizeof(void*) * CHAR_BIT;
 
 // Constants for the memory reclaim logic.
 static const size_t kMaxFreeableSpans = 16;
 
-#ifndef NDEBUG
+#if ENABLE(ASSERT)
 // These two byte values match tcmalloc.
 static const unsigned char kUninitializedByte = 0xAB;
 static const unsigned char kFreedByte = 0xCD;
 static const uint32_t kCookieValue = 0xDEADBEEFu;
 static const size_t kCookieSize = 16; // Handles alignment up to XMM instructions on Intel.
 #endif
 
 struct PartitionBucket;
 struct PartitionRootBase;
 
@@ skipping 122 matching lines @@
 #if CPU(BIG_ENDIAN)
     uintptr_t masked = ~reinterpret_cast<uintptr_t>(ptr);
 #else
     uintptr_t masked = bswapuintptrt(reinterpret_cast<uintptr_t>(ptr));
 #endif
     return reinterpret_cast<PartitionFreelistEntry*>(masked);
 }
 
 ALWAYS_INLINE size_t partitionCookieSizeAdjustAdd(size_t size)
 {
-#ifndef NDEBUG
+#if ENABLE(ASSERT)
     // Add space for cookies, checking for integer overflow.
     ASSERT(size + (2 * kCookieSize) > size);
     size += 2 * kCookieSize;
 #endif
     return size;
 }
 
 ALWAYS_INLINE size_t partitionCookieSizeAdjustSubtract(size_t size)
 {
-#ifndef NDEBUG
+#if ENABLE(ASSERT)
     // Remove space for cookies.
     ASSERT(size >= 2 * kCookieSize);
     size -= 2 * kCookieSize;
 #endif
     return size;
 }
 
 ALWAYS_INLINE void* partitionCookieFreePointerAdjust(void* ptr)
 {
-#ifndef NDEBUG
+#if ENABLE(ASSERT)
     // The value given to the application is actually just after the cookie.
     ptr = static_cast<char*>(ptr) - kCookieSize;
 #endif
     return ptr;
 }
 
 ALWAYS_INLINE void partitionCookieWriteValue(void* ptr)
 {
-#ifndef NDEBUG
+#if ENABLE(ASSERT)
     uint32_t* cookiePtr = reinterpret_cast<uint32_t*>(ptr);
     for (size_t i = 0; i < kCookieSize / sizeof(kCookieValue); ++i, ++cookiePtr)
         *cookiePtr = kCookieValue;
 #endif
 }
 
 ALWAYS_INLINE void partitionCookieCheckValue(void* ptr)
 {
-#ifndef NDEBUG
+#if ENABLE(ASSERT)
     uint32_t* cookiePtr = reinterpret_cast<uint32_t*>(ptr);
     for (size_t i = 0; i < kCookieSize / sizeof(kCookieValue); ++i, ++cookiePtr)
         ASSERT(*cookiePtr == kCookieValue);
 #endif
 }
 
 ALWAYS_INLINE char* partitionSuperPageToMetadataArea(char* ptr)
 {
     uintptr_t pointerAsUint = reinterpret_cast<uintptr_t>(ptr);
     ASSERT(!(pointerAsUint & kSuperPageOffsetMask));
@@ skipping 61 matching lines @@
     if (LIKELY(ret != 0)) {
         // If these asserts fire, you probably corrupted memory.
         ASSERT(partitionPointerIsValid(ret));
         PartitionFreelistEntry* newHead = partitionFreelistMask(static_cast<PartitionFreelistEntry*>(ret)->next);
         page->freelistHead = newHead;
         ASSERT(!ret || partitionPointerIsValid(ret));
         page->numAllocatedSlots++;
     } else {
         ret = partitionAllocSlowPath(root, flags, size, bucket);
     }
-#ifndef NDEBUG
+#if ENABLE(ASSERT)
     if (!ret)
         return 0;
     // Fill the uninitialized pattern. and write the cookies.
     page = partitionPointerToPage(ret);
     size_t bucketSize = page->bucket->slotSize;
     memset(ret, kUninitializedByte, bucketSize);
     partitionCookieWriteValue(ret);
     partitionCookieWriteValue(reinterpret_cast<char*>(ret) + bucketSize - kCookieSize);
     // The value given to the application is actually just after the cookie.
     ret = static_cast<char*>(ret) + kCookieSize;
@@ skipping 14 matching lines @@
     ASSERT(index < root->numBuckets);
     ASSERT(size == index << kBucketShift);
     PartitionBucket* bucket = &root->buckets()[index];
     return partitionBucketAlloc(root, 0, size, bucket);
 #endif // defined(MEMORY_TOOL_REPLACES_ALLOCATOR)
 }
 
 ALWAYS_INLINE void partitionFreeWithPage(void* ptr, PartitionPage* page)
 {
     // If these asserts fire, you probably corrupted memory.
-#ifndef NDEBUG
+#if ENABLE(ASSERT)
     size_t bucketSize = page->bucket->slotSize;
     partitionCookieCheckValue(ptr);
     partitionCookieCheckValue(reinterpret_cast<char*>(ptr) + bucketSize - kCookieSize);
     memset(ptr, kFreedByte, bucketSize);
 #endif
     ASSERT(page->numAllocatedSlots);
     PartitionFreelistEntry* freelistHead = page->freelistHead;
     ASSERT(!freelistHead || partitionPointerIsValid(freelistHead));
     RELEASE_ASSERT(ptr != freelistHead); // Catches an immediate double free.
     ASSERT(!freelistHead || ptr != partitionFreelistMask(freelistHead->next)); // Look for double free one level deeper in debug.
@@ skipping 161 matching lines @@
 using WTF::partitionAlloc;
 using WTF::partitionFree;
 using WTF::partitionAllocGeneric;
 using WTF::partitionFreeGeneric;
 using WTF::partitionReallocGeneric;
 using WTF::partitionAllocActualSize;
 using WTF::partitionAllocSupportsGetSize;
 using WTF::partitionAllocGetSize;
 
 #endif // WTF_PartitionAlloc_h