Avoid fragmenting address space on small windows systems.

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 40 matching lines @@
 #elif OS(WIN)
 
 #include <windows.h>
 
 #else
 #error Unknown OS
 #endif // OS(POSIX)
 
 namespace WTF {
 
+#if OS(WIN)
+
+static bool shouldUseAddressHint()
+{
+#if !CPU(X86_64)
+    // Determine if userspace is limited to 2 GB.
+    static bool architectureKnown = false;
+    static bool useHint = true;
+    if (!architectureKnown) {
+        SYSTEM_INFO systemInfo = { 0 };
+        ::GetNativeSystemInfo(&systemInfo);
+        if (systemInfo.wProcessorArchitecture == PROCESSOR_ARCHITECTURE_INTEL)

[Chris Evans, 2014/07/18 18:21:00]

Ah. Maybe I get it now. Is the 3G/1G for Windows 32-bit processes restricted to
when the underlying CPU is x86_64? I still find it a bit unclear.

Would it be clearer to use the lpMaximumApplicationAddress field of this
structure? If it is over 0x80000000 then we can use the hints, otherwise not?

+            useHint = false;
+        architectureKnown = true;
+    }
+    return useHint;
+#else // !CPU(X86_64)
+    return true;
+#endif // !CPU(X86_64)
+}
+
+#endif // OS(WIN)
+
 // This simple internal function wraps the OS-specific page allocation call so
 // that it behaves consistently: the address is a hint and if it cannot be used,
 // the allocation will be placed elsewhere.
 static void* systemAllocPages(void* addr, size_t len)
 {
     ASSERT(!(len & kPageAllocationGranularityOffsetMask));
     ASSERT(!(reinterpret_cast<uintptr_t>(addr) & kPageAllocationGranularityOffsetMask));
-    void* ret;
+    void* ret = 0;
 #if OS(WIN)
-    ret = VirtualAlloc(addr, len, MEM_RESERVE | MEM_COMMIT, PAGE_READWRITE);
+    if (shouldUseAddressHint())
+        ret = VirtualAlloc(addr, len, MEM_RESERVE | MEM_COMMIT, PAGE_READWRITE);
     if (!ret)
         ret = VirtualAlloc(0, len, MEM_RESERVE | MEM_COMMIT, PAGE_READWRITE);
 #else
     ret = mmap(addr, len, PROT_READ | PROT_WRITE, MAP_ANONYMOUS | MAP_PRIVATE, -1, 0);
     if (ret == MAP_FAILED)
         ret = 0;
 #endif
     return ret;
 }
 
@@ skipping 135 matching lines @@
     ASSERT(!(len & kSystemPageOffsetMask));
 #if OS(POSIX)
     (void) addr;
 #else
     setSystemPagesAccessible(addr, len);
 #endif
 }
 
 } // namespace WTF