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

Source/wtf/PageAllocator.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 13 matching lines @@
  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
 #include "config.h"
 #include "wtf/PageAllocator.h"
 
-#include "wtf/Assertions.h"
-#include "wtf/CPU.h"
 #include "wtf/CryptographicallyRandomNumber.h"
 
 #if OS(POSIX)
 
 #include <sys/mman.h>
 
 #ifndef MADV_FREE
 #define MADV_FREE MADV_DONTNEED
 #endif
 
@@ skipping 44 matching lines @@
     }
     void* ret = ptr;
 #else
     // Windows is a lot simpler because we've designed around its
     // coarser-grained alignement.
     void* ret = VirtualAlloc(addr, len, MEM_RESERVE | MEM_COMMIT, PAGE_READWRITE);
     if (!ret)
         ret = VirtualAlloc(0, len, MEM_RESERVE | MEM_COMMIT, PAGE_READWRITE);
     RELEASE_ASSERT(ret);
 #endif // OS(POSIX)
+
+    SuperPageBitmap::registerSuperPage(ret);
     return ret;
 }
 
 void freeSuperPages(void* addr, size_t len)
 {
     ASSERT(!(reinterpret_cast<uintptr_t>(addr) & kSuperPageOffsetMask));
     ASSERT(!(len & kSuperPageOffsetMask));
 #if OS(POSIX)
     int ret = munmap(addr, len);
     ASSERT(!ret);
 #else
     BOOL ret = VirtualFree(addr, 0, MEM_RELEASE);
     ASSERT(ret);
 #endif
+
+    SuperPageBitmap::unregisterSuperPage(addr);
 }
 
 void setSystemPagesInaccessible(void* addr, size_t len)
 {
     ASSERT(!(len & kSystemPageOffsetMask));
 #if OS(POSIX)
     int ret = mprotect(addr, len, PROT_NONE);
     ASSERT(!ret);
 #else
     BOOL ret = VirtualFree(addr, len, MEM_DECOMMIT);
@@ skipping 32 matching lines @@
 #endif
 #else // !CPU(X86_64)
     // This is a good range on Windows, Linux and Mac.
     // Allocates in the 0.5-1.5GB region.
     random &= (0x3fffffff & kSuperPageBaseMask);
     random += 0x20000000;
 #endif // CPU(X86_64)
     return reinterpret_cast<char*>(random);
 }
 
+#if CPU(32BIT)
+unsigned char SuperPageBitmap::s_bitmap[1 << (32 - kSuperPageShift - 3)];
+
+void SuperPageBitmap::registerSuperPage(void* ptr)
+{
+    ASSERT(!isPointerInSuperPage(ptr));
+    uintptr_t raw = reinterpret_cast<uintptr_t>(ptr);
+    raw >>= kSuperPageShift;
+    size_t idx = raw >> 3;

[ojan, 2013/10/03 00:44:09]

Nit: Here an elsewhere, I'm not sure what "idx" stands for. Is this supposed to
be "index"? Blink code prefers to avoid abbreviations in general.

+    size_t bit = raw & 7;
+    ASSERT(idx < sizeof(s_bitmap));
+    s_bitmap[idx] |= (1 << bit);
+}
+
+void SuperPageBitmap::unregisterSuperPage(void* ptr)
+{
+    ASSERT(isPointerInSuperPage(ptr));
+    uintptr_t raw = reinterpret_cast<uintptr_t>(ptr);
+    raw >>= kSuperPageShift;
+    size_t idx = raw >> 3;
+    size_t bit = raw & 7;
+    ASSERT(idx < sizeof(s_bitmap));
+    s_bitmap[idx] &= ~(1 << bit);
+}
+#endif
+
 } // namespace WTF