Optimize test for pointer being in a partition on 32-bit.

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 70 matching lines @@
 // - No double-free detection (tcmalloc has some but it may be only a detection
 // and not a defense).
 // - No randomness in freelist pointers.
 // - Per-object bucketing (instead of per-size) is mostly available at the API,
 // but not used yet.
 // - No randomness of freelist entries or bucket position.
 // - No specific protection against corruption of page header metadata.
 
 #include "wtf/Assertions.h"
 #include "wtf/FastMalloc.h"
+#include "wtf/PageAllocator.h"
 #include "wtf/SpinLock.h"
+#include "wtf/UnusedParam.h"
 
 #if defined(MEMORY_TOOL_REPLACES_ALLOCATOR)
 #include <stdlib.h>
 #endif
 
 namespace WTF {
 
 // Allocation granularity of sizeof(void*) bytes.
 static const size_t kAllocationGranularity = sizeof(void*);
 static const size_t kAllocationGranularityMask = kAllocationGranularity - 1;
@@ skipping 157 matching lines @@
     PartitionFreelistEntry* entry = static_cast<PartitionFreelistEntry*>(ptr);
     entry->next = partitionFreelistMask(page->freelistHead);
     page->freelistHead = entry;
     --page->numAllocatedSlots;
     if (UNLIKELY(page->numAllocatedSlots <= 0))
         partitionFreeSlowPath(page);
 }
 
 ALWAYS_INLINE bool partitionPointerIsValid(PartitionRoot* root, void* ptr)
 {
+#if CPU(32BIT)
+    // On 32-bit systems, we have an optimization where we have a bitmap that
+    // can instantly tell us if a pointer is in a super page or not.
+    // It is a global bitmap instead of a per-partition bitmap but this is a
+    // reasonable space vs. accuracy trade off.
+    UNUSED_PARAM(root);
+    return SuperPageBitmap::isPointerInSuperPage(ptr);
+#else
+    // On 64-bit systems, we check the list of super page extents. Due to the
+    // massive address space, we typically have a single extent.
     // Dominant case: the pointer is in the first extent, which grew without any collision.
     if (LIKELY(ptr >= root->firstExtent.superPageBase) && LIKELY(ptr < root->firstExtent.superPagesEnd))
         return true;
 
     // Otherwise, scan through the extent list.
     PartitionSuperPageExtentEntry* entry = root->firstExtent.next;
     while (UNLIKELY(entry != 0)) {
         if (ptr >= entry->superPageBase && ptr < entry->superPagesEnd)
             return true;
         entry = entry->next;
     }
 
     return false;
+#endif
 }
 
 ALWAYS_INLINE void partitionFree(void* ptr)
 {
 #if defined(MEMORY_TOOL_REPLACES_ALLOCATOR)
     free(ptr);
 #else
     PartitionPageHeader* page = partitionPointerToPage(ptr);
     ASSERT(partitionPointerIsValid(page->bucket->root, ptr));
     partitionFreeWithPage(ptr, page);
@@ skipping 64 matching lines @@
 using WTF::PartitionRoot;
 using WTF::partitionAllocInit;
 using WTF::partitionAllocShutdown;
 using WTF::partitionAlloc;
 using WTF::partitionFree;
 using WTF::partitionAllocGeneric;
 using WTF::partitionFreeGeneric;
 using WTF::partitionReallocGeneric;
 
 #endif // WTF_PartitionAlloc_h