Refactor and cleanup VirtualMemory.

src/spaces.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 227 matching lines @@
   allocation_list_[current_allocation_block_index_].start += *allocated;
   allocation_list_[current_allocation_block_index_].size -= *allocated;
   if (*allocated == current.size) {
     GetNextAllocationBlock(0);  // This block is used up, get the next one.
   }
   return current.start;
 }
 
 
 bool CodeRange::CommitRawMemory(Address start, size_t length) {
-  return isolate_->memory_allocator()->CommitMemory(start, length, EXECUTABLE);
+  return isolate_->memory_allocator()->CommitMemory(
+      start, length, VirtualMemory::EXECUTABLE);
 }
 
 
 bool CodeRange::UncommitRawMemory(Address start, size_t length) {
   return code_range_->Uncommit(start, length);
 }
 
 
 void CodeRange::FreeRawMemory(Address address, size_t length) {
   ASSERT(IsAddressAligned(address, MemoryChunk::kAlignment));
   free_list_.Add(FreeBlock(address, length));
-  code_range_->Uncommit(address, length);
+  bool result = code_range_->Uncommit(address, length);
+  ASSERT(result);
+  USE(result);
 }
 
 
 void CodeRange::TearDown() {
     delete code_range_;  // Frees all memory in the virtual memory range.
     code_range_ = NULL;
     free_list_.Free();
     allocation_list_.Free();
 }
 
