Move aligned allocation to the platform files.

src/platform-linux.cc

 // 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
@@ skipping 116 matching lines @@
            "-DUSE_EABI_HARDFLOAT\n");
     exit(1);
 #endif
   }
 #endif
 }
 
 
 uint64_t OS::CpuFeaturesImpliedByPlatform() {
 #if(defined(__mips_hard_float) && __mips_hard_float != 0)
     // Here gcc is telling us that we are on an MIPS and gcc is assuming that we

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

Accident edit?

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

No edit visible to me?

     // have FPU instructions.  If gcc can assume it then so can we.
     return 1u << FPU;
 #else
   return 0;  // Linux runs on anything.
 #endif
 }
 
 
 #ifdef __arm__
 static bool CPUInfoContainsString(const char * search_string) {
@@ skipping 452 matching lines @@
 #else  // ndef __GLIBC__
   return 0;
 #endif  // ndef __GLIBC__
 }
 
 
 // Constants used for mmap.
 static const int kMmapFd = -1;
 static const int kMmapFdOffset = 0;
 
+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* 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;
+
+  address_ = reservation;
+  size_ = request_size;
+}
+
+
 VirtualMemory::~VirtualMemory() {
   if (IsReserved()) {
-    if (ReleaseRegion(address(), size())) address_ = NULL;
+    bool result = ReleaseRegion(address(), size());
+    ASSERT(result);
+    USE(result);
   }
 }
 
 
 bool VirtualMemory::IsReserved() {
   return address_ != NULL;
 }
 
 
+void VirtualMemory::Reset() {
+  address_ = NULL;
+  size_ = 0;
+}
+
+
 bool VirtualMemory::Commit(void* address, size_t size, bool is_executable) {
   return CommitRegion(address, size, is_executable);
 }
 
 
 bool VirtualMemory::Uncommit(void* address, size_t size) {
   return UncommitRegion(address, size);
 }
 
 
@@ skipping 540 matching lines @@
 
 
 void Sampler::Stop() {
   ASSERT(IsActive());
   SignalSender::RemoveActiveSampler(this);
   SetActive(false);
 }
 
 
 } }  // namespace v8::internal