Don't align size on allocation granularity for unaligned ReserveRegion calls.

src/platform/virtual-memory.cc

 // Copyright 2013 the V8 project authors. 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
 //       copyright notice, this list of conditions and the following
 //       disclaimer in the documentation and/or other materials provided
@@ skipping 140 matching lines @@
 
 // static
 void* VirtualMemory::ReserveRegion(size_t size, size_t* size_return) {
   ASSERT_LT(0, size);
   ASSERT_NE(NULL, size_return);
   // The minimum size that can be reserved is 64KiB, see
   // http://msdn.microsoft.com/en-us/library/ms810627.aspx
   if (size < 64 * KB) {
     size = 64 * KB;
   }
-  size = RoundUp(size, GetAllocationGranularity());
+  size = RoundUp(size, GetPageSize());
   LPVOID address = NULL;
   // Try and randomize the allocation address (up to three attempts).
   for (unsigned attempts = 0; address == NULL && attempts < 3; ++attempts) {
     address = VirtualAlloc(GenerateRandomAddress(),
                            size,
                            MEM_RESERVE,
                            PAGE_NOACCESS);
   }
   if (address == NULL) {
     // After three attempts give up and let the kernel find an address.
@@ skipping 10 matching lines @@
 
 
 // static
 void* VirtualMemory::ReserveRegion(size_t size,
                                    size_t* size_return,
                                    size_t alignment) {
   ASSERT_LT(0, size);
   ASSERT_NE(NULL, size_return);
   ASSERT(IsAligned(alignment, GetAllocationGranularity()));
 
-  size_t reserved_size;
+  size_t reserved_size = RoundUp(size + alignment, GetAllocationGranularity());
   Address reserved_base = static_cast<Address>(
-      ReserveRegion(size + alignment, &reserved_size));
+      ReserveRegion(reserved_size, &reserved_size));
   if (reserved_base == NULL) {
     return NULL;
   }
   ASSERT_LE(size, reserved_size);
+  ASSERT_LE(size + alignment, reserved_size);
   ASSERT(IsAligned(reserved_size, GetPageSize()));
 
   // Try reducing the size by freeing and then reallocating a specific area.
   bool result = ReleaseRegion(reserved_base, reserved_size);
   USE(result);
   ASSERT(result);
   size_t aligned_size = RoundUp(size, GetPageSize());
   Address aligned_base = static_cast<Address>(
       VirtualAlloc(RoundUp(reserved_base, alignment),
                    aligned_size,
                    MEM_RESERVE,
                    PAGE_NOACCESS));
   if (aligned_base != NULL) {
     ASSERT(aligned_base == RoundUp(reserved_base, alignment));
     ASSERT(IsAligned(reinterpret_cast<uintptr_t>(aligned_base),
                      GetAllocationGranularity()));
     ASSERT(IsAligned(aligned_size, GetPageSize()));
     *size_return = aligned_size;
     return aligned_base;
   }
 
   // Resizing failed, just go with a bigger area.
+  ASSERT(IsAligned(reserved_size, GetAllocationGranularity()));
   return ReserveRegion(reserved_size, size_return);
 }
 
 
 // static
 bool VirtualMemory::CommitRegion(void* address,
                                  size_t size,
                                  Executability executability) {
   ASSERT_NE(NULL, address);
   ASSERT_LT(0, size);
@@ skipping 53 matching lines @@
 
 // static
 size_t VirtualMemory::GetAllocationGranularity() {
   static size_t allocation_granularity = 0;
   if (allocation_granularity == 0) {
     SYSTEM_INFO system_info;
     GetSystemInfo(&system_info);
     allocation_granularity = system_info.dwAllocationGranularity;
     MemoryBarrier();
   }
+  ASSERT_GE(allocation_granularity, GetPageSize());
   return allocation_granularity;
 }
 
 
 // static
 size_t VirtualMemory::GetLimit() {
   return 0;
 }
 
 
@@ skipping 197 matching lines @@
 
 // static
 size_t VirtualMemory::GetPageSize() {
   static const size_t kPageSize = getpagesize();
   return kPageSize;
 }
 
 #endif  // V8_OS_CYGWIN || V8_OS_WIN
 
 } }  // namespace v8::internal