Move aligned allocation to the platform files.

src/platform-win32.cc

-// Copyright 2006-2008 the V8 project authors. All rights reserved.
+// Copyright 2011 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
 //       with the distribution.
@@ skipping 48 matching lines @@
 
 // Test for infinity - usually defined in math.h
 int isinf(double x) {
   return (_fpclass(x) & (_FPCLASS_PINF | _FPCLASS_NINF)) != 0;
 }
 
 
 // Test if x is less than y and both nominal - usually defined in math.h
 int isless(double x, double y) {
   return isnan(x) || isnan(y) ? 0 : x < y;
 }

[Vyacheslav Egorov (Chromium), 2011/09/14 12:46:51]

Accident edit?

[Lasse Reichstein, 2011/09/15 10:58:49]

Also no edit here.
Are you comparing to previous CL (because an update of the working checkout to
tip of tree will make that not work).

 
 
 // Test if x is greater than y and both nominal - usually defined in math.h
 int isgreater(double x, double y) {
   return isnan(x) || isnan(y) ? 0 : x > y;
 }
 
 
 // Classify floating point number - usually defined in math.h
 int fpclassify(double x) {
@@ skipping 1377 matching lines @@
 #endif
 }
 
 
 void OS::ReleaseStore(volatile AtomicWord* ptr, AtomicWord value) {
   MemoryBarrier();
   *ptr = value;
 }
 
 
+VirtualMemory::VirtualMemory() : address_(NULL), size_(0) { }
+
+
+VirtualMemory::VirtualMemory(size_t size)
+    : address_(ReserveRegion(size)), size_(size) { }
+
+
+VirtualMemory::VirtualMemory(size_t size, size_t alignment)
+    : address_(NULL), size_(0) {
+  ASSERT(IsAligned(alignment, static_cast<intptr_t>(OS::AllocateAlignment())));
+  size_t request_size = RoundUp(size + alignment,
+                                static_cast<intptr_t>(OS::AllocateAlignment()));
+  void* address = ReserveRegion(reserve_size);
+  if (address == NULL) return;
+  Address base = RoundUp(static_cast<Address>(address), alignment);
+  // Try reducing the size by freeing and then reallocating a specific area.
+  ReleaseRegion(address, request_size);
+  address = VirtualAlloc(base, size, MEM_RESERVE, PAGE_NOACCESS);
+  if (address != NULL) {
+    request_size = size;
+    ASSERT(base == static_cast<Address>(address));
+  } else {
+    // Resizing failed, just go with a bigger area.
+    address = ReserveRegion(reserve_size);
+    if (address == NULL) return;
+  }
+  address_ = address;
+  size_ = request_size;
+}
+
+
+VirtualMemory::~VirtualMemory() {
+  if (IsReserved()) {
+    bool result = ReleaseRegion(address_, size_);
+    ASSERT(result);
+    USE(result);
+  }
+}
+
+
 bool VirtualMemory::IsReserved() {
   return address_ != NULL;
 }
 
 
-VirtualMemory::VirtualMemory(size_t size) {
-  address_ = ReserveRegion(size);
-  size_ = size;
-}
-
-
-VirtualMemory::~VirtualMemory() {
-  if (IsReserved()) {
-    if (0 == VirtualFree(address(), 0, MEM_RELEASE)) address_ = NULL;
-  }
+void VirtualMemory::Reset() {
+  address_ = NULL;
+  size_ = 0;
 }
 
 
 bool VirtualMemory::Commit(void* address, size_t size, bool is_executable) {
   if (CommitRegion(address, size, is_executable)) {
     UpdateAllocatedSpaceLimits(address, static_cast<int>(size));
     return true;
   }
   return false;
 }
@@ skipping 15 matching lines @@
   if (NULL == VirtualAlloc(base, size, MEM_COMMIT, prot)) {
     return false;
   }
 
   UpdateAllocatedSpaceLimits(base, static_cast<int>(size));
   return true;
 }
 
 
 bool VirtualMemory::UncommitRegion(void* base, size_t size) {
-  return VirtualFree(base, size, MEM_DECOMMIT) != false;
+  return VirtualFree(base, size, MEM_DECOMMIT) != 0;
 }
 
 
 bool VirtualMemory::ReleaseRegion(void* base, size_t size) {
-  return VirtualFree(base, size, MEM_DECOMMIT) != false;
+  return VirtualFree(base, 0, MEM_RELEASE) != 0;
 }
 
 
 
 // ----------------------------------------------------------------------------
 // Win32 thread support.
 
 // Definition of invalid thread handle and id.
 static const HANDLE kNoThread = INVALID_HANDLE_VALUE;
 
@@ skipping 529 matching lines @@
 
 
 void Sampler::Stop() {
   ASSERT(IsActive());
   SamplerThread::RemoveActiveSampler(this);
   SetActive(false);
 }
 
 
 } }  // namespace v8::internal