Move aligned allocation to the platform files.

src/platform-macos.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 315 matching lines @@
     // Make sure line termination is in place.
     frames[i].text[kStackWalkMaxTextLen - 1] = '\0';
   }
 
   free(symbols);
 
   return frames_count;
 }
 
 
-VirtualMemory::VirtualMemory(size_t size) {
-  address_ = ReserveRegion(size);
+VirtualMemory::VirtualMemory() : address_(NULL), size_(size) { }
+
+
+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* reservation = mmap(GetRandomMmapAddr(),
+                           request_size,
+                           PROT_NONE,
+                           MAP_PRIVATE | MAP_ANONYMOUS | MAP_NORESERVE,
+                           kMmapFd,
+                           kMmapFdOffset);
+  if (reservation == MAP_FAILED) return;
+  Address base = static_cast<Address>(reservation);
+  Address aligned_base = RoundUp(base, alignment);
+  ASSERT(base <= aligned_base);
+
+  // Unmap extra memory reserved before and after the desired block.
+  size_t bytes_prior = static_cast<size_t>(aligned_base - base);
+  if (bytes_prior > 0) {
+    munmap(base, bytes_prior);
+  }
+  if (static_cast<size_t>(aligned_base - base) < request_size - size) {
+    munmap(aligned_base + size, request_size - size - bytes_prior);
+  }
+
+  address_ = static_cast<void*>(aligned_base);
   size_ = size;
 }
 
 
+VirtualMemory::~VirtualMemory() {
+  if (IsReserved()) {
+    bool result = ReleaseRegion(address(), size());
+    ASSERT(result);
+    USE(result);
+  }
+}
+
+
+void VirtualMemory::Reset() {
+  address_ = NULL;
+  size_ = 0;
+}
+
+
 void* VirtualMemory::ReserveRegion(size_t size) {
   void* result = mmap(NULL,
                       size,
                       PROT_NONE,
                       MAP_PRIVATE | MAP_ANON | MAP_NORESERVE,
                       kMmapFd,
                       kMmapFdOffset);
 
   if (result == MAP_FAILED) return NULL;
 
   return result;
 }
 
 
-VirtualMemory::~VirtualMemory() {
-  if (IsReserved()) {
-    if (ReleaseRegion(address_, size_)) address_ = MAP_FAILED;
-  }
-}
-
-
 bool VirtualMemory::IsReserved() {
-  return address_ != MAP_FAILED;
+  return address_ != NULL;
 }
 
 
 bool VirtualMemory::Commit(void* address, size_t size, bool is_executable) {
   return CommitRegion(address, size, is_executable);
 }
 
 
 bool VirtualMemory::CommitRegion(void* address,
                                  size_t size,
@@ skipping 455 matching lines @@
 
 
 void Sampler::Stop() {
   ASSERT(IsActive());
   SamplerThread::RemoveActiveSampler(this);
   SetActive(false);
 }
 
 
 } }  // namespace v8::internal