Allow assertions to be enabled in Blink Release builds.

Source/wtf/PartitionAllocTest.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 37 matching lines @@
 
 #if !defined(MEMORY_TOOL_REPLACES_ALLOCATOR)
 
 namespace {
 
 static const size_t kTestMaxAllocation = 4096;
 static SizeSpecificPartitionAllocator<kTestMaxAllocation> allocator;
 static PartitionAllocatorGeneric genericAllocator;
 
 static const size_t kTestAllocSize = 16;
-#ifdef NDEBUG
+#if !ENABLE(ASSERT)
 static const size_t kPointerOffset = 0;
 static const size_t kExtraAllocSize = 0;
 #else
 static const size_t kPointerOffset = WTF::kCookieSize;
 static const size_t kExtraAllocSize = WTF::kCookieSize * 2;
 #endif
 static const size_t kRealAllocSize = kTestAllocSize + kExtraAllocSize;
 static const size_t kTestBucketIndex = kRealAllocSize >> WTF::kBucketShift;
 
 static void TestSetup()
@@ skipping 378 matching lines @@
     EXPECT_EQ(ptr, newPtr);
     newPtr = partitionReallocGeneric(genericAllocator.root(), ptr, WTF::kGenericSmallestBucket);
     EXPECT_EQ(ptr, newPtr);
 
     // Change the size of the realloc, switching buckets.
     newPtr = partitionReallocGeneric(genericAllocator.root(), ptr, WTF::kGenericSmallestBucket + 1);
     EXPECT_NE(newPtr, ptr);
     // Check that the realloc copied correctly.
     char* newCharPtr = static_cast<char*>(newPtr);
     EXPECT_EQ(*newCharPtr, 'A');
-#ifndef NDEBUG
+#if ENABLE(ASSERT)
     // Subtle: this checks for an old bug where we copied too much from the
     // source of the realloc. The condition can be detected by a trashing of
     // the uninitialized value in the space of the upsized allocation.
     EXPECT_EQ(WTF::kUninitializedByte, static_cast<unsigned char>(*(newCharPtr + WTF::kGenericSmallestBucket)));
 #endif
     *newCharPtr = 'B';
     // The realloc moved. To check that the old allocation was freed, we can
     // do an alloc of the old allocation size and check that the old allocation
     // address is at the head of the freelist and reused.
     void* reusedPtr = partitionAllocGeneric(genericAllocator.root(), 1);
@@ skipping 82 matching lines @@
     partitionFreeGeneric(genericAllocator.root(), ptr3);
     partitionFreeGeneric(genericAllocator.root(), ptr2);
     // Should be freeable at this point.
     EXPECT_NE(-1, page->freeCacheIndex);
     EXPECT_EQ(0, page->numAllocatedSlots);
     EXPECT_EQ(0, page->numUnprovisionedSlots);
     void* newPtr = partitionAllocGeneric(genericAllocator.root(), size);
     EXPECT_EQ(ptr3, newPtr);
     newPtr = partitionAllocGeneric(genericAllocator.root(), size);
     EXPECT_EQ(ptr2, newPtr);
-#if OS(LINUX) && defined(NDEBUG)
+#if OS(LINUX) && !ENABLE(ASSERT)
     // On Linux, we have a guarantee that freelisting a page should cause its
     // contents to be nulled out. We check for null here to detect an bug we
     // had where a large slot size was causing us to not properly free all
     // resources back to the system.
-    // We only run the check in optimized builds because the debug build
-    // writes over the allocated area with an "uninitialized" byte pattern.
+    // We only run the check when asserts are disabled because when they are
+    // enabled, the allocated area is overwritten with an "uninitialized"
+    // byte pattern.
     EXPECT_EQ(0, *(reinterpret_cast<char*>(newPtr) + (size - 1)));
 #endif
     partitionFreeGeneric(genericAllocator.root(), newPtr);
     partitionFreeGeneric(genericAllocator.root(), ptr3);
     partitionFreeGeneric(genericAllocator.root(), ptr4);
 
     // Can we allocate a massive (512MB) size?
     ptr = partitionAllocGeneric(genericAllocator.root(), 512 * 1024 * 1024);
     partitionFreeGeneric(genericAllocator.root(), ptr);
 
@@ skipping 97 matching lines @@
     // old allocation.
     size_t size = WTF::kSystemPageSize - kExtraAllocSize;
     EXPECT_EQ(size, partitionAllocActualSize(genericAllocator.root(), size));
     ptr = partitionAllocGeneric(genericAllocator.root(), size);
     memset(ptr, 'A', size);
     ptr2 = partitionReallocGeneric(genericAllocator.root(), ptr, size + 1);
     EXPECT_NE(ptr, ptr2);
     char* charPtr2 = static_cast<char*>(ptr2);
     EXPECT_EQ('A', charPtr2[0]);
     EXPECT_EQ('A', charPtr2[size - 1]);
-#ifndef NDEBUG
+#if ENABLE(ASSERT)
     EXPECT_EQ(WTF::kUninitializedByte, static_cast<unsigned char>(charPtr2[size]));
 #endif
 
     // Test that shrinking an allocation with realloc() also copies everything
     // from the old allocation.
     ptr = partitionReallocGeneric(genericAllocator.root(), ptr2, size - 1);
     EXPECT_NE(ptr2, ptr);
     char* charPtr = static_cast<char*>(ptr);
     EXPECT_EQ('A', charPtr[0]);
     EXPECT_EQ('A', charPtr[size - 2]);
-#ifndef NDEBUG
+#if ENABLE(ASSERT)
     EXPECT_EQ(WTF::kUninitializedByte, static_cast<unsigned char>(charPtr[size - 1]));
 #endif
 
     partitionFreeGeneric(genericAllocator.root(), ptr);
 
     // Test that shrinking a direct mapped allocation happens in-place.
     size = WTF::kGenericMaxBucketed + 16 * WTF::kSystemPageSize;
     ptr = partitionAllocGeneric(genericAllocator.root(), size);
     size_t actualSize = partitionAllocGetSize(ptr);
     ptr2 = partitionReallocGeneric(genericAllocator.root(), ptr, WTF::kGenericMaxBucketed + 8 * WTF::kSystemPageSize);
@@ skipping 482 matching lines @@
     EXPECT_EQ(32u, WTF::countLeadingZerosSizet(0u));
     EXPECT_EQ(31u, WTF::countLeadingZerosSizet(1u));
     EXPECT_EQ(1u, WTF::countLeadingZerosSizet(1u << 30));
     EXPECT_EQ(0u, WTF::countLeadingZerosSizet(1u << 31));
 #endif
 }
 
 } // namespace
 
 #endif // !defined(MEMORY_TOOL_REPLACES_ALLOCATOR)