@@ skipping 30 matching lines @@
   ASSERT(size_ == 0);
   // TODO(gc) this will be true again when we fix FreeMemory.
   // ASSERT(size_executable_ == 0);
   capacity_ = 0;
   capacity_executable_ = 0;
 }
 
 
 bool MemoryAllocator::CommitMemory(Address base,
                                    size_t size,
-                                   Executability executable) {
-  if (!VirtualMemory::CommitRegion(base, size, executable == EXECUTABLE)) {
+                                   VirtualMemory::Executability executability) {
+  if (!VirtualMemory::CommitRegion(base, size, executability)) {
     return false;
   }
   UpdateAllocatedSpaceLimits(base, base + size);
   return true;
 }
 
 
 void MemoryAllocator::FreeMemory(VirtualMemory* reservation,
-                                 Executability executable) {
+                                 VirtualMemory::Executability executability) {
   // TODO(gc) make code_range part of memory allocator?
   ASSERT(reservation->IsReserved());
   size_t size = reservation->size();
   ASSERT(size_ >= size);
   size_ -= size;
 
   isolate_->counters()->memory_allocated()->Decrement(static_cast<int>(size));
 
-  if (executable == EXECUTABLE) {
+  if (executability == VirtualMemory::EXECUTABLE) {
     ASSERT(size_executable_ >= size);
     size_executable_ -= size;
   }
   // Code which is part of the code-range does not have its own VirtualMemory.
   ASSERT(!isolate_->code_range()->contains(
       static_cast<Address>(reservation->address())));
-  ASSERT(executable == NOT_EXECUTABLE || !isolate_->code_range()->exists());
+  ASSERT(executability == VirtualMemory::NOT_EXECUTABLE ||
+         !isolate_->code_range()->exists());
   reservation->Release();
 }
 
 
 void MemoryAllocator::FreeMemory(Address base,
                                  size_t size,
-                                 Executability executable) {
+                                 VirtualMemory::Executability executability) {
   // TODO(gc) make code_range part of memory allocator?
   ASSERT(size_ >= size);
   size_ -= size;
 
   isolate_->counters()->memory_allocated()->Decrement(static_cast<int>(size));
 
-  if (executable == EXECUTABLE) {
+  if (executability == VirtualMemory::EXECUTABLE) {
     ASSERT(size_executable_ >= size);
     size_executable_ -= size;
   }
   if (isolate_->code_range()->contains(static_cast<Address>(base))) {
-    ASSERT(executable == EXECUTABLE);
+    ASSERT(executability == VirtualMemory::EXECUTABLE);
     isolate_->code_range()->FreeRawMemory(base, size);
   } else {
-    ASSERT(executable == NOT_EXECUTABLE || !isolate_->code_range()->exists());
+    ASSERT(executability == VirtualMemory::NOT_EXECUTABLE ||
+           !isolate_->code_range()->exists());
     bool result = VirtualMemory::ReleaseRegion(base, size);
     USE(result);
     ASSERT(result);
   }
 }
 
 
 Address MemoryAllocator::ReserveAlignedMemory(size_t size,
                                               size_t alignment,
                                               VirtualMemory* controller) {
   VirtualMemory reservation(size, alignment);
 
   if (!reservation.IsReserved()) return NULL;
   size_ += reservation.size();
   Address base = RoundUp(static_cast<Address>(reservation.address()),
                          alignment);
   controller->TakeControl(&reservation);
   return base;
 }
 
 
-Address MemoryAllocator::AllocateAlignedMemory(size_t reserve_size,
-                                               size_t commit_size,
-                                               size_t alignment,
-                                               Executability executable,
-                                               VirtualMemory* controller) {
+Address MemoryAllocator::AllocateAlignedMemory(
+    size_t reserve_size,
+    size_t commit_size,
+    size_t alignment,
+    VirtualMemory::Executability executability,
+    VirtualMemory* controller) {
   ASSERT(commit_size <= reserve_size);
   VirtualMemory reservation;
   Address base = ReserveAlignedMemory(reserve_size, alignment, &reservation);
   if (base == NULL) return NULL;
 
-  if (executable == EXECUTABLE) {
+  if (executability == VirtualMemory::EXECUTABLE) {
     if (!CommitExecutableMemory(&reservation,
                                 base,
                                 commit_size,
                                 reserve_size)) {
       base = NULL;
     }
   } else {
-    if (reservation.Commit(base, commit_size, false)) {
+    if (reservation.Commit(base, commit_size, VirtualMemory::NOT_EXECUTABLE)) {
       UpdateAllocatedSpaceLimits(base, base + commit_size);
     } else {
       base = NULL;
     }
   }
 
   if (base == NULL) {
     // Failed to commit the body. Release the mapping and any partially
     // commited regions inside it.
     reservation.Release();
@@ skipping 16 matching lines @@
                                        Address start,
                                        SemiSpace* semi_space) {
   Address area_start = start + NewSpacePage::kObjectStartOffset;
   Address area_end = start + Page::kPageSize;
 
   MemoryChunk* chunk = MemoryChunk::Initialize(heap,
                                                start,
                                                Page::kPageSize,
                                                area_start,
                                                area_end,
-                                               NOT_EXECUTABLE,
+                                               VirtualMemory::NOT_EXECUTABLE,
                                                semi_space);
   chunk->set_next_chunk(NULL);
   chunk->set_prev_chunk(NULL);
   chunk->initialize_scan_on_scavenge(true);
   bool in_to_space = (semi_space->id() != kFromSpace);
   chunk->SetFlag(in_to_space ? MemoryChunk::IN_TO_SPACE
                              : MemoryChunk::IN_FROM_SPACE);
   ASSERT(!chunk->IsFlagSet(in_to_space ? MemoryChunk::IN_FROM_SPACE
                                        : MemoryChunk::IN_TO_SPACE));
   NewSpacePage* page = static_cast<NewSpacePage*>(chunk);
@@ skipping 10 matching lines @@
   // All real new-space pages will be in new-space.
   SetFlags(0, ~0);
 }
 
 
 MemoryChunk* MemoryChunk::Initialize(Heap* heap,
                                      Address base,
                                      size_t size,
                                      Address area_start,
                                      Address area_end,
-                                     Executability executable,
+                                     VirtualMemory::Executability executability,
                                      Space* owner) {
   MemoryChunk* chunk = FromAddress(base);
 
   ASSERT(base == chunk->address());
 
   chunk->heap_ = heap;
   chunk->size_ = size;
   chunk->area_start_ = area_start;
   chunk->area_end_ = area_end;
   chunk->flags_ = 0;
@@ skipping 11 matching lines @@
   chunk->available_in_huge_free_list_ = 0;
   chunk->non_available_small_blocks_ = 0;
   chunk->ResetLiveBytes();
   Bitmap::Clear(chunk);
   chunk->initialize_scan_on_scavenge(false);
   chunk->SetFlag(WAS_SWEPT_PRECISELY);
 
   ASSERT(OFFSET_OF(MemoryChunk, flags_) == kFlagsOffset);
   ASSERT(OFFSET_OF(MemoryChunk, live_byte_count_) == kLiveBytesOffset);
 
-  if (executable == EXECUTABLE) {
+  if (executability == VirtualMemory::EXECUTABLE) {
     chunk->SetFlag(IS_EXECUTABLE);
   }
 
   if (owner == heap->old_data_space()) {
     chunk->SetFlag(CONTAINS_ONLY_DATA);
   }
 
   return chunk;
 }
 
 
 // Commit MemoryChunk area to the requested size.
 bool MemoryChunk::CommitArea(size_t requested) {
   size_t guard_size = IsFlagSet(IS_EXECUTABLE) ?
                       MemoryAllocator::CodePageGuardSize() : 0;
   size_t header_size = area_start() - address() - guard_size;
-  size_t commit_size = RoundUp(header_size + requested, OS::CommitPageSize());
+  size_t commit_size = RoundUp(header_size + requested,
+                               VirtualMemory::GetPageSize());
   size_t committed_size = RoundUp(header_size + (area_end() - area_start()),
-                                  OS::CommitPageSize());
+                                  VirtualMemory::GetPageSize());
 
   if (commit_size > committed_size) {
     // Commit size should be less or equal than the reserved size.
     ASSERT(commit_size <= size() - 2 * guard_size);
     // Append the committed area.
     Address start = address() + committed_size + guard_size;
     size_t length = commit_size - committed_size;
     if (reservation_.IsReserved()) {
-      Executability executable = IsFlagSet(IS_EXECUTABLE)
-          ? EXECUTABLE : NOT_EXECUTABLE;
+      VirtualMemory::Executability executability = IsFlagSet(IS_EXECUTABLE)
+          ? VirtualMemory::EXECUTABLE : VirtualMemory::NOT_EXECUTABLE;
       if (!heap()->isolate()->memory_allocator()->CommitMemory(
-              start, length, executable)) {
+              start, length, executability)) {
         return false;
       }
     } else {
       CodeRange* code_range = heap_->isolate()->code_range();
       ASSERT(code_range->exists() && IsFlagSet(IS_EXECUTABLE));
       if (!code_range->CommitRawMemory(start, length)) return false;
     }
 
     if (Heap::ShouldZapGarbage()) {
       heap_->isolate()->memory_allocator()->ZapBlock(start, length);
@@ skipping 41 matching lines @@
     heap_->decrement_scan_on_scavenge_pages();
     ClearFlag(SCAN_ON_SCAVENGE);
   }
   next_chunk_->prev_chunk_ = prev_chunk_;
   prev_chunk_->next_chunk_ = next_chunk_;
   prev_chunk_ = NULL;
   next_chunk_ = NULL;
 }
 
 
-MemoryChunk* MemoryAllocator::AllocateChunk(intptr_t reserve_area_size,
-                                            intptr_t commit_area_size,
-                                            Executability executable,
-                                            Space* owner) {
+MemoryChunk* MemoryAllocator::AllocateChunk(
+    intptr_t reserve_area_size,
+    intptr_t commit_area_size,
+    VirtualMemory::Executability executability,
+    Space* owner) {
   ASSERT(commit_area_size <= reserve_area_size);
 
   size_t chunk_size;
   Heap* heap = isolate_->heap();
   Address base = NULL;
   VirtualMemory reservation;
   Address area_start = NULL;
   Address area_end = NULL;
 
   //
@@ skipping 19 matching lines @@
   // |          Header            |
   // +----------------------------+<- area_start_ (base + kObjectStartOffset)
   // |           Area             |
   // +----------------------------+<- area_end_ (area_start + commit_area_size)
   // |  Committed but not used    |
   // +----------------------------+<- aligned at OS page boundary
   // | Reserved but not committed |
   // +----------------------------+<- base + chunk_size
   //
 
-  if (executable == EXECUTABLE) {
+  if (executability == VirtualMemory::EXECUTABLE) {
     chunk_size = RoundUp(CodePageAreaStartOffset() + reserve_area_size,
-                         OS::CommitPageSize()) + CodePageGuardSize();
+                         VirtualMemory::GetPageSize()) + CodePageGuardSize();
 
     // Check executable memory limit.
     if (size_executable_ + chunk_size > capacity_executable_) {
       LOG(isolate_,
           StringEvent("MemoryAllocator::AllocateRawMemory",
                       "V8 Executable Allocation capacity exceeded"));
       return NULL;
     }
 
     // Size of header (not executable) plus area (executable).
     size_t commit_size = RoundUp(CodePageGuardStartOffset() + commit_area_size,
-                                 OS::CommitPageSize());
+                                 VirtualMemory::GetPageSize());
     // Allocate executable memory either from code range or from the
     // OS.
     if (isolate_->code_range()->exists()) {
       base = isolate_->code_range()->AllocateRawMemory(chunk_size,
                                                        commit_size,
                                                        &chunk_size);
       ASSERT(IsAligned(reinterpret_cast<intptr_t>(base),
                        MemoryChunk::kAlignment));
       if (base == NULL) return NULL;
       size_ += chunk_size;
       // Update executable memory size.
       size_executable_ += chunk_size;
     } else {
       base = AllocateAlignedMemory(chunk_size,
                                    commit_size,
                                    MemoryChunk::kAlignment,
-                                   executable,
+                                   executability,
                                    &reservation);
       if (base == NULL) return NULL;
       // Update executable memory size.
       size_executable_ += reservation.size();
     }
 
     if (Heap::ShouldZapGarbage()) {
       ZapBlock(base, CodePageGuardStartOffset());
       ZapBlock(base + CodePageAreaStartOffset(), commit_area_size);
     }
 
     area_start = base + CodePageAreaStartOffset();
     area_end = area_start + commit_area_size;
   } else {
     chunk_size = RoundUp(MemoryChunk::kObjectStartOffset + reserve_area_size,
-                         OS::CommitPageSize());
-    size_t commit_size = RoundUp(MemoryChunk::kObjectStartOffset +
-                                 commit_area_size, OS::CommitPageSize());
+                         VirtualMemory::GetPageSize());
+    size_t commit_size = RoundUp(
+        MemoryChunk::kObjectStartOffset + commit_area_size,
+        VirtualMemory::GetPageSize());
     base = AllocateAlignedMemory(chunk_size,
                                  commit_size,
                                  MemoryChunk::kAlignment,
-                                 executable,
+                                 executability,
                                  &reservation);
 
     if (base == NULL) return NULL;
 
     if (Heap::ShouldZapGarbage()) {
       ZapBlock(base, Page::kObjectStartOffset + commit_area_size);
     }
 
     area_start = base + Page::kObjectStartOffset;
     area_end = area_start + commit_area_size;
   }
 
   // Use chunk_size for statistics and callbacks because we assume that they
   // treat reserved but not-yet committed memory regions of chunks as allocated.
   isolate_->counters()->memory_allocated()->
       Increment(static_cast<int>(chunk_size));
 
   LOG(isolate_, NewEvent("MemoryChunk", base, chunk_size));
   if (owner != NULL) {
     ObjectSpace space = static_cast<ObjectSpace>(1 << owner->identity());
     PerformAllocationCallback(space, kAllocationActionAllocate, chunk_size);
   }
 
   MemoryChunk* result = MemoryChunk::Initialize(heap,
                                                 base,
                                                 chunk_size,
                                                 area_start,
                                                 area_end,
-                                                executable,
+                                                executability,
                                                 owner);
   result->set_reserved_memory(&reservation);
   return result;
 }
 
 
 void Page::ResetFreeListStatistics() {
   non_available_small_blocks_ = 0;
   available_in_small_free_list_ = 0;
   available_in_medium_free_list_ = 0;
   available_in_large_free_list_ = 0;
   available_in_huge_free_list_ = 0;
 }
 
 
-Page* MemoryAllocator::AllocatePage(intptr_t size,
-                                    PagedSpace* owner,
-                                    Executability executable) {
-  MemoryChunk* chunk = AllocateChunk(size, size, executable, owner);
+Page* MemoryAllocator::AllocatePage(
+    intptr_t size,
+    PagedSpace* owner,
+    VirtualMemory::Executability executability) {
+  MemoryChunk* chunk = AllocateChunk(size, size, executability, owner);
 
   if (chunk == NULL) return NULL;
 
-  return Page::Initialize(isolate_->heap(), chunk, executable, owner);
+  return Page::Initialize(isolate_->heap(), chunk, executability, owner);
 }
 
 
-LargePage* MemoryAllocator::AllocateLargePage(intptr_t object_size,
-                                              Space* owner,
-                                              Executability executable) {
+LargePage* MemoryAllocator::AllocateLargePage(
+    intptr_t object_size,
+    Space* owner,
+    VirtualMemory::Executability executability) {
   MemoryChunk* chunk = AllocateChunk(object_size,
                                      object_size,
-                                     executable,
+                                     executability,
                                      owner);
   if (chunk == NULL) return NULL;
   return LargePage::Initialize(isolate_->heap(), chunk);
 }
 
 
 void MemoryAllocator::Free(MemoryChunk* chunk) {
   LOG(isolate_, DeleteEvent("MemoryChunk", chunk));
   if (chunk->owner() != NULL) {
     ObjectSpace space =
         static_cast<ObjectSpace>(1 << chunk->owner()->identity());
     PerformAllocationCallback(space, kAllocationActionFree, chunk->size());
   }
 
   isolate_->heap()->RememberUnmappedPage(
       reinterpret_cast<Address>(chunk), chunk->IsEvacuationCandidate());
 
   delete chunk->slots_buffer();
   delete chunk->skip_list();
 
   VirtualMemory* reservation = chunk->reserved_memory();
   if (reservation->IsReserved()) {
-    FreeMemory(reservation, chunk->executable());
+    FreeMemory(reservation, chunk->executability());
   } else {
     FreeMemory(chunk->address(),
                chunk->size(),
-               chunk->executable());
+               chunk->executability());
   }
 }
 
 
 bool MemoryAllocator::CommitBlock(Address start,
                                   size_t size,
-                                  Executability executable) {
-  if (!CommitMemory(start, size, executable)) return false;
+                                  VirtualMemory::Executability executability) {
+  if (!CommitMemory(start, size, executability)) return false;
 
   if (Heap::ShouldZapGarbage()) {
     ZapBlock(start, size);
   }
 
   isolate_->counters()->memory_allocated()->Increment(static_cast<int>(size));
   return true;
 }
 
 
@@ skipping 64 matching lines @@
              ", used: %" V8_PTR_PREFIX "d"
              ", available: %%%d\n\n",
          capacity_, size_, static_cast<int>(pct*100));
 }
 #endif
 
 
 int MemoryAllocator::CodePageGuardStartOffset() {
   // We are guarding code pages: the first OS page after the header
   // will be protected as non-writable.
-  return RoundUp(Page::kObjectStartOffset, OS::CommitPageSize());
+  return RoundUp(Page::kObjectStartOffset, VirtualMemory::GetPageSize());
 }
 
 
 int MemoryAllocator::CodePageGuardSize() {
-  return static_cast<int>(OS::CommitPageSize());
+  return static_cast<int>(VirtualMemory::GetPageSize());
 }
 
 
 int MemoryAllocator::CodePageAreaStartOffset() {
   // We are guarding code pages: the first OS page after the header
   // will be protected as non-writable.
   return CodePageGuardStartOffset() + CodePageGuardSize();
 }
 
 
 int MemoryAllocator::CodePageAreaEndOffset() {
   // We are guarding code pages: the last OS page will be protected as
   // non-writable.
-  return Page::kPageSize - static_cast<int>(OS::CommitPageSize());
+  return Page::kPageSize - static_cast<int>(VirtualMemory::GetPageSize());
 }
 
 
 bool MemoryAllocator::CommitExecutableMemory(VirtualMemory* vm,
                                              Address start,
                                              size_t commit_size,
                                              size_t reserved_size) {
   // Commit page header (not executable).
   if (!vm->Commit(start,
                   CodePageGuardStartOffset(),
-                  false)) {
+                  VirtualMemory::NOT_EXECUTABLE)) {
     return false;
   }
 
   // Create guard page after the header.
-  if (!vm->Guard(start + CodePageGuardStartOffset())) {
+  if (!vm->Guard(start + CodePageGuardStartOffset(),
+                 VirtualMemory::GetPageSize())) {
     return false;
   }
 
   // Commit page body (executable).
   if (!vm->Commit(start + CodePageAreaStartOffset(),
                   commit_size - CodePageGuardStartOffset(),
-                  true)) {
+                  VirtualMemory::EXECUTABLE)) {
     return false;
   }
 
   // Create guard page before the end.
-  if (!vm->Guard(start + reserved_size - CodePageGuardSize())) {
+  if (!vm->Guard(start + reserved_size - CodePageGuardSize(),
+                 VirtualMemory::GetPageSize())) {
     return false;
   }
 
   UpdateAllocatedSpaceLimits(start,
                              start + CodePageAreaStartOffset() +
                              commit_size - CodePageGuardStartOffset());
   return true;
 }
 
 
 // -----------------------------------------------------------------------------
 // MemoryChunk implementation
 
 void MemoryChunk::IncrementLiveBytesFromMutator(Address address, int by) {
   MemoryChunk* chunk = MemoryChunk::FromAddress(address);
   if (!chunk->InNewSpace() && !static_cast<Page*>(chunk)->WasSwept()) {
     static_cast<PagedSpace*>(chunk->owner())->IncrementUnsweptFreeBytes(-by);
   }
   chunk->IncrementLiveBytes(by);
 }
 
 
 // -----------------------------------------------------------------------------
 // PagedSpace implementation
 
 PagedSpace::PagedSpace(Heap* heap,
                        intptr_t max_capacity,
                        AllocationSpace id,
-                       Executability executable)
-    : Space(heap, id, executable),
+                       VirtualMemory::Executability executability)
+    : Space(heap, id, executability),
       free_list_(this),
       was_swept_conservatively_(false),
       first_unswept_page_(Page::FromAddress(NULL)),
       unswept_free_bytes_(0) {
   if (id == CODE_SPACE) {
     area_size_ = heap->isolate()->memory_allocator()->
         CodePageAreaSize();
   } else {
     area_size_ = Page::kPageSize - Page::kObjectStartOffset;
   }
@@ skipping 77 matching lines @@
 bool PagedSpace::Expand() {
   if (!CanExpand()) return false;
 
   intptr_t size = AreaSize();
 
   if (anchor_.next_page() == &anchor_) {
     size = SizeOfFirstPage();
   }
 
   Page* p = heap()->isolate()->memory_allocator()->AllocatePage(
-      size, this, executable());
+      size, this, executability());
   if (p == NULL) return false;
 
   ASSERT(Capacity() <= max_capacity_);
 
   p->InsertAfter(anchor_.prev_page());
 
   return true;
 }
 
 
@@ skipping 226 matching lines @@
   start_ = NULL;
   allocation_info_.top = NULL;
   allocation_info_.limit = NULL;
 
   to_space_.TearDown();
   from_space_.TearDown();
 
   LOG(heap()->isolate(), DeleteEvent("InitialChunk", chunk_base_));
 
   ASSERT(reservation_.IsReserved());
-  heap()->isolate()->memory_allocator()->FreeMemory(&reservation_,
-                                                    NOT_EXECUTABLE);
+  heap()->isolate()->memory_allocator()->FreeMemory(
+      &reservation_, VirtualMemory::NOT_EXECUTABLE);
   chunk_base_ = NULL;
   chunk_size_ = 0;
 }
 
 
 void NewSpace::Flip() {
   SemiSpace::Swap(&from_space_, &to_space_);
 }
 
 
@@ skipping 214 matching lines @@
 }
 
 
 bool SemiSpace::Commit() {
   ASSERT(!is_committed());
   int pages = capacity_ / Page::kPageSize;
   Address end = start_ + maximum_capacity_;
   Address start = end - pages * Page::kPageSize;
   if (!heap()->isolate()->memory_allocator()->CommitBlock(start,
                                                           capacity_,
-                                                          executable())) {
+                                                          executability())) {
     return false;
   }
 
   NewSpacePage* page = anchor();
   for (int i = 1; i <= pages; i++) {
     NewSpacePage* new_page =
       NewSpacePage::Initialize(heap(), end - i * Page::kPageSize, this);
     new_page->InsertAfter(page);
     page = new_page;
   }
@@ skipping 36 matching lines @@
   ASSERT((new_capacity & Page::kPageAlignmentMask) == 0);
   ASSERT(new_capacity <= maximum_capacity_);
   ASSERT(new_capacity > capacity_);
   int pages_before = capacity_ / Page::kPageSize;
   int pages_after = new_capacity / Page::kPageSize;
 
   Address end = start_ + maximum_capacity_;
   Address start = end - new_capacity;
   size_t delta = new_capacity - capacity_;
 
-  ASSERT(IsAligned(delta, OS::AllocateAlignment()));
+  ASSERT(IsAligned(delta, VirtualMemory::GetAllocationGranularity()));
   if (!heap()->isolate()->memory_allocator()->CommitBlock(
-      start, delta, executable())) {
+      start, delta, executability())) {
     return false;
   }
   capacity_ = new_capacity;
   NewSpacePage* last_page = anchor()->prev_page();
   ASSERT(last_page != anchor());
   for (int i = pages_before + 1; i <= pages_after; i++) {
     Address page_address = end - i * Page::kPageSize;
     NewSpacePage* new_page = NewSpacePage::Initialize(heap(),
                                                       page_address,
                                                       this);
@@ skipping 12 matching lines @@
   ASSERT((new_capacity & Page::kPageAlignmentMask) == 0);
   ASSERT(new_capacity >= initial_capacity_);
   ASSERT(new_capacity < capacity_);
   if (is_committed()) {
     // Semispaces grow backwards from the end of their allocated capacity,
     // so we find the before and after start addresses relative to the
     // end of the space.
     Address space_end = start_ + maximum_capacity_;
     Address old_start = space_end - capacity_;
     size_t delta = capacity_ - new_capacity;
-    ASSERT(IsAligned(delta, OS::AllocateAlignment()));
+    ASSERT(IsAligned(delta, VirtualMemory::GetAllocationGranularity()));
 
     MemoryAllocator* allocator = heap()->isolate()->memory_allocator();
     if (!allocator->UncommitBlock(old_start, delta)) {
       return false;
     }
 
     int pages_after = new_capacity / Page::kPageSize;
     NewSpacePage* new_last_page =
         NewSpacePage::FromAddress(space_end - pages_after * Page::kPageSize);
     new_last_page->set_next_page(anchor());
@@ skipping 1287 matching lines @@
 // -----------------------------------------------------------------------------
 // LargeObjectSpace
 static bool ComparePointers(void* key1, void* key2) {
     return key1 == key2;
 }
 
 
 LargeObjectSpace::LargeObjectSpace(Heap* heap,
                                    intptr_t max_capacity,
                                    AllocationSpace id)
-    : Space(heap, id, NOT_EXECUTABLE),  // Managed on a per-allocation basis
+    // Managed on a per-allocation basis
+    : Space(heap, id, VirtualMemory::NOT_EXECUTABLE),
       max_capacity_(max_capacity),
       first_page_(NULL),
       size_(0),
       page_count_(0),
       objects_size_(0),
       chunk_map_(ComparePointers, 1024) {}
 
 
 bool LargeObjectSpace::SetUp() {
   first_page_ = NULL;
@@ skipping 13 matching lines @@
 
     ObjectSpace space = static_cast<ObjectSpace>(1 << identity());
     heap()->isolate()->memory_allocator()->PerformAllocationCallback(
         space, kAllocationActionFree, page->size());
     heap()->isolate()->memory_allocator()->Free(page);
   }
   SetUp();
 }
 
 
-MaybeObject* LargeObjectSpace::AllocateRaw(int object_size,
-                                           Executability executable) {
+MaybeObject* LargeObjectSpace::AllocateRaw(
+    int object_size, VirtualMemory::Executability executability) {
   // Check if we want to force a GC before growing the old space further.
   // If so, fail the allocation.
   if (!heap()->always_allocate() &&
       heap()->OldGenerationAllocationLimitReached()) {
     return Failure::RetryAfterGC(identity());
   }
 
   if (Size() + object_size > max_capacity_) {
     return Failure::RetryAfterGC(identity());
   }
 
   LargePage* page = heap()->isolate()->memory_allocator()->
-      AllocateLargePage(object_size, this, executable);
+      AllocateLargePage(object_size, this, executability);
   if (page == NULL) return Failure::RetryAfterGC(identity());
   ASSERT(page->area_size() >= object_size);
 
   size_ += static_cast<int>(page->size());
   objects_size_ += object_size;
   page_count_++;
   page->set_next_page(first_page_);
   first_page_ = page;
 
   // Register all MemoryChunk::kAlignment-aligned chunks covered by
@@ skipping 235 matching lines @@
     object->ShortPrint();
     PrintF("\n");
   }
   printf(" --------------------------------------\n");
   printf(" Marked: %x, LiveCount: %x\n", mark_size, LiveBytes());
 }
 
 #endif  // DEBUG
 
 } }  // namespace v8::internal