Make PartitionAllocDeathTest.GuardPages pass on Win64.

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 1302 matching lines @@
     EXPECT_DEATH(partitionFreeGeneric(genericAllocator.root(), ptr), "");
 
     TestShutdown();
 }
 
 // Check that guard pages are present where expected.
 TEST(PartitionAllocDeathTest, GuardPages)
 {
     TestSetup();
 
-    // This large size will result in a direct mapped allocation with guard
-    // pages at either end.
-    size_t size = (kGenericMaxBucketed + kSystemPageSize) - kExtraAllocSize;
+    // partitionAlloc adds kPartitionPageSize to the requested size
+    // (for metadata), and then rounds that size to kPageAllocationGranularity.
+    // To be able to reliably write one past a direct allocation, choose a size
+    // that's
+    // a) larger than kGenericMaxBucketed (to make the allocation direct)
+    // b) aligned at kPageAllocationGranularity boundaries after
+    //    kPartitionPageSize has been added to it.
+    // (On 32-bit, partitionAlloc adds another kSystemPageSize to the
+    // allocation size before rounding, but there it marks the memory right
+    // after size as inaccessible, so it's fine to write 1 past the size we
+    // hand to partitionAlloc and we don't need to worry about allocation
+    // granularities.)
+#define ALIGN(N, A) (((N) + (A) - 1) / (A) * (A))
+    const int kSize = ALIGN(kGenericMaxBucketed + 1 + kPartitionPageSize, kPageAllocationGranularity) - kPartitionPageSize;
+#undef ALIGN
+    static_assert(kSize > kGenericMaxBucketed, "allocation not large enough for direct allocation");
+    size_t size = kSize - kExtraAllocSize;
     void* ptr = partitionAllocGeneric(genericAllocator.root(), size);
+
     EXPECT_TRUE(ptr);
     char* charPtr = reinterpret_cast<char*>(ptr) - kPointerOffset;
 
     EXPECT_DEATH(*(charPtr - 1) = 'A', "");
     EXPECT_DEATH(*(charPtr + size + kExtraAllocSize) = 'A', "");
 
     partitionFreeGeneric(genericAllocator.root(), ptr);
 
     TestShutdown();
 }
@@ skipping 605 matching lines @@
     EXPECT_EQ(32u, countLeadingZerosSizet(0u));
     EXPECT_EQ(31u, countLeadingZerosSizet(1u));
     EXPECT_EQ(1u, countLeadingZerosSizet(1u << 30));
     EXPECT_EQ(0u, countLeadingZerosSizet(1u << 31));
 #endif
 }
 
 } // namespace WTF
 
 #endif // !defined(MEMORY_TOOL_REPLACES_ALLOCATOR